4 * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
\r
6 * Contact: Ankit Jogi <ankit.jogi@samsung.com>
\r
8 * PROPRIETARY/CONFIDENTIAL
\r
10 * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
\r
11 * You shall not disclose such Confidential Information and shall
\r
12 * use it only in accordance with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
\r
13 * SAMSUNG make no representations or warranties about the suitability
\r
14 * of the software, either express or implied, including but not
\r
15 * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-infringement.
\r
16 * SAMSUNG shall not be liable for any damages suffered by licensee as
\r
17 * a result of using, modifying or distributing this software or its derivatives.
\r
26 #include <core_object.h>
\r
30 #include <storage.h>
\r
31 #include <user_request.h>
\r
35 #include "s_common.h"
\r
38 #define ID_RESERVED_AT 0x0229
\r
40 #define SWAPBYTES16(x) \
\r
42 unsigned short int data = *(unsigned short int*)&(x); \
\r
43 data = ((data & 0xff00) >> 8) | \
\r
44 ((data & 0x00ff) << 8); \
\r
45 *(unsigned short int*)&(x) = data ; \
\r
48 enum s_sim_file_type_e {
\r
49 SIM_FTYPE_DEDICATED = 0x00, /**< Dedicated */
\r
50 SIM_FTYPE_TRANSPARENT = 0x01, /**< Transparent -binary type*/
\r
51 SIM_FTYPE_LINEAR_FIXED = 0x02, /**< Linear fixed - record type*/
\r
52 SIM_FTYPE_CYCLIC = 0x04, /**< Cyclic - record type*/
\r
53 SIM_FTYPE_INVALID_TYPE = 0xFF /**< Invalid type */
\r
56 enum s_sim_sec_op_e {
\r
68 SEC_PIN2_DISABLE, //10
\r
78 SEC_CP_DISABLE, //20
\r
89 SEC_SIM_UNKNOWN = 0xff
\r
92 struct s_sim_property {
\r
93 gboolean b_valid; /**< Valid or not */
\r
94 enum tel_sim_file_id file_id; /**< File identifier */
\r
95 enum s_sim_file_type_e file_type; /**< File type and structure */
\r
96 int rec_length; /**< Length of one record in file */
\r
97 int rec_count; /**< Number of records in file */
\r
98 int data_size; /**< File size */
\r
99 int current_index; /**< current index to read */
\r
100 enum tel_sim_status first_recv_status;
\r
101 enum s_sim_sec_op_e current_sec_op; /**< current index to read */
\r
102 struct tresp_sim_read files;
\r
105 static void _next_from_get_file_info(CoreObject *o, UserRequest *ur, enum tel_sim_file_id ef, enum tel_sim_access_result rt);
\r
106 static void _next_from_get_file_data(CoreObject *o, UserRequest *ur, enum tel_sim_access_result rt, int decode_ret);
\r
107 static gboolean _get_sim_type(CoreObject *o);
\r
108 static TReturn _get_file_info(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef);
\r
109 static gboolean _get_file_data(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int offset, const int length);
\r
110 static gboolean _get_file_record(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int index, const int length);
\r
111 static void _sim_status_update(CoreObject *o, enum tel_sim_status sim_status);
\r
112 static void on_confirmation_sim_message_send(TcorePending *p, gboolean result, void *user_data ); // from Kernel
\r
114 static void on_confirmation_sim_message_send( TcorePending *p, gboolean result, void *user_data )
\r
116 dbg("on_confirmation_sim_message_send - msg out from queue.\n");
\r
118 if (result == FALSE) {
\r
128 static enum tcore_response_command _find_resp_command(UserRequest *ur)
\r
130 enum tcore_request_command command;
\r
131 command = tcore_user_request_get_command(ur);
\r
133 case TREQ_SIM_VERIFY_PINS:
\r
134 return TRESP_SIM_VERIFY_PINS;
\r
136 case TREQ_SIM_VERIFY_PUKS:
\r
137 return TRESP_SIM_VERIFY_PUKS;
\r
139 case TREQ_SIM_CHANGE_PINS:
\r
140 return TRESP_SIM_CHANGE_PINS;
\r
142 case TREQ_SIM_GET_FACILITY_STATUS:
\r
143 return TRESP_SIM_GET_FACILITY_STATUS;
\r
145 case TREQ_SIM_DISABLE_FACILITY:
\r
146 return TRESP_SIM_DISABLE_FACILITY;
\r
148 case TREQ_SIM_ENABLE_FACILITY:
\r
149 return TRESP_SIM_ENABLE_FACILITY;
\r
151 case TREQ_SIM_GET_LOCK_INFO:
\r
152 return TRESP_SIM_GET_LOCK_INFO;
\r
154 case TREQ_SIM_TRANSMIT_APDU:
\r
155 return TRESP_SIM_TRANSMIT_APDU;
\r
157 case TREQ_SIM_GET_ATR:
\r
158 return TRESP_SIM_GET_ATR;
\r
160 case TREQ_SIM_GET_ECC:
\r
161 return TRESP_SIM_GET_ECC;
\r
163 case TREQ_SIM_GET_LANGUAGE:
\r
164 return TRESP_SIM_GET_LANGUAGE;
\r
166 case TREQ_SIM_SET_LANGUAGE:
\r
167 return TRESP_SIM_SET_LANGUAGE;
\r
169 case TREQ_SIM_GET_ICCID:
\r
170 return TRESP_SIM_GET_ICCID;
\r
172 case TREQ_SIM_GET_MAILBOX:
\r
173 return TRESP_SIM_GET_MAILBOX;
\r
175 case TREQ_SIM_GET_CALLFORWARDING:
\r
176 return TRESP_SIM_GET_CALLFORWARDING;
\r
178 case TREQ_SIM_SET_CALLFORWARDING:
\r
179 return TRESP_SIM_SET_CALLFORWARDING;
\r
181 case TREQ_SIM_GET_MESSAGEWAITING:
\r
182 return TRESP_SIM_GET_MESSAGEWAITING;
\r
184 case TREQ_SIM_GET_CPHS_INFO:
\r
185 return TRESP_SIM_GET_CPHS_INFO;
\r
187 case TREQ_SIM_GET_MSISDN:
\r
188 return TRESP_SIM_GET_MSISDN;
\r
190 case TREQ_SIM_GET_SPN:
\r
191 return TRESP_SIM_GET_SPN;
\r
193 case TREQ_SIM_GET_SPDI:
\r
194 return TRESP_SIM_GET_SPDI;
\r
196 case TREQ_SIM_GET_OPL:
\r
197 return TRESP_SIM_GET_OPL;
\r
199 case TREQ_SIM_GET_PNN:
\r
200 return TRESP_SIM_GET_PNN;
\r
202 case TREQ_SIM_GET_CPHS_NETNAME:
\r
203 return TRESP_SIM_GET_CPHS_NETNAME;
\r
205 case TREQ_SIM_GET_OPLMNWACT:
\r
206 return TRESP_SIM_GET_OPLMNWACT;
\r
208 case TREQ_SIM_REQ_AUTHENTICATION:
\r
209 return TRESP_SIM_REQ_AUTHENTICATION;
\r
214 return TRESP_UNKNOWN;
\r
217 static int _sim_get_current_pin_facility(enum s_sim_sec_op_e op)
\r
220 dbg("current sec_op[%d]", op);
\r
223 case SEC_PIN1_VERIFY :
\r
224 case SEC_PIN1_CHANGE :
\r
225 ret_type = SIM_PTYPE_PIN1;
\r
227 case SEC_PIN2_VERIFY :
\r
228 case SEC_PIN2_CHANGE :
\r
229 ret_type = SIM_PTYPE_PIN2;
\r
231 case SEC_PUK1_VERIFY :
\r
232 ret_type = SIM_PTYPE_PUK1;
\r
234 case SEC_PUK2_VERIFY :
\r
235 ret_type = SIM_PTYPE_PUK2;
\r
237 case SEC_SIM_VERIFY :
\r
238 ret_type = SIM_PTYPE_SIM;
\r
240 case SEC_ADM_VERIFY :
\r
241 ret_type = SIM_PTYPE_ADM;
\r
244 case SEC_PIN1_ENABLE :
\r
245 case SEC_PIN1_DISABLE :
\r
246 case SEC_PIN1_STATUS :
\r
247 ret_type = SIM_FACILITY_SC;
\r
249 case SEC_SIM_ENABLE :
\r
250 case SEC_SIM_DISABLE :
\r
251 case SEC_SIM_STATUS :
\r
252 ret_type = SIM_FACILITY_PS;
\r
254 case SEC_NET_ENABLE :
\r
255 case SEC_NET_DISABLE :
\r
256 case SEC_NET_STATUS :
\r
257 ret_type = SIM_FACILITY_PN;
\r
259 case SEC_NS_ENABLE :
\r
260 case SEC_NS_DISABLE :
\r
261 case SEC_NS_STATUS :
\r
262 ret_type = SIM_FACILITY_PU;
\r
264 case SEC_SP_ENABLE :
\r
265 case SEC_SP_DISABLE :
\r
266 case SEC_SP_STATUS :
\r
267 ret_type = SIM_FACILITY_PP;
\r
269 case SEC_CP_ENABLE :
\r
270 case SEC_CP_DISABLE :
\r
271 case SEC_CP_STATUS :
\r
272 ret_type = SIM_FACILITY_PC;
\r
274 case SEC_FDN_ENABLE :
\r
275 case SEC_FDN_DISABLE :
\r
276 case SEC_FDN_STATUS :
\r
277 ret_type = SIM_FACILITY_FD;
\r
281 dbg("not handled current sec op[%d]",op )
\r
287 static enum tel_sim_access_result _decode_status_word(unsigned short status_word1, unsigned short status_word2)
\r
289 enum tel_sim_access_result rst = SIM_ACCESS_FAILED;
\r
291 if (status_word1 == 0x93 && status_word2 == 0x00)
\r
293 rst = SIM_ACCESS_FAILED;
\r
294 /*Failed SIM request command*/
\r
295 dbg(" error - SIM application toolkit busy [%x][%x]", status_word1, status_word2);
\r
297 else if (status_word1 == 0x94 && status_word2 == 0x00)
\r
299 rst = SIM_ACCESS_FAILED;
\r
300 /*Failed SIM request command*/
\r
301 dbg(" error - No EF Selected [%x][%x]", status_word1, status_word2);
\r
303 else if (status_word1 == 0x94 && status_word2 == 0x02)
\r
305 rst = SIM_ACCESS_FAILED;
\r
306 /*Failed SIM request command*/
\r
307 dbg("error - Out of Range - Invalid address or record number[%x][%x]",
\r
308 status_word1, status_word2);
\r
310 else if (status_word1 == 0x94 && status_word2 == 0x04)
\r
312 rst = SIM_ACCESS_FILE_NOT_FOUND;
\r
313 /*Failed SIM request command*/
\r
314 dbg(" error - File ID not found [%x][%x]", status_word1, status_word2);
\r
316 else if (status_word1 == 0x94 && status_word2 == 0x08)
\r
318 rst = SIM_ACCESS_FAILED; /* MOdem not support */
\r
319 /*Failed SIM request command*/
\r
320 dbg(" error - File is inconsistent with command - Modem not support or USE IPC [%x][%x]",
\r
321 status_word1, status_word2);
\r
323 else if (status_word1 == 0x98 && status_word2 == 0x02)
\r
325 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
326 /*Failed SIM request command*/
\r
327 dbg(" error - CHV not initialized [%x][%x]", status_word1, status_word2);
\r
329 else if (status_word1 == 0x98 && status_word2 == 0x04)
\r
331 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
332 /*Failed SIM request command*/
\r
333 dbg(" error - Access condition not fullfilled [%x][%x]", status_word1, status_word2);
\r
334 dbg(" error -Unsuccessful CHV verification - at least one attempt left [%x][%x]",
\r
335 status_word1, status_word2);
\r
336 dbg(" error - Unsuccessful Unblock CHV - at least one attempt left [%x][%x]",
\r
337 status_word1, status_word2);
\r
338 dbg(" error - Authentication failure [%x][%x]", status_word1, status_word2);
\r
340 else if (status_word1 == 0x98 && status_word2 == 0x08)
\r
342 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
343 /*Failed SIM request command*/
\r
344 dbg(" error - Contradiction with CHV status [%x][%x]", status_word1, status_word2);
\r
346 else if (status_word1 == 0x98 && status_word2 == 0x10)
\r
348 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
349 /*Failed SIM request command*/
\r
350 dbg(" error - Contradiction with invalidation status [%x][%x]",
\r
351 status_word1, status_word2);
\r
353 else if (status_word1 == 0x98 && status_word2 == 0x40)
\r
355 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
356 /*Failed SIM request command*/
\r
357 dbg(" error -Unsuccessful CHV verification - no attempt left [%x][%x]",
\r
358 status_word1, status_word2);
\r
359 dbg(" error - Unsuccessful Unblock CHV - no attempt left [%x][%x]",
\r
360 status_word1, status_word2);
\r
361 dbg(" error - CHV blocked [%x][%x]", status_word1, status_word2);
\r
363 else if (status_word1 == 0x67 && status_word2 == 0x00)
\r
365 rst = SIM_ACCESS_FAILED;
\r
366 dbg(" error -Incorrect Parameter 3 [%x][%x]", status_word1, status_word2);
\r
368 else if (status_word1 == 0x6B && status_word2 == 0x00)
\r
370 rst = SIM_ACCESS_FAILED;
\r
371 dbg(" error -Incorrect Parameter 1 or 2 [%x][%x]", status_word1, status_word2);
\r
373 else if (status_word1 == 0x6D && status_word2 == 0x00)
\r
375 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
376 dbg(" error -Unknown instruction given as command [%x][%x]", status_word1, status_word2);
\r
378 else if (status_word1 == 0x6E && status_word2 == 0x00)
\r
380 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
381 dbg(" error -Unknown instruction given as command [%x][%x]", status_word1, status_word2);
\r
383 else if (status_word1 == 0x69 && status_word2 == 0x82)
\r
385 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;
\r
386 dbg(" error -Access denied [%x][%x]", status_word1, status_word2);
\r
388 else if (status_word1 == 0x6A && status_word2 == 0x87)
\r
390 rst = SIM_ACCESS_FAILED;
\r
391 dbg(" error -Incorrect parameters [%x][%x]", status_word1, status_word2);
\r
393 else if (status_word1 == 0x6A && status_word2 == 0x82)
\r
395 rst = SIM_ACCESS_FILE_NOT_FOUND; // not sure of the SW1 and SW2 meaning here
\r
396 dbg(" error -File Not found [%x][%x]", status_word1, status_word2);
\r
398 else if (status_word1 == 0x6A && status_word2 == 0x83)
\r
400 rst = SIM_ACCESS_FILE_NOT_FOUND; // not sure of the SW1 and SW2 meaning here
\r
401 dbg(" error -Record Not found [%x][%x]", status_word1, status_word2);
\r
405 rst = SIM_ACCESS_CARD_ERROR;
\r
406 dbg(" error -Unknown state [%x][%x]", status_word1, status_word2);
\r
411 static gboolean _sim_check_identity(CoreObject *o, struct tel_sim_imsi *imsi)
\r
414 Storage *strg = NULL;
\r
415 char* old_imsi = NULL;
\r
416 char new_imsi[15+1] = {0,};
\r
418 s = tcore_plugin_ref_server(tcore_object_ref_plugin(o));
\r
421 dbg("there is no valid server at this point");
\r
424 strg = (Storage*)tcore_server_find_storage(s, "vconf");
\r
427 dbg("there is no valid storage plugin");
\r
430 memcpy(&new_imsi, imsi->plmn, strlen(imsi->plmn));
\r
431 memcpy(&new_imsi[strlen(imsi->plmn)], imsi->msin, strlen(imsi->msin));
\r
432 new_imsi[strlen(imsi->plmn)+strlen(imsi->msin)] = '\0';
\r
434 old_imsi = tcore_storage_get_string(strg, STORAGE_KEY_TELEPHONY_IMSI);
\r
435 dbg("old_imsi[%s],newImsi[%s]", old_imsi, new_imsi);
\r
437 if (old_imsi != NULL)
\r
439 if (strncmp(old_imsi, new_imsi, 15) != 0)
\r
442 if (tcore_storage_set_string(strg, STORAGE_KEY_TELEPHONY_IMSI, (const char*) &new_imsi) == FALSE )
\r
444 dbg("[FAIL] UPDATE STORAGE_KEY_TELEPHONY_IMSI");
\r
446 tcore_sim_set_identification(o, TRUE);
\r
451 tcore_sim_set_identification(o, FALSE);
\r
456 dbg("OLD SIM VALUE IS NULL. NEW SIM");
\r
457 if (tcore_storage_set_string(strg, STORAGE_KEY_TELEPHONY_IMSI, (const char*) &new_imsi) == FALSE)
\r
459 dbg("[FAIL] UPDATE STORAGE_KEY_TELEPHONY_IMSI");
\r
461 tcore_sim_set_identification(o, TRUE);
\r
466 static void _next_from_get_file_info(CoreObject *o, UserRequest *ur, enum tel_sim_file_id ef, enum tel_sim_access_result rt )
\r
468 struct tresp_sim_read resp = {0,};
\r
469 struct s_sim_property *file_meta = NULL;
\r
470 dbg("EF[0x%x] access Result[%d]", ef, rt);
\r
473 memset(&resp.data, 0x00, sizeof(resp.data));
\r
474 file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);
\r
476 if ((ef != SIM_EF_ELP && ef != SIM_EF_LP && ef != SIM_EF_USIM_PL && ef != SIM_EF_CPHS_CPHS_INFO )
\r
477 && (rt != SIM_ACCESS_SUCCESS))
\r
479 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read),&resp);
\r
486 if (rt == SIM_ACCESS_SUCCESS)
\r
488 dbg("[SIM DATA] exist EFELP/PL(0x2F05)");
\r
489 /* if (po->language_file == 0x00)
\r
490 po->language_file = SIM_EF_ELP;*/
\r
491 _get_file_data(o, ur, ef, 0, file_meta->data_size);
\r
495 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
497 dbg(" [SIM DATA]SIM_EF_ELP(2F05) access fail. Request SIM_EF_LP(0x6F05) info");
\r
498 /* The ME requests the Language Preference (EFLP) if EFELP is not available */
\r
499 _get_file_info(o, ur, SIM_EF_LP);
\r
501 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
504 " [SIM DATA]fail to get Language information in USIM(EF-LI(6F05),EF-PL(2F05)). Request SIM_EF_ECC(0x6FB7) info");
\r
505 /* EFELPand EFLI not present at this point. */
\r
506 /* po->language.lang_cnt = 0;*/
\r
507 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
508 sizeof(struct tresp_sim_read), &resp);
\r
514 case SIM_EF_LP: //same with SIM_EF_USIM_LI
\r
515 if (rt == SIM_ACCESS_SUCCESS)
\r
517 dbg("[SIM DATA] exist EFLP/LI(0x6F05)");
\r
518 _get_file_data(o, ur, ef, 0, file_meta->data_size);
\r
522 dbg("[SIM DATA]SIM_EF_LP/LI(6F05) access fail. Current CardType[%d]",
\r
523 tcore_sim_get_type(o));
\r
524 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
526 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
527 sizeof(struct tresp_sim_read), &resp);
\r
530 /* if EFLI is not present, then the language selection shall be as defined in EFPL at the MF level */
\r
531 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
533 dbg("[SIM DATA] try USIM EFPL(0x2F05)");
\r
534 _get_file_info(o, ur, SIM_EF_ELP);
\r
539 case SIM_EF_USIM_PL:
\r
540 if (rt == SIM_ACCESS_SUCCESS)
\r
542 dbg("[SIM DATA] exist EFELP/PL(0x2F05)");
\r
543 _get_file_data(o, ur, SIM_EF_ELP, 0, file_meta->data_size);
\r
547 /* EFELIand EFPL not present, so set language count as zero and select ECC */
\r
549 " [SIM DATA]SIM_EF_USIM_PL(2A05) access fail. Request SIM_EF_ECC(0x6FB7) info");
\r
550 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
551 sizeof(struct tresp_sim_read), &resp);
\r
557 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
559 _get_file_data(o, ur, ef, 0, file_meta->data_size);
\r
561 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
563 if (file_meta->rec_count > SIM_ECC_RECORD_CNT_MAX)
\r
565 file_meta->rec_count = SIM_ECC_RECORD_CNT_MAX;
\r
568 file_meta->current_index++;
\r
569 _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);
\r
578 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:
\r
579 case SIM_EF_CPHS_VOICE_MSG_WAITING:
\r
580 case SIM_EF_CPHS_OPERATOR_NAME_STRING:
\r
581 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:
\r
582 case SIM_EF_CPHS_DYNAMICFLAGS:
\r
583 case SIM_EF_CPHS_DYNAMIC2FLAG:
\r
584 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE:
\r
585 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE_LINE2:
\r
586 _get_file_data(o, ur, ef, 0, file_meta->data_size);
\r
589 case SIM_EF_CPHS_CPHS_INFO:
\r
590 if (rt == SIM_ACCESS_SUCCESS)
\r
592 tcore_sim_set_cphs_status(o, TRUE);
\r
593 if (!tcore_user_request_ref_communicator(ur))
\r
595 dbg("internal CPHS INFO request before sim status update");
\r
596 _sim_status_update(o, SIM_STATUS_INIT_COMPLETED);
\r
599 dbg("external CPHS INFO request");
\r
600 _get_file_data(o, ur, ef, 0, file_meta->data_size);
\r
604 tcore_sim_set_cphs_status(o, FALSE);
\r
605 if (!tcore_user_request_ref_communicator(ur))
\r
607 dbg("internal CPHS INFO request before sim status update");
\r
608 _sim_status_update(o, SIM_STATUS_INIT_COMPLETED);
\r
611 dbg("external CPHS INFO request");
\r
612 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
613 sizeof(struct tresp_sim_read), &resp);
\r
619 case SIM_EF_USIM_CFIS:
\r
620 if (file_meta->rec_count > SIM_CF_RECORD_CNT_MAX)
\r
622 file_meta->rec_count = SIM_CF_RECORD_CNT_MAX;
\r
624 file_meta->current_index++;
\r
625 _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);
\r
630 case SIM_EF_USIM_MWIS:
\r
631 case SIM_EF_USIM_MBI:
\r
633 case SIM_EF_CPHS_MAILBOX_NUMBERS:
\r
634 case SIM_EF_CPHS_INFORMATION_NUMBERS:
\r
635 file_meta->current_index++;
\r
636 _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);
\r
640 dbg( "error - File id for get file info [0x%x]", ef);
\r
646 static void _next_from_get_file_data(CoreObject *o, UserRequest *ur, enum tel_sim_access_result rt, int decode_ret)
\r
648 struct s_sim_property *file_meta = NULL;
\r
651 file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);
\r
652 dbg("[SIM]EF[0x%x] read rt[%d] Decode rt[%d]", file_meta->file_id, rt, decode_ret);
\r
653 switch (file_meta->file_id)
\r
656 case SIM_EF_USIM_PL:
\r
658 case SIM_EF_USIM_LI:
\r
659 if (decode_ret == TRUE)
\r
661 if (file_meta->file_id == SIM_EF_LP || file_meta->file_id == SIM_EF_USIM_LI)
\r
663 /* po->language_file = SIM_EF_LP;*/
\r
664 } else if (file_meta->file_id == SIM_EF_ELP || file_meta->file_id == SIM_EF_USIM_PL)
\r
666 /* po->language_file = SIM_EF_ELP;*/
\r
668 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
672 /* The ME requests the Extended Language Preference. The ME only requests the Language Preference (EFLP) if at least one of the following conditions holds:
\r
673 - EFELP is not available;
\r
674 - EFELP does not contain an entry corresponding to a language specified in ISO 639[30];
\r
675 - the ME does not support any of the languages in EFELP.
\r
678 /* The ME only requests the Language Preference (EFPL) if at least one of the following conditions holds:
\r
679 - if the EFLI has the value 'FFFF' in its highest priority position
\r
680 - if the ME does not support any of the language codes indicated in EFLI , or if EFLI is not present
\r
682 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
684 if (file_meta->file_id == SIM_EF_LP)
\r
686 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
690 _get_file_info(o, ur, SIM_EF_LP);
\r
692 } else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
695 if (file_meta->file_id == SIM_EF_LP || file_meta->file_id == SIM_EF_USIM_LI)
\r
697 _get_file_info(o, ur, SIM_EF_ELP);
\r
701 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
708 if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
710 if (file_meta->current_index == file_meta->rec_count)
\r
712 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
715 file_meta->current_index++;
\r
716 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );
\r
718 } else if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
720 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
723 dbg("[SIM DATA]Invalid CardType[%d] Unable to handle", tcore_sim_get_type(o));
\r
728 ur = tcore_user_request_new(NULL, NULL); //this is for using ur metainfo set/ref functionality.
\r
729 _get_file_info(o, ur, SIM_EF_CPHS_CPHS_INFO);
\r
732 case SIM_EF_MSISDN:
\r
733 if (file_meta->current_index == file_meta->rec_count)
\r
735 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
738 file_meta->current_index++;
\r
739 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );
\r
744 if (file_meta->current_index == file_meta->rec_count)
\r
746 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
749 file_meta->current_index++;
\r
750 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );
\r
755 if (file_meta->current_index == file_meta->rec_count)
\r
757 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
760 file_meta->current_index++;
\r
761 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );
\r
765 case SIM_EF_USIM_CFIS:
\r
766 case SIM_EF_USIM_MWIS:
\r
767 case SIM_EF_USIM_MBI:
\r
769 case SIM_EF_CPHS_MAILBOX_NUMBERS:
\r
770 case SIM_EF_CPHS_INFORMATION_NUMBERS:
\r
771 if (file_meta->current_index == file_meta->rec_count)
\r
773 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
776 file_meta->current_index++;
\r
777 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );
\r
781 case SIM_EF_CPHS_OPERATOR_NAME_STRING:
\r
782 file_meta->files.result = rt;
\r
783 if (decode_ret == TRUE && rt == SIM_ACCESS_SUCCESS)
\r
785 memcpy(file_meta->files.data.cphs_net.full_name, file_meta->files.data.cphs_net.full_name, strlen((char*)file_meta->files.data.cphs_net.full_name));
\r
787 _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING);
\r
790 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:
\r
791 if (file_meta->files.result == SIM_ACCESS_SUCCESS || file_meta->files.result == SIM_ACCESS_SUCCESS)
\r
793 file_meta->files.result = SIM_ACCESS_SUCCESS;
\r
795 if (strlen((char*)file_meta->files.data.cphs_net.full_name))
\r
797 memcpy(&file_meta->files.data.cphs_net.full_name, &file_meta->files.data.cphs_net.full_name, strlen((char*)file_meta->files.data.cphs_net.full_name));
\r
799 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
806 case SIM_EF_OPLMN_ACT:
\r
807 case SIM_EF_CPHS_CPHS_INFO :
\r
808 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:
\r
809 case SIM_EF_CPHS_VOICE_MSG_WAITING:
\r
810 case SIM_EF_CPHS_DYNAMICFLAGS:
\r
811 case SIM_EF_CPHS_DYNAMIC2FLAG:
\r
812 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE:
\r
813 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE_LINE2:
\r
814 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read), &file_meta->files);
\r
818 dbg("File id not handled [0x%x]", file_meta->file_id);
\r
823 static void _sim_status_update(CoreObject *o, enum tel_sim_status sim_status)
\r
825 struct tnoti_sim_status noti_data = {0,};
\r
827 dbg("tcore_sim_set_status and send noti w/ [%d]", sim_status);
\r
828 tcore_sim_set_status(o, sim_status);
\r
829 noti_data.sim_status = sim_status;
\r
830 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_SIM_STATUS,
\r
831 sizeof(struct tnoti_sim_status), ¬i_data);
\r
834 static void _response_get_sim_type(TcorePending *p, int data_len, const void *data, void *user_data)
\r
836 const TcoreATResponse *resp = data;
\r
837 UserRequest *ur = NULL;
\r
838 CoreObject *co_sim = NULL;
\r
839 struct s_sim_property *sp = NULL;
\r
840 GSList *tokens=NULL;
\r
841 enum tel_sim_type sim_type = SIM_TYPE_UNKNOWN;
\r
845 dbg(" Function entry ");
\r
847 co_sim = tcore_pending_ref_core_object(p);
\r
848 sp = tcore_sim_ref_userdata(co_sim);
\r
849 ur = tcore_pending_ref_user_request(p);
\r
851 if(resp->success > 0)
\r
853 dbg("RESPONSE OK");
\r
856 line = (const char*)resp->lines->data;
\r
857 tokens = tcore_at_tok_new(line);
\r
858 if (g_slist_length(tokens) != 1)
\r
860 msg("invalid message");
\r
861 tcore_at_tok_free(tokens);
\r
865 state = atoi(g_slist_nth_data(tokens, 0));
\r
866 dbg("SIM Type is %d", state);
\r
870 sim_type = SIM_TYPE_GSM;
\r
871 }else if(state == 1)
\r
873 sim_type = SIM_TYPE_USIM;
\r
876 sim_type = SIM_TYPE_UNKNOWN;
\r
882 dbg("RESPONSE NOK");
\r
883 sim_type = SIM_TYPE_UNKNOWN;
\r
886 tcore_sim_set_type(co_sim, sim_type);
\r
887 _sim_status_update(co_sim, sp->first_recv_status);
\r
888 tcore_at_tok_free(tokens);
\r
889 dbg(" Function exit");
\r
892 static void _response_get_file_info(TcorePending *p, int data_len, const void *data, void *user_data)
\r
894 const TcoreATResponse *resp = data;
\r
895 UserRequest *ur = NULL;
\r
896 CoreObject *co_sim = NULL;
\r
897 struct s_sim_property *file_meta = NULL;
\r
898 GSList *tokens=NULL;
\r
899 enum tel_sim_access_result rt;
\r
900 const char *line = NULL;
\r
904 dbg(" Function entry ");
\r
906 co_sim = tcore_pending_ref_core_object(p);
\r
907 ur = tcore_pending_ref_user_request(p);
\r
908 file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);
\r
910 if(resp->success > 0)
\r
912 dbg("RESPONSE OK");
\r
915 line = (const char*)resp->lines->data;
\r
916 tokens = tcore_at_tok_new(line);
\r
917 if (g_slist_length(tokens) < 2)
\r
919 err("invalid message");
\r
920 tcore_at_tok_free(tokens);
\r
924 sw1 = atoi(g_slist_nth_data(tokens, 0));
\r
925 sw2 = atoi(g_slist_nth_data(tokens, 1));
\r
927 /*1. SIM access success case*/
\r
928 if ((sw1 == 0x90 && sw2 == 0x00) || sw1 == 0x91) {
\r
929 unsigned char tag_len = 0; /* 1 or 2 bytes ??? */
\r
930 unsigned short record_len = 0;
\r
931 char num_of_records = 0;
\r
932 unsigned char file_id_len = 0;
\r
933 unsigned short file_id = 0;
\r
934 unsigned short file_size = 0;
\r
935 unsigned short file_type = 0;
\r
936 unsigned short arr_file_id = 0;
\r
937 int arr_file_id_rec_num = 0;
\r
939 /* handling only last 3 bits */
\r
940 unsigned char file_type_tag = 0x07;
\r
941 unsigned char *ptr_data;
\r
945 char *recordData = NULL;
\r
946 hexData = g_slist_nth_data(tokens, 2);
\r
947 dbg("hexData: %s", hexData);
\r
948 dbg("hexData: %s", hexData+1);
\r
950 tmp = calloc(1, strlen(hexData)-1);
\r
951 memcpy(tmp, hexData+1, strlen(hexData)-2);
\r
952 dbg("tmp: %s", tmp);
\r
954 recordData = util_hexStringToBytes(tmp);
\r
955 dbg("recordData: %x", recordData);
\r
957 util_hex_dump(" ", strlen(hexData)/2, recordData);
\r
959 ptr_data = (unsigned char *)recordData;
\r
960 if (tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)
\r
963 ETSI TS 102 221 v7.9.0
\r
965 '62' FCP template tag
\r
966 - Response for an EF
\r
967 '82' M File Descriptor
\r
968 '83' M File Identifier
\r
969 'A5' O Proprietary information
\r
970 '8A' M Life Cycle Status Integer
\r
971 '8B', '8C' or 'AB' C1 Security attributes
\r
973 '81' O Total file size
\r
974 '88' O Short File Identifier (SFI)
\r
977 /* rsim.res_len has complete data length received */
\r
979 /* FCP template tag - File Control Parameters tag*/
\r
980 if (*ptr_data == 0x62)
\r
982 /* parse complete FCP tag*/
\r
983 /* increment to next byte */
\r
985 tag_len = *ptr_data++;
\r
986 dbg("tag_len: %02x", tag_len);
\r
987 /* FCP file descriptor - file type, accessibility, DF, ADF etc*/
\r
988 if (*ptr_data == 0x82)
\r
990 /* increment to next byte */
\r
994 /* unsigned char file_desc_len = *ptr_data++;*/
\r
995 /* dbg("file descriptor length: [%d]", file_desc_len);*/
\r
996 /* TBD: currently capture only file type : ignore sharable, non sharable, working, internal etc*/
\r
997 /* consider only last 3 bits*/
\r
998 dbg("file_type_tag: %02x", file_type_tag);
\r
999 file_type_tag = file_type_tag & (*ptr_data);
\r
1000 dbg("file_type_tag: %02x", file_type_tag);
\r
1002 switch (file_type_tag)
\r
1004 /* increment to next byte */
\r
1007 dbg("Getting FileType: [Transparent file type]");
\r
1008 file_type = SIM_FTYPE_TRANSPARENT;
\r
1010 /* increment to next byte */
\r
1012 /* increment to next byte */
\r
1017 dbg("Getting FileType: [Linear fixed file type]");
\r
1018 /* increment to next byte */
\r
1020 /* data coding byte - value 21 */
\r
1023 memcpy(&record_len, ptr_data, 2);
\r
1025 SWAPBYTES16(record_len);
\r
1026 ptr_data = ptr_data + 2;
\r
1027 num_of_records = *ptr_data++;
\r
1028 /* Data lossy conversation from enum (int) to unsigned char */
\r
1029 file_type = SIM_FTYPE_LINEAR_FIXED;
\r
1033 dbg(" Cyclic fixed file type");
\r
1034 /* increment to next byte */
\r
1036 /* data coding byte - value 21 */
\r
1039 memcpy(&record_len, ptr_data, 2);
\r
1041 SWAPBYTES16(record_len);
\r
1042 ptr_data = ptr_data + 2;
\r
1043 num_of_records = *ptr_data++;
\r
1044 file_type = SIM_FTYPE_CYCLIC;
\r
1048 dbg("not handled file type [0x%x]", *ptr_data);
\r
1053 dbg("INVALID FCP received - DEbug!");
\r
1057 /*File identifier - file id?? */ // 0x84,0x85,0x86 etc are currently ignored and not handled
\r
1058 if (*ptr_data == 0x83)
\r
1060 /* increment to next byte */
\r
1062 file_id_len = *ptr_data++;
\r
1063 dbg("file_id_len: %02x", file_id_len);
\r
1065 memcpy(&file_id, ptr_data, file_id_len);
\r
1066 dbg("file_id: %x", file_id);
\r
1069 SWAPBYTES16(file_id);
\r
1070 dbg("file_id: %x", file_id);
\r
1072 ptr_data = ptr_data + 2;
\r
1073 dbg("Getting FileID=[0x%x]", file_id);
\r
1076 dbg("INVALID FCP received - DEbug!");
\r
1081 /* proprietary information */
\r
1082 if (*ptr_data == 0xA5)
\r
1084 unsigned short prop_len;
\r
1085 /* increment to next byte */
\r
1089 prop_len = *ptr_data;
\r
1090 dbg("prop_len: %02x", prop_len);
\r
1093 ptr_data = ptr_data + prop_len + 1;
\r
1096 dbg("INVALID FCP received - DEbug!");
\r
1099 /* life cycle status integer [8A][length:0x01][status]*/
\r
1102 00000000 : No information given
\r
1103 00000001 : creation state
\r
1104 00000011 : initialization state
\r
1105 000001-1 : operation state -activated
\r
1106 000001-0 : operation state -deactivated
\r
1107 000011-- : Termination state
\r
1108 b8~b5 !=0, b4~b1=X : Proprietary
\r
1109 Any other value : RFU
\r
1111 if (*ptr_data == 0x8A)
\r
1113 /* increment to next byte */
\r
1115 /* length - value 1 */
\r
1118 switch (*ptr_data) {
\r
1121 dbg("<RX> operation state -deactivated");
\r
1126 dbg("<RX> operation state -activated");
\r
1130 dbg("<RX> DEBUG! LIFE CYCLE STATUS =[0x%x]",*ptr_data);
\r
1136 /* related to security attributes : currently not handled*/
\r
1137 if (*ptr_data == 0x86 || *ptr_data == 0x8B || *ptr_data == 0x8C || *ptr_data == 0xAB)
\r
1139 /* increment to next byte */
\r
1141 /* if tag length is 3 */
\r
1142 if (*ptr_data == 0x03)
\r
1144 /* increment to next byte */
\r
1146 /* EFARR file id */
\r
1147 memcpy(&arr_file_id, ptr_data, 2);
\r
1149 SWAPBYTES16(arr_file_id);
\r
1150 ptr_data = ptr_data + 2;
\r
1151 arr_file_id_rec_num = *ptr_data++;
\r
1154 /* if tag length is not 3 */
\r
1155 /* ignoring bytes */
\r
1156 // ptr_data = ptr_data + 4;
\r
1157 dbg("Useless security attributes, so jump to next tag");
\r
1158 ptr_data = ptr_data + (*ptr_data + 1);
\r
1162 dbg("INVALID FCP received[0x%x] - DEbug!", *ptr_data);
\r
1167 dbg("Current ptr_data value is [%x]", *ptr_data);
\r
1169 /* file size excluding structural info*/
\r
1170 if (*ptr_data == 0x80)
\r
1172 /* for EF file size is body of file and for Linear or cyclic it is
\r
1173 * number of recXsizeof(one record)
\r
1175 /* increment to next byte */
\r
1177 /* length is 1 byte - value is 2 bytes or more */
\r
1179 memcpy(&file_size, ptr_data, 2);
\r
1181 SWAPBYTES16(file_size);
\r
1182 ptr_data = ptr_data + 2;
\r
1185 dbg("INVALID FCP received - DEbug!");
\r
1190 /* total file size including structural info*/
\r
1191 if (*ptr_data == 0x81)
\r
1194 /* increment to next byte */
\r
1198 /* ignored bytes */
\r
1199 ptr_data = ptr_data + 3;
\r
1202 dbg("INVALID FCP received - DEbug!");
\r
1203 /* 0x81 is optional tag?? check out! so do not return -1 from here! */
\r
1206 /*short file identifier ignored*/
\r
1207 if (*ptr_data == 0x88)
\r
1209 dbg("0x88: Do Nothing");
\r
1214 dbg("INVALID FCP received - DEbug!");
\r
1218 } else if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)
\r
1220 unsigned char gsm_specific_file_data_len = 0;
\r
1221 /* ignore RFU byte1 and byte2 */
\r
1225 //file_size = p_info->response_len;
\r
1226 memcpy(&file_size, ptr_data, 2);
\r
1228 SWAPBYTES16(file_size);
\r
1229 /* parsed file size */
\r
1230 ptr_data = ptr_data + 2;
\r
1232 memcpy(&file_id, ptr_data, 2);
\r
1233 SWAPBYTES16(file_id);
\r
1234 dbg(" FILE id --> [%x]", file_id);
\r
1235 ptr_data = ptr_data + 2;
\r
1236 /* save file type - transparent, linear fixed or cyclic */
\r
1237 file_type_tag = (*(ptr_data + 7));
\r
1239 switch (*ptr_data)
\r
1242 /* RFU file type */
\r
1243 dbg(" RFU file type- not handled - Debug!");
\r
1246 /* MF file type */
\r
1247 dbg(" MF file type - not handled - Debug!");
\r
1250 /* DF file type */
\r
1251 dbg(" DF file type - not handled - Debug!");
\r
1254 /* EF file type */
\r
1255 dbg(" EF file type [%d] ", file_type_tag);
\r
1256 /* increment to next byte */
\r
1259 if (file_type_tag == 0x00 || file_type_tag == 0x01)
\r
1261 /* increament to next byte as this byte is RFU */
\r
1264 (file_type_tag == 0x00) ? SIM_FTYPE_TRANSPARENT : SIM_FTYPE_LINEAR_FIXED;
\r
1267 /* increment to next byte */
\r
1269 /* For a cyclic EF all bits except bit 7 are RFU; b7=1 indicates that */
\r
1270 /* the INCREASE command is allowed on the selected cyclic file. */
\r
1271 file_type = SIM_FTYPE_CYCLIC;
\r
1273 /* bytes 9 to 11 give SIM file access conditions */
\r
1275 /* byte 10 has one nibble that is RF U and another for INCREASE which is not used currently */
\r
1277 /* byte 11 is invalidate and rehabilate nibbles */
\r
1279 /* byte 12 - file status */
\r
1281 /* byte 13 - GSM specific data */
\r
1282 gsm_specific_file_data_len = *ptr_data;
\r
1284 /* byte 14 - structure of EF - transparent or linear or cyclic , already saved above */
\r
1286 /* byte 15 - length of record for linear and cyclic , for transparent it is set to 0x00. */
\r
1287 record_len = *ptr_data;
\r
1288 dbg("record length[%d], file size[%d]", record_len, file_size);
\r
1290 if (record_len != 0)
\r
1291 num_of_records = (file_size / record_len);
\r
1293 dbg("Number of records [%d]", num_of_records);
\r
1297 dbg(" not handled file type");
\r
1303 dbg(" Card Type - UNKNOWN [%d]", tcore_sim_get_type(co_sim));
\r
1306 dbg("req ef[0x%x] resp ef[0x%x] size[%ld] Type[0x%x] NumOfRecords[%ld] RecordLen[%ld]",
\r
1307 file_meta->file_id, file_id, file_size, file_type, num_of_records, record_len);
\r
1309 file_meta->file_type = file_type;
\r
1310 file_meta->data_size = file_size;
\r
1311 file_meta->rec_length = record_len;
\r
1312 file_meta->rec_count = num_of_records;
\r
1313 file_meta->current_index = 0; //reset for new record type EF
\r
1314 rt = SIM_ACCESS_SUCCESS;
\r
1319 /*2. SIM access fail case*/
\r
1320 dbg("error to get ef[0x%x]", file_meta->file_id);
\r
1321 dbg("error to get ef[0x%x] (file_meta->file_id) ", file_meta->file_id);
\r
1322 rt = _decode_status_word(sw1, sw2);
\r
1324 ur = tcore_user_request_ref(ur);
\r
1326 dbg("Calling _next_from_get_file_info");
\r
1327 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);
\r
1328 tcore_at_tok_free(tokens);
\r
1332 dbg("RESPONSE NOK");
\r
1333 dbg("error to get ef[0x%x]", file_meta->file_id);
\r
1334 dbg("error to get ef[0x%x] (file_meta->file_id) ", file_meta->file_id);
\r
1335 rt = SIM_ACCESS_FAILED;
\r
1337 ur = tcore_user_request_ref(ur);
\r
1338 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);
\r
1340 dbg(" Function exit");
\r
1343 static void _response_get_file_data(TcorePending *p, int data_len, const void *data, void *user_data)
\r
1345 const TcoreATResponse *resp = data;
\r
1346 UserRequest *ur = NULL;
\r
1347 CoreObject *co_sim = NULL;
\r
1348 struct s_sim_property *file_meta = NULL;
\r
1349 GSList *tokens=NULL;
\r
1350 enum tel_sim_access_result rt;
\r
1351 struct tel_sim_imsi imsi;
\r
1352 struct tel_sim_ecc ecc;
\r
1353 struct tel_sim_msisdn msisdn;
\r
1354 struct tel_sim_opl opl;
\r
1355 struct tel_sim_pnn pnn;
\r
1356 gboolean dr = FALSE;
\r
1357 const char *line = NULL;
\r
1364 dbg(" Function entry ");
\r
1366 co_sim = tcore_pending_ref_core_object(p);
\r
1367 ur = tcore_pending_ref_user_request(p);
\r
1368 file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);
\r
1370 if(resp->success > 0)
\r
1372 dbg("RESPONSE OK");
\r
1375 line = (const char*)resp->lines->data;
\r
1376 tokens = tcore_at_tok_new(line);
\r
1377 if (g_slist_length(tokens) != 3)
\r
1379 msg("invalid message");
\r
1380 tcore_at_tok_free(tokens);
\r
1384 sw1 = atoi(g_slist_nth_data(tokens, 0));
\r
1385 sw2 = atoi(g_slist_nth_data(tokens, 1));
\r
1386 res = g_slist_nth_data(tokens, 2);
\r
1388 res_len = strlen((const char*)res);
\r
1389 tmp = calloc(1, res_len-1);
\r
1390 memcpy(tmp, res+1, res_len-2);
\r
1391 dbg("tmp: %s", tmp);
\r
1393 res = util_hexStringToBytes(tmp);
\r
1394 res_len = strlen((const char*)res);
\r
1395 dbg("res: %s res_len: %d", res, res_len);
\r
1397 if((sw1 == 0x90 && sw2 == 0x00) || sw1 == 0x91)
\r
1399 rt = SIM_ACCESS_SUCCESS;
\r
1400 file_meta->files.result = rt;
\r
1401 dbg("file_meta->file_id : %x", file_meta->file_id);
\r
1403 switch (file_meta->file_id)
\r
1407 dbg("res: %s", res);
\r
1408 dr = tcore_sim_decode_imsi(&imsi, (unsigned char*)res, res_len);
\r
1411 dbg("imsi decoding failed");
\r
1414 _sim_check_identity(co_sim,&imsi);
\r
1415 tcore_sim_set_imsi(co_sim,&imsi);
\r
1419 case SIM_EF_ICCID:
\r
1420 dr = tcore_sim_decode_iccid(&file_meta->files.data.iccid, (unsigned char*)res, res_len);
\r
1423 case SIM_EF_ELP:/* 2G EF - 2 bytes decoding*/
\r
1424 case SIM_EF_USIM_LI: /* 3G EF - 2 bytes decoding*/
\r
1425 case SIM_EF_USIM_PL:/* 3G EF - same as EFELP, so 2 byte decoding*/
\r
1426 case SIM_EF_LP:/* 1 byte encoding*/
\r
1427 if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM && file_meta->file_id == SIM_EF_LP)
\r
1429 /*2G LP(0x6F05) has 1 byte for each language*/
\r
1430 dr = tcore_sim_decode_lp(&file_meta->files.data.language, (unsigned char*)res, res_len);
\r
1433 /*3G LI(0x6F05)/PL(0x2F05), 2G ELP(0x2F05) has 2 bytes for each language*/
\r
1434 dr = tcore_sim_decode_li(file_meta->file_id, &file_meta->files.data.language, (unsigned char*)res, res_len);
\r
1438 dr = tcore_sim_decode_spn(&file_meta->files.data.spn, (unsigned char*)res, res_len);
\r
1441 dr = tcore_sim_decode_spdi(&file_meta->files.data.spdi, (unsigned char*)res, res_len);
\r
1444 if(tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)
\r
1446 dr = tcore_sim_decode_ecc(&file_meta->files.data.ecc, (unsigned char*)res, res_len);
\r
1447 } else if(tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)
\r
1449 dbg("decode w/ index [%d]",file_meta->current_index);
\r
1450 memset(&ecc, 0x00, sizeof(struct tel_sim_ecc));
\r
1451 dr = tcore_sim_decode_uecc(&ecc, (unsigned char*)res, res_len);
\r
1454 memcpy( &file_meta->files.data.ecc.ecc[file_meta->files.data.ecc.ecc_count], &ecc, sizeof(struct tel_sim_ecc) );
\r
1455 file_meta->files.data.ecc.ecc_count++;
\r
1459 dbg("err not handled tcore_sim_get_type(o)[%d] in here",tcore_sim_get_type(co_sim));
\r
1462 case SIM_EF_MSISDN :
\r
1463 dbg("decode w/ index [%d]",file_meta->current_index);
\r
1464 memset(&msisdn, 0x00, sizeof(struct tel_sim_msisdn));
\r
1465 dr = tcore_sim_decode_msisdn(&msisdn, (unsigned char*)res, res_len);
\r
1468 memcpy( &file_meta->files.data.msisdn_list.msisdn[file_meta->files.data.msisdn_list.count], &msisdn, sizeof(struct tel_sim_msisdn) );
\r
1469 file_meta->files.data.msisdn_list.count++;
\r
1473 dbg("decode w/ index [%d]",file_meta->current_index);
\r
1474 memset(&opl, 0x00, sizeof(struct tel_sim_opl));
\r
1475 dr = tcore_sim_decode_opl(&opl, (unsigned char*)res, res_len);
\r
1478 memcpy( &file_meta->files.data.opl.opl[file_meta->files.data.opl.opl_count], &opl, sizeof(struct tel_sim_opl) );
\r
1479 file_meta->files.data.opl.opl_count++;
\r
1483 dbg("decode w/ index [%d]",file_meta->current_index);
\r
1484 memset(&pnn, 0x00, sizeof(struct tel_sim_pnn));
\r
1485 dr = tcore_sim_decode_pnn(&pnn, (unsigned char*)res, res_len);
\r
1488 memcpy( &file_meta->files.data.pnn.pnn[file_meta->files.data.pnn.pnn_count], &opl, sizeof(struct tel_sim_pnn) );
\r
1489 file_meta->files.data.pnn.pnn_count++;
\r
1492 case SIM_EF_OPLMN_ACT:
\r
1493 dr = tcore_sim_decode_oplmnwact(&file_meta->files.data.opwa, (unsigned char*)res, res_len);
\r
1495 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:
\r
1496 dr = tcore_sim_decode_cff(&file_meta->files.data.cf, (unsigned char*)res, res_len);
\r
1498 case SIM_EF_CPHS_VOICE_MSG_WAITING:
\r
1499 dr = tcore_sim_decode_vmwf(&file_meta->files.data.mw.mw_data_u.cphs_mw, (unsigned char*)res, res_len);
\r
1501 case SIM_EF_USIM_MWIS:
\r
1502 dr = tcore_sim_decode_mwis(&file_meta->files.data.mw.mw_data_u.mw, (unsigned char*)res, res_len);
\r
1504 case SIM_EF_USIM_CFIS:
\r
1505 dr = tcore_sim_decode_cfis(&file_meta->files.data.cf, (unsigned char*)res, res_len);
\r
1507 case SIM_EF_CPHS_SERVICE_STRING_TABLE:
\r
1508 dbg(" not handled -SIM_EF_CPHS_SERVICE_STRING_TABLE ");
\r
1510 case SIM_EF_CPHS_OPERATOR_NAME_STRING:
\r
1511 dr = tcore_sim_decode_ons((unsigned char*)&file_meta->files.data.cphs_net.full_name, (unsigned char*)res, res_len);
\r
1512 dbg(" file_meta->files.result[%d],file_meta->files.data.cphs_net.full_name[%s]", file_meta->files.result, file_meta->files.data.cphs_net.full_name);
\r
1514 case SIM_EF_CPHS_CPHS_INFO:
\r
1515 dr = tcore_sim_decode_cphs_info(&file_meta->files.data.cphs, (unsigned char*)res, res_len);
\r
1517 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:
\r
1518 dr = tcore_sim_decode_short_ons((unsigned char*)&file_meta->files.data.cphs_net.short_name, (unsigned char*)res, res_len);
\r
1521 dbg("File Decoding Failed - not handled File[0x%x]", file_meta->file_id);
\r
1528 rt = _decode_status_word(sw1, sw2);
\r
1529 file_meta->files.result = rt;
\r
1532 tcore_at_tok_free(tokens);
\r
1536 dbg("RESPONSE NOK");
\r
1537 dbg("error to get ef[0x%x]", file_meta->file_id);
\r
1538 rt = SIM_ACCESS_FAILED;
\r
1540 ur = tcore_user_request_ref(ur);
\r
1542 dbg("Calling _next_from_get_file_data");
\r
1543 _next_from_get_file_data(tcore_pending_ref_core_object(p), ur, rt, dr);
\r
1544 dbg(" Function exit");
\r
1547 static void _on_response_get_retry_count(TcorePending *p, int data_len, const void *data, void *user_data)
\r
1549 const TcoreATResponse *resp = data;
\r
1550 UserRequest *ur = NULL;
\r
1551 CoreObject *co_sim = NULL;
\r
1552 struct s_sim_property *sp = NULL;
\r
1553 GSList *tokens=NULL;
\r
1554 const char *line = NULL;
\r
1555 struct tresp_sim_verify_pins v_pin = {0,};
\r
1556 struct tresp_sim_verify_puks v_puk = {0,};
\r
1557 struct tresp_sim_change_pins change_pin = {0,};
\r
1558 struct tresp_sim_disable_facility dis_facility = {0,};
\r
1559 struct tresp_sim_enable_facility en_facility = {0,};
\r
1560 int lock_type = 0;
\r
1561 int attempts_left = 0;
\r
1562 int time_penalty = 0;
\r
1564 dbg(" Function entry ");
\r
1566 co_sim = tcore_pending_ref_core_object(p);
\r
1567 sp = tcore_sim_ref_userdata(co_sim);
\r
1568 ur = tcore_pending_ref_user_request(p);
\r
1570 if(resp->success > 0)
\r
1572 dbg("RESPONSE OK");
\r
1575 line = (const char*)resp->lines->data;
\r
1576 tokens = tcore_at_tok_new(line);
\r
1577 if (g_slist_length(tokens) < 3)
\r
1579 msg("invalid message");
\r
1580 tcore_at_tok_free(tokens);
\r
1584 lock_type = atoi(g_slist_nth_data(tokens, 0));
\r
1585 attempts_left = atoi(g_slist_nth_data(tokens, 1));
\r
1586 time_penalty = atoi(g_slist_nth_data(tokens, 2));
\r
1588 dbg("lock_type = %d, attempts_left = %d, time_penalty = %d",
\r
1589 lock_type,attempts_left,time_penalty);
\r
1591 switch (sp->current_sec_op)
\r
1593 case SEC_PIN1_VERIFY:
\r
1594 case SEC_PIN2_VERIFY:
\r
1595 case SEC_SIM_VERIFY:
\r
1596 case SEC_ADM_VERIFY:
\r
1597 v_pin.result = SIM_INCORRECT_PASSWORD;
\r
1598 v_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
1599 v_pin.retry_count = attempts_left;
\r
1600 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
1601 sizeof(struct tresp_sim_verify_pins), &v_pin);
\r
1603 case SEC_PUK1_VERIFY:
\r
1604 case SEC_PUK2_VERIFY:
\r
1605 v_puk.result = SIM_INCORRECT_PASSWORD;
\r
1606 v_puk.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
1607 v_puk.retry_count = attempts_left;
\r
1608 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
1609 sizeof(struct tresp_sim_verify_puks), &v_puk);
\r
1611 case SEC_PIN1_CHANGE:
\r
1612 case SEC_PIN2_CHANGE:
\r
1613 change_pin.result = SIM_INCORRECT_PASSWORD;
\r
1614 change_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
1615 change_pin.retry_count = attempts_left;
\r
1616 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
1617 sizeof(struct tresp_sim_change_pins), &change_pin);
\r
1619 case SEC_PIN1_DISABLE:
\r
1620 case SEC_PIN2_DISABLE:
\r
1621 case SEC_FDN_DISABLE:
\r
1622 case SEC_SIM_DISABLE:
\r
1623 case SEC_NET_DISABLE:
\r
1624 case SEC_NS_DISABLE:
\r
1625 case SEC_SP_DISABLE:
\r
1626 case SEC_CP_DISABLE:
\r
1627 dis_facility.result = SIM_INCORRECT_PASSWORD;
\r
1628 dis_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
1629 dis_facility.retry_count = attempts_left;
\r
1630 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
1631 sizeof(struct tresp_sim_disable_facility), &dis_facility);
\r
1633 case SEC_PIN1_ENABLE:
\r
1634 case SEC_PIN2_ENABLE:
\r
1635 case SEC_FDN_ENABLE:
\r
1636 case SEC_SIM_ENABLE:
\r
1637 case SEC_NET_ENABLE:
\r
1638 case SEC_NS_ENABLE:
\r
1639 case SEC_SP_ENABLE:
\r
1640 case SEC_CP_ENABLE:
\r
1641 en_facility.result = SIM_INCORRECT_PASSWORD;
\r
1642 en_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
1643 en_facility.retry_count = attempts_left;
\r
1644 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
1645 sizeof(struct tresp_sim_enable_facility), &en_facility);
\r
1648 dbg("not handled sec op[%d]", sp->current_sec_op);
\r
1651 tcore_at_tok_free(tokens);
\r
1653 dbg(" Function exit");
\r
1656 static gboolean _get_sim_type(CoreObject *o)
\r
1658 TcoreHal* hal= NULL;
\r
1659 TcoreATRequest *req= NULL;
\r
1660 TcorePending *pending = NULL;
\r
1661 UserRequest *ur = NULL;
\r
1662 char *cmd_str = NULL;
\r
1664 dbg(" Function entry ");
\r
1666 hal = tcore_object_get_hal(o);
\r
1667 pending = tcore_pending_new(o, 0);
\r
1669 cmd_str = g_strdup_printf("AT+XUICC?");
\r
1670 req = tcore_at_request_new(cmd_str, "+XUICC:", TCORE_AT_SINGLELINE);
\r
1672 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
1674 tcore_pending_set_request_data(pending, 0, req);
\r
1675 tcore_pending_set_response_callback(pending, _response_get_sim_type, hal);
\r
1676 tcore_pending_link_user_request(pending, ur);
\r
1677 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
1678 tcore_hal_send_request(hal, pending);
\r
1681 dbg(" Function exit");
\r
1685 static TReturn _get_file_info(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef)
\r
1687 TcoreHal* hal= NULL;
\r
1688 TcorePending *pending = NULL;
\r
1689 struct s_sim_property file_meta={0,};
\r
1690 char *cmd_str = NULL;
\r
1693 dbg(" Function entry ");
\r
1695 file_meta.file_id = ef;
\r
1696 dbg("file_meta.file_id: %d", file_meta.file_id);
\r
1697 hal = tcore_object_get_hal(o);
\r
1698 dbg("hal: %x", hal);
\r
1699 pending = tcore_pending_new(o, 0);
\r
1701 trt = tcore_user_request_set_metainfo(ur, sizeof(struct s_sim_property), &file_meta);
\r
1702 dbg("trt[%d]",trt);
\r
1703 cmd_str = g_strdup_printf("AT+CRSM=192, %d", ef); /*command - 192 : GET RESPONSE*/
\r
1704 dbg("cmd_str: %x", cmd_str);
\r
1706 pending = tcore_at_pending_new(o, cmd_str, "+CRSM:", TCORE_AT_SINGLELINE, _response_get_file_info, NULL);
\r
1707 tcore_pending_link_user_request(pending, ur);
\r
1708 tcore_hal_send_request(hal, pending);
\r
1711 dbg(" Function exit");
\r
1712 return TCORE_RETURN_SUCCESS;
\r
1715 static gboolean _get_file_data(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int offset, const int length)
\r
1717 TcoreHal* hal= NULL;
\r
1718 TcoreATRequest *req= NULL;
\r
1719 TcorePending *pending = NULL;
\r
1720 char *cmd_str = NULL;
\r
1725 dbg(" Function entry ");
\r
1726 hal = tcore_object_get_hal(o);
\r
1727 pending = tcore_pending_new(o, 0);
\r
1729 dbg("file_id: %x", ef);
\r
1731 p1 = (unsigned char)(offset & 0xFF00) >> 8;
\r
1732 p2 = (unsigned char)offset & 0x00FF; //offset low
\r
1733 p3 = (unsigned char)length;
\r
1735 cmd_str = g_strdup_printf("AT+CRSM=176, %d, %d, %d, %d", ef,p1,p2,p3); /*command - 176 : READ BINARY*/
\r
1737 req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);
\r
1739 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
1741 tcore_pending_set_request_data(pending, 0, req);
\r
1742 tcore_pending_set_response_callback(pending, _response_get_file_data, hal);
\r
1743 tcore_pending_link_user_request(pending, ur);
\r
1744 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
1746 tcore_hal_send_request(hal, pending);
\r
1749 dbg(" Function exit");
\r
1753 static gboolean _get_file_record(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int index, const int length)
\r
1756 TcoreHal* hal= NULL;
\r
1757 TcoreATRequest *req= NULL;
\r
1758 TcorePending *pending = NULL;
\r
1759 char *cmd_str = NULL;
\r
1763 dbg(" Function entry ");
\r
1765 hal = tcore_object_get_hal(o);
\r
1766 pending = tcore_pending_new(o, 0);
\r
1768 p1 = (unsigned char)index;
\r
1769 p2 = (unsigned char)0x04; /* 0x4 for absolute mode */
\r
1770 p3 = (unsigned char)length;
\r
1772 cmd_str = g_strdup_printf("AT+CRSM=178, %d, %d, %d, %d", ef,p1,p2,p3); /*command - 178 : READ RECORD*/
\r
1774 req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);
\r
1776 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
1778 tcore_pending_set_request_data(pending, 0, req);
\r
1779 tcore_pending_set_response_callback(pending, _response_get_file_data, hal);
\r
1780 tcore_pending_link_user_request(pending, ur);
\r
1781 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
1783 tcore_hal_send_request(hal, pending);
\r
1786 dbg(" Function exit");
\r
1790 static TReturn _get_retry_count(CoreObject *o, UserRequest *ur)
\r
1792 TcoreHal* hal= NULL;
\r
1793 TcoreATRequest *req= NULL;
\r
1794 TcorePending *pending = NULL;
\r
1795 char *cmd_str = NULL;
\r
1796 int lock_type = 0;
\r
1797 struct s_sim_property *sp = NULL;
\r
1798 const struct treq_sim_get_lock_info *req_data= NULL;
\r
1800 dbg(" Function entry ");
\r
1802 hal = tcore_object_get_hal(o);
\r
1803 pending = tcore_pending_new(o, 0);
\r
1804 req_data = tcore_user_request_ref_data(ur, NULL);
\r
1805 sp = tcore_sim_ref_userdata(o);
\r
1807 switch (sp->current_sec_op)
\r
1809 case SEC_PIN1_VERIFY:
\r
1810 case SEC_PIN1_CHANGE:
\r
1811 case SEC_PIN1_ENABLE:
\r
1812 case SEC_PIN1_DISABLE:
\r
1815 case SEC_PIN2_VERIFY:
\r
1816 case SEC_PIN2_CHANGE:
\r
1817 case SEC_PIN2_ENABLE:
\r
1818 case SEC_PIN2_DISABLE:
\r
1819 case SEC_FDN_ENABLE:
\r
1820 case SEC_FDN_DISABLE:
\r
1823 case SEC_PUK1_VERIFY:
\r
1826 case SEC_PUK2_VERIFY:
\r
1829 case SEC_NET_ENABLE:
\r
1830 case SEC_NET_DISABLE:
\r
1833 case SEC_NS_ENABLE:
\r
1834 case SEC_NS_DISABLE:
\r
1837 case SEC_SP_ENABLE:
\r
1838 case SEC_SP_DISABLE:
\r
1841 case SEC_CP_ENABLE:
\r
1842 case SEC_CP_DISABLE:
\r
1845 case SEC_ADM_VERIFY:
\r
1852 cmd_str = g_strdup_printf("AT+XPINCNT=%d", lock_type);
\r
1853 req = tcore_at_request_new(cmd_str, "+XPINCNT:", TCORE_AT_SINGLELINE);
\r
1854 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
1856 tcore_pending_set_request_data(pending, 0, req);
\r
1857 tcore_pending_set_response_callback(pending, _on_response_get_retry_count, hal);
\r
1858 tcore_pending_link_user_request(pending, ur);
\r
1859 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
1860 tcore_hal_send_request(hal, pending);
\r
1863 dbg(" Function exit");
\r
1864 return TCORE_RETURN_SUCCESS;
\r
1868 static gboolean on_event_facility_lock_status(CoreObject *o, const void *event_info, void *user_data)
\r
1870 struct s_sim_property *sp = NULL;
\r
1871 char *line = NULL;
\r
1872 GSList *tokens=NULL;
\r
1873 GSList *lines = NULL;
\r
1875 dbg("Function entry");
\r
1878 sp = tcore_sim_ref_userdata(o);
\r
1879 lines = (GSList*)event_info;
\r
1880 if (1 != g_slist_length(lines))
\r
1882 dbg("unsolicited msg but multiple line");
\r
1885 line = (char*)(lines->data);
\r
1886 tokens = tcore_at_tok_new(line);
\r
1887 if (g_slist_length(tokens) != 1)
\r
1889 msg("invalid message");
\r
1890 tcore_at_tok_free(tokens);
\r
1895 dbg(" Function exit");
\r
1897 tcore_at_tok_free(tokens);
\r
1902 static gboolean on_event_pin_status(CoreObject *o, const void *event_info, void *user_data)
\r
1904 UserRequest *ur = NULL;
\r
1905 struct s_sim_property *sp = NULL;
\r
1906 enum tel_sim_status sim_status = SIM_STATUS_INITIALIZING;
\r
1907 GSList *tokens=NULL;
\r
1908 GSList *lines = NULL;
\r
1909 const char *line = NULL;
\r
1910 int sim_state = 0;
\r
1912 dbg(" Function entry ");
\r
1914 sp = tcore_sim_ref_userdata(o);
\r
1916 lines = (GSList*)event_info;
\r
1917 if (1 != g_slist_length(lines))
\r
1919 dbg("unsolicited msg but multiple line");
\r
1922 line = (char*)(lines->data);
\r
1924 tokens = tcore_at_tok_new(line);
\r
1925 if (g_slist_length(tokens) != 1)
\r
1927 msg("invalid message");
\r
1928 tcore_at_tok_free(tokens);
\r
1931 sim_state = atoi(g_slist_nth_data(tokens, 0));
\r
1933 switch (sim_state)
\r
1935 case 0: //sim state = SIM not present
\r
1936 sim_status = SIM_STATUS_CARD_NOT_PRESENT;
\r
1939 case 1: //sim state = PIN verification needed
\r
1940 sim_status = SIM_STATUS_PIN_REQUIRED;
\r
1941 dbg( " PIN required");
\r
1943 case 2: //sim state = PIN verification not needed \96 Ready
\r
1944 case 3: //sim state = PIN verified \96 Ready
\r
1945 sim_status = SIM_STATUS_INITIALIZING;
\r
1946 dbg(" Inside PIN disabled at BOOT UP");
\r
1948 case 4: //sim state = PUK verification needed
\r
1949 sim_status = SIM_STATUS_PUK_REQUIRED;
\r
1950 dbg(" PUK required");
\r
1952 case 5: //sim state = SIM permanently blocked
\r
1953 sim_status = SIM_STATUS_CARD_BLOCKED;
\r
1954 dbg(" Card permanently blocked");
\r
1956 case 6: //sim state = SIM error
\r
1957 sim_status = SIM_STATUS_CARD_ERROR;
\r
1958 dbg( "SIM card error ");
\r
1960 case 7: //sim state = ready for attach (+COPS)
\r
1961 sim_status = SIM_STATUS_INIT_COMPLETED;
\r
1962 dbg( "Modem init completed");
\r
1964 case 8: //sim state = SIM Technical Problem
\r
1965 sim_status = SIM_STATUS_CARD_ERROR;
\r
1966 dbg( "SIM unavailable");
\r
1968 case 9: //sim state = SIM removed
\r
1969 sim_status = SIM_STATUS_CARD_REMOVED;
\r
1970 dbg( "SIM removed");
\r
1972 case 99: //sim state = SIM State Unknown
\r
1973 sim_status = SIM_STATUS_UNKNOWN;
\r
1974 dbg( "SIM State Unknown");
\r
1977 dbg( "SIM Status : %d", sim_status);
\r
1980 dbg(" not handled SEC lock type ");
\r
1984 switch (sim_status)
\r
1986 case SIM_STATUS_INIT_COMPLETED:
\r
1987 ur = tcore_user_request_new(NULL, NULL); //this is for using ur metainfo set/ref functionality.
\r
1988 _get_file_info(o, ur, SIM_EF_IMSI);
\r
1990 case SIM_STATUS_INITIALIZING:
\r
1991 case SIM_STATUS_PIN_REQUIRED:
\r
1992 case SIM_STATUS_PUK_REQUIRED:
\r
1993 case SIM_STATUS_CARD_BLOCKED:
\r
1994 case SIM_STATUS_NCK_REQUIRED:
\r
1995 case SIM_STATUS_NSCK_REQUIRED:
\r
1996 case SIM_STATUS_SPCK_REQUIRED:
\r
1997 case SIM_STATUS_CCK_REQUIRED:
\r
1998 case SIM_STATUS_LOCK_REQUIRED:
\r
1999 if( sp->first_recv_status == SIM_STATUS_UNKNOWN )
\r
2001 dbg("first received sim status[%d]",sim_status);
\r
2002 sp->first_recv_status = sim_status;
\r
2005 dbg("second or later received lock status[%d]",sim_status);
\r
2006 if ( tcore_sim_get_status(o) != SIM_STATUS_INIT_COMPLETED )
\r
2008 dbg("sim is not init complete in telephony side yet");
\r
2009 _sim_status_update(o,sim_status);
\r
2013 case SIM_STATUS_CARD_REMOVED:
\r
2014 case SIM_STATUS_CARD_NOT_PRESENT:
\r
2015 case SIM_STATUS_CARD_ERROR:
\r
2016 if (sim_status == SIM_STATUS_CARD_NOT_PRESENT && tcore_sim_get_status(o) != SIM_STATUS_UNKNOWN)
\r
2018 dbg("[SIM]SIM CARD REMOVED!!");
\r
2019 sim_status = SIM_STATUS_CARD_REMOVED;
\r
2021 _sim_status_update(o,sim_status);
\r
2024 dbg("not handled status[%d]", sim_status);
\r
2029 dbg(" Function exit");
\r
2031 tcore_at_tok_free(tokens);
\r
2037 static void on_response_verify_pins(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2039 const TcoreATResponse *resp = data;
\r
2040 UserRequest *ur = NULL;
\r
2041 CoreObject *co_sim = NULL;
\r
2042 struct s_sim_property *sp = NULL;
\r
2043 GSList *tokens=NULL;
\r
2044 struct tresp_sim_verify_pins res;
\r
2045 GQueue *queue= NULL;
\r
2049 dbg(" Function entry ");
\r
2051 co_sim = tcore_pending_ref_core_object(p);
\r
2052 sp = tcore_sim_ref_userdata(co_sim);
\r
2053 ur = tcore_pending_ref_user_request(p);
\r
2055 memset(&res, 0, sizeof(struct tresp_sim_verify_pins));
\r
2057 if(resp->success > 0)
\r
2059 dbg("RESPONSE OK");
\r
2060 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2061 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2062 if (res.pin_type == SIM_PTYPE_PIN1 || res.pin_type == SIM_PTYPE_SIM)
\r
2064 if (tcore_sim_get_status(co_sim) != SIM_STATUS_INIT_COMPLETED)
\r
2065 _sim_status_update(co_sim, SIM_STATUS_INITIALIZING);
\r
2067 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PINS, sizeof(struct tresp_sim_verify_pins), &res);
\r
2071 dbg("RESPONSE NOK");
\r
2072 line = (const char*)resp->final_response;
\r
2073 tokens = tcore_at_tok_new(line);
\r
2074 if (g_slist_length(tokens) < 1)
\r
2076 dbg("err cause not specified or string corrupted");
\r
2077 res.result = TCORE_RETURN_3GPP_ERROR;
\r
2081 err = atoi(g_slist_nth_data(tokens, 0));
\r
2082 dbg("on_response_verify_pins: err = %d", err);
\r
2083 queue = tcore_object_ref_user_data(co_sim);
\r
2084 ur = tcore_user_request_ref(ur);
\r
2085 _get_retry_count(co_sim, ur);
\r
2087 tcore_at_tok_free(tokens);
\r
2089 dbg(" Function exit");
\r
2092 static void on_response_verify_puks(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2094 const TcoreATResponse *resp = data;
\r
2095 UserRequest *ur = NULL;
\r
2096 CoreObject *co_sim = NULL;
\r
2097 struct s_sim_property *sp = NULL;
\r
2098 GSList *tokens=NULL;
\r
2099 struct tresp_sim_verify_puks res;
\r
2100 GQueue *queue= NULL;
\r
2104 dbg(" Function entry ");
\r
2106 co_sim = tcore_pending_ref_core_object(p);
\r
2107 sp = tcore_sim_ref_userdata(co_sim);
\r
2108 ur = tcore_pending_ref_user_request(p);
\r
2110 memset(&res, 0, sizeof(struct tresp_sim_verify_pins));
\r
2112 if(resp->success > 0)
\r
2114 dbg("RESPONSE OK");
\r
2115 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2116 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2117 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PUKS, sizeof(struct tresp_sim_verify_pins), &res);
\r
2121 dbg("RESPONSE NOK");
\r
2122 line = (const char*)resp->final_response;
\r
2123 tokens = tcore_at_tok_new(line);
\r
2125 if (g_slist_length(tokens) < 1)
\r
2127 dbg("err cause not specified or string corrupted");
\r
2128 res.result = TCORE_RETURN_3GPP_ERROR;
\r
2132 err = atoi(g_slist_nth_data(tokens, 0));
\r
2133 queue = tcore_object_ref_user_data(co_sim);
\r
2134 ur = tcore_user_request_ref(ur);
\r
2135 _get_retry_count(co_sim, ur);
\r
2137 tcore_at_tok_free(tokens);
\r
2139 dbg(" Function exit");
\r
2142 static void on_response_change_pins(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2144 const TcoreATResponse *resp = data;
\r
2145 UserRequest *ur = NULL;
\r
2146 CoreObject *co_sim = NULL;
\r
2147 struct s_sim_property *sp = NULL;
\r
2148 GSList *tokens=NULL;
\r
2149 struct tresp_sim_change_pins res;
\r
2154 dbg(" Function entry ");
\r
2156 co_sim = tcore_pending_ref_core_object(p);
\r
2157 sp = tcore_sim_ref_userdata(co_sim);
\r
2158 ur = tcore_pending_ref_user_request(p);
\r
2160 memset(&res, 0, sizeof(struct tresp_sim_change_pins));
\r
2162 if(resp->success > 0)
\r
2164 dbg("RESPONSE OK");
\r
2165 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2166 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2167 tcore_user_request_send_response(ur, TRESP_SIM_CHANGE_PINS,sizeof(struct tresp_sim_change_pins), &res);
\r
2171 dbg("RESPONSE NOK");
\r
2172 line = (const char*)resp->final_response;
\r
2173 tokens = tcore_at_tok_new(line);
\r
2175 if (g_slist_length(tokens) < 1)
\r
2177 dbg("err cause not specified or string corrupted");
\r
2178 res.result = TCORE_RETURN_3GPP_ERROR;
\r
2182 err = atoi(g_slist_nth_data(tokens, 0));
\r
2183 queue = tcore_object_ref_user_data(co_sim);
\r
2184 ur = tcore_user_request_ref(ur);
\r
2185 _get_retry_count(co_sim, ur);
\r
2187 tcore_at_tok_free(tokens);
\r
2189 dbg(" Function exit");
\r
2192 static void on_response_get_facility_status(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2194 const TcoreATResponse *resp = data;
\r
2195 UserRequest *ur = NULL;
\r
2196 CoreObject *co_sim = NULL;
\r
2197 struct s_sim_property *sp = NULL;
\r
2198 GSList *tokens=NULL;
\r
2199 struct tresp_sim_get_facility_status res;
\r
2202 dbg(" Function entry ");
\r
2204 co_sim = tcore_pending_ref_core_object(p);
\r
2205 sp = tcore_sim_ref_userdata(co_sim);
\r
2206 ur = tcore_pending_ref_user_request(p);
\r
2208 memset(&res, 0, sizeof(struct tresp_sim_get_facility_status));
\r
2210 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2211 res.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2213 if(resp->success > 0)
\r
2215 dbg("RESPONSE OK");
\r
2217 line = (const char*)resp->lines->data;
\r
2218 tokens = tcore_at_tok_new(line);
\r
2219 if (g_slist_length(tokens) != 1)
\r
2221 msg("invalid message");
\r
2222 tcore_at_tok_free(tokens);
\r
2226 res.b_enable = atoi(g_slist_nth_data(tokens, 0));
\r
2231 dbg("RESPONSE NOK");
\r
2232 res.result = SIM_INCOMPATIBLE_PIN_OPERATION;
\r
2237 tcore_user_request_send_response(ur, TRESP_SIM_GET_FACILITY_STATUS,
\r
2238 sizeof(struct tresp_sim_get_facility_status), &res);
\r
2240 tcore_at_tok_free(tokens);
\r
2241 dbg(" Function exit");
\r
2244 static void on_response_enable_facility(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2246 const TcoreATResponse *resp = data;
\r
2247 UserRequest *ur = NULL;
\r
2248 CoreObject *co_sim = NULL;
\r
2249 struct s_sim_property *sp = NULL;
\r
2250 GSList *tokens=NULL;
\r
2251 struct tresp_sim_enable_facility res;
\r
2255 dbg(" Function entry ");
\r
2257 co_sim = tcore_pending_ref_core_object(p);
\r
2258 sp = tcore_sim_ref_userdata(co_sim);
\r
2259 ur = tcore_pending_ref_user_request(p);
\r
2261 memset(&res, 0, sizeof(struct tresp_sim_enable_facility));
\r
2263 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2264 res.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2266 if(resp->success > 0)
\r
2268 dbg("RESPONSE OK");
\r
2271 line = (const char*)resp->lines->data;
\r
2272 tokens = tcore_at_tok_new(line);
\r
2273 if (g_slist_length(tokens) != 1)
\r
2275 msg("invalid message");
\r
2276 tcore_at_tok_free(tokens);
\r
2280 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2283 tcore_user_request_send_response(ur, TRESP_SIM_ENABLE_FACILITY,
\r
2284 sizeof(struct tresp_sim_enable_facility), &res);
\r
2286 tcore_at_tok_free(tokens);
\r
2290 dbg("RESPONSE NOK");
\r
2291 queue = tcore_object_ref_user_data(co_sim);
\r
2292 ur = tcore_user_request_ref(ur);
\r
2293 _get_retry_count(co_sim, ur);
\r
2295 dbg(" Function exit");
\r
2298 static void on_response_disable_facility(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2300 const TcoreATResponse *resp = data;
\r
2301 UserRequest *ur = NULL;
\r
2302 CoreObject *co_sim = NULL;
\r
2303 struct s_sim_property *sp = NULL;
\r
2304 GSList *tokens=NULL;
\r
2305 struct tresp_sim_disable_facility res;
\r
2309 dbg(" Function entry ");
\r
2311 co_sim = tcore_pending_ref_core_object(p);
\r
2312 sp = tcore_sim_ref_userdata(co_sim);
\r
2313 ur = tcore_pending_ref_user_request(p);
\r
2315 memset(&res, 0, sizeof(struct tresp_sim_disable_facility));
\r
2317 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2318 res.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2320 if(resp->success > 0)
\r
2322 dbg("RESPONSE OK");
\r
2324 line = (const char*)resp->lines->data;
\r
2325 tokens = tcore_at_tok_new(line);
\r
2326 if (g_slist_length(tokens) != 1)
\r
2328 msg("invalid message");
\r
2329 tcore_at_tok_free(tokens);
\r
2333 res.result = SIM_PIN_OPERATION_SUCCESS;
\r
2336 tcore_user_request_send_response(ur, TRESP_SIM_DISABLE_FACILITY,
\r
2337 sizeof(struct tresp_sim_disable_facility), &res);
\r
2339 tcore_at_tok_free(tokens);
\r
2343 dbg("RESPONSE NOK");
\r
2344 queue = tcore_object_ref_user_data(co_sim);
\r
2345 ur = tcore_user_request_ref(ur);
\r
2346 _get_retry_count(co_sim, ur);
\r
2348 dbg(" Function exit");
\r
2351 static void on_response_get_lock_info(TcorePending * p, int data_len, const void *data, void *user_data)
\r
2353 const TcoreATResponse *resp = data;
\r
2354 UserRequest *ur = NULL;
\r
2355 CoreObject *co_sim = NULL;
\r
2356 struct s_sim_property *sp = NULL;
\r
2357 GSList *tokens=NULL;
\r
2359 struct tresp_sim_verify_pins v_pin = {0,};
\r
2360 struct tresp_sim_verify_puks v_puk = {0,};
\r
2361 struct tresp_sim_change_pins change_pin = {0,};
\r
2362 struct tresp_sim_disable_facility dis_facility = {0,};
\r
2363 struct tresp_sim_enable_facility en_facility = {0,};
\r
2365 int attempts_left = 0;
\r
2366 int time_penalty = 0;
\r
2368 dbg(" Function entry ");
\r
2370 co_sim = tcore_pending_ref_core_object(p);
\r
2371 sp = tcore_sim_ref_userdata(co_sim);
\r
2372 ur = tcore_pending_ref_user_request(p);
\r
2374 if(resp->success > 0)
\r
2376 dbg("RESPONSE OK");
\r
2378 line = (const char*)resp->lines->data;
\r
2379 tokens = tcore_at_tok_new(line);
\r
2380 if (g_slist_length(tokens) != 3)
\r
2382 msg("invalid message");
\r
2383 tcore_at_tok_free(tokens);
\r
2387 lock_type = atoi(g_slist_nth_data(tokens, 0));
\r
2388 attempts_left = atoi(g_slist_nth_data(tokens, 1));
\r
2389 time_penalty = atoi(g_slist_nth_data(tokens, 2));
\r
2391 switch (sp->current_sec_op)
\r
2393 case SEC_PIN1_VERIFY:
\r
2394 case SEC_PIN2_VERIFY:
\r
2395 case SEC_SIM_VERIFY:
\r
2396 case SEC_ADM_VERIFY:
\r
2397 v_pin.result = SIM_INCORRECT_PASSWORD;
\r
2398 v_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2399 v_pin.retry_count = attempts_left;
\r
2400 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
2401 sizeof(struct tresp_sim_verify_pins), &v_pin);
\r
2403 case SEC_PUK1_VERIFY:
\r
2404 case SEC_PUK2_VERIFY:
\r
2405 v_puk.result = SIM_INCORRECT_PASSWORD;
\r
2406 v_puk.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2407 v_puk.retry_count = attempts_left;
\r
2408 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
2409 sizeof(struct tresp_sim_verify_puks), &v_puk);
\r
2411 case SEC_PIN1_CHANGE:
\r
2412 case SEC_PIN2_CHANGE:
\r
2413 change_pin.result = SIM_INCORRECT_PASSWORD;
\r
2414 change_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2415 change_pin.retry_count = attempts_left;
\r
2416 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
2417 sizeof(struct tresp_sim_change_pins), &change_pin);
\r
2419 case SEC_PIN1_DISABLE:
\r
2420 case SEC_PIN2_DISABLE:
\r
2421 case SEC_FDN_DISABLE:
\r
2422 case SEC_SIM_DISABLE:
\r
2423 case SEC_NET_DISABLE:
\r
2424 case SEC_NS_DISABLE:
\r
2425 case SEC_SP_DISABLE:
\r
2426 case SEC_CP_DISABLE:
\r
2427 dis_facility.result = SIM_INCORRECT_PASSWORD;
\r
2428 dis_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2429 dis_facility.retry_count = attempts_left;
\r
2430 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
2431 sizeof(struct tresp_sim_disable_facility), &dis_facility);
\r
2433 case SEC_PIN1_ENABLE:
\r
2434 case SEC_PIN2_ENABLE:
\r
2435 case SEC_FDN_ENABLE:
\r
2436 case SEC_SIM_ENABLE:
\r
2437 case SEC_NET_ENABLE:
\r
2438 case SEC_NS_ENABLE:
\r
2439 case SEC_SP_ENABLE:
\r
2440 case SEC_CP_ENABLE:
\r
2441 en_facility.result = SIM_INCORRECT_PASSWORD;
\r
2442 en_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);
\r
2443 en_facility.retry_count = attempts_left;
\r
2444 tcore_user_request_send_response(ur, _find_resp_command(ur),
\r
2445 sizeof(struct tresp_sim_enable_facility), &en_facility);
\r
2448 dbg("not handled sec op[%d]", sp->current_sec_op);
\r
2451 tcore_at_tok_free(tokens);
\r
2453 dbg(" Function exit");
\r
2456 static void on_response_update_file(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2458 const TcoreATResponse *resp = data;
\r
2459 UserRequest *ur = NULL;
\r
2460 CoreObject *co_sim = NULL;
\r
2461 struct tresp_sim_set_callforwarding resp_cf = {0, };
\r
2462 struct tresp_sim_set_language resp_language ={0,};
\r
2463 struct s_sim_property *sp = NULL;
\r
2464 GSList *tokens=NULL;
\r
2465 enum tel_sim_access_result result;
\r
2470 dbg(" Function entry ");
\r
2472 co_sim = tcore_pending_ref_core_object(p);
\r
2473 sp = tcore_sim_ref_userdata(co_sim);
\r
2474 ur = tcore_pending_ref_user_request(p);
\r
2476 if(resp->success > 0)
\r
2478 dbg("RESPONSE OK");
\r
2481 line = (const char*)resp->lines->data;
\r
2482 tokens = tcore_at_tok_new(line);
\r
2483 if (g_slist_length(tokens) != 2)
\r
2485 msg("invalid message");
\r
2486 tcore_at_tok_free(tokens);
\r
2490 sw1 = atoi(g_slist_nth_data(tokens, 0));
\r
2491 sw2 = atoi(g_slist_nth_data(tokens, 1));
\r
2493 if((sw1 == 0x90 && sw2 == 0x00) ||sw1 == 0x91)
\r
2495 result = SIM_ACCESS_SUCCESS;
\r
2498 result = _decode_status_word(sw1, sw2);
\r
2501 dbg("RESPONSE NOK");
\r
2502 result = SIM_ACCESS_FAILED;
\r
2505 switch(sp->file_id)
\r
2507 case SIM_EF_CPHS_CALL_FORWARD_FLAGS :
\r
2508 case SIM_EF_USIM_CFIS :
\r
2509 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_set_callforwarding), &resp_cf);
\r
2513 case SIM_EF_USIM_LI:
\r
2514 case SIM_EF_USIM_PL:
\r
2515 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_set_language), &resp_language);
\r
2520 tcore_at_tok_free(tokens);
\r
2521 dbg(" Function exit");
\r
2524 static void on_response_transmit_apdu(TcorePending *p, int data_len, const void *data, void *user_data)
\r
2526 const TcoreATResponse *resp = data;
\r
2527 UserRequest *ur = NULL;
\r
2528 CoreObject *co_sim = NULL;
\r
2529 struct s_sim_property *sp = NULL;
\r
2530 GSList *tokens=NULL;
\r
2531 struct tresp_sim_transmit_apdu res;
\r
2534 dbg(" Function entry ");
\r
2536 co_sim = tcore_pending_ref_core_object(p);
\r
2537 sp = tcore_sim_ref_userdata(co_sim);
\r
2538 ur = tcore_pending_ref_user_request(p);
\r
2540 memset(&res, 0, sizeof(struct tresp_sim_transmit_apdu));
\r
2542 if(resp->success > 0)
\r
2544 dbg("RESPONSE OK");
\r
2545 res.result = SIM_ACCESS_SUCCESS;
\r
2548 line = (const char*)resp->lines->data;
\r
2549 tokens = tcore_at_tok_new(line);
\r
2550 if (g_slist_length(tokens) != 2)
\r
2552 msg("invalid message");
\r
2553 tcore_at_tok_free(tokens);
\r
2557 res.apdu_resp_length = atoi(g_slist_nth_data(tokens, 0));
\r
2558 strncpy((char *)res.apdu_resp, (const char *)g_slist_nth_data(tokens, 1), res.apdu_resp_length);
\r
2562 dbg("RESPONSE NOK");
\r
2563 res.result = SIM_ACCESS_FAILED;
\r
2565 ur = tcore_pending_ref_user_request(p);
\r
2568 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_transmit_apdu), &res);
\r
2570 tcore_at_tok_free(tokens);
\r
2571 dbg(" Function exit");
\r
2574 static TReturn s_verify_pins(CoreObject *o, UserRequest *ur)
\r
2576 TcoreHal* hal= NULL;
\r
2577 TcoreATRequest *req = NULL;
\r
2578 TcorePending *pending = NULL;
\r
2579 char *cmd_str = NULL;
\r
2580 const struct treq_sim_verify_pins *req_data = NULL;
\r
2581 struct s_sim_property *sp = NULL;
\r
2583 dbg(" Function entry ");
\r
2585 hal = tcore_object_get_hal(o);
\r
2586 sp = tcore_sim_ref_userdata(o);
\r
2587 pending = tcore_pending_new(o, 0);
\r
2588 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2591 return TCORE_RETURN_EINVAL;
\r
2593 if (req_data->pin_type == SIM_PTYPE_PIN1)
\r
2595 sp->current_sec_op = SEC_PIN1_VERIFY;
\r
2596 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);
\r
2598 else if (req_data->pin_type == SIM_PTYPE_PIN2)
\r
2600 sp->current_sec_op = SEC_PIN2_VERIFY;
\r
2601 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\"", req_data->pin);
\r
2603 else if (req_data->pin_type == SIM_PTYPE_SIM)
\r
2605 sp->current_sec_op = SEC_SIM_VERIFY;
\r
2606 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);
\r
2608 else if (req_data->pin_type == SIM_PTYPE_ADM)
\r
2610 sp->current_sec_op = SEC_ADM_VERIFY;
\r
2611 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);
\r
2615 return TCORE_RETURN_EINVAL;
\r
2618 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
\r
2620 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2622 tcore_pending_set_request_data(pending, 0, req);
\r
2623 tcore_pending_set_response_callback(pending, on_response_verify_pins, hal);
\r
2624 tcore_pending_link_user_request(pending, ur);
\r
2625 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2626 tcore_hal_send_request(hal, pending);
\r
2629 dbg(" Function exit");
\r
2630 return TCORE_RETURN_SUCCESS;
\r
2633 static TReturn s_verify_puks(CoreObject *o, UserRequest *ur)
\r
2635 TcoreHal* hal= NULL;
\r
2636 TcoreATRequest *req= NULL;
\r
2637 TcorePending *pending = NULL;
\r
2638 char *cmd_str = NULL;
\r
2639 const struct treq_sim_verify_puks *req_data;
\r
2640 struct s_sim_property *sp = NULL;
\r
2642 dbg(" Function entry ");
\r
2644 hal = tcore_object_get_hal(o);
\r
2645 sp = tcore_sim_ref_userdata(o);
\r
2646 pending = tcore_pending_new(o, 0);
\r
2647 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2650 return TCORE_RETURN_EINVAL;
\r
2652 if(req_data->puk_type == SIM_PTYPE_PUK1)
\r
2654 sp->current_sec_op = SEC_PUK1_VERIFY;
\r
2655 cmd_str = g_strdup_printf("AT+CPIN=\"%s\", \"%s\"", req_data->puk, req_data->pin);
\r
2657 else if(req_data->puk_type == SIM_PTYPE_PUK2)
\r
2659 sp->current_sec_op = SEC_PUK2_VERIFY;
\r
2660 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\", \"%s\"", req_data->puk, req_data->pin);
\r
2664 return TCORE_RETURN_EINVAL;
\r
2666 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
\r
2668 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2670 tcore_pending_set_request_data(pending, 0, req);
\r
2671 tcore_pending_set_response_callback(pending, on_response_verify_puks, hal);
\r
2672 tcore_pending_link_user_request(pending, ur);
\r
2673 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2674 tcore_hal_send_request(hal, pending);
\r
2677 dbg(" Function exit");
\r
2678 return TCORE_RETURN_SUCCESS;
\r
2681 static TReturn s_change_pins(CoreObject *o, UserRequest *ur)
\r
2683 TcoreHal* hal= NULL;
\r
2684 TcoreATRequest *req= NULL;
\r
2685 TcorePending *pending = NULL;
\r
2686 char *cmd_str = NULL;
\r
2687 const struct treq_sim_change_pins *req_data;
\r
2688 struct s_sim_property *sp = NULL;
\r
2689 char *pin1 = "SC";
\r
2690 char *pin2 = "P2";
\r
2692 dbg(" Function entry ");
\r
2694 hal = tcore_object_get_hal(o);
\r
2695 sp = tcore_sim_ref_userdata(o);
\r
2696 pending = tcore_pending_new(o, 0);
\r
2697 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2700 return TCORE_RETURN_EINVAL;
\r
2702 if(req_data->type == SIM_PTYPE_PIN1)
\r
2704 sp->current_sec_op = SEC_PIN1_CHANGE;
\r
2705 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", pin1, req_data->old_pin, req_data->new_pin);
\r
2708 else if(req_data->type == SIM_PTYPE_PIN2)
\r
2710 sp->current_sec_op = SEC_PIN2_CHANGE;
\r
2711 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", pin2, req_data->old_pin, req_data->new_pin);
\r
2715 return TCORE_RETURN_EINVAL;
\r
2717 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
\r
2719 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2721 tcore_pending_set_request_data(pending, 0, req);
\r
2722 tcore_pending_set_response_callback(pending, on_response_change_pins, hal);
\r
2723 tcore_pending_link_user_request(pending, ur);
\r
2724 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2725 tcore_hal_send_request(hal, pending);
\r
2728 dbg(" Function exit");
\r
2729 return TCORE_RETURN_SUCCESS;
\r
2732 static TReturn s_get_facility_status(CoreObject *o, UserRequest *ur)
\r
2734 TcoreHal* hal= NULL;
\r
2735 TcoreATRequest *req= NULL;
\r
2736 TcorePending *pending = NULL;
\r
2737 char *cmd_str = NULL;
\r
2738 const struct treq_sim_get_facility_status *req_data;
\r
2739 struct s_sim_property *sp = NULL;
\r
2741 int mode = 2; /* 0:unlock, 1:lock, 2:query*/
\r
2743 dbg(" Function entry ");
\r
2745 hal = tcore_object_get_hal(o);
\r
2746 sp = tcore_sim_ref_userdata(o);
\r
2747 pending = tcore_pending_new(o, 0);
\r
2748 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2751 return TCORE_RETURN_EINVAL;
\r
2753 if(req_data->type == SIM_FACILITY_PS)
\r
2755 fac = "PS"; /*PH-SIM, Lock PHone to SIM/UICC card*/
\r
2756 }else if(req_data->type == SIM_FACILITY_SC)
\r
2758 fac = "SC"; /*Lock SIM/UICC card, simply PIN1*/
\r
2759 }else if(req_data->type == SIM_FACILITY_FD)
\r
2761 fac = "FD"; /*Fixed Dialing Number feature, need PIN2*/
\r
2762 }else if(req_data->type == SIM_FACILITY_PN)
\r
2764 fac = "PN"; /*Network Personalization*/
\r
2765 }else if(req_data->type == SIM_FACILITY_PU)
\r
2767 fac = "PU"; /*network sUbset Personalization*/
\r
2768 }else if(req_data->type == SIM_FACILITY_PP)
\r
2770 fac = "PP"; /*service Provider Personalization*/
\r
2771 }else if(req_data->type == SIM_FACILITY_PC)
\r
2773 fac = "PC"; /*Corporate Personalization*/
\r
2776 return TCORE_RETURN_EINVAL;
\r
2778 cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d", fac, mode);
\r
2779 req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);
\r
2781 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2783 tcore_pending_set_request_data(pending, 0, req);
\r
2784 tcore_pending_set_response_callback(pending, on_response_get_facility_status, hal);
\r
2785 tcore_pending_link_user_request(pending, ur);
\r
2786 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2787 tcore_hal_send_request(hal, pending);
\r
2790 dbg(" Function exit");
\r
2791 return TCORE_RETURN_SUCCESS;
\r
2794 static TReturn s_enable_facility(CoreObject *o, UserRequest *ur)
\r
2796 TcoreHal* hal = NULL;
\r
2797 TcoreATRequest *req = NULL;
\r
2798 TcorePending *pending = NULL;
\r
2799 char *cmd_str = NULL;
\r
2800 const struct treq_sim_enable_facility *req_data;
\r
2801 struct s_sim_property *sp = NULL;
\r
2803 int mode = 1; /* 0:unlock, 1:lock, 2:query*/
\r
2805 dbg(" Function entry ");
\r
2807 hal = tcore_object_get_hal(o);
\r
2808 sp = tcore_sim_ref_userdata(o);
\r
2809 pending = tcore_pending_new(o, 0);
\r
2810 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2813 return TCORE_RETURN_EINVAL;
\r
2815 if(req_data->type == SIM_FACILITY_PS)
\r
2817 fac = "PS"; /*PH-SIM, Lock PHone to SIM/UICC card*/
\r
2818 sp->current_sec_op = SEC_SIM_ENABLE;
\r
2819 }else if(req_data->type == SIM_FACILITY_SC)
\r
2821 fac = "SC"; /*Lock SIM/UICC card, simply PIN1*/
\r
2822 sp->current_sec_op = SEC_PIN1_ENABLE;
\r
2823 }else if(req_data->type == SIM_FACILITY_FD)
\r
2825 fac = "FD"; /*Fixed Dialing Number feature, need PIN2*/
\r
2826 sp->current_sec_op = SEC_FDN_ENABLE;
\r
2827 }else if(req_data->type == SIM_FACILITY_PN)
\r
2829 fac = "PN"; /*Network Personalization*/
\r
2830 sp->current_sec_op = SEC_NET_ENABLE;
\r
2831 }else if(req_data->type == SIM_FACILITY_PU)
\r
2833 fac = "PU"; /*network sUbset Personalization*/
\r
2834 sp->current_sec_op = SEC_NS_ENABLE;
\r
2835 }else if(req_data->type == SIM_FACILITY_PP)
\r
2837 fac = "PP"; /*service Provider Personalization*/
\r
2838 sp->current_sec_op = SEC_SP_ENABLE;
\r
2839 }else if(req_data->type == SIM_FACILITY_PC)
\r
2841 fac = "PC"; /*Corporate Personalization*/
\r
2842 sp->current_sec_op = SEC_CP_ENABLE;
\r
2845 return TCORE_RETURN_EINVAL;
\r
2847 cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d, \"%s\"", fac, mode, req_data->password);
\r
2848 req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);
\r
2850 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2852 tcore_pending_set_request_data(pending, 0, req);
\r
2853 tcore_pending_set_response_callback(pending, on_response_enable_facility, hal);
\r
2854 tcore_pending_link_user_request(pending, ur);
\r
2855 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2856 tcore_hal_send_request(hal, pending);
\r
2859 dbg(" Function exit");
\r
2860 return TCORE_RETURN_SUCCESS;
\r
2863 static TReturn s_disable_facility(CoreObject *o, UserRequest *ur)
\r
2866 TcoreATRequest *req;
\r
2867 TcorePending *pending = NULL;
\r
2868 char *cmd_str = NULL;
\r
2869 const struct treq_sim_enable_facility *req_data;
\r
2870 struct s_sim_property *sp = NULL;
\r
2872 int mode = 0; /* 0:unlock, 1:lock, 2:query*/
\r
2874 dbg(" Function entry ");
\r
2876 hal = tcore_object_get_hal(o);
\r
2877 sp = tcore_sim_ref_userdata(o);
\r
2878 pending = tcore_pending_new(o, 0);
\r
2879 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2882 return TCORE_RETURN_EINVAL;
\r
2884 if(req_data->type == SIM_FACILITY_PS)
\r
2886 fac = "PS"; /*PH-SIM, Lock PHone to SIM/UICC card*/
\r
2887 sp->current_sec_op = SEC_SIM_DISABLE;
\r
2888 }else if(req_data->type == SIM_FACILITY_SC)
\r
2890 fac = "SC"; /*Lock SIM/UICC card, simply PIN1*/
\r
2891 sp->current_sec_op = SEC_PIN1_DISABLE;
\r
2892 }else if(req_data->type == SIM_FACILITY_FD)
\r
2894 fac = "FD"; /*Fixed Dialing Number feature, need PIN2*/
\r
2895 sp->current_sec_op = SEC_FDN_DISABLE;
\r
2896 }else if(req_data->type == SIM_FACILITY_PN)
\r
2898 fac = "PN"; /*Network Personalization*/
\r
2899 sp->current_sec_op = SEC_NET_DISABLE;
\r
2900 }else if(req_data->type == SIM_FACILITY_PU)
\r
2902 fac = "PU"; /*network sUbset Personalization*/
\r
2903 sp->current_sec_op = SEC_NS_DISABLE;
\r
2904 }else if(req_data->type == SIM_FACILITY_PP)
\r
2906 fac = "PP"; /*service Provider Personalization*/
\r
2907 sp->current_sec_op = SEC_SP_DISABLE;
\r
2908 }else if(req_data->type == SIM_FACILITY_PC)
\r
2910 fac = "PC"; /*Corporate Personalization*/
\r
2911 sp->current_sec_op = SEC_CP_DISABLE;
\r
2914 return TCORE_RETURN_EINVAL;
\r
2916 cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d, \"%s\"", fac, mode, req_data->password);
\r
2917 req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);
\r
2919 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2921 tcore_pending_set_request_data(pending, 0, req);
\r
2922 tcore_pending_set_response_callback(pending, on_response_disable_facility, hal);
\r
2923 tcore_pending_link_user_request(pending, ur);
\r
2924 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2925 tcore_hal_send_request(hal, pending);
\r
2928 dbg(" Function exit");
\r
2929 return TCORE_RETURN_SUCCESS;
\r
2932 static TReturn s_get_lock_info(CoreObject *o, UserRequest *ur)
\r
2934 TcoreHal* hal = NULL;
\r
2935 TcoreATRequest *req = NULL;
\r
2936 TcorePending *pending = NULL;
\r
2937 char *cmd_str = NULL;
\r
2938 char *lock_type = NULL;
\r
2939 const struct treq_sim_get_lock_info *req_data;
\r
2940 struct s_sim_property *sp = NULL;
\r
2942 dbg(" Function entry ");
\r
2944 hal = tcore_object_get_hal(o);
\r
2945 sp = tcore_sim_ref_userdata(o);
\r
2946 pending = tcore_pending_new(o, 0);
\r
2947 req_data = tcore_user_request_ref_data(ur, NULL);
\r
2950 return TCORE_RETURN_EINVAL;
\r
2952 switch (req_data->type)
\r
2954 case SIM_FACILITY_PS:
\r
2957 case SIM_FACILITY_SC:
\r
2960 case SIM_FACILITY_FD:
\r
2963 case SIM_FACILITY_PN:
\r
2966 case SIM_FACILITY_PU:
\r
2969 case SIM_FACILITY_PP:
\r
2972 case SIM_FACILITY_PC:
\r
2978 cmd_str = g_strdup_printf("AT+XPINCNT =\"%s\"", lock_type);
\r
2979 req = tcore_at_request_new(cmd_str, "+XPINCNT:", TCORE_AT_SINGLELINE);
\r
2981 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
2983 tcore_pending_set_request_data(pending, 0, req);
\r
2984 tcore_pending_set_response_callback(pending, on_response_get_lock_info, hal);
\r
2985 tcore_pending_link_user_request(pending, ur);
\r
2986 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
2987 tcore_hal_send_request(hal, pending);
\r
2990 dbg(" Function exit");
\r
2991 return TCORE_RETURN_SUCCESS;
\r
2994 static TReturn s_read_file(CoreObject *o, UserRequest *ur)
\r
2996 TReturn api_ret = TCORE_RETURN_SUCCESS;
\r
2997 enum tcore_request_command command;
\r
2998 command = tcore_user_request_get_command(ur);
\r
3000 dbg(" Function entry ");
\r
3003 return TCORE_RETURN_EINVAL;
\r
3007 case TREQ_SIM_GET_ECC:
\r
3008 api_ret = _get_file_info(o, ur, SIM_EF_ECC);
\r
3010 case TREQ_SIM_GET_LANGUAGE:
\r
3011 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
3012 api_ret = _get_file_info(o, ur, SIM_EF_ELP);
\r
3013 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
3014 api_ret = _get_file_info(o, ur, SIM_EF_LP);
\r
3016 api_ret = TCORE_RETURN_ENOSYS;
\r
3018 case TREQ_SIM_GET_ICCID:
\r
3019 api_ret = _get_file_info(o, ur, SIM_EF_ICCID);
\r
3021 case TREQ_SIM_GET_MAILBOX:
\r
3022 if(tcore_sim_get_cphs_status(o))
\r
3023 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_MAILBOX_NUMBERS);
\r
3025 api_ret = _get_file_info(o, ur, SIM_EF_MBDN);
\r
3027 case TREQ_SIM_GET_CALLFORWARDING:
\r
3028 if(tcore_sim_get_cphs_status(o))
\r
3029 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CALL_FORWARD_FLAGS);
\r
3031 api_ret = _get_file_info(o, ur, SIM_EF_USIM_CFIS);
\r
3033 case TREQ_SIM_GET_MESSAGEWAITING:
\r
3034 if(tcore_sim_get_cphs_status(o))
\r
3035 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_VOICE_MSG_WAITING);
\r
3037 api_ret = _get_file_info(o, ur, SIM_EF_USIM_MWIS);
\r
3039 case TREQ_SIM_GET_CPHS_INFO:
\r
3040 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CPHS_INFO);
\r
3042 case TREQ_SIM_GET_MSISDN:
\r
3043 api_ret = _get_file_info(o, ur, SIM_EF_MSISDN);
\r
3045 case TREQ_SIM_GET_SPN:
\r
3046 dbg("enter case SPN");
\r
3047 api_ret = _get_file_info(o, ur, SIM_EF_SPN);
\r
3049 case TREQ_SIM_GET_SPDI:
\r
3050 api_ret = _get_file_info(o, ur, SIM_EF_SPDI);
\r
3052 case TREQ_SIM_GET_OPL:
\r
3053 api_ret = _get_file_info(o, ur, SIM_EF_OPL);
\r
3055 case TREQ_SIM_GET_PNN:
\r
3056 api_ret = _get_file_info(o, ur, SIM_EF_PNN);
\r
3058 case TREQ_SIM_GET_CPHS_NETNAME:
\r
3059 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_STRING);
\r
3061 case TREQ_SIM_GET_OPLMNWACT:
\r
3062 api_ret = _get_file_info(o, ur, SIM_EF_OPLMN_ACT);
\r
3065 dbg("error - not handled read treq command[%d]", command);
\r
3066 api_ret = TCORE_RETURN_EINVAL;
\r
3069 dbg(" Function exit");
\r
3073 static TReturn s_update_file(CoreObject *o, UserRequest *ur)
\r
3076 TcoreATRequest *req;
\r
3077 TcorePending *pending = NULL;
\r
3078 char *cmd_str = NULL;
\r
3079 TReturn api_ret = TCORE_RETURN_SUCCESS;
\r
3080 char *encoded_data = NULL;
\r
3081 int encoded_len = 0;
\r
3082 enum tcore_request_command command;
\r
3083 enum tel_sim_file_id ef = SIM_EF_INVALID;
\r
3084 const struct treq_sim_set_callforwarding *cf;
\r
3085 const struct treq_sim_set_language *cl;
\r
3091 struct tel_sim_language sim_language;
\r
3093 command = tcore_user_request_get_command(ur);
\r
3095 dbg(" Function entry ");
\r
3097 hal = tcore_object_get_hal(o);
\r
3098 pending = tcore_pending_new(o, 0);
\r
3101 return TCORE_RETURN_EINVAL;
\r
3103 switch (command) {
\r
3104 case TREQ_SIM_SET_LANGUAGE:
\r
3105 cl = tcore_user_request_ref_data(ur, NULL);
\r
3106 memset(&sim_language, 0x00, sizeof(struct tel_sim_language));
\r
3111 sim_language.language_count = 1;
\r
3112 sim_language.language[0] = cl->language;
\r
3114 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)
\r
3118 encoded_data = tcore_sim_encode_lp(&length, &sim_language);
\r
3119 dbg("%d ---", encoded_data[0]);
\r
3121 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)
\r
3125 encoded_data = tcore_sim_encode_li(&length, &sim_language);
\r
3126 dbg("encoded_data %s", encoded_data);
\r
3130 api_ret = TCORE_RETURN_ENOSYS;
\r
3134 case TREQ_SIM_SET_CALLFORWARDING:
\r
3135 cf = tcore_user_request_ref_data(ur, NULL);
\r
3136 if(tcore_sim_get_cphs_status(o))
\r
3138 encoded_data = tcore_sim_encode_cff((const struct tel_sim_callforwarding*)cf);
\r
3139 ef = SIM_EF_CPHS_CALL_FORWARD_FLAGS;
\r
3142 p3 = strlen(encoded_data);
\r
3143 cmd = 214; /*command - 214 : UPDATE BINARY*/
\r
3146 encoded_data = tcore_sim_encode_cfis(&encoded_len, (const struct tel_sim_callforwarding*)cf);
\r
3147 ef = SIM_EF_USIM_CFIS;
\r
3151 cmd = 220; /*command - 220 : UPDATE RECORD*/
\r
3156 dbg("error - not handled update treq command[%d]", command);
\r
3157 api_ret = TCORE_RETURN_EINVAL;
\r
3160 cmd_str = g_strdup_printf("AT+CRSM=%d,%d,%d,%d,%d,\"%s\"", cmd,ef,p1,p2,p3, encoded_data);
\r
3161 req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);
\r
3163 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
3165 tcore_pending_set_request_data(pending, 0, req);
\r
3166 tcore_pending_set_response_callback(pending, on_response_update_file, hal);
\r
3167 tcore_pending_link_user_request(pending, ur);
\r
3168 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
3170 tcore_hal_send_request(hal, pending);
\r
3171 if(NULL != encoded_data){
\r
3172 g_free(encoded_data);
\r
3175 dbg(" Function exit");
\r
3176 return TCORE_RETURN_SUCCESS;
\r
3179 static TReturn s_transmit_apdu(CoreObject *o, UserRequest *ur)
\r
3181 TcoreHal* hal= NULL;
\r
3182 TcoreATRequest *req= NULL;
\r
3183 TcorePending *pending = NULL;
\r
3184 char *cmd_str = NULL;
\r
3185 const struct treq_sim_transmit_apdu *req_data;
\r
3186 dbg(" Function entry ");
\r
3188 hal = tcore_object_get_hal(o);
\r
3189 pending = tcore_pending_new(o, 0);
\r
3190 req_data = tcore_user_request_ref_data(ur, NULL);
\r
3193 return TCORE_RETURN_EINVAL;
\r
3195 cmd_str = g_strdup_printf("AT+CSIM=%d,\"%s\"", req_data->apdu_length, req_data->apdu);
\r
3197 req = tcore_at_request_new(cmd_str, "+CSIM:", TCORE_AT_SINGLELINE);
\r
3199 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
\r
3201 tcore_pending_set_request_data(pending, 0, req);
\r
3202 tcore_pending_set_response_callback(pending, on_response_transmit_apdu, hal);
\r
3203 tcore_pending_link_user_request(pending, ur);
\r
3204 tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);
\r
3205 tcore_hal_send_request(hal, pending);
\r
3208 dbg(" Function exit");
\r
3209 return TCORE_RETURN_SUCCESS;
\r
3212 static struct tcore_sim_operations sim_ops =
\r
3214 .verify_pins = s_verify_pins,
\r
3215 .verify_puks = s_verify_puks,
\r
3216 .change_pins = s_change_pins,
\r
3217 .get_facility_status = s_get_facility_status,
\r
3218 .enable_facility = s_enable_facility,
\r
3219 .disable_facility = s_disable_facility,
\r
3220 .get_lock_info = s_get_lock_info,
\r
3221 .read_file = s_read_file,
\r
3222 .update_file = s_update_file,
\r
3223 .transmit_apdu = s_transmit_apdu,
\r
3224 /*ToDo - Need to be implemented in Phase-2*/
\r
3225 /*.get_atr = s_get_atr,
\r
3226 .req_authentication = s_req_authentication*/
\r
3229 gboolean s_sim_init(TcorePlugin *p, TcoreHal *h)
\r
3232 struct s_sim_property *file_meta = NULL;
\r
3233 GQueue *work_queue;
\r
3237 o = tcore_sim_new(p, "sim", &sim_ops, h);
\r
3242 file_meta = calloc(sizeof(struct s_sim_property),1);
\r
3246 work_queue = g_queue_new();
\r
3247 tcore_object_link_user_data(o, work_queue);
\r
3249 file_meta->first_recv_status = SIM_STATUS_UNKNOWN;
\r
3250 tcore_sim_link_userdata(o, file_meta);
\r
3252 tcore_object_add_callback(o, "+XLOCK", on_event_facility_lock_status, NULL);
\r
3253 tcore_object_add_callback(o, "+XSIM", on_event_pin_status, NULL);
\r
3259 void s_sim_exit(TcorePlugin *p)
\r
3263 o = tcore_plugin_ref_core_object(p, "sim");
\r
3266 tcore_sim_free(o);
\r