src/s_sim.c

   1 /**\r
   2  * tel-plugin-samsung\r
   3  *\r
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved\r
   5  *\r
   6  * Contact: Ankit Jogi <ankit.jogi@samsung.com>\r
   7  *\r
   8  * PROPRIETARY/CONFIDENTIAL\r
   9  *\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
  18  */\r
  19 \r
  20 #include <stdio.h>\r
  21 #include <stdlib.h>\r
  22 #include <string.h>\r
  23 #include <glib.h>\r
  24 #include <tcore.h>\r
  25 #include <hal.h>\r
  26 #include <core_object.h>\r
  27 #include <plugin.h>\r
  28 #include <queue.h>\r
  29 #include <co_sim.h>\r
  30 #include <storage.h>\r
  31 #include <user_request.h>\r
  32 #include <server.h>\r
  33 #include <at.h>\r
  34 \r
  35 #include "s_common.h"\r
  36 #include "s_sim.h"\r
  37 \r
  38 #define ID_RESERVED_AT 0x0229\r
  39 \r
  40 #define SWAPBYTES16(x) \\r
  41 { \\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
  46 }\r
  47 \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
  54 };\r
  55 \r
  56 enum s_sim_sec_op_e {\r
  57         SEC_PIN1_VERIFY,\r
  58         SEC_PIN2_VERIFY,\r
  59         SEC_PUK1_VERIFY,\r
  60         SEC_PUK2_VERIFY,\r
  61         SEC_SIM_VERIFY,\r
  62         SEC_ADM_VERIFY,\r
  63         SEC_PIN1_CHANGE,\r
  64         SEC_PIN2_CHANGE,\r
  65         SEC_PIN1_ENABLE,\r
  66         SEC_PIN1_DISABLE,\r
  67         SEC_PIN2_ENABLE,\r
  68         SEC_PIN2_DISABLE, //10\r
  69         SEC_SIM_ENABLE,\r
  70         SEC_SIM_DISABLE,\r
  71         SEC_NET_ENABLE,\r
  72         SEC_NET_DISABLE,\r
  73         SEC_NS_ENABLE,\r
  74         SEC_NS_DISABLE,\r
  75         SEC_SP_ENABLE,\r
  76         SEC_SP_DISABLE,\r
  77         SEC_CP_ENABLE,\r
  78         SEC_CP_DISABLE, //20\r
  79         SEC_FDN_ENABLE,\r
  80         SEC_FDN_DISABLE,\r
  81         SEC_PIN1_STATUS,\r
  82         SEC_PIN2_STATUS,\r
  83         SEC_FDN_STATUS,\r
  84         SEC_NET_STATUS,\r
  85         SEC_NS_STATUS,\r
  86         SEC_SP_STATUS,\r
  87         SEC_CP_STATUS,\r
  88         SEC_SIM_STATUS,\r
  89         SEC_SIM_UNKNOWN = 0xff\r
  90 };\r
  91 \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
 103 };\r
 104 \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
 113 \r
 114 static void on_confirmation_sim_message_send( TcorePending *p, gboolean result, void *user_data )\r
 115 {\r
 116         dbg("on_confirmation_sim_message_send - msg out from queue.\n");\r
 117 \r
 118         if (result == FALSE) {\r
 119                 /* Fail */\r
 120                 dbg("SEND FAIL");\r
 121         }\r
 122         else\r
 123         {\r
 124                 dbg("SEND OK");\r
 125         }\r
 126 }\r
 127 \r
 128 static enum tcore_response_command _find_resp_command(UserRequest *ur)\r
 129 {\r
 130         enum tcore_request_command command;\r
 131         command = tcore_user_request_get_command(ur);\r
 132         switch(command){\r
 133                 case TREQ_SIM_VERIFY_PINS:\r
 134                         return TRESP_SIM_VERIFY_PINS;\r
 135                         break;\r
 136                 case TREQ_SIM_VERIFY_PUKS:\r
 137                         return TRESP_SIM_VERIFY_PUKS;\r
 138                         break;\r
 139                 case TREQ_SIM_CHANGE_PINS:\r
 140                         return TRESP_SIM_CHANGE_PINS;\r
 141                         break;\r
 142                 case TREQ_SIM_GET_FACILITY_STATUS:\r
 143                         return TRESP_SIM_GET_FACILITY_STATUS;\r
 144                         break;\r
 145                 case TREQ_SIM_DISABLE_FACILITY:\r
 146                         return TRESP_SIM_DISABLE_FACILITY;\r
 147                         break;\r
 148                 case TREQ_SIM_ENABLE_FACILITY:\r
 149                         return TRESP_SIM_ENABLE_FACILITY;\r
 150                         break;\r
 151                 case TREQ_SIM_GET_LOCK_INFO:\r
 152                         return TRESP_SIM_GET_LOCK_INFO;\r
 153                         break;\r
 154                 case TREQ_SIM_TRANSMIT_APDU:\r
 155                         return TRESP_SIM_TRANSMIT_APDU;\r
 156                         break;\r
 157                 case TREQ_SIM_GET_ATR:\r
 158                         return TRESP_SIM_GET_ATR;\r
 159                         break;\r
 160                 case TREQ_SIM_GET_ECC:\r
 161                         return TRESP_SIM_GET_ECC;\r
 162                         break;\r
 163                 case TREQ_SIM_GET_LANGUAGE:\r
 164                         return TRESP_SIM_GET_LANGUAGE;\r
 165                         break;\r
 166                 case TREQ_SIM_SET_LANGUAGE:\r
 167                         return TRESP_SIM_SET_LANGUAGE;\r
 168                         break;\r
 169                 case TREQ_SIM_GET_ICCID:\r
 170                         return TRESP_SIM_GET_ICCID;\r
 171                         break;\r
 172                 case TREQ_SIM_GET_MAILBOX:\r
 173                         return TRESP_SIM_GET_MAILBOX;\r
 174                         break;\r
 175                 case TREQ_SIM_GET_CALLFORWARDING:\r
 176                         return TRESP_SIM_GET_CALLFORWARDING;\r
 177                         break;\r
 178                 case TREQ_SIM_SET_CALLFORWARDING:\r
 179                         return TRESP_SIM_SET_CALLFORWARDING;\r
 180                         break;\r
 181                 case TREQ_SIM_GET_MESSAGEWAITING:\r
 182                         return TRESP_SIM_GET_MESSAGEWAITING;\r
 183                         break;\r
 184                 case TREQ_SIM_GET_CPHS_INFO:\r
 185                         return TRESP_SIM_GET_CPHS_INFO;\r
 186                         break;\r
 187                 case TREQ_SIM_GET_MSISDN:\r
 188                         return TRESP_SIM_GET_MSISDN;\r
 189                         break;\r
 190                 case TREQ_SIM_GET_SPN:\r
 191                         return TRESP_SIM_GET_SPN;\r
 192                         break;\r
 193                 case TREQ_SIM_GET_SPDI:\r
 194                         return TRESP_SIM_GET_SPDI;\r
 195                         break;\r
 196                 case TREQ_SIM_GET_OPL:\r
 197                         return TRESP_SIM_GET_OPL;\r
 198                         break;\r
 199                 case TREQ_SIM_GET_PNN:\r
 200                         return TRESP_SIM_GET_PNN;\r
 201                         break;\r
 202                 case TREQ_SIM_GET_CPHS_NETNAME:\r
 203                         return TRESP_SIM_GET_CPHS_NETNAME;\r
 204                         break;\r
 205                 case TREQ_SIM_GET_OPLMNWACT:\r
 206                         return TRESP_SIM_GET_OPLMNWACT;\r
 207                         break;\r
 208                 case TREQ_SIM_REQ_AUTHENTICATION:\r
 209                         return TRESP_SIM_REQ_AUTHENTICATION;\r
 210                         break;\r
 211                 default:\r
 212                         break;\r
 213         }\r
 214         return TRESP_UNKNOWN;\r
 215 }\r
 216 \r
 217 static int _sim_get_current_pin_facility(enum s_sim_sec_op_e op)\r
 218 {\r
 219         int ret_type = 0;\r
 220         dbg("current sec_op[%d]", op);\r
 221         switch(op)\r
 222         {\r
 223                 case SEC_PIN1_VERIFY :\r
 224                 case SEC_PIN1_CHANGE :\r
 225                         ret_type = SIM_PTYPE_PIN1;\r
 226                         break;\r
 227                 case SEC_PIN2_VERIFY :\r
 228                 case SEC_PIN2_CHANGE :\r
 229                         ret_type = SIM_PTYPE_PIN2;\r
 230                         break;\r
 231                 case SEC_PUK1_VERIFY :\r
 232                         ret_type = SIM_PTYPE_PUK1;\r
 233                         break;\r
 234                 case SEC_PUK2_VERIFY :\r
 235                         ret_type = SIM_PTYPE_PUK2;\r
 236                         break;\r
 237                 case SEC_SIM_VERIFY :\r
 238                         ret_type = SIM_PTYPE_SIM;\r
 239                         break;\r
 240                 case SEC_ADM_VERIFY :\r
 241                         ret_type = SIM_PTYPE_ADM;\r
 242                         break;\r
 243 \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
 248                         break;\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
 253                         break;\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
 258                         break;\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
 263                         break;\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
 268                         break;\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
 273                         break;\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
 278                         break;\r
 279 \r
 280                 default:\r
 281                         dbg("not handled current sec op[%d]",op )\r
 282                         break;\r
 283         }\r
 284         return ret_type;\r
 285 }\r
 286 \r
 287 static enum tel_sim_access_result _decode_status_word(unsigned short status_word1, unsigned short status_word2)\r
 288 {\r
 289         enum tel_sim_access_result rst = SIM_ACCESS_FAILED;\r
 290 \r
 291         if (status_word1 == 0x93 && status_word2 == 0x00)\r
 292         {\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
 296         }\r
 297         else if (status_word1 == 0x94 && status_word2 == 0x00)\r
 298         {\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
 302         }\r
 303         else if (status_word1 == 0x94 && status_word2 == 0x02)\r
 304         {\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
 309         }\r
 310         else if (status_word1 == 0x94 && status_word2 == 0x04)\r
 311         {\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
 315         }\r
 316         else if (status_word1 == 0x94 && status_word2 == 0x08)\r
 317         {\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
 322         }\r
 323         else if (status_word1 == 0x98 && status_word2 == 0x02)\r
 324         {\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
 328         }\r
 329         else if (status_word1 == 0x98 && status_word2 == 0x04)\r
 330         {\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
 339         }\r
 340         else if (status_word1 == 0x98 && status_word2 == 0x08)\r
 341         {\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
 345         }\r
 346         else if (status_word1 == 0x98 && status_word2 == 0x10)\r
 347         {\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
 352         }\r
 353         else if (status_word1 == 0x98 && status_word2 == 0x40)\r
 354         {\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
 362         }\r
 363         else if (status_word1 == 0x67 && status_word2 == 0x00)\r
 364         {\r
 365                 rst = SIM_ACCESS_FAILED;\r
 366                 dbg(" error -Incorrect Parameter 3 [%x][%x]", status_word1, status_word2);\r
 367         }\r
 368         else if (status_word1 == 0x6B && status_word2 == 0x00)\r
 369         {\r
 370                 rst = SIM_ACCESS_FAILED;\r
 371                 dbg(" error -Incorrect Parameter 1 or 2 [%x][%x]", status_word1, status_word2);\r
 372         }\r
 373         else if (status_word1 == 0x6D && status_word2 == 0x00)\r
 374         {\r
 375                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 376                 dbg(" error -Unknown instruction given as command [%x][%x]", status_word1, status_word2);\r
 377         }\r
 378         else if (status_word1 == 0x6E && status_word2 == 0x00)\r
 379         {\r
 380                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 381                 dbg(" error -Unknown instruction given as command [%x][%x]", status_word1, status_word2);\r
 382         }\r
 383         else if (status_word1 == 0x69 && status_word2 == 0x82)\r
 384         {\r
 385                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 386                 dbg(" error -Access denied [%x][%x]", status_word1, status_word2);\r
 387         }\r
 388         else if (status_word1 == 0x6A && status_word2 == 0x87)\r
 389         {\r
 390                 rst = SIM_ACCESS_FAILED;\r
 391                 dbg(" error -Incorrect parameters [%x][%x]", status_word1, status_word2);\r
 392         }\r
 393         else if (status_word1 == 0x6A && status_word2 == 0x82)\r
 394         {\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
 397         }\r
 398         else if (status_word1 == 0x6A && status_word2 == 0x83)\r
 399         {\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
 402         }\r
 403         else\r
 404         {\r
 405                 rst = SIM_ACCESS_CARD_ERROR;\r
 406                 dbg(" error -Unknown state [%x][%x]", status_word1, status_word2);\r
 407         }\r
 408         return rst;\r
 409 }\r
 410 \r
 411 static gboolean _sim_check_identity(CoreObject *o, struct tel_sim_imsi *imsi)\r
 412 {\r
 413         Server *s = NULL;\r
 414         Storage *strg = NULL;\r
 415         char* old_imsi = NULL;\r
 416         char new_imsi[15+1] = {0,};\r
 417 \r
 418         s = tcore_plugin_ref_server(tcore_object_ref_plugin(o));\r
 419         if(!s)\r
 420         {\r
 421                 dbg("there is no valid server at this point");\r
 422                 return FALSE;\r
 423         }\r
 424         strg = (Storage*)tcore_server_find_storage(s, "vconf");\r
 425         if(!strg)\r
 426         {\r
 427                 dbg("there is no valid storage plugin");\r
 428                 return FALSE;\r
 429         }\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
 433 \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
 436 \r
 437         if (old_imsi != NULL)\r
 438         {\r
 439                 if (strncmp(old_imsi, new_imsi, 15) != 0)\r
 440                 {\r
 441                         dbg("NEW SIM");\r
 442                         if (tcore_storage_set_string(strg, STORAGE_KEY_TELEPHONY_IMSI, (const char*) &new_imsi) == FALSE )\r
 443                         {\r
 444                                 dbg("[FAIL] UPDATE STORAGE_KEY_TELEPHONY_IMSI");\r
 445                         }\r
 446                         tcore_sim_set_identification(o, TRUE);\r
 447                 }\r
 448                 else\r
 449                 {\r
 450                         dbg("SAME SIM");\r
 451                         tcore_sim_set_identification(o, FALSE);\r
 452                 }\r
 453         }\r
 454         else\r
 455         {\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
 458                 {\r
 459                         dbg("[FAIL] UPDATE STORAGE_KEY_TELEPHONY_IMSI");\r
 460                 }\r
 461                 tcore_sim_set_identification(o, TRUE);\r
 462         }\r
 463         return 1;\r
 464 }\r
 465 \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
 467 {\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
 471 \r
 472         resp.result = 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
 475 \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
 478         {\r
 479                 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read),&resp);\r
 480                 return;\r
 481         }\r
 482 \r
 483         switch (ef)\r
 484         {\r
 485                 case SIM_EF_ELP:\r
 486                         if (rt == SIM_ACCESS_SUCCESS)\r
 487                         {\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
 492                         }\r
 493                         else\r
 494                         {\r
 495                                 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 496                                 {\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
 500                                 }\r
 501                                 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 502                                 {\r
 503                                         dbg(\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
 509                                         return;\r
 510                                 }\r
 511                         }\r
 512                         break;\r
 513 \r
 514                 case SIM_EF_LP: //same with SIM_EF_USIM_LI\r
 515                         if (rt == SIM_ACCESS_SUCCESS)\r
 516                         {\r
 517                                 dbg("[SIM DATA] exist EFLP/LI(0x6F05)");\r
 518                                 _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 519                         }\r
 520                         else\r
 521                         {\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
 525                                 {\r
 526                                         tcore_user_request_send_response(ur, _find_resp_command(ur),\r
 527                                                         sizeof(struct tresp_sim_read), &resp);\r
 528                                         return;\r
 529                                 }\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
 532                                 {\r
 533                                         dbg("[SIM DATA] try USIM EFPL(0x2F05)");\r
 534                                         _get_file_info(o, ur, SIM_EF_ELP);\r
 535                                 }\r
 536                         }\r
 537                         break;\r
 538 \r
 539                 case SIM_EF_USIM_PL:\r
 540                         if (rt == SIM_ACCESS_SUCCESS)\r
 541                         {\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
 544                         }\r
 545                         else\r
 546                         {\r
 547                                 /* EFELIand EFPL not present, so set language count as zero and select ECC */\r
 548                                 dbg(\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
 552                                 return;\r
 553                         }\r
 554                         break;\r
 555 \r
 556                 case SIM_EF_ECC:\r
 557                         if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 558                         {\r
 559                                 _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 560                         }\r
 561                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 562                         {\r
 563                                 if (file_meta->rec_count > SIM_ECC_RECORD_CNT_MAX)\r
 564                                 {\r
 565                                         file_meta->rec_count = SIM_ECC_RECORD_CNT_MAX;\r
 566                                 }\r
 567 \r
 568                                 file_meta->current_index++;\r
 569                                 _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);\r
 570                         }\r
 571                         break;\r
 572 \r
 573                 case SIM_EF_ICCID:\r
 574                 case SIM_EF_IMSI:\r
 575                 case SIM_EF_SST:\r
 576                 case SIM_EF_SPN:\r
 577                 case SIM_EF_SPDI:\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
 587                         break;\r
 588 \r
 589                 case SIM_EF_CPHS_CPHS_INFO:\r
 590                         if (rt == SIM_ACCESS_SUCCESS)\r
 591                         {\r
 592                                 tcore_sim_set_cphs_status(o, TRUE);\r
 593                                 if (!tcore_user_request_ref_communicator(ur))\r
 594                                 {\r
 595                                         dbg("internal CPHS INFO request before sim status update");\r
 596                                         _sim_status_update(o, SIM_STATUS_INIT_COMPLETED);\r
 597                                 } else\r
 598                                 {\r
 599                                         dbg("external CPHS INFO request");\r
 600                                         _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 601                                 }\r
 602                         } else\r
 603                         {\r
 604                                 tcore_sim_set_cphs_status(o, FALSE);\r
 605                                 if (!tcore_user_request_ref_communicator(ur))\r
 606                                 {\r
 607                                         dbg("internal CPHS INFO request before sim status update");\r
 608                                         _sim_status_update(o, SIM_STATUS_INIT_COMPLETED);\r
 609                                 } else\r
 610                                 {\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
 614                                 }\r
 615                         }\r
 616                         break;\r
 617 \r
 618 \r
 619                 case SIM_EF_USIM_CFIS:\r
 620                         if (file_meta->rec_count > SIM_CF_RECORD_CNT_MAX)\r
 621                         {\r
 622                                 file_meta->rec_count = SIM_CF_RECORD_CNT_MAX;\r
 623                         }\r
 624                         file_meta->current_index++;\r
 625                         _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);\r
 626                         break;\r
 627 \r
 628                 case SIM_EF_OPL:\r
 629                 case SIM_EF_PNN:\r
 630                 case SIM_EF_USIM_MWIS:\r
 631                 case SIM_EF_USIM_MBI:\r
 632                 case SIM_EF_MBDN:\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
 637                         break;\r
 638 \r
 639                 default:\r
 640                         dbg( "error - File id for get file info [0x%x]", ef);\r
 641                         break;\r
 642         }\r
 643         return;\r
 644 }\r
 645 \r
 646 static void _next_from_get_file_data(CoreObject *o, UserRequest *ur, enum tel_sim_access_result rt, int decode_ret)\r
 647 {\r
 648         struct s_sim_property *file_meta = NULL;\r
 649         dbg("Entry");\r
 650 \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
 654         {\r
 655                 case SIM_EF_ELP:\r
 656                 case SIM_EF_USIM_PL:\r
 657                 case SIM_EF_LP:\r
 658                 case SIM_EF_USIM_LI:\r
 659                         if (decode_ret == TRUE)\r
 660                         {\r
 661                                 if (file_meta->file_id == SIM_EF_LP || file_meta->file_id == SIM_EF_USIM_LI)\r
 662                                 {\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
 665                                 {\r
 666 /*                                      po->language_file = SIM_EF_ELP;*/\r
 667                                 }\r
 668                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 669                         } else\r
 670                         {\r
 671                                 /* 2G */\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
 676                                  */\r
 677                                 /* 3G */\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
 681                                  */\r
 682                                 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 683                                 {\r
 684                                         if (file_meta->file_id == SIM_EF_LP)\r
 685                                         {\r
 686                                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 687                                         }\r
 688                                         else\r
 689                                         {\r
 690                                                 _get_file_info(o, ur, SIM_EF_LP);\r
 691                                         }\r
 692                                 } else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 693                                 {\r
 694 \r
 695                                         if (file_meta->file_id == SIM_EF_LP || file_meta->file_id == SIM_EF_USIM_LI)\r
 696                                         {\r
 697                                                 _get_file_info(o, ur, SIM_EF_ELP);\r
 698                                         }\r
 699                                         else\r
 700                                         {\r
 701                                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 702                                         }\r
 703                                 }\r
 704                         }\r
 705                         break;\r
 706 \r
 707                 case SIM_EF_ECC:\r
 708                         if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 709                         {\r
 710                                 if (file_meta->current_index == file_meta->rec_count)\r
 711                                 {\r
 712                                         tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 713                                 } else\r
 714                                 {\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
 717                                 }\r
 718                         } else if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 719                         {\r
 720                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 721                         } else\r
 722                         {\r
 723                                 dbg("[SIM DATA]Invalid CardType[%d] Unable to handle", tcore_sim_get_type(o));\r
 724                         }\r
 725                         break;\r
 726 \r
 727                 case SIM_EF_IMSI:\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
 730                         break;\r
 731 \r
 732                 case SIM_EF_MSISDN:\r
 733                         if (file_meta->current_index == file_meta->rec_count)\r
 734                         {\r
 735                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 736                         } else\r
 737                         {\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
 740                         }\r
 741                         break;\r
 742 \r
 743                 case SIM_EF_OPL:\r
 744                         if (file_meta->current_index == file_meta->rec_count)\r
 745                         {\r
 746                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 747                         } else\r
 748                         {\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
 751                         }\r
 752                         break;\r
 753 \r
 754                 case SIM_EF_PNN:\r
 755                         if (file_meta->current_index == file_meta->rec_count)\r
 756                         {\r
 757                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 758                         } else\r
 759                         {\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
 762                         }\r
 763                         break;\r
 764 \r
 765                 case SIM_EF_USIM_CFIS:\r
 766                 case SIM_EF_USIM_MWIS:\r
 767                 case SIM_EF_USIM_MBI:\r
 768                 case SIM_EF_MBDN:\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
 772                         {\r
 773                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 774                         } else\r
 775                         {\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
 778                         }\r
 779                         break;\r
 780 \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
 784                         {\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
 786                         }\r
 787                         _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING);\r
 788                         break;\r
 789 \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
 792                         {\r
 793                                 file_meta->files.result = SIM_ACCESS_SUCCESS;\r
 794                         }\r
 795                         if (strlen((char*)file_meta->files.data.cphs_net.full_name))\r
 796                         {\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
 798                         }\r
 799                         tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 800                         break;\r
 801 \r
 802                 case SIM_EF_ICCID:\r
 803                 case SIM_EF_SST:\r
 804                 case SIM_EF_SPN:\r
 805                 case SIM_EF_SPDI:\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
 815                         break;\r
 816 \r
 817                 default:\r
 818                         dbg("File id not handled [0x%x]", file_meta->file_id);\r
 819                         break;\r
 820         }\r
 821 }\r
 822 \r
 823 static void _sim_status_update(CoreObject *o, enum tel_sim_status sim_status)\r
 824 {\r
 825         struct tnoti_sim_status noti_data = {0,};\r
 826 \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), &noti_data);\r
 832 }\r
 833 \r
 834 static void _response_get_sim_type(TcorePending *p, int data_len, const void *data, void *user_data)\r
 835 {\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
 842         const char *line;\r
 843         int state;\r
 844 \r
 845         dbg(" Function entry ");\r
 846 \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
 850 \r
 851         if(resp->success > 0)\r
 852         {\r
 853                 dbg("RESPONSE OK");\r
 854                 if(resp->lines)\r
 855                 {\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
 859                         {\r
 860                                 msg("invalid message");\r
 861                                 tcore_at_tok_free(tokens);\r
 862                                 return;\r
 863                         }\r
 864                 }\r
 865                 state = atoi(g_slist_nth_data(tokens, 0));\r
 866                 dbg("SIM Type is %d", state);\r
 867 \r
 868                 if(state == 0)\r
 869                 {\r
 870                         sim_type = SIM_TYPE_GSM;\r
 871                 }else if(state == 1)\r
 872                 {\r
 873                         sim_type = SIM_TYPE_USIM;\r
 874                 }else\r
 875                 {\r
 876                         sim_type = SIM_TYPE_UNKNOWN;\r
 877                 }\r
 878 \r
 879         }\r
 880         else\r
 881         {\r
 882                 dbg("RESPONSE NOK");\r
 883                 sim_type = SIM_TYPE_UNKNOWN;\r
 884         }\r
 885 \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
 890 }\r
 891 \r
 892 static void _response_get_file_info(TcorePending *p, int data_len, const void *data, void *user_data)\r
 893 {\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
 901         int sw1 = 0;\r
 902         int sw2 = 0;\r
 903 \r
 904         dbg(" Function entry ");\r
 905 \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
 909 \r
 910         if(resp->success > 0)\r
 911         {\r
 912                 dbg("RESPONSE OK");\r
 913                 if(resp->lines)\r
 914                 {\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
 918                         {\r
 919                                 err("invalid message");\r
 920                                 tcore_at_tok_free(tokens);\r
 921                                 return;\r
 922                         }\r
 923                 }\r
 924                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
 925                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
 926 \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
 938 \r
 939                         /*      handling only last 3 bits */\r
 940                         unsigned char file_type_tag = 0x07;\r
 941                         unsigned char *ptr_data;\r
 942 \r
 943                         char *hexData;\r
 944                         char *tmp;\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
 949 \r
 950                         tmp = calloc(1, strlen(hexData)-1);\r
 951                         memcpy(tmp, hexData+1, strlen(hexData)-2);\r
 952                         dbg("tmp: %s", tmp);\r
 953 \r
 954                         recordData = util_hexStringToBytes(tmp);\r
 955                         dbg("recordData: %x", recordData);\r
 956                         free(tmp);\r
 957                         util_hex_dump("    ", strlen(hexData)/2, recordData);\r
 958 \r
 959                         ptr_data = (unsigned char *)recordData;\r
 960                         if (tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)\r
 961                         {\r
 962                                 /*\r
 963                                  ETSI TS 102 221 v7.9.0\r
 964                                  - Response Data\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
 972                                  '80'   M       File size\r
 973                                  '81'   O       Total file size\r
 974                                  '88'   O       Short File Identifier (SFI)\r
 975                                  */\r
 976 \r
 977                                 /* rsim.res_len  has complete data length received  */\r
 978 \r
 979                                 /* FCP template tag - File Control Parameters tag*/\r
 980                                 if (*ptr_data == 0x62)\r
 981                                 {\r
 982                                         /* parse complete FCP tag*/\r
 983                                         /* increment to next byte */\r
 984                                         ptr_data++;\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
 989                                         {\r
 990                                                 /* increment to next byte */\r
 991                                                 ptr_data++;\r
 992                                                 /* 2 or 5 value*/\r
 993                                                 ptr_data++;\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
1001 \r
1002                                                 switch (file_type_tag)\r
1003                                                 {\r
1004                                                         /* increment to next byte */\r
1005                                                         //ptr_data++;\r
1006                                                         case 0x1:\r
1007                                                                 dbg("Getting FileType: [Transparent file type]");\r
1008                                                                 file_type = SIM_FTYPE_TRANSPARENT;\r
1009 \r
1010                                                                 /* increment to next byte */\r
1011                                                                 ptr_data++;\r
1012                                                                 /* increment to next byte */\r
1013                                                                 ptr_data++;\r
1014                                                                 break;\r
1015 \r
1016                                                         case 0x2:\r
1017                                                                 dbg("Getting FileType: [Linear fixed file type]");\r
1018                                                                 /* increment to next byte */\r
1019                                                                 ptr_data++;\r
1020                                                                 /*      data coding byte - value 21 */\r
1021                                                                 ptr_data++;\r
1022                                                                 /*      2bytes */\r
1023                                                                 memcpy(&record_len, ptr_data, 2);\r
1024                                                                 /* swap bytes */\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
1030                                                                 break;\r
1031 \r
1032                                                         case 0x6:\r
1033                                                                 dbg(" Cyclic fixed file type");\r
1034                                                                 /* increment to next byte */\r
1035                                                                 ptr_data++;\r
1036                                                                 /*      data coding byte - value 21 */\r
1037                                                                 ptr_data++;\r
1038                                                                 /*      2bytes */\r
1039                                                                 memcpy(&record_len, ptr_data, 2);\r
1040                                                                 /* swap bytes  */\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
1045                                                                 break;\r
1046 \r
1047                                                 default:\r
1048                                                         dbg("not handled file type [0x%x]", *ptr_data);\r
1049                                                         break;\r
1050                                                 }\r
1051                                         } else\r
1052                                         {\r
1053                                                 dbg("INVALID FCP received - DEbug!");\r
1054                                                 return;\r
1055                                         }\r
1056 \r
1057                                         /*File identifier - file id?? */ // 0x84,0x85,0x86 etc are currently ignored and not handled\r
1058                                         if (*ptr_data == 0x83)\r
1059                                         {\r
1060                                                 /* increment to next byte */\r
1061                                                 ptr_data++;\r
1062                                                 file_id_len = *ptr_data++;\r
1063                                                 dbg("file_id_len: %02x", file_id_len);\r
1064 \r
1065                                                 memcpy(&file_id, ptr_data, file_id_len);\r
1066                                                 dbg("file_id: %x", file_id);\r
1067 \r
1068                                                 /* swap bytes    */\r
1069                                                 SWAPBYTES16(file_id);\r
1070                                                 dbg("file_id: %x", file_id);\r
1071 \r
1072                                                 ptr_data = ptr_data + 2;\r
1073                                                 dbg("Getting FileID=[0x%x]", file_id);\r
1074                                         } else\r
1075                                         {\r
1076                                                 dbg("INVALID FCP received - DEbug!");\r
1077                                                 free(recordData);\r
1078                                                 return;\r
1079                                         }\r
1080 \r
1081                                         /*      proprietary information  */\r
1082                                         if (*ptr_data == 0xA5)\r
1083                                         {\r
1084                                                 unsigned short prop_len;\r
1085                                                 /* increment to next byte */\r
1086                                                 ptr_data++;\r
1087 \r
1088                                                 /* length */\r
1089                                                 prop_len = *ptr_data;\r
1090                                                 dbg("prop_len: %02x", prop_len);\r
1091 \r
1092                                                 /* skip data */\r
1093                                                 ptr_data = ptr_data + prop_len + 1;\r
1094                                         } else\r
1095                                         {\r
1096                                                 dbg("INVALID FCP received - DEbug!");\r
1097                                         }\r
1098 \r
1099                                         /* life cycle status integer [8A][length:0x01][status]*/\r
1100                                         /*\r
1101                                          status info b8~b1\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
1110                                          */\r
1111                                         if (*ptr_data == 0x8A)\r
1112                                         {\r
1113                                                 /* increment to next byte */\r
1114                                                 ptr_data++;\r
1115                                                 /* length - value 1 */\r
1116                                                 ptr_data++;\r
1117 \r
1118                                                 switch (*ptr_data) {\r
1119                                                         case 0x04:\r
1120                                                         case 0x06:\r
1121                                                                 dbg("<RX> operation state -deactivated");\r
1122                                                                 ptr_data++;\r
1123                                                                 break;\r
1124                                                         case 0x05:\r
1125                                                         case 0x07:\r
1126                                                                 dbg("<RX> operation state -activated");\r
1127                                                                 ptr_data++;\r
1128                                                                 break;\r
1129                                                         default:\r
1130                                                                 dbg("<RX> DEBUG! LIFE CYCLE STATUS =[0x%x]",*ptr_data);\r
1131                                                                 ptr_data++;\r
1132                                                                 break;\r
1133                                                 }\r
1134                                         }\r
1135 \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
1138                                         {\r
1139                                                 /* increment to next byte */\r
1140                                                 ptr_data++;\r
1141                                                 /* if tag length is 3 */\r
1142                                                 if (*ptr_data == 0x03)\r
1143                                                 {\r
1144                                                         /* increment to next byte */\r
1145                                                         ptr_data++;\r
1146                                                         /* EFARR file id */\r
1147                                                         memcpy(&arr_file_id, ptr_data, 2);\r
1148                                                         /* swap byes */\r
1149                                                         SWAPBYTES16(arr_file_id);\r
1150                                                         ptr_data = ptr_data + 2;\r
1151                                                         arr_file_id_rec_num = *ptr_data++;\r
1152                                                 } else\r
1153                                                 {\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
1159                                                 }\r
1160                                         } else\r
1161                                         {\r
1162                                                 dbg("INVALID FCP received[0x%x] - DEbug!", *ptr_data);\r
1163                                                 free(recordData);\r
1164                                                 return;\r
1165                                         }\r
1166 \r
1167                                         dbg("Current ptr_data value is [%x]", *ptr_data);\r
1168 \r
1169                                         /* file size excluding structural info*/\r
1170                                         if (*ptr_data == 0x80)\r
1171                                         {\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
1174                                                  */\r
1175                                                 /* increment to next byte */\r
1176                                                 ptr_data++;\r
1177                                                 /* length is 1 byte - value is 2 bytes or more */\r
1178                                                 ptr_data++;\r
1179                                                 memcpy(&file_size, ptr_data, 2);\r
1180                                                 /* swap bytes */\r
1181                                                 SWAPBYTES16(file_size);\r
1182                                                 ptr_data = ptr_data + 2;\r
1183                                         } else\r
1184                                         {\r
1185                                                 dbg("INVALID FCP received - DEbug!");\r
1186                                                 free(recordData);\r
1187                                                 return;\r
1188                                         }\r
1189 \r
1190                                         /* total file size including structural info*/\r
1191                                         if (*ptr_data == 0x81)\r
1192                                         {\r
1193                                                 int len;\r
1194                                                 /* increment to next byte */\r
1195                                                 ptr_data++;\r
1196                                                 /* length */\r
1197                                                 len = *ptr_data;\r
1198                                                 /* ignored bytes */\r
1199                                                 ptr_data = ptr_data + 3;\r
1200                                         } else\r
1201                                         {\r
1202                                                 dbg("INVALID FCP received - DEbug!");\r
1203                                                 /* 0x81 is optional tag?? check out! so do not return -1 from here! */\r
1204                                                 /* return -1; */\r
1205                                         }\r
1206                                         /*short file identifier ignored*/\r
1207                                         if (*ptr_data == 0x88)\r
1208                                         {\r
1209                                                 dbg("0x88: Do Nothing");\r
1210                                                 /*DO NOTHING*/\r
1211                                         }\r
1212                                 } else\r
1213                                 {\r
1214                                         dbg("INVALID FCP received - DEbug!");\r
1215                                         free(recordData);\r
1216                                         return;\r
1217                                 }\r
1218                         } else if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)\r
1219                         {\r
1220                                 unsigned char gsm_specific_file_data_len = 0;\r
1221                                 /*      ignore RFU byte1 and byte2 */\r
1222                                 ptr_data++;\r
1223                                 ptr_data++;\r
1224                                 /*      file size */\r
1225                                 //file_size = p_info->response_len;\r
1226                                 memcpy(&file_size, ptr_data, 2);\r
1227                                 /* swap bytes */\r
1228                                 SWAPBYTES16(file_size);\r
1229                                 /*      parsed file size */\r
1230                                 ptr_data = ptr_data + 2;\r
1231                                 /*  file id  */\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
1238 \r
1239                                 switch (*ptr_data)\r
1240                                 {\r
1241                                         case 0x0:\r
1242                                                 /* RFU file type */\r
1243                                                 dbg(" RFU file type- not handled - Debug!");\r
1244                                                 break;\r
1245                                         case 0x1:\r
1246                                                 /* MF file type */\r
1247                                                 dbg(" MF file type - not handled - Debug!");\r
1248                                                 break;\r
1249                                         case 0x2:\r
1250                                                 /* DF file type */\r
1251                                                 dbg(" DF file type - not handled - Debug!");\r
1252                                                 break;\r
1253                                         case 0x4:\r
1254                                                 /* EF file type */\r
1255                                                 dbg(" EF file type [%d] ", file_type_tag);\r
1256                                                 /*      increment to next byte */\r
1257                                                 ptr_data++;\r
1258 \r
1259                                                 if (file_type_tag == 0x00 || file_type_tag == 0x01)\r
1260                                                 {\r
1261                                                         /* increament to next byte as this byte is RFU */\r
1262                                                         ptr_data++;\r
1263                                                         file_type =\r
1264                                                                         (file_type_tag == 0x00) ? SIM_FTYPE_TRANSPARENT : SIM_FTYPE_LINEAR_FIXED;\r
1265                                                 } else\r
1266                                                 {\r
1267                                                         /* increment to next byte */\r
1268                                                         ptr_data++;\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
1272                                                 }\r
1273                                                 /* bytes 9 to 11 give SIM file access conditions */\r
1274                                                 ptr_data++;\r
1275                                                 /* byte 10 has one nibble that is RF U and another for INCREASE which is not used currently */\r
1276                                                 ptr_data++;\r
1277                                                 /* byte 11 is invalidate and rehabilate nibbles */\r
1278                                                 ptr_data++;\r
1279                                                 /* byte 12 - file status */\r
1280                                                 ptr_data++;\r
1281                                                 /* byte 13 - GSM specific data */\r
1282                                                 gsm_specific_file_data_len = *ptr_data;\r
1283                                                 ptr_data++;\r
1284                                                 /*      byte 14 - structure of EF - transparent or linear or cyclic , already saved above */\r
1285                                                 ptr_data++;\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
1289 \r
1290                                                 if (record_len != 0)\r
1291                                                         num_of_records = (file_size / record_len);\r
1292 \r
1293                                                 dbg("Number of records [%d]", num_of_records);\r
1294                                                 break;\r
1295 \r
1296                                         default:\r
1297                                                 dbg(" not handled file type");\r
1298                                                 break;\r
1299                                 }\r
1300                         }\r
1301                         else\r
1302                         {\r
1303                                 dbg(" Card Type - UNKNOWN  [%d]", tcore_sim_get_type(co_sim));\r
1304                         }\r
1305 \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
1308 \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
1315                         free(recordData);\r
1316                 }\r
1317                 else\r
1318                 {\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
1323                 }\r
1324                 ur = tcore_user_request_ref(ur);\r
1325                 \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
1329         }\r
1330         else\r
1331         {\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
1336 \r
1337                 ur = tcore_user_request_ref(ur);\r
1338                 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);\r
1339         }\r
1340         dbg(" Function exit");\r
1341 }\r
1342 \r
1343 static void _response_get_file_data(TcorePending *p, int data_len, const void *data, void *user_data)\r
1344 {\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
1358         char *res = NULL;\r
1359         char *tmp = NULL;\r
1360         int res_len;\r
1361         int sw1 = 0;\r
1362         int sw2 = 0;\r
1363 \r
1364         dbg(" Function entry ");\r
1365 \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
1369 \r
1370         if(resp->success > 0)\r
1371         {\r
1372                 dbg("RESPONSE OK");\r
1373                 if(resp->lines)\r
1374                 {\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
1378                         {\r
1379                                 msg("invalid message");\r
1380                                 tcore_at_tok_free(tokens);\r
1381                                 return;\r
1382                         }\r
1383                 }\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
1387 \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
1392 \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
1396 \r
1397                 if((sw1 == 0x90 && sw2 == 0x00) || sw1 == 0x91)\r
1398                 {\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
1402 \r
1403                         switch (file_meta->file_id)\r
1404                         {\r
1405                                 case SIM_EF_IMSI:\r
1406                                 {\r
1407                                         dbg("res: %s", res);\r
1408                                         dr = tcore_sim_decode_imsi(&imsi, (unsigned char*)res, res_len);\r
1409                                         if (dr == FALSE)\r
1410                                         {\r
1411                                                 dbg("imsi decoding failed");\r
1412                                         } else\r
1413                                         {\r
1414                                                 _sim_check_identity(co_sim,&imsi);\r
1415                                                 tcore_sim_set_imsi(co_sim,&imsi);\r
1416                                         }\r
1417                                         break;\r
1418                                 }\r
1419                                 case SIM_EF_ICCID:\r
1420                                         dr = tcore_sim_decode_iccid(&file_meta->files.data.iccid, (unsigned char*)res, res_len);\r
1421                                         break;\r
1422 \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
1428                                         {\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
1431                                         } else\r
1432                                         {\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
1435                                         }\r
1436                                         break;\r
1437                                 case SIM_EF_SPN:\r
1438                                         dr = tcore_sim_decode_spn(&file_meta->files.data.spn, (unsigned char*)res, res_len);\r
1439                                         break;\r
1440                                 case SIM_EF_SPDI:\r
1441                                         dr = tcore_sim_decode_spdi(&file_meta->files.data.spdi, (unsigned char*)res, res_len);\r
1442                                         break;\r
1443                                 case SIM_EF_ECC:\r
1444                                         if(tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)\r
1445                                         {\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
1448                                         {\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
1452                                                 if (dr == TRUE)\r
1453                                                 {\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
1456                                                 }\r
1457                                         } else\r
1458                                         {\r
1459                                                 dbg("err not handled tcore_sim_get_type(o)[%d] in here",tcore_sim_get_type(co_sim));\r
1460                                         }\r
1461                                         break;\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
1466                                         if (dr == TRUE)\r
1467                                         {\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
1470                                         }\r
1471                                         break;\r
1472                                 case SIM_EF_OPL:\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
1476                                         if (dr == TRUE)\r
1477                                         {\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
1480                                         }\r
1481                                         break;\r
1482                                 case SIM_EF_PNN:\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
1486                                         if (dr == TRUE)\r
1487                                         {\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
1490                                         }\r
1491                                         break;\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
1494                                         break;\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
1497                                         break;\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
1500                                         break;\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
1503                                         break;\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
1506                                         break;\r
1507                                 case SIM_EF_CPHS_SERVICE_STRING_TABLE:\r
1508                                         dbg(" not handled -SIM_EF_CPHS_SERVICE_STRING_TABLE ");\r
1509                                         break;\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
1513                                         break;\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
1516                                         break;\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
1519                                         break;\r
1520                                 default:\r
1521                                         dbg("File Decoding Failed - not handled File[0x%x]", file_meta->file_id);\r
1522                                         dr = 0;\r
1523                                         break;\r
1524                         }\r
1525                 }\r
1526                 else\r
1527                 {\r
1528                         rt =  _decode_status_word(sw1, sw2);\r
1529                         file_meta->files.result = rt;\r
1530                 }\r
1531                 free(tmp);\r
1532                 tcore_at_tok_free(tokens);\r
1533         }\r
1534         else\r
1535         {\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
1539         }\r
1540         ur = tcore_user_request_ref(ur);\r
1541         \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
1545 }\r
1546 \r
1547 static void _on_response_get_retry_count(TcorePending *p, int data_len, const void *data, void *user_data)\r
1548 {\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
1563 \r
1564         dbg(" Function entry ");\r
1565 \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
1569 \r
1570         if(resp->success > 0)\r
1571         {\r
1572                 dbg("RESPONSE OK");\r
1573                 if(resp->lines)\r
1574                 {\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
1578                         {\r
1579                                 msg("invalid message");\r
1580                                 tcore_at_tok_free(tokens);\r
1581                                 return;\r
1582                         }\r
1583                 }\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
1587 \r
1588                 dbg("lock_type = %d, attempts_left = %d, time_penalty = %d",\r
1589                 lock_type,attempts_left,time_penalty);\r
1590 \r
1591                 switch (sp->current_sec_op)\r
1592                 {\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
1602                                 break;\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
1610                                 break;\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
1618                                 break;\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
1632                                 break;\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
1646                                 break;\r
1647                         default:\r
1648                                 dbg("not handled sec op[%d]", sp->current_sec_op);\r
1649                                 break;\r
1650                 }\r
1651                 tcore_at_tok_free(tokens);\r
1652         }\r
1653         dbg(" Function exit");\r
1654 }\r
1655 \r
1656 static gboolean _get_sim_type(CoreObject *o)\r
1657 {\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
1663 \r
1664         dbg(" Function entry ");\r
1665 \r
1666         hal = tcore_object_get_hal(o);\r
1667         pending = tcore_pending_new(o, 0);\r
1668 \r
1669         cmd_str = g_strdup_printf("AT+XUICC?");\r
1670         req = tcore_at_request_new(cmd_str, "+XUICC:", TCORE_AT_SINGLELINE);\r
1671 \r
1672         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1673 \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
1679 \r
1680         free(cmd_str);\r
1681         dbg(" Function exit");\r
1682         return TRUE;\r
1683 }\r
1684 \r
1685 static TReturn _get_file_info(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef)\r
1686 {\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
1691         int trt = 0;\r
1692 \r
1693         dbg(" Function entry ");\r
1694 \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
1700 \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
1705 \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
1709 \r
1710         free(cmd_str);\r
1711         dbg(" Function exit");\r
1712         return TCORE_RETURN_SUCCESS;\r
1713 }\r
1714 \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
1716 {\r
1717         TcoreHal* hal= NULL;\r
1718         TcoreATRequest *req= NULL;\r
1719         TcorePending *pending = NULL;\r
1720         char *cmd_str = NULL;\r
1721         int p1 = 0;\r
1722         int p2 = 0;\r
1723         int p3 = 0;\r
1724 \r
1725         dbg(" Function entry ");\r
1726         hal = tcore_object_get_hal(o);\r
1727         pending = tcore_pending_new(o, 0);\r
1728 \r
1729         dbg("file_id: %x", ef);\r
1730 \r
1731         p1 = (unsigned char)(offset & 0xFF00) >> 8;\r
1732         p2 = (unsigned char)offset & 0x00FF; //offset low\r
1733         p3 = (unsigned char)length;\r
1734 \r
1735         cmd_str = g_strdup_printf("AT+CRSM=176, %d, %d, %d, %d", ef,p1,p2,p3);                  /*command - 176 : READ BINARY*/\r
1736 \r
1737         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
1738 \r
1739         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1740 \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
1745 \r
1746         tcore_hal_send_request(hal, pending);\r
1747 \r
1748         free(cmd_str);\r
1749         dbg(" Function exit");\r
1750         return TRUE;\r
1751 }\r
1752 \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
1754 {\r
1755 \r
1756         TcoreHal* hal= NULL;\r
1757         TcoreATRequest *req= NULL;\r
1758         TcorePending *pending = NULL;\r
1759         char *cmd_str = NULL;\r
1760         int p1 = 0;\r
1761         int p2 = 0;\r
1762         int p3 = 0;\r
1763         dbg(" Function entry ");\r
1764 \r
1765         hal = tcore_object_get_hal(o);\r
1766         pending = tcore_pending_new(o, 0);\r
1767 \r
1768         p1 = (unsigned char)index;\r
1769         p2 = (unsigned char)0x04;               /* 0x4 for absolute mode  */\r
1770         p3 = (unsigned char)length;\r
1771 \r
1772         cmd_str = g_strdup_printf("AT+CRSM=178, %d, %d, %d, %d", ef,p1,p2,p3);                  /*command - 178 : READ RECORD*/\r
1773 \r
1774         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
1775 \r
1776         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1777 \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
1782 \r
1783         tcore_hal_send_request(hal, pending);\r
1784 \r
1785         free(cmd_str);\r
1786         dbg(" Function exit");\r
1787         return TRUE;\r
1788 }\r
1789 \r
1790 static TReturn _get_retry_count(CoreObject *o, UserRequest *ur)\r
1791 {\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
1799 \r
1800         dbg(" Function entry ");\r
1801 \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
1806 \r
1807         switch (sp->current_sec_op)\r
1808         {\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
1813                         lock_type = 1;\r
1814                         break;\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
1821                         lock_type = 2;\r
1822                         break;\r
1823                 case SEC_PUK1_VERIFY:\r
1824                         lock_type = 3;\r
1825                         break;\r
1826                 case SEC_PUK2_VERIFY:\r
1827                         lock_type = 4;\r
1828                         break;\r
1829                 case SEC_NET_ENABLE:\r
1830                 case SEC_NET_DISABLE:\r
1831                         lock_type = 5;\r
1832                         break;\r
1833                 case SEC_NS_ENABLE:\r
1834                 case SEC_NS_DISABLE:\r
1835                         lock_type = 6;\r
1836                         break;\r
1837                 case SEC_SP_ENABLE:\r
1838                 case SEC_SP_DISABLE:\r
1839                         lock_type = 7;\r
1840                         break;\r
1841                 case SEC_CP_ENABLE:\r
1842                 case SEC_CP_DISABLE:\r
1843                         lock_type = 8;\r
1844                         break;\r
1845                 case SEC_ADM_VERIFY:\r
1846                         lock_type = 9;\r
1847                         break;\r
1848                 default:\r
1849                         break;\r
1850         }\r
1851 \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
1855 \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
1861 \r
1862         free(cmd_str);\r
1863         dbg(" Function exit");\r
1864         return TCORE_RETURN_SUCCESS;\r
1865 }\r
1866 \r
1867 \r
1868 static gboolean on_event_facility_lock_status(CoreObject *o, const void *event_info, void *user_data)\r
1869 {\r
1870         struct s_sim_property *sp = NULL;\r
1871         char *line = NULL;\r
1872         GSList *tokens=NULL;\r
1873         GSList *lines = NULL;\r
1874 \r
1875         dbg("Function entry");\r
1876         return TRUE;\r
1877 \r
1878         sp = tcore_sim_ref_userdata(o);\r
1879         lines = (GSList*)event_info;\r
1880         if (1 != g_slist_length(lines))\r
1881         {\r
1882                 dbg("unsolicited msg but multiple line");\r
1883                 goto OUT;\r
1884         }\r
1885         line  = (char*)(lines->data);\r
1886         tokens = tcore_at_tok_new(line);\r
1887         if (g_slist_length(tokens) != 1)\r
1888         {\r
1889                 msg("invalid message");\r
1890                 tcore_at_tok_free(tokens);\r
1891                 return TRUE;\r
1892         }\r
1893 \r
1894 OUT:\r
1895         dbg(" Function exit");\r
1896         if(NULL!=tokens)\r
1897                 tcore_at_tok_free(tokens);\r
1898         return TRUE;\r
1899 }\r
1900 \r
1901 \r
1902 static gboolean on_event_pin_status(CoreObject *o, const void *event_info, void *user_data)\r
1903 {\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
1911 \r
1912         dbg(" Function entry ");\r
1913 \r
1914         sp = tcore_sim_ref_userdata(o);\r
1915 \r
1916         lines = (GSList*)event_info;\r
1917         if (1 != g_slist_length(lines))\r
1918         {\r
1919                 dbg("unsolicited msg but multiple line");\r
1920                 goto OUT;\r
1921         }\r
1922         line  = (char*)(lines->data);\r
1923 \r
1924         tokens = tcore_at_tok_new(line);\r
1925         if (g_slist_length(tokens) != 1)\r
1926         {\r
1927                 msg("invalid message");\r
1928                 tcore_at_tok_free(tokens);\r
1929                 return TRUE;\r
1930         }\r
1931         sim_state = atoi(g_slist_nth_data(tokens, 0));\r
1932 \r
1933         switch (sim_state)\r
1934         {\r
1935                 case 0:                                                                                                         //sim state = SIM not present\r
1936                         sim_status = SIM_STATUS_CARD_NOT_PRESENT;\r
1937                         dbg( "NO SIM");\r
1938                         break;\r
1939                 case 1:                                                                                                         //sim state = PIN verification needed\r
1940                         sim_status = SIM_STATUS_PIN_REQUIRED;\r
1941                         dbg( " PIN required");\r
1942                         break;\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
1947                         break;\r
1948                 case 4:                                                                                                         //sim state = PUK verification needed\r
1949                         sim_status = SIM_STATUS_PUK_REQUIRED;\r
1950                         dbg(" PUK required");\r
1951                         break;\r
1952                 case 5:                                                                                                         //sim state = SIM permanently blocked\r
1953                         sim_status = SIM_STATUS_CARD_BLOCKED;\r
1954                         dbg(" Card permanently blocked");\r
1955                         break;\r
1956                 case 6:                                                                                                         //sim state = SIM error\r
1957                         sim_status = SIM_STATUS_CARD_ERROR;\r
1958                         dbg( "SIM card error ");\r
1959                         break;\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
1963                         break;\r
1964                 case 8:                                                                                                         //sim state = SIM Technical Problem\r
1965                         sim_status = SIM_STATUS_CARD_ERROR;\r
1966                         dbg( "SIM unavailable");\r
1967                         break;\r
1968                 case 9:                                                                                                         //sim state = SIM removed\r
1969                         sim_status = SIM_STATUS_CARD_REMOVED;\r
1970                         dbg( "SIM removed");\r
1971                         break;\r
1972                 case 99:                                                                                                                //sim state = SIM State Unknown\r
1973                         sim_status = SIM_STATUS_UNKNOWN;\r
1974                         dbg( "SIM State Unknown");\r
1975                         break;\r
1976                 case 12:\r
1977                         dbg( "SIM Status : %d", sim_status);\r
1978                         goto OUT;\r
1979                 default:\r
1980                         dbg(" not handled SEC lock type ");\r
1981                         break;\r
1982         }\r
1983 \r
1984         switch (sim_status)\r
1985         {\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
1989                         break;\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
2000                         {\r
2001                                 dbg("first received sim status[%d]",sim_status);\r
2002                                 sp->first_recv_status = sim_status;\r
2003                                 _get_sim_type(o);\r
2004                         } else {\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
2007                                 {\r
2008                                         dbg("sim is not init complete in telephony side yet");\r
2009                                         _sim_status_update(o,sim_status);\r
2010                                 }\r
2011                         }\r
2012                         break;\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
2017                         {\r
2018                                 dbg("[SIM]SIM CARD REMOVED!!");\r
2019                                 sim_status = SIM_STATUS_CARD_REMOVED;\r
2020                         }\r
2021                         _sim_status_update(o,sim_status);\r
2022                         break;\r
2023                 default:\r
2024                         dbg("not handled status[%d]", sim_status);\r
2025 \r
2026                         break;\r
2027                 }\r
2028 OUT:\r
2029         dbg(" Function exit");\r
2030         if(NULL!=tokens)\r
2031                 tcore_at_tok_free(tokens);\r
2032         return TRUE;\r
2033 }\r
2034 \r
2035 \r
2036 \r
2037 static void on_response_verify_pins(TcorePending *p, int data_len, const void *data, void *user_data)\r
2038 {\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
2046         const char *line;\r
2047         int err;\r
2048 \r
2049         dbg(" Function entry ");\r
2050 \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
2054 \r
2055         memset(&res, 0, sizeof(struct tresp_sim_verify_pins));\r
2056 \r
2057         if(resp->success > 0)\r
2058         {\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
2063                 {\r
2064                         if (tcore_sim_get_status(co_sim) != SIM_STATUS_INIT_COMPLETED)\r
2065                                 _sim_status_update(co_sim, SIM_STATUS_INITIALIZING);\r
2066                 }\r
2067                 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PINS,     sizeof(struct tresp_sim_verify_pins), &res);\r
2068         }\r
2069         else\r
2070         {\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
2075                 {\r
2076                         dbg("err cause not specified or string corrupted");\r
2077                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2078                 }\r
2079                 else\r
2080                 {\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
2086                 }\r
2087                 tcore_at_tok_free(tokens);\r
2088         }\r
2089         dbg(" Function exit");\r
2090 }\r
2091 \r
2092 static void on_response_verify_puks(TcorePending *p, int data_len, const void *data, void *user_data)\r
2093 {\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
2101         const char *line;\r
2102         int err;\r
2103 \r
2104         dbg(" Function entry ");\r
2105 \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
2109 \r
2110         memset(&res, 0, sizeof(struct tresp_sim_verify_pins));\r
2111 \r
2112         if(resp->success > 0)\r
2113         {\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
2118         }\r
2119         else\r
2120         {\r
2121                 dbg("RESPONSE NOK");\r
2122                 line = (const char*)resp->final_response;\r
2123                 tokens = tcore_at_tok_new(line);\r
2124 \r
2125                 if (g_slist_length(tokens) < 1)\r
2126                 {\r
2127                         dbg("err cause not specified or string corrupted");\r
2128                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2129                 }\r
2130                 else\r
2131                 {\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
2136                 }\r
2137                 tcore_at_tok_free(tokens);\r
2138         }\r
2139         dbg(" Function exit");\r
2140 }\r
2141 \r
2142 static void on_response_change_pins(TcorePending *p, int data_len, const void *data, void *user_data)\r
2143 {\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
2150         GQueue *queue;\r
2151         const char *line;\r
2152         int err;\r
2153 \r
2154         dbg(" Function entry ");\r
2155 \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
2159 \r
2160         memset(&res, 0, sizeof(struct tresp_sim_change_pins));\r
2161 \r
2162         if(resp->success > 0)\r
2163         {\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
2168         }\r
2169         else\r
2170         {\r
2171                 dbg("RESPONSE NOK");\r
2172                 line = (const char*)resp->final_response;\r
2173                 tokens = tcore_at_tok_new(line);\r
2174 \r
2175                 if (g_slist_length(tokens) < 1)\r
2176                 {\r
2177                         dbg("err cause not specified or string corrupted");\r
2178                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2179                 }\r
2180                 else\r
2181                 {\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
2186                 }\r
2187                 tcore_at_tok_free(tokens);\r
2188         }\r
2189         dbg(" Function exit");\r
2190 }\r
2191 \r
2192 static void on_response_get_facility_status(TcorePending *p, int data_len, const void *data, void *user_data)\r
2193 {\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
2200         const char *line;\r
2201 \r
2202         dbg(" Function entry ");\r
2203 \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
2207 \r
2208         memset(&res, 0, sizeof(struct tresp_sim_get_facility_status));\r
2209 \r
2210         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2211         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2212 \r
2213         if(resp->success > 0)\r
2214         {\r
2215                 dbg("RESPONSE OK");\r
2216                 if(resp->lines) {\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
2220                         {\r
2221                                 msg("invalid message");\r
2222                                 tcore_at_tok_free(tokens);\r
2223                                 return;\r
2224                         }\r
2225                 }\r
2226                 res.b_enable = atoi(g_slist_nth_data(tokens, 0));\r
2227 \r
2228         }\r
2229         else\r
2230         {\r
2231                 dbg("RESPONSE NOK");\r
2232                 res.result = SIM_INCOMPATIBLE_PIN_OPERATION;\r
2233         }\r
2234 \r
2235         if (ur)\r
2236         {\r
2237                 tcore_user_request_send_response(ur, TRESP_SIM_GET_FACILITY_STATUS,\r
2238                                 sizeof(struct tresp_sim_get_facility_status), &res);\r
2239         }\r
2240         tcore_at_tok_free(tokens);\r
2241         dbg(" Function exit");\r
2242 }\r
2243 \r
2244 static void on_response_enable_facility(TcorePending *p, int data_len, const void *data, void *user_data)\r
2245 {\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
2252         GQueue *queue;\r
2253         const char *line;\r
2254 \r
2255         dbg(" Function entry ");\r
2256 \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
2260 \r
2261         memset(&res, 0, sizeof(struct tresp_sim_enable_facility));\r
2262 \r
2263         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2264         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2265 \r
2266         if(resp->success > 0)\r
2267         {\r
2268                 dbg("RESPONSE OK");\r
2269                 if(resp->lines)\r
2270                 {\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
2274                         {\r
2275                                 msg("invalid message");\r
2276                                 tcore_at_tok_free(tokens);\r
2277                                 return;\r
2278                         }\r
2279                 }\r
2280                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2281                 if (ur)\r
2282                 {\r
2283                         tcore_user_request_send_response(ur, TRESP_SIM_ENABLE_FACILITY,\r
2284                                 sizeof(struct tresp_sim_enable_facility), &res);\r
2285                 }\r
2286                 tcore_at_tok_free(tokens);\r
2287         }\r
2288         else\r
2289         {\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
2294         }\r
2295         dbg(" Function exit");\r
2296 }\r
2297 \r
2298 static void on_response_disable_facility(TcorePending *p, int data_len, const void *data, void *user_data)\r
2299 {\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
2306         GQueue *queue;\r
2307         const char *line;\r
2308 \r
2309         dbg(" Function entry ");\r
2310 \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
2314 \r
2315         memset(&res, 0, sizeof(struct tresp_sim_disable_facility));\r
2316 \r
2317         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2318         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2319 \r
2320         if(resp->success > 0)\r
2321         {\r
2322                 dbg("RESPONSE OK");\r
2323                 if(resp->lines) {\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
2327                         {\r
2328                                 msg("invalid message");\r
2329                                 tcore_at_tok_free(tokens);\r
2330                                 return;\r
2331                         }\r
2332                 }\r
2333                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2334                 if (ur)\r
2335                 {\r
2336                         tcore_user_request_send_response(ur, TRESP_SIM_DISABLE_FACILITY,\r
2337                                 sizeof(struct tresp_sim_disable_facility), &res);\r
2338                 }\r
2339                 tcore_at_tok_free(tokens);\r
2340         }\r
2341         else\r
2342         {\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
2347         }\r
2348         dbg(" Function exit");\r
2349 }\r
2350 \r
2351 static void on_response_get_lock_info(TcorePending *    p, int data_len, const void *data, void *user_data)\r
2352 {\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
2358         const char *line;\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
2364         int lock_type;\r
2365         int attempts_left = 0;\r
2366         int time_penalty = 0;\r
2367 \r
2368         dbg(" Function entry ");\r
2369 \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
2373 \r
2374         if(resp->success > 0)\r
2375         {\r
2376                 dbg("RESPONSE OK");\r
2377                 if(resp->lines) {\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
2381                         {\r
2382                                 msg("invalid message");\r
2383                                 tcore_at_tok_free(tokens);\r
2384                                 return;\r
2385                         }\r
2386                 }\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
2390 \r
2391                 switch (sp->current_sec_op)\r
2392                 {\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
2402                                 break;\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
2410                                 break;\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
2418                                 break;\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
2432                                 break;\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
2446                                 break;\r
2447                         default:\r
2448                                 dbg("not handled sec op[%d]", sp->current_sec_op);\r
2449                                 break;\r
2450                 }\r
2451                 tcore_at_tok_free(tokens);\r
2452         }\r
2453         dbg(" Function exit");\r
2454 }\r
2455 \r
2456 static void on_response_update_file(TcorePending *p, int data_len, const void *data, void *user_data)\r
2457 {\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
2466         const char *line;\r
2467         int sw1 = 0;\r
2468         int sw2 = 0;\r
2469 \r
2470         dbg(" Function entry ");\r
2471 \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
2475 \r
2476         if(resp->success > 0)\r
2477         {\r
2478                 dbg("RESPONSE OK");\r
2479                 if(resp->lines)\r
2480                 {\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
2484                         {\r
2485                                 msg("invalid message");\r
2486                                 tcore_at_tok_free(tokens);\r
2487                                 return;\r
2488                         }\r
2489                 }\r
2490                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
2491                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
2492 \r
2493                 if((sw1 == 0x90 && sw2 == 0x00) ||sw1 == 0x91)\r
2494                 {\r
2495                         result = SIM_ACCESS_SUCCESS;\r
2496                 }else\r
2497                 {\r
2498                         result =  _decode_status_word(sw1, sw2);\r
2499                 }\r
2500         }else{\r
2501                 dbg("RESPONSE NOK");\r
2502                 result = SIM_ACCESS_FAILED;\r
2503         }\r
2504 \r
2505         switch(sp->file_id)\r
2506         {\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
2510                         break;\r
2511                 case SIM_EF_ELP:\r
2512                 case SIM_EF_LP:\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
2516                         break;\r
2517                 default:\r
2518                         break;\r
2519         }\r
2520         tcore_at_tok_free(tokens);\r
2521         dbg(" Function exit");\r
2522 }\r
2523 \r
2524 static void on_response_transmit_apdu(TcorePending *p, int data_len, const void *data, void *user_data)\r
2525 {\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
2532         const char *line;\r
2533 \r
2534         dbg(" Function entry ");\r
2535 \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
2539 \r
2540         memset(&res, 0, sizeof(struct tresp_sim_transmit_apdu));\r
2541 \r
2542         if(resp->success > 0)\r
2543         {\r
2544                 dbg("RESPONSE OK");\r
2545                 res.result = SIM_ACCESS_SUCCESS;\r
2546                 if(resp->lines)\r
2547                 {\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
2551                         {\r
2552                                 msg("invalid message");\r
2553                                 tcore_at_tok_free(tokens);\r
2554                                 return;\r
2555                         }\r
2556                 }\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
2559         }\r
2560         else\r
2561         {\r
2562                 dbg("RESPONSE NOK");\r
2563                 res.result = SIM_ACCESS_FAILED;\r
2564         }\r
2565         ur = tcore_pending_ref_user_request(p);\r
2566         if (ur)\r
2567         {\r
2568                 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_transmit_apdu), &res);\r
2569         }\r
2570         tcore_at_tok_free(tokens);\r
2571         dbg(" Function exit");\r
2572 }\r
2573 \r
2574 static TReturn s_verify_pins(CoreObject *o, UserRequest *ur)\r
2575 {\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
2582 \r
2583         dbg(" Function entry ");\r
2584 \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
2589 \r
2590         if (!o || !ur)\r
2591                 return TCORE_RETURN_EINVAL;\r
2592 \r
2593         if (req_data->pin_type == SIM_PTYPE_PIN1)\r
2594         {\r
2595                 sp->current_sec_op = SEC_PIN1_VERIFY;\r
2596                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2597         }\r
2598         else if (req_data->pin_type == SIM_PTYPE_PIN2)\r
2599         {\r
2600                 sp->current_sec_op = SEC_PIN2_VERIFY;\r
2601                 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\"", req_data->pin);\r
2602         }\r
2603         else if (req_data->pin_type == SIM_PTYPE_SIM)\r
2604         {\r
2605                 sp->current_sec_op = SEC_SIM_VERIFY;\r
2606                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2607         }\r
2608         else if (req_data->pin_type == SIM_PTYPE_ADM)\r
2609         {\r
2610                 sp->current_sec_op = SEC_ADM_VERIFY;\r
2611                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2612         }\r
2613         else\r
2614         {\r
2615                 return TCORE_RETURN_EINVAL;\r
2616         }\r
2617 \r
2618         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2619 \r
2620         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2621 \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
2627 \r
2628         free(cmd_str);\r
2629         dbg(" Function exit");\r
2630         return TCORE_RETURN_SUCCESS;\r
2631 }\r
2632 \r
2633 static TReturn s_verify_puks(CoreObject *o, UserRequest *ur)\r
2634 {\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
2641 \r
2642         dbg(" Function entry ");\r
2643 \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
2648 \r
2649         if (!o || !ur)\r
2650                 return TCORE_RETURN_EINVAL;\r
2651 \r
2652         if(req_data->puk_type == SIM_PTYPE_PUK1)\r
2653         {\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
2656         }\r
2657         else if(req_data->puk_type == SIM_PTYPE_PUK2)\r
2658         {\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
2661         }\r
2662         else\r
2663         {\r
2664                 return TCORE_RETURN_EINVAL;\r
2665         }\r
2666         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2667 \r
2668         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2669 \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
2675 \r
2676         free(cmd_str);\r
2677         dbg(" Function exit");\r
2678         return TCORE_RETURN_SUCCESS;\r
2679 }\r
2680 \r
2681 static TReturn s_change_pins(CoreObject *o, UserRequest *ur)\r
2682 {\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
2691 \r
2692         dbg(" Function entry ");\r
2693 \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
2698 \r
2699         if (!o || !ur)\r
2700                 return TCORE_RETURN_EINVAL;\r
2701                 \r
2702         if(req_data->type == SIM_PTYPE_PIN1)\r
2703         {\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
2706 \r
2707         }\r
2708         else if(req_data->type == SIM_PTYPE_PIN2)\r
2709         {\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
2712         }\r
2713         else\r
2714         {\r
2715                 return TCORE_RETURN_EINVAL;\r
2716         }\r
2717         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2718 \r
2719         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2720 \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
2726 \r
2727         free(cmd_str);\r
2728         dbg(" Function exit");\r
2729         return TCORE_RETURN_SUCCESS;\r
2730 }\r
2731 \r
2732 static TReturn s_get_facility_status(CoreObject *o, UserRequest *ur)\r
2733 {\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
2740         char *fac = "SC";\r
2741         int mode = 2;           /* 0:unlock, 1:lock, 2:query*/\r
2742 \r
2743         dbg(" Function entry ");\r
2744 \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
2749 \r
2750         if (!o || !ur)\r
2751                 return TCORE_RETURN_EINVAL;\r
2752 \r
2753         if(req_data->type == SIM_FACILITY_PS)\r
2754         {\r
2755                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2756         }else if(req_data->type == SIM_FACILITY_SC)\r
2757         {\r
2758                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2759         }else if(req_data->type == SIM_FACILITY_FD)\r
2760         {\r
2761                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2762         }else if(req_data->type == SIM_FACILITY_PN)\r
2763         {\r
2764                 fac = "PN";                                                             /*Network Personalization*/\r
2765         }else if(req_data->type == SIM_FACILITY_PU)\r
2766         {\r
2767                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2768         }else if(req_data->type == SIM_FACILITY_PP)\r
2769         {\r
2770                 fac = "PP";                                                             /*service Provider Personalization*/\r
2771         }else if(req_data->type == SIM_FACILITY_PC)\r
2772         {\r
2773                 fac = "PC";                                                             /*Corporate Personalization*/\r
2774         }else\r
2775         {\r
2776                 return TCORE_RETURN_EINVAL;\r
2777         }\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
2780 \r
2781         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2782 \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
2788 \r
2789         free(cmd_str);\r
2790         dbg(" Function exit");\r
2791         return TCORE_RETURN_SUCCESS;\r
2792 }\r
2793 \r
2794 static TReturn s_enable_facility(CoreObject *o, UserRequest *ur)\r
2795 {\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
2802         char *fac = "SC";\r
2803         int mode = 1;           /* 0:unlock, 1:lock, 2:query*/\r
2804 \r
2805         dbg(" Function entry ");\r
2806 \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
2811 \r
2812         if (!o || !ur)\r
2813                 return TCORE_RETURN_EINVAL;\r
2814 \r
2815         if(req_data->type == SIM_FACILITY_PS)\r
2816         {\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
2820         {\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
2824         {\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
2828         {\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
2832         {\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
2836         {\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
2840         {\r
2841                 fac = "PC";                                                             /*Corporate Personalization*/\r
2842                 sp->current_sec_op = SEC_CP_ENABLE;\r
2843         }else\r
2844         {\r
2845                 return TCORE_RETURN_EINVAL;\r
2846         }\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
2849 \r
2850         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2851 \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
2857 \r
2858         free(cmd_str);\r
2859         dbg(" Function exit");\r
2860         return TCORE_RETURN_SUCCESS;\r
2861 }\r
2862 \r
2863 static TReturn s_disable_facility(CoreObject *o, UserRequest *ur)\r
2864 {\r
2865         TcoreHal* hal;\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
2871         char *fac = "SC";\r
2872         int mode = 0;           /* 0:unlock, 1:lock, 2:query*/\r
2873 \r
2874         dbg(" Function entry ");\r
2875 \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
2880 \r
2881         if (!o || !ur)\r
2882                 return TCORE_RETURN_EINVAL;\r
2883 \r
2884         if(req_data->type == SIM_FACILITY_PS)\r
2885         {\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
2889         {\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
2893         {\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
2897         {\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
2901         {\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
2905         {\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
2909         {\r
2910                 fac = "PC";                                                             /*Corporate Personalization*/\r
2911                 sp->current_sec_op = SEC_CP_DISABLE;\r
2912         }else\r
2913         {\r
2914                 return TCORE_RETURN_EINVAL;\r
2915         }\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
2918 \r
2919         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2920 \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
2926 \r
2927         free(cmd_str);\r
2928         dbg(" Function exit");\r
2929         return TCORE_RETURN_SUCCESS;\r
2930 }\r
2931 \r
2932 static TReturn s_get_lock_info(CoreObject *o, UserRequest *ur)\r
2933 {\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
2941 \r
2942         dbg(" Function entry ");\r
2943 \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
2948 \r
2949         if (!o || !ur)\r
2950                 return TCORE_RETURN_EINVAL;\r
2951 \r
2952         switch (req_data->type)\r
2953         {\r
2954                 case SIM_FACILITY_PS:\r
2955                         lock_type = "PS";\r
2956                         break;\r
2957                 case SIM_FACILITY_SC:\r
2958                         lock_type = "SC";\r
2959                         break;\r
2960                 case SIM_FACILITY_FD:\r
2961                         lock_type = "FD";\r
2962                         break;\r
2963                 case SIM_FACILITY_PN:\r
2964                         lock_type = "PN";\r
2965                         break;\r
2966                 case SIM_FACILITY_PU:\r
2967                         lock_type = "PU";\r
2968                         break;\r
2969                 case SIM_FACILITY_PP:\r
2970                         lock_type = "PP";\r
2971                         break;\r
2972                 case SIM_FACILITY_PC:\r
2973                         lock_type = "PC";\r
2974                         break;\r
2975                 default:\r
2976                         break;\r
2977         }\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
2980 \r
2981         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2982 \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
2988 \r
2989         free(cmd_str);\r
2990         dbg(" Function exit");\r
2991         return TCORE_RETURN_SUCCESS;\r
2992 }\r
2993 \r
2994 static TReturn s_read_file(CoreObject *o, UserRequest *ur)\r
2995 {\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
2999 \r
3000         dbg(" Function entry ");\r
3001 \r
3002         if (!o || !ur)\r
3003                 return TCORE_RETURN_EINVAL;\r
3004 \r
3005         switch (command)\r
3006         {\r
3007                 case TREQ_SIM_GET_ECC:\r
3008                         api_ret = _get_file_info(o, ur, SIM_EF_ECC);\r
3009                         break;\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
3015                         else\r
3016                                 api_ret = TCORE_RETURN_ENOSYS;\r
3017                         break;\r
3018                 case TREQ_SIM_GET_ICCID:\r
3019                         api_ret = _get_file_info(o, ur, SIM_EF_ICCID);\r
3020                         break;\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
3024                         else\r
3025                                 api_ret = _get_file_info(o, ur, SIM_EF_MBDN);\r
3026                         break;\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
3030                         else\r
3031                                 api_ret = _get_file_info(o, ur, SIM_EF_USIM_CFIS);\r
3032                         break;\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
3036                         else\r
3037                                 api_ret = _get_file_info(o, ur, SIM_EF_USIM_MWIS);\r
3038                         break;\r
3039                 case TREQ_SIM_GET_CPHS_INFO:\r
3040                         api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CPHS_INFO);\r
3041                         break;\r
3042                 case TREQ_SIM_GET_MSISDN:\r
3043                         api_ret = _get_file_info(o, ur, SIM_EF_MSISDN);\r
3044                         break;\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
3048                         break;\r
3049                 case TREQ_SIM_GET_SPDI:\r
3050                         api_ret = _get_file_info(o, ur, SIM_EF_SPDI);\r
3051                         break;\r
3052                 case TREQ_SIM_GET_OPL:\r
3053                         api_ret = _get_file_info(o, ur, SIM_EF_OPL);\r
3054                         break;\r
3055                 case TREQ_SIM_GET_PNN:\r
3056                         api_ret = _get_file_info(o, ur, SIM_EF_PNN);\r
3057                         break;\r
3058                 case TREQ_SIM_GET_CPHS_NETNAME:\r
3059                         api_ret = _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_STRING);\r
3060                         break;\r
3061                 case TREQ_SIM_GET_OPLMNWACT:\r
3062                         api_ret = _get_file_info(o, ur, SIM_EF_OPLMN_ACT);\r
3063                         break;\r
3064                 default:\r
3065                         dbg("error - not handled read treq command[%d]", command);\r
3066                         api_ret = TCORE_RETURN_EINVAL;\r
3067                         break;\r
3068         }\r
3069         dbg(" Function exit");\r
3070         return api_ret;\r
3071 }\r
3072 \r
3073 static TReturn s_update_file(CoreObject *o, UserRequest *ur)\r
3074 {\r
3075         TcoreHal* hal;\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
3086         int p1 = 0;\r
3087         int p2 = 0;\r
3088         int p3 = 0;\r
3089         int cmd = 0;\r
3090         gboolean bresult = FALSE;\r
3091         struct tel_sim_language sim_language;\r
3092 \r
3093         command = tcore_user_request_get_command(ur);\r
3094 \r
3095         dbg(" Function entry ");\r
3096 \r
3097         hal = tcore_object_get_hal(o);\r
3098         pending = tcore_pending_new(o, 0);\r
3099 \r
3100         if (!o || !ur)\r
3101                 return TCORE_RETURN_EINVAL;\r
3102 \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
3107                         cmd = 214;\r
3108                         p1 = 0;\r
3109                         p2 = 0;\r
3110                         p3 = 1;\r
3111                         sim_language.language_count = 1;\r
3112                         sim_language.language[0] = cl->language;\r
3113                         encoded_data = malloc(1);\r
3114                         memset(encoded_data, 0x00, 1);\r
3115                         if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
3116                         {\r
3117                                 dbg("2G");\r
3118                                 ef = SIM_EF_ELP;\r
3119                                 bresult = tcore_sim_encode_lp(encoded_data, 1, &sim_language);\r
3120                                 dbg("%d ---", encoded_data[0]);\r
3121                                 dbg("result %d ", bresult);\r
3122                         }\r
3123                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
3124                         {\r
3125                                 dbg("3G");\r
3126                                 ef = SIM_EF_LP;\r
3127                                 bresult = tcore_sim_encode_li(encoded_data, 1, &sim_language);\r
3128                                 dbg("result %d ", bresult);\r
3129                                 dbg("encoded_data %s", encoded_data);\r
3130                         }\r
3131                         else\r
3132                         {\r
3133                                 api_ret = TCORE_RETURN_ENOSYS;\r
3134                         }\r
3135                         break;\r
3136 \r
3137                 case TREQ_SIM_SET_CALLFORWARDING:\r
3138                         cf = tcore_user_request_ref_data(ur, NULL);\r
3139                         if(tcore_sim_get_cphs_status(o))\r
3140                         {\r
3141                                 encoded_data = tcore_sim_encode_cff((const struct tel_sim_callforwarding*)cf);\r
3142                                 ef = SIM_EF_CPHS_CALL_FORWARD_FLAGS;\r
3143                                 p1 = 0;\r
3144                                 p2 = 0;\r
3145                                 p3 = strlen(encoded_data);\r
3146                                 cmd = 214;                              /*command - 214 : UPDATE BINARY*/\r
3147                         } else\r
3148                         {\r
3149                                 encoded_data = tcore_sim_encode_cfis(&encoded_len, (const struct tel_sim_callforwarding*)cf);\r
3150                                 ef = SIM_EF_USIM_CFIS;\r
3151                                 p1 = 1;\r
3152                                 p2 = 0x04;\r
3153                                 p3 = encoded_len;\r
3154                                 cmd = 220;                              /*command - 220 : UPDATE RECORD*/\r
3155                         }\r
3156                         break;\r
3157 \r
3158                 default:\r
3159                         dbg("error - not handled update treq command[%d]", command);\r
3160                         api_ret = TCORE_RETURN_EINVAL;\r
3161                         break;\r
3162         }\r
3163         cmd_str = g_strdup_printf("AT+CRSM=%d,%d,%d,%d,%d,\"%s\"", cmd,ef,p1,p2,p3, encoded_data);\r
3164         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
3165 \r
3166         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
3167 \r
3168         tcore_pending_set_request_data(pending, 0, req);\r
3169         tcore_pending_set_response_callback(pending, on_response_update_file, hal);\r
3170         tcore_pending_link_user_request(pending, ur);\r
3171         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
3172 \r
3173         tcore_hal_send_request(hal, pending);\r
3174         if(NULL != encoded_data){\r
3175                 g_free(encoded_data);\r
3176         }\r
3177         free(cmd_str);\r
3178         dbg(" Function exit");\r
3179         return TCORE_RETURN_SUCCESS;\r
3180 }\r
3181 \r
3182 static TReturn s_transmit_apdu(CoreObject *o, UserRequest *ur)\r
3183 {\r
3184         TcoreHal* hal= NULL;\r
3185         TcoreATRequest *req= NULL;\r
3186         TcorePending *pending = NULL;\r
3187         char *cmd_str = NULL;\r
3188         const struct treq_sim_transmit_apdu *req_data;\r
3189         dbg(" Function entry ");\r
3190 \r
3191         hal = tcore_object_get_hal(o);\r
3192         pending = tcore_pending_new(o, 0);\r
3193         req_data = tcore_user_request_ref_data(ur, NULL);\r
3194 \r
3195         if (!o || !ur)\r
3196                 return TCORE_RETURN_EINVAL;\r
3197 \r
3198         cmd_str = g_strdup_printf("AT+CSIM=%d,\"%s\"", req_data->apdu_length, req_data->apdu);\r
3199 \r
3200         req = tcore_at_request_new(cmd_str, "+CSIM:", TCORE_AT_SINGLELINE);\r
3201 \r
3202         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
3203 \r
3204         tcore_pending_set_request_data(pending, 0, req);\r
3205         tcore_pending_set_response_callback(pending, on_response_transmit_apdu, hal);\r
3206         tcore_pending_link_user_request(pending, ur);\r
3207         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
3208         tcore_hal_send_request(hal, pending);\r
3209 \r
3210         free(cmd_str);\r
3211         dbg(" Function exit");\r
3212         return TCORE_RETURN_SUCCESS;\r
3213 }\r
3214 \r
3215 static struct tcore_sim_operations sim_ops =\r
3216 {\r
3217                 .verify_pins = s_verify_pins,\r
3218                 .verify_puks = s_verify_puks,\r
3219                 .change_pins = s_change_pins,\r
3220                 .get_facility_status = s_get_facility_status,\r
3221                 .enable_facility = s_enable_facility,\r
3222                 .disable_facility = s_disable_facility,\r
3223                 .get_lock_info = s_get_lock_info,\r
3224                 .read_file = s_read_file,\r
3225                 .update_file = s_update_file,\r
3226                 .transmit_apdu = s_transmit_apdu,\r
3227                 /*ToDo - Need to be implemented in Phase-2*/\r
3228                 /*.get_atr = s_get_atr,\r
3229                 .req_authentication = s_req_authentication*/\r
3230 };\r
3231 \r
3232 gboolean s_sim_init(TcorePlugin *p, TcoreHal *h)\r
3233 {\r
3234         CoreObject *o;\r
3235         struct s_sim_property *file_meta = NULL;\r
3236         GQueue *work_queue;\r
3237 \r
3238         dbg("entry");\r
3239 \r
3240         o = tcore_sim_new(p, "sim", &sim_ops, h);\r
3241 \r
3242         if (!o)\r
3243                 return FALSE;\r
3244 \r
3245         file_meta = calloc(sizeof(struct s_sim_property),1);\r
3246         if (!file_meta)\r
3247                 return FALSE;\r
3248 \r
3249         work_queue = g_queue_new();\r
3250         tcore_object_link_user_data(o, work_queue);\r
3251 \r
3252         file_meta->first_recv_status = SIM_STATUS_UNKNOWN;\r
3253         tcore_sim_link_userdata(o, file_meta);\r
3254         \r
3255         tcore_object_add_callback(o, "+XLOCK", on_event_facility_lock_status, NULL);\r
3256         tcore_object_add_callback(o, "+XSIM", on_event_pin_status, NULL);\r
3257 \r
3258         dbg("exit");\r
3259         return TRUE;\r
3260 }\r
3261 \r
3262 void s_sim_exit(TcorePlugin *p)\r
3263 {\r
3264         CoreObject *o;\r
3265 \r
3266         o = tcore_plugin_ref_core_object(p, "sim");\r
3267         if (!o)\r
3268                 return;\r
3269         tcore_sim_free(o);\r
3270 }