src/s_sim.c

   1 /*\r
   2  * tel-plugin-imc\r
   3  *\r
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.\r
   5  *\r
   6  * Contact: Ankit Jogi <ankit.jogi@samsung.com>\r
   7  *\r
   8  * Licensed under the Apache License, Version 2.0 (the "License");\r
   9  * you may not use this file except in compliance with the License.\r
  10  * You may obtain a copy of the License at\r
  11  *\r
  12  * http://www.apache.org/licenses/LICENSE-2.0\r
  13  *\r
  14  * Unless required by applicable law or agreed to in writing, software\r
  15  * distributed under the License is distributed on an "AS IS" BASIS,\r
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17  * See the License for the specific language governing permissions and\r
  18  * limitations under the License.\r
  19  */\r
  20 \r
  21 #include <stdio.h>\r
  22 #include <stdlib.h>\r
  23 #include <string.h>\r
  24 #include <glib.h>\r
  25 #include <tcore.h>\r
  26 #include <hal.h>\r
  27 #include <core_object.h>\r
  28 #include <plugin.h>\r
  29 #include <queue.h>\r
  30 #include <co_sim.h>\r
  31 #include <storage.h>\r
  32 #include <user_request.h>\r
  33 #include <server.h>\r
  34 #include <at.h>\r
  35 \r
  36 #include "s_common.h"\r
  37 #include "s_sim.h"\r
  38 \r
  39 #define ID_RESERVED_AT 0x0229\r
  40 \r
  41 #define SWAPBYTES16(x) \\r
  42 { \\r
  43     unsigned short int data = *(unsigned short int*)&(x); \\r
  44     data = ((data & 0xff00) >> 8) |    \\r
  45            ((data & 0x00ff) << 8);     \\r
  46     *(unsigned short int*)&(x) = data ;      \\r
  47 }\r
  48 \r
  49 enum s_sim_file_type_e {\r
  50         SIM_FTYPE_DEDICATED = 0x00, /**< Dedicated */\r
  51         SIM_FTYPE_TRANSPARENT = 0x01, /**< Transparent -binary type*/\r
  52         SIM_FTYPE_LINEAR_FIXED = 0x02, /**< Linear fixed - record type*/\r
  53         SIM_FTYPE_CYCLIC = 0x04, /**< Cyclic - record type*/\r
  54         SIM_FTYPE_INVALID_TYPE = 0xFF /**< Invalid type */\r
  55 };\r
  56 \r
  57 enum s_sim_sec_op_e {\r
  58         SEC_PIN1_VERIFY,\r
  59         SEC_PIN2_VERIFY,\r
  60         SEC_PUK1_VERIFY,\r
  61         SEC_PUK2_VERIFY,\r
  62         SEC_SIM_VERIFY,\r
  63         SEC_ADM_VERIFY,\r
  64         SEC_PIN1_CHANGE,\r
  65         SEC_PIN2_CHANGE,\r
  66         SEC_PIN1_ENABLE,\r
  67         SEC_PIN1_DISABLE,\r
  68         SEC_PIN2_ENABLE,\r
  69         SEC_PIN2_DISABLE, //10\r
  70         SEC_SIM_ENABLE,\r
  71         SEC_SIM_DISABLE,\r
  72         SEC_NET_ENABLE,\r
  73         SEC_NET_DISABLE,\r
  74         SEC_NS_ENABLE,\r
  75         SEC_NS_DISABLE,\r
  76         SEC_SP_ENABLE,\r
  77         SEC_SP_DISABLE,\r
  78         SEC_CP_ENABLE,\r
  79         SEC_CP_DISABLE, //20\r
  80         SEC_FDN_ENABLE,\r
  81         SEC_FDN_DISABLE,\r
  82         SEC_PIN1_STATUS,\r
  83         SEC_PIN2_STATUS,\r
  84         SEC_FDN_STATUS,\r
  85         SEC_NET_STATUS,\r
  86         SEC_NS_STATUS,\r
  87         SEC_SP_STATUS,\r
  88         SEC_CP_STATUS,\r
  89         SEC_SIM_STATUS,\r
  90         SEC_SIM_UNKNOWN = 0xff\r
  91 };\r
  92 \r
  93 struct s_sim_property {\r
  94         gboolean b_valid; /**< Valid or not */\r
  95         enum tel_sim_file_id file_id; /**< File identifier */\r
  96         enum s_sim_file_type_e file_type; /**< File type and structure */\r
  97         int rec_length; /**< Length of one record in file */\r
  98         int rec_count; /**< Number of records in file */\r
  99         int data_size; /**< File size */\r
 100         int current_index; /**< current index to read */\r
 101         enum tel_sim_status first_recv_status;\r
 102         enum s_sim_sec_op_e current_sec_op; /**< current index to read */\r
 103         struct tresp_sim_read files;\r
 104 };\r
 105 \r
 106 static void _next_from_get_file_info(CoreObject *o, UserRequest *ur, enum tel_sim_file_id ef, enum tel_sim_access_result rt);\r
 107 static void _next_from_get_file_data(CoreObject *o, UserRequest *ur, enum tel_sim_access_result rt, int decode_ret);\r
 108 static gboolean _get_sim_type(CoreObject *o);\r
 109 static TReturn _get_file_info(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef);\r
 110 static gboolean _get_file_data(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int offset, const int length);\r
 111 static gboolean _get_file_record(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int index, const int length);\r
 112 static void _sim_status_update(CoreObject *o, enum tel_sim_status sim_status);\r
 113 static void on_confirmation_sim_message_send(TcorePending *p, gboolean result, void *user_data ); // from Kernel\r
 114 \r
 115 static void on_confirmation_sim_message_send( TcorePending *p, gboolean result, void *user_data )\r
 116 {\r
 117         dbg("on_confirmation_sim_message_send - msg out from queue.\n");\r
 118 \r
 119         if (result == FALSE) {\r
 120                 /* Fail */\r
 121                 dbg("SEND FAIL");\r
 122         }\r
 123         else\r
 124         {\r
 125                 dbg("SEND OK");\r
 126         }\r
 127 }\r
 128 \r
 129 static enum tcore_response_command _find_resp_command(UserRequest *ur)\r
 130 {\r
 131         enum tcore_request_command command;\r
 132         command = tcore_user_request_get_command(ur);\r
 133         switch(command){\r
 134                 case TREQ_SIM_VERIFY_PINS:\r
 135                         return TRESP_SIM_VERIFY_PINS;\r
 136                         break;\r
 137                 case TREQ_SIM_VERIFY_PUKS:\r
 138                         return TRESP_SIM_VERIFY_PUKS;\r
 139                         break;\r
 140                 case TREQ_SIM_CHANGE_PINS:\r
 141                         return TRESP_SIM_CHANGE_PINS;\r
 142                         break;\r
 143                 case TREQ_SIM_GET_FACILITY_STATUS:\r
 144                         return TRESP_SIM_GET_FACILITY_STATUS;\r
 145                         break;\r
 146                 case TREQ_SIM_DISABLE_FACILITY:\r
 147                         return TRESP_SIM_DISABLE_FACILITY;\r
 148                         break;\r
 149                 case TREQ_SIM_ENABLE_FACILITY:\r
 150                         return TRESP_SIM_ENABLE_FACILITY;\r
 151                         break;\r
 152                 case TREQ_SIM_GET_LOCK_INFO:\r
 153                         return TRESP_SIM_GET_LOCK_INFO;\r
 154                         break;\r
 155                 case TREQ_SIM_TRANSMIT_APDU:\r
 156                         return TRESP_SIM_TRANSMIT_APDU;\r
 157                         break;\r
 158                 case TREQ_SIM_GET_ATR:\r
 159                         return TRESP_SIM_GET_ATR;\r
 160                         break;\r
 161                 case TREQ_SIM_GET_ECC:\r
 162                         return TRESP_SIM_GET_ECC;\r
 163                         break;\r
 164                 case TREQ_SIM_GET_LANGUAGE:\r
 165                         return TRESP_SIM_GET_LANGUAGE;\r
 166                         break;\r
 167                 case TREQ_SIM_SET_LANGUAGE:\r
 168                         return TRESP_SIM_SET_LANGUAGE;\r
 169                         break;\r
 170                 case TREQ_SIM_GET_ICCID:\r
 171                         return TRESP_SIM_GET_ICCID;\r
 172                         break;\r
 173                 case TREQ_SIM_GET_MAILBOX:\r
 174                         return TRESP_SIM_GET_MAILBOX;\r
 175                         break;\r
 176                 case TREQ_SIM_GET_CALLFORWARDING:\r
 177                         return TRESP_SIM_GET_CALLFORWARDING;\r
 178                         break;\r
 179                 case TREQ_SIM_SET_CALLFORWARDING:\r
 180                         return TRESP_SIM_SET_CALLFORWARDING;\r
 181                         break;\r
 182                 case TREQ_SIM_GET_MESSAGEWAITING:\r
 183                         return TRESP_SIM_GET_MESSAGEWAITING;\r
 184                         break;\r
 185                 case TREQ_SIM_GET_CPHS_INFO:\r
 186                         return TRESP_SIM_GET_CPHS_INFO;\r
 187                         break;\r
 188                 case TREQ_SIM_GET_MSISDN:\r
 189                         return TRESP_SIM_GET_MSISDN;\r
 190                         break;\r
 191                 case TREQ_SIM_GET_SPN:\r
 192                         return TRESP_SIM_GET_SPN;\r
 193                         break;\r
 194                 case TREQ_SIM_GET_SPDI:\r
 195                         return TRESP_SIM_GET_SPDI;\r
 196                         break;\r
 197                 case TREQ_SIM_GET_OPL:\r
 198                         return TRESP_SIM_GET_OPL;\r
 199                         break;\r
 200                 case TREQ_SIM_GET_PNN:\r
 201                         return TRESP_SIM_GET_PNN;\r
 202                         break;\r
 203                 case TREQ_SIM_GET_CPHS_NETNAME:\r
 204                         return TRESP_SIM_GET_CPHS_NETNAME;\r
 205                         break;\r
 206                 case TREQ_SIM_GET_OPLMNWACT:\r
 207                         return TRESP_SIM_GET_OPLMNWACT;\r
 208                         break;\r
 209                 case TREQ_SIM_REQ_AUTHENTICATION:\r
 210                         return TRESP_SIM_REQ_AUTHENTICATION;\r
 211                         break;\r
 212                 default:\r
 213                         break;\r
 214         }\r
 215         return TRESP_UNKNOWN;\r
 216 }\r
 217 \r
 218 static int _sim_get_current_pin_facility(enum s_sim_sec_op_e op)\r
 219 {\r
 220         int ret_type = 0;\r
 221         dbg("current sec_op[%d]", op);\r
 222         switch(op)\r
 223         {\r
 224                 case SEC_PIN1_VERIFY :\r
 225                 case SEC_PIN1_CHANGE :\r
 226                         ret_type = SIM_PTYPE_PIN1;\r
 227                         break;\r
 228                 case SEC_PIN2_VERIFY :\r
 229                 case SEC_PIN2_CHANGE :\r
 230                         ret_type = SIM_PTYPE_PIN2;\r
 231                         break;\r
 232                 case SEC_PUK1_VERIFY :\r
 233                         ret_type = SIM_PTYPE_PUK1;\r
 234                         break;\r
 235                 case SEC_PUK2_VERIFY :\r
 236                         ret_type = SIM_PTYPE_PUK2;\r
 237                         break;\r
 238                 case SEC_SIM_VERIFY :\r
 239                         ret_type = SIM_PTYPE_SIM;\r
 240                         break;\r
 241                 case SEC_ADM_VERIFY :\r
 242                         ret_type = SIM_PTYPE_ADM;\r
 243                         break;\r
 244 \r
 245                 case SEC_PIN1_ENABLE :\r
 246                 case SEC_PIN1_DISABLE :\r
 247                 case SEC_PIN1_STATUS :\r
 248                         ret_type = SIM_FACILITY_SC;\r
 249                         break;\r
 250                 case SEC_SIM_ENABLE :\r
 251                 case SEC_SIM_DISABLE :\r
 252                 case SEC_SIM_STATUS :\r
 253                         ret_type = SIM_FACILITY_PS;\r
 254                         break;\r
 255                 case SEC_NET_ENABLE :\r
 256                 case SEC_NET_DISABLE :\r
 257                 case SEC_NET_STATUS :\r
 258                         ret_type = SIM_FACILITY_PN;\r
 259                         break;\r
 260                 case SEC_NS_ENABLE :\r
 261                 case SEC_NS_DISABLE :\r
 262                 case SEC_NS_STATUS :\r
 263                         ret_type = SIM_FACILITY_PU;\r
 264                         break;\r
 265                 case SEC_SP_ENABLE :\r
 266                 case SEC_SP_DISABLE :\r
 267                 case SEC_SP_STATUS :\r
 268                         ret_type = SIM_FACILITY_PP;\r
 269                         break;\r
 270                 case SEC_CP_ENABLE :\r
 271                 case SEC_CP_DISABLE :\r
 272                 case SEC_CP_STATUS :\r
 273                         ret_type = SIM_FACILITY_PC;\r
 274                         break;\r
 275                 case SEC_FDN_ENABLE :\r
 276                 case SEC_FDN_DISABLE :\r
 277                 case SEC_FDN_STATUS :\r
 278                         ret_type = SIM_FACILITY_FD;\r
 279                         break;\r
 280 \r
 281                 default:\r
 282                         dbg("not handled current sec op[%d]",op )\r
 283                         break;\r
 284         }\r
 285         return ret_type;\r
 286 }\r
 287 \r
 288 static enum tel_sim_access_result _decode_status_word(unsigned short status_word1, unsigned short status_word2)\r
 289 {\r
 290         enum tel_sim_access_result rst = SIM_ACCESS_FAILED;\r
 291 \r
 292         if (status_word1 == 0x93 && status_word2 == 0x00)\r
 293         {\r
 294                 rst = SIM_ACCESS_FAILED;\r
 295                 /*Failed SIM request command*/\r
 296                 dbg(" error - SIM application toolkit busy [%x][%x]", status_word1, status_word2);\r
 297         }\r
 298         else if (status_word1 == 0x94 && status_word2 == 0x00)\r
 299         {\r
 300                 rst = SIM_ACCESS_FAILED;\r
 301                 /*Failed SIM request command*/\r
 302                 dbg(" error - No EF Selected [%x][%x]", status_word1, status_word2);\r
 303         }\r
 304         else if (status_word1 == 0x94 && status_word2 == 0x02)\r
 305         {\r
 306                 rst = SIM_ACCESS_FAILED;\r
 307                 /*Failed SIM request command*/\r
 308                 dbg("error - Out of Range - Invalid address or record number[%x][%x]",\r
 309                                 status_word1, status_word2);\r
 310         }\r
 311         else if (status_word1 == 0x94 && status_word2 == 0x04)\r
 312         {\r
 313                 rst = SIM_ACCESS_FILE_NOT_FOUND;\r
 314                 /*Failed SIM request command*/\r
 315                 dbg(" error - File ID not found [%x][%x]", status_word1, status_word2);\r
 316         }\r
 317         else if (status_word1 == 0x94 && status_word2 == 0x08)\r
 318         {\r
 319                 rst = SIM_ACCESS_FAILED; /* MOdem not support */\r
 320                 /*Failed SIM request command*/\r
 321                 dbg(" error - File is inconsistent with command - Modem not support or USE IPC [%x][%x]",\r
 322                                 status_word1, status_word2);\r
 323         }\r
 324         else if (status_word1 == 0x98 && status_word2 == 0x02)\r
 325         {\r
 326                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 327                 /*Failed SIM request command*/\r
 328                 dbg(" error - CHV not initialized [%x][%x]", status_word1, status_word2);\r
 329         }\r
 330         else if (status_word1 == 0x98 && status_word2 == 0x04)\r
 331         {\r
 332                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 333                 /*Failed SIM request command*/\r
 334                 dbg(" error - Access condition not fullfilled [%x][%x]", status_word1, status_word2);\r
 335                 dbg(" error -Unsuccessful CHV verification - at least one attempt left [%x][%x]",\r
 336                                 status_word1, status_word2);\r
 337                 dbg(" error - Unsuccessful Unblock CHV - at least one attempt left [%x][%x]",\r
 338                                 status_word1, status_word2);\r
 339                 dbg(" error - Authentication failure [%x][%x]", status_word1, status_word2);\r
 340         }\r
 341         else if (status_word1 == 0x98 && status_word2 == 0x08)\r
 342         {\r
 343                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 344                 /*Failed SIM request command*/\r
 345                 dbg(" error - Contradiction with CHV status [%x][%x]", status_word1, status_word2);\r
 346         }\r
 347         else if (status_word1 == 0x98 && status_word2 == 0x10)\r
 348         {\r
 349                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 350                 /*Failed SIM request command*/\r
 351                 dbg(" error - Contradiction with invalidation  status [%x][%x]",\r
 352                                 status_word1, status_word2);\r
 353         }\r
 354         else if (status_word1 == 0x98 && status_word2 == 0x40)\r
 355         {\r
 356                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 357                 /*Failed SIM request command*/\r
 358                 dbg(" error -Unsuccessful CHV verification - no attempt left [%x][%x]",\r
 359                                 status_word1, status_word2);\r
 360                 dbg(" error - Unsuccessful Unblock CHV - no attempt left [%x][%x]",\r
 361                                 status_word1, status_word2);\r
 362                 dbg(" error - CHV blocked [%x][%x]", status_word1, status_word2);\r
 363         }\r
 364         else if (status_word1 == 0x67 && status_word2 == 0x00)\r
 365         {\r
 366                 rst = SIM_ACCESS_FAILED;\r
 367                 dbg(" error -Incorrect Parameter 3 [%x][%x]", status_word1, status_word2);\r
 368         }\r
 369         else if (status_word1 == 0x6B && status_word2 == 0x00)\r
 370         {\r
 371                 rst = SIM_ACCESS_FAILED;\r
 372                 dbg(" error -Incorrect Parameter 1 or 2 [%x][%x]", status_word1, status_word2);\r
 373         }\r
 374         else if (status_word1 == 0x6D && status_word2 == 0x00)\r
 375         {\r
 376                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 377                 dbg(" error -Unknown instruction given as command [%x][%x]", status_word1, status_word2);\r
 378         }\r
 379         else if (status_word1 == 0x6E && status_word2 == 0x00)\r
 380         {\r
 381                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 382                 dbg(" error -Unknown instruction given as command [%x][%x]", status_word1, status_word2);\r
 383         }\r
 384         else if (status_word1 == 0x69 && status_word2 == 0x82)\r
 385         {\r
 386                 rst = SIM_ACCESS_CONDITION_NOT_SATISFIED;\r
 387                 dbg(" error -Access denied [%x][%x]", status_word1, status_word2);\r
 388         }\r
 389         else if (status_word1 == 0x6A && status_word2 == 0x87)\r
 390         {\r
 391                 rst = SIM_ACCESS_FAILED;\r
 392                 dbg(" error -Incorrect parameters [%x][%x]", status_word1, status_word2);\r
 393         }\r
 394         else if (status_word1 == 0x6A && status_word2 == 0x82)\r
 395         {\r
 396                 rst = SIM_ACCESS_FILE_NOT_FOUND; // not sure of the SW1 and SW2 meaning here\r
 397                 dbg(" error -File Not found [%x][%x]", status_word1, status_word2);\r
 398         }\r
 399         else if (status_word1 == 0x6A && status_word2 == 0x83)\r
 400         {\r
 401                 rst = SIM_ACCESS_FILE_NOT_FOUND; // not sure of the SW1 and SW2 meaning here\r
 402                 dbg(" error -Record Not found [%x][%x]", status_word1, status_word2);\r
 403         }\r
 404         else\r
 405         {\r
 406                 rst = SIM_ACCESS_CARD_ERROR;\r
 407                 dbg(" error -Unknown state [%x][%x]", status_word1, status_word2);\r
 408         }\r
 409         return rst;\r
 410 }\r
 411 \r
 412 static gboolean _sim_check_identity(CoreObject *o, struct tel_sim_imsi *imsi)\r
 413 {\r
 414         Server *s = NULL;\r
 415         Storage *strg = NULL;\r
 416         char* old_imsi = NULL;\r
 417         char new_imsi[15+1] = {0,};\r
 418 \r
 419         s = tcore_plugin_ref_server(tcore_object_ref_plugin(o));\r
 420         if(!s)\r
 421         {\r
 422                 dbg("there is no valid server at this point");\r
 423                 return FALSE;\r
 424         }\r
 425         strg = (Storage*)tcore_server_find_storage(s, "vconf");\r
 426         if(!strg)\r
 427         {\r
 428                 dbg("there is no valid storage plugin");\r
 429                 return FALSE;\r
 430         }\r
 431         memcpy(&new_imsi, imsi->plmn, strlen(imsi->plmn));\r
 432         memcpy(&new_imsi[strlen(imsi->plmn)], imsi->msin, strlen(imsi->msin));\r
 433         new_imsi[strlen(imsi->plmn)+strlen(imsi->msin)] = '\0';\r
 434 \r
 435         old_imsi = tcore_storage_get_string(strg, STORAGE_KEY_TELEPHONY_IMSI);\r
 436         dbg("old_imsi[%s],newImsi[%s]", old_imsi, new_imsi);\r
 437 \r
 438         if (old_imsi != NULL)\r
 439         {\r
 440                 if (strncmp(old_imsi, new_imsi, 15) != 0)\r
 441                 {\r
 442                         dbg("NEW SIM");\r
 443                         if (tcore_storage_set_string(strg, STORAGE_KEY_TELEPHONY_IMSI, (const char*) &new_imsi) == FALSE )\r
 444                         {\r
 445                                 dbg("[FAIL] UPDATE STORAGE_KEY_TELEPHONY_IMSI");\r
 446                         }\r
 447                         tcore_sim_set_identification(o, TRUE);\r
 448                 }\r
 449                 else\r
 450                 {\r
 451                         dbg("SAME SIM");\r
 452                         tcore_sim_set_identification(o, FALSE);\r
 453                 }\r
 454         }\r
 455         else\r
 456         {\r
 457                 dbg("OLD SIM VALUE IS NULL. NEW SIM");\r
 458                 if (tcore_storage_set_string(strg, STORAGE_KEY_TELEPHONY_IMSI, (const char*) &new_imsi) == FALSE)\r
 459                 {\r
 460                         dbg("[FAIL] UPDATE STORAGE_KEY_TELEPHONY_IMSI");\r
 461                 }\r
 462                 tcore_sim_set_identification(o, TRUE);\r
 463         }\r
 464         return 1;\r
 465 }\r
 466 \r
 467 static void  _next_from_get_file_info(CoreObject *o,  UserRequest *ur, enum tel_sim_file_id ef, enum tel_sim_access_result rt )\r
 468 {\r
 469         struct tresp_sim_read resp = {0,};\r
 470         struct s_sim_property *file_meta = NULL;\r
 471         dbg("EF[0x%x] access Result[%d]", ef, rt);\r
 472 \r
 473         resp.result = rt;\r
 474         memset(&resp.data, 0x00, sizeof(resp.data));\r
 475         file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);\r
 476 \r
 477         if ((ef != SIM_EF_ELP && ef != SIM_EF_LP && ef != SIM_EF_USIM_PL && ef != SIM_EF_CPHS_CPHS_INFO )\r
 478                         && (rt != SIM_ACCESS_SUCCESS))\r
 479         {\r
 480                 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_read),&resp);\r
 481                 return;\r
 482         }\r
 483 \r
 484         switch (ef)\r
 485         {\r
 486                 case SIM_EF_ELP:\r
 487                         if (rt == SIM_ACCESS_SUCCESS)\r
 488                         {\r
 489                                 dbg("[SIM DATA] exist EFELP/PL(0x2F05)");\r
 490                                 /*                              if (po->language_file == 0x00)\r
 491                                  po->language_file = SIM_EF_ELP;*/\r
 492                                 _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 493                         }\r
 494                         else\r
 495                         {\r
 496                                 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 497                                 {\r
 498                                         dbg(" [SIM DATA]SIM_EF_ELP(2F05) access fail. Request SIM_EF_LP(0x6F05) info");\r
 499                                         /* The ME requests the Language Preference (EFLP) if EFELP is not available  */\r
 500                                         _get_file_info(o, ur, SIM_EF_LP);\r
 501                                 }\r
 502                                 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 503                                 {\r
 504                                         dbg(\r
 505                                                         " [SIM DATA]fail to get Language information in USIM(EF-LI(6F05),EF-PL(2F05)). Request SIM_EF_ECC(0x6FB7) info");\r
 506                                         /* EFELPand EFLI not present at this point. */\r
 507                                         /*                                      po->language.lang_cnt = 0;*/\r
 508                                         tcore_user_request_send_response(ur, _find_resp_command(ur),\r
 509                                                         sizeof(struct tresp_sim_read), &resp);\r
 510                                         return;\r
 511                                 }\r
 512                         }\r
 513                         break;\r
 514 \r
 515                 case SIM_EF_LP: //same with SIM_EF_USIM_LI\r
 516                         if (rt == SIM_ACCESS_SUCCESS)\r
 517                         {\r
 518                                 dbg("[SIM DATA] exist EFLP/LI(0x6F05)");\r
 519                                 _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 520                         }\r
 521                         else\r
 522                         {\r
 523                                 dbg("[SIM DATA]SIM_EF_LP/LI(6F05) access fail. Current CardType[%d]",\r
 524                                                 tcore_sim_get_type(o));\r
 525                                 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 526                                 {\r
 527                                         tcore_user_request_send_response(ur, _find_resp_command(ur),\r
 528                                                         sizeof(struct tresp_sim_read), &resp);\r
 529                                         return;\r
 530                                 }\r
 531                                 /*  if EFLI is not present, then the language selection shall be as defined in EFPL at the MF level     */\r
 532                                 else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 533                                 {\r
 534                                         dbg("[SIM DATA] try USIM EFPL(0x2F05)");\r
 535                                         _get_file_info(o, ur, SIM_EF_ELP);\r
 536                                 }\r
 537                         }\r
 538                         break;\r
 539 \r
 540                 case SIM_EF_USIM_PL:\r
 541                         if (rt == SIM_ACCESS_SUCCESS)\r
 542                         {\r
 543                                 dbg("[SIM DATA] exist EFELP/PL(0x2F05)");\r
 544                                 _get_file_data(o, ur, SIM_EF_ELP, 0, file_meta->data_size);\r
 545                         }\r
 546                         else\r
 547                         {\r
 548                                 /* EFELIand EFPL not present, so set language count as zero and select ECC */\r
 549                                 dbg(\r
 550                                                 " [SIM DATA]SIM_EF_USIM_PL(2A05) access fail. Request SIM_EF_ECC(0x6FB7) info");\r
 551                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
 552                                                 sizeof(struct tresp_sim_read), &resp);\r
 553                                 return;\r
 554                         }\r
 555                         break;\r
 556 \r
 557                 case SIM_EF_ECC:\r
 558                         if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 559                         {\r
 560                                 _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 561                         }\r
 562                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 563                         {\r
 564                                 if (file_meta->rec_count > SIM_ECC_RECORD_CNT_MAX)\r
 565                                 {\r
 566                                         file_meta->rec_count = SIM_ECC_RECORD_CNT_MAX;\r
 567                                 }\r
 568 \r
 569                                 file_meta->current_index++;\r
 570                                 _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);\r
 571                         }\r
 572                         break;\r
 573 \r
 574                 case SIM_EF_ICCID:\r
 575                 case SIM_EF_IMSI:\r
 576                 case SIM_EF_SST:\r
 577                 case SIM_EF_SPN:\r
 578                 case SIM_EF_SPDI:\r
 579                 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:\r
 580                 case SIM_EF_CPHS_VOICE_MSG_WAITING:\r
 581                 case SIM_EF_CPHS_OPERATOR_NAME_STRING:\r
 582                 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:\r
 583                 case SIM_EF_CPHS_DYNAMICFLAGS:\r
 584                 case SIM_EF_CPHS_DYNAMIC2FLAG:\r
 585                 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE:\r
 586                 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE_LINE2:\r
 587                         _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 588                         break;\r
 589 \r
 590                 case SIM_EF_CPHS_CPHS_INFO:\r
 591                         if (rt == SIM_ACCESS_SUCCESS)\r
 592                         {\r
 593                                 tcore_sim_set_cphs_status(o, TRUE);\r
 594                                 if (!tcore_user_request_ref_communicator(ur))\r
 595                                 {\r
 596                                         dbg("internal CPHS INFO request before sim status update");\r
 597                                         _sim_status_update(o, SIM_STATUS_INIT_COMPLETED);\r
 598                                 } else\r
 599                                 {\r
 600                                         dbg("external CPHS INFO request");\r
 601                                         _get_file_data(o, ur, ef, 0, file_meta->data_size);\r
 602                                 }\r
 603                         } else\r
 604                         {\r
 605                                 tcore_sim_set_cphs_status(o, FALSE);\r
 606                                 if (!tcore_user_request_ref_communicator(ur))\r
 607                                 {\r
 608                                         dbg("internal CPHS INFO request before sim status update");\r
 609                                         _sim_status_update(o, SIM_STATUS_INIT_COMPLETED);\r
 610                                 } else\r
 611                                 {\r
 612                                         dbg("external CPHS INFO request");\r
 613                                         tcore_user_request_send_response(ur, _find_resp_command(ur),\r
 614                                                         sizeof(struct tresp_sim_read), &resp);\r
 615                                 }\r
 616                         }\r
 617                         break;\r
 618 \r
 619 \r
 620                 case SIM_EF_USIM_CFIS:\r
 621                         if (file_meta->rec_count > SIM_CF_RECORD_CNT_MAX)\r
 622                         {\r
 623                                 file_meta->rec_count = SIM_CF_RECORD_CNT_MAX;\r
 624                         }\r
 625                         file_meta->current_index++;\r
 626                         _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);\r
 627                         break;\r
 628 \r
 629                 case SIM_EF_OPL:\r
 630                 case SIM_EF_PNN:\r
 631                 case SIM_EF_USIM_MWIS:\r
 632                 case SIM_EF_USIM_MBI:\r
 633                 case SIM_EF_MBDN:\r
 634                 case SIM_EF_CPHS_MAILBOX_NUMBERS:\r
 635                 case SIM_EF_CPHS_INFORMATION_NUMBERS:\r
 636                         file_meta->current_index++;\r
 637                         _get_file_record(o, ur, ef, file_meta->current_index, file_meta->rec_length);\r
 638                         break;\r
 639 \r
 640                 default:\r
 641                         dbg( "error - File id for get file info [0x%x]", ef);\r
 642                         break;\r
 643         }\r
 644         return;\r
 645 }\r
 646 \r
 647 static void _next_from_get_file_data(CoreObject *o, UserRequest *ur, enum tel_sim_access_result rt, int decode_ret)\r
 648 {\r
 649         struct s_sim_property *file_meta = NULL;\r
 650         dbg("Entry");\r
 651 \r
 652         file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);\r
 653         dbg("[SIM]EF[0x%x] read rt[%d] Decode rt[%d]", file_meta->file_id, rt, decode_ret);\r
 654         switch (file_meta->file_id)\r
 655         {\r
 656                 case SIM_EF_ELP:\r
 657                 case SIM_EF_USIM_PL:\r
 658                 case SIM_EF_LP:\r
 659                 case SIM_EF_USIM_LI:\r
 660                         if (decode_ret == TRUE)\r
 661                         {\r
 662                                 if (file_meta->file_id == SIM_EF_LP || file_meta->file_id == SIM_EF_USIM_LI)\r
 663                                 {\r
 664 /*                                      po->language_file = SIM_EF_LP;*/\r
 665                                 } else if (file_meta->file_id == SIM_EF_ELP || file_meta->file_id == SIM_EF_USIM_PL)\r
 666                                 {\r
 667 /*                                      po->language_file = SIM_EF_ELP;*/\r
 668                                 }\r
 669                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 670                         } else\r
 671                         {\r
 672                                 /* 2G */\r
 673                                 /*  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
 674                                  -      EFELP is not available;\r
 675                                  -      EFELP does not contain an entry corresponding to a language specified in ISO 639[30];\r
 676                                  -      the ME does not support any of the languages in EFELP.\r
 677                                  */\r
 678                                 /* 3G */\r
 679                                 /*  The ME only requests the Language Preference (EFPL) if at least one of the following conditions holds:\r
 680                                  -      if the EFLI has the value 'FFFF' in its highest priority position\r
 681                                  -      if the ME does not support any of the language codes indicated in EFLI , or if EFLI is not present\r
 682                                  */\r
 683                                 if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 684                                 {\r
 685                                         if (file_meta->file_id == SIM_EF_LP)\r
 686                                         {\r
 687                                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 688                                         }\r
 689                                         else\r
 690                                         {\r
 691                                                 _get_file_info(o, ur, SIM_EF_LP);\r
 692                                         }\r
 693                                 } else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 694                                 {\r
 695 \r
 696                                         if (file_meta->file_id == SIM_EF_LP || file_meta->file_id == SIM_EF_USIM_LI)\r
 697                                         {\r
 698                                                 _get_file_info(o, ur, SIM_EF_ELP);\r
 699                                         }\r
 700                                         else\r
 701                                         {\r
 702                                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 703                                         }\r
 704                                 }\r
 705                         }\r
 706                         break;\r
 707 \r
 708                 case SIM_EF_ECC:\r
 709                         if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
 710                         {\r
 711                                 if (file_meta->current_index == file_meta->rec_count)\r
 712                                 {\r
 713                                         tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 714                                 } else\r
 715                                 {\r
 716                                         file_meta->current_index++;\r
 717                                         _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );\r
 718                                 }\r
 719                         } else if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
 720                         {\r
 721                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 722                         } else\r
 723                         {\r
 724                                 dbg("[SIM DATA]Invalid CardType[%d] Unable to handle", tcore_sim_get_type(o));\r
 725                         }\r
 726                         break;\r
 727 \r
 728                 case SIM_EF_IMSI:\r
 729                         ur = tcore_user_request_new(NULL, NULL); //this is for using ur metainfo set/ref functionality.\r
 730                         _get_file_info(o, ur, SIM_EF_CPHS_CPHS_INFO);\r
 731                         break;\r
 732 \r
 733                 case SIM_EF_MSISDN:\r
 734                         if (file_meta->current_index == file_meta->rec_count)\r
 735                         {\r
 736                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 737                         } else\r
 738                         {\r
 739                                 file_meta->current_index++;\r
 740                                 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );\r
 741                         }\r
 742                         break;\r
 743 \r
 744                 case SIM_EF_OPL:\r
 745                         if (file_meta->current_index == file_meta->rec_count)\r
 746                         {\r
 747                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 748                         } else\r
 749                         {\r
 750                                 file_meta->current_index++;\r
 751                                 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );\r
 752                         }\r
 753                         break;\r
 754 \r
 755                 case SIM_EF_PNN:\r
 756                         if (file_meta->current_index == file_meta->rec_count)\r
 757                         {\r
 758                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 759                         } else\r
 760                         {\r
 761                                 file_meta->current_index++;\r
 762                                 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );\r
 763                         }\r
 764                         break;\r
 765 \r
 766                 case SIM_EF_USIM_CFIS:\r
 767                 case SIM_EF_USIM_MWIS:\r
 768                 case SIM_EF_USIM_MBI:\r
 769                 case SIM_EF_MBDN:\r
 770                 case SIM_EF_CPHS_MAILBOX_NUMBERS:\r
 771                 case SIM_EF_CPHS_INFORMATION_NUMBERS:\r
 772                         if (file_meta->current_index == file_meta->rec_count)\r
 773                         {\r
 774                                 tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 775                         } else\r
 776                         {\r
 777                                 file_meta->current_index++;\r
 778                                 _get_file_record(o, ur, file_meta->file_id, file_meta->current_index, file_meta->rec_length );\r
 779                         }\r
 780                         break;\r
 781 \r
 782                 case SIM_EF_CPHS_OPERATOR_NAME_STRING:\r
 783                         file_meta->files.result = rt;\r
 784                         if (decode_ret == TRUE && rt == SIM_ACCESS_SUCCESS)\r
 785                         {\r
 786                                 memcpy(file_meta->files.data.cphs_net.full_name, file_meta->files.data.cphs_net.full_name, strlen((char*)file_meta->files.data.cphs_net.full_name));\r
 787                         }\r
 788                         _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING);\r
 789                         break;\r
 790 \r
 791                 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:\r
 792                         if (file_meta->files.result == SIM_ACCESS_SUCCESS || file_meta->files.result == SIM_ACCESS_SUCCESS)\r
 793                         {\r
 794                                 file_meta->files.result = SIM_ACCESS_SUCCESS;\r
 795                         }\r
 796                         if (strlen((char*)file_meta->files.data.cphs_net.full_name))\r
 797                         {\r
 798                                 memcpy(&file_meta->files.data.cphs_net.full_name, &file_meta->files.data.cphs_net.full_name, strlen((char*)file_meta->files.data.cphs_net.full_name));\r
 799                         }\r
 800                         tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 801                         break;\r
 802 \r
 803                 case SIM_EF_ICCID:\r
 804                 case SIM_EF_SST:\r
 805                 case SIM_EF_SPN:\r
 806                 case SIM_EF_SPDI:\r
 807                 case SIM_EF_OPLMN_ACT:\r
 808                 case SIM_EF_CPHS_CPHS_INFO :\r
 809                 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:\r
 810                 case SIM_EF_CPHS_VOICE_MSG_WAITING:\r
 811                 case SIM_EF_CPHS_DYNAMICFLAGS:\r
 812                 case SIM_EF_CPHS_DYNAMIC2FLAG:\r
 813                 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE:\r
 814                 case SIM_EF_CPHS_CUSTOMER_SERVICE_PROFILE_LINE2:\r
 815                         tcore_user_request_send_response(ur, _find_resp_command(ur),    sizeof(struct tresp_sim_read), &file_meta->files);\r
 816                         break;\r
 817 \r
 818                 default:\r
 819                         dbg("File id not handled [0x%x]", file_meta->file_id);\r
 820                         break;\r
 821         }\r
 822 }\r
 823 \r
 824 static void _sim_status_update(CoreObject *o, enum tel_sim_status sim_status)\r
 825 {\r
 826         struct tnoti_sim_status noti_data = {0,};\r
 827 \r
 828         dbg("tcore_sim_set_status and send noti w/ [%d]", sim_status);\r
 829         tcore_sim_set_status(o, sim_status);\r
 830         noti_data.sim_status = sim_status;\r
 831         tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)), o, TNOTI_SIM_STATUS,\r
 832                         sizeof(struct tnoti_sim_status), &noti_data);\r
 833 }\r
 834 \r
 835 static void _response_get_sim_type(TcorePending *p, int data_len, const void *data, void *user_data)\r
 836 {\r
 837         const TcoreATResponse *resp = data;\r
 838         UserRequest *ur = NULL;\r
 839         CoreObject *co_sim = NULL;\r
 840         struct s_sim_property *sp = NULL;\r
 841         GSList *tokens=NULL;\r
 842         enum tel_sim_type sim_type = SIM_TYPE_UNKNOWN;\r
 843         const char *line;\r
 844         int state;\r
 845 \r
 846         dbg(" Function entry ");\r
 847 \r
 848         co_sim = tcore_pending_ref_core_object(p);\r
 849         sp = tcore_sim_ref_userdata(co_sim);\r
 850         ur = tcore_pending_ref_user_request(p);\r
 851 \r
 852         if(resp->success > 0)\r
 853         {\r
 854                 dbg("RESPONSE OK");\r
 855                 if(resp->lines)\r
 856                 {\r
 857                         line = (const char*)resp->lines->data;\r
 858                         tokens = tcore_at_tok_new(line);\r
 859                         if (g_slist_length(tokens) != 1)\r
 860                         {\r
 861                                 msg("invalid message");\r
 862                                 tcore_at_tok_free(tokens);\r
 863                                 return;\r
 864                         }\r
 865                 }\r
 866                 state = atoi(g_slist_nth_data(tokens, 0));\r
 867                 dbg("SIM Type is %d", state);\r
 868 \r
 869                 if(state == 0)\r
 870                 {\r
 871                         sim_type = SIM_TYPE_GSM;\r
 872                 }else if(state == 1)\r
 873                 {\r
 874                         sim_type = SIM_TYPE_USIM;\r
 875                 }else\r
 876                 {\r
 877                         sim_type = SIM_TYPE_UNKNOWN;\r
 878                 }\r
 879 \r
 880         }\r
 881         else\r
 882         {\r
 883                 dbg("RESPONSE NOK");\r
 884                 sim_type = SIM_TYPE_UNKNOWN;\r
 885         }\r
 886 \r
 887         tcore_sim_set_type(co_sim, sim_type);\r
 888         _sim_status_update(co_sim, sp->first_recv_status);\r
 889         tcore_at_tok_free(tokens);\r
 890         dbg(" Function exit");\r
 891 }\r
 892 \r
 893 static void _response_get_file_info(TcorePending *p, int data_len, const void *data, void *user_data)\r
 894 {\r
 895         const TcoreATResponse *resp = data;\r
 896         UserRequest *ur = NULL;\r
 897         CoreObject *co_sim = NULL;\r
 898         struct s_sim_property *file_meta = NULL;\r
 899         GSList *tokens=NULL;\r
 900         enum tel_sim_access_result rt;\r
 901         const char *line = NULL;\r
 902         int sw1 = 0;\r
 903         int sw2 = 0;\r
 904 \r
 905         dbg(" Function entry ");\r
 906 \r
 907         co_sim = tcore_pending_ref_core_object(p);\r
 908         ur = tcore_pending_ref_user_request(p);\r
 909         file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);\r
 910 \r
 911         if(resp->success > 0)\r
 912         {\r
 913                 dbg("RESPONSE OK");\r
 914                 if(resp->lines)\r
 915                 {\r
 916                         line = (const char*)resp->lines->data;\r
 917                         tokens = tcore_at_tok_new(line);\r
 918                         if (g_slist_length(tokens) < 2)\r
 919                         {\r
 920                                 err("invalid message");\r
 921                                 tcore_at_tok_free(tokens);\r
 922                                 return;\r
 923                         }\r
 924                 }\r
 925                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
 926                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
 927 \r
 928                 /*1. SIM access success case*/\r
 929                 if ((sw1 == 0x90 && sw2 == 0x00) || sw1 == 0x91) {\r
 930                         unsigned char tag_len = 0; /*   1 or 2 bytes ??? */\r
 931                         unsigned short record_len = 0;\r
 932                         char num_of_records = 0;\r
 933                         unsigned char file_id_len = 0;\r
 934                         unsigned short file_id = 0;\r
 935                         unsigned short file_size = 0;\r
 936                         unsigned short file_type = 0;\r
 937                         unsigned short arr_file_id = 0;\r
 938                         int arr_file_id_rec_num = 0;\r
 939 \r
 940                         /*      handling only last 3 bits */\r
 941                         unsigned char file_type_tag = 0x07;\r
 942                         unsigned char *ptr_data;\r
 943 \r
 944                         char *hexData;\r
 945                         char *tmp;\r
 946                         char *recordData = NULL;\r
 947                         hexData = g_slist_nth_data(tokens, 2);\r
 948                         dbg("hexData: %s", hexData);\r
 949                         dbg("hexData: %s", hexData+1);\r
 950 \r
 951                         tmp = calloc(1, strlen(hexData)-1);\r
 952                         memcpy(tmp, hexData+1, strlen(hexData)-2);\r
 953                         dbg("tmp: %s", tmp);\r
 954 \r
 955                         recordData = util_hexStringToBytes(tmp);\r
 956                         dbg("recordData: %x", recordData);\r
 957                         free(tmp);\r
 958                         util_hex_dump("    ", strlen(hexData)/2, recordData);\r
 959 \r
 960                         ptr_data = (unsigned char *)recordData;\r
 961                         if (tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)\r
 962                         {\r
 963                                 /*\r
 964                                  ETSI TS 102 221 v7.9.0\r
 965                                  - Response Data\r
 966                                  '62'   FCP template tag\r
 967                                  - Response for an EF\r
 968                                  '82'   M       File Descriptor\r
 969                                  '83'   M       File Identifier\r
 970                                  'A5'   O       Proprietary information\r
 971                                  '8A'   M       Life Cycle Status Integer\r
 972                                  '8B', '8C' or 'AB'     C1      Security attributes\r
 973                                  '80'   M       File size\r
 974                                  '81'   O       Total file size\r
 975                                  '88'   O       Short File Identifier (SFI)\r
 976                                  */\r
 977 \r
 978                                 /* rsim.res_len  has complete data length received  */\r
 979 \r
 980                                 /* FCP template tag - File Control Parameters tag*/\r
 981                                 if (*ptr_data == 0x62)\r
 982                                 {\r
 983                                         /* parse complete FCP tag*/\r
 984                                         /* increment to next byte */\r
 985                                         ptr_data++;\r
 986                                         tag_len = *ptr_data++;\r
 987                                         dbg("tag_len: %02x", tag_len);\r
 988                                         /* FCP file descriptor - file type, accessibility, DF, ADF etc*/\r
 989                                         if (*ptr_data == 0x82)\r
 990                                         {\r
 991                                                 /* increment to next byte */\r
 992                                                 ptr_data++;\r
 993                                                 /* 2 or 5 value*/\r
 994                                                 ptr_data++;\r
 995                                                 /*      unsigned char file_desc_len = *ptr_data++;*/\r
 996                                                 /*      dbg("file descriptor length: [%d]", file_desc_len);*/\r
 997                                                 /* TBD:  currently capture only file type : ignore sharable, non sharable, working, internal etc*/\r
 998                                                 /* consider only last 3 bits*/\r
 999                                                 dbg("file_type_tag: %02x", file_type_tag);\r
1000                                                 file_type_tag = file_type_tag & (*ptr_data);\r
1001                                                 dbg("file_type_tag: %02x", file_type_tag);\r
1002 \r
1003                                                 switch (file_type_tag)\r
1004                                                 {\r
1005                                                         /* increment to next byte */\r
1006                                                         //ptr_data++;\r
1007                                                         case 0x1:\r
1008                                                                 dbg("Getting FileType: [Transparent file type]");\r
1009                                                                 file_type = SIM_FTYPE_TRANSPARENT;\r
1010 \r
1011                                                                 /* increment to next byte */\r
1012                                                                 ptr_data++;\r
1013                                                                 /* increment to next byte */\r
1014                                                                 ptr_data++;\r
1015                                                                 break;\r
1016 \r
1017                                                         case 0x2:\r
1018                                                                 dbg("Getting FileType: [Linear fixed file type]");\r
1019                                                                 /* increment to next byte */\r
1020                                                                 ptr_data++;\r
1021                                                                 /*      data coding byte - value 21 */\r
1022                                                                 ptr_data++;\r
1023                                                                 /*      2bytes */\r
1024                                                                 memcpy(&record_len, ptr_data, 2);\r
1025                                                                 /* swap bytes */\r
1026                                                                 SWAPBYTES16(record_len);\r
1027                                                                 ptr_data = ptr_data + 2;\r
1028                                                                 num_of_records = *ptr_data++;\r
1029                                                                 /* Data lossy conversation from enum (int) to unsigned char */\r
1030                                                                 file_type = SIM_FTYPE_LINEAR_FIXED;\r
1031                                                                 break;\r
1032 \r
1033                                                         case 0x6:\r
1034                                                                 dbg(" Cyclic fixed file type");\r
1035                                                                 /* increment to next byte */\r
1036                                                                 ptr_data++;\r
1037                                                                 /*      data coding byte - value 21 */\r
1038                                                                 ptr_data++;\r
1039                                                                 /*      2bytes */\r
1040                                                                 memcpy(&record_len, ptr_data, 2);\r
1041                                                                 /* swap bytes  */\r
1042                                                                 SWAPBYTES16(record_len);\r
1043                                                                 ptr_data = ptr_data + 2;\r
1044                                                                 num_of_records = *ptr_data++;\r
1045                                                                 file_type = SIM_FTYPE_CYCLIC;\r
1046                                                                 break;\r
1047 \r
1048                                                 default:\r
1049                                                         dbg("not handled file type [0x%x]", *ptr_data);\r
1050                                                         break;\r
1051                                                 }\r
1052                                         } else\r
1053                                         {\r
1054                                                 dbg("INVALID FCP received - DEbug!");\r
1055                                                 return;\r
1056                                         }\r
1057 \r
1058                                         /*File identifier - file id?? */ // 0x84,0x85,0x86 etc are currently ignored and not handled\r
1059                                         if (*ptr_data == 0x83)\r
1060                                         {\r
1061                                                 /* increment to next byte */\r
1062                                                 ptr_data++;\r
1063                                                 file_id_len = *ptr_data++;\r
1064                                                 dbg("file_id_len: %02x", file_id_len);\r
1065 \r
1066                                                 memcpy(&file_id, ptr_data, file_id_len);\r
1067                                                 dbg("file_id: %x", file_id);\r
1068 \r
1069                                                 /* swap bytes    */\r
1070                                                 SWAPBYTES16(file_id);\r
1071                                                 dbg("file_id: %x", file_id);\r
1072 \r
1073                                                 ptr_data = ptr_data + 2;\r
1074                                                 dbg("Getting FileID=[0x%x]", file_id);\r
1075                                         } else\r
1076                                         {\r
1077                                                 dbg("INVALID FCP received - DEbug!");\r
1078                                                 free(recordData);\r
1079                                                 return;\r
1080                                         }\r
1081 \r
1082                                         /*      proprietary information  */\r
1083                                         if (*ptr_data == 0xA5)\r
1084                                         {\r
1085                                                 unsigned short prop_len;\r
1086                                                 /* increment to next byte */\r
1087                                                 ptr_data++;\r
1088 \r
1089                                                 /* length */\r
1090                                                 prop_len = *ptr_data;\r
1091                                                 dbg("prop_len: %02x", prop_len);\r
1092 \r
1093                                                 /* skip data */\r
1094                                                 ptr_data = ptr_data + prop_len + 1;\r
1095                                         } else\r
1096                                         {\r
1097                                                 dbg("INVALID FCP received - DEbug!");\r
1098                                         }\r
1099 \r
1100                                         /* life cycle status integer [8A][length:0x01][status]*/\r
1101                                         /*\r
1102                                          status info b8~b1\r
1103                                          00000000 : No information given\r
1104                                          00000001 : creation state\r
1105                                          00000011 : initialization state\r
1106                                          000001-1 : operation state -activated\r
1107                                          000001-0 : operation state -deactivated\r
1108                                          000011-- : Termination state\r
1109                                          b8~b5 !=0, b4~b1=X : Proprietary\r
1110                                          Any other value : RFU\r
1111                                          */\r
1112                                         if (*ptr_data == 0x8A)\r
1113                                         {\r
1114                                                 /* increment to next byte */\r
1115                                                 ptr_data++;\r
1116                                                 /* length - value 1 */\r
1117                                                 ptr_data++;\r
1118 \r
1119                                                 switch (*ptr_data) {\r
1120                                                         case 0x04:\r
1121                                                         case 0x06:\r
1122                                                                 dbg("<RX> operation state -deactivated");\r
1123                                                                 ptr_data++;\r
1124                                                                 break;\r
1125                                                         case 0x05:\r
1126                                                         case 0x07:\r
1127                                                                 dbg("<RX> operation state -activated");\r
1128                                                                 ptr_data++;\r
1129                                                                 break;\r
1130                                                         default:\r
1131                                                                 dbg("<RX> DEBUG! LIFE CYCLE STATUS =[0x%x]",*ptr_data);\r
1132                                                                 ptr_data++;\r
1133                                                                 break;\r
1134                                                 }\r
1135                                         }\r
1136 \r
1137                                         /* related to security attributes : currently not handled*/\r
1138                                         if (*ptr_data == 0x86 || *ptr_data == 0x8B || *ptr_data == 0x8C || *ptr_data == 0xAB)\r
1139                                         {\r
1140                                                 /* increment to next byte */\r
1141                                                 ptr_data++;\r
1142                                                 /* if tag length is 3 */\r
1143                                                 if (*ptr_data == 0x03)\r
1144                                                 {\r
1145                                                         /* increment to next byte */\r
1146                                                         ptr_data++;\r
1147                                                         /* EFARR file id */\r
1148                                                         memcpy(&arr_file_id, ptr_data, 2);\r
1149                                                         /* swap byes */\r
1150                                                         SWAPBYTES16(arr_file_id);\r
1151                                                         ptr_data = ptr_data + 2;\r
1152                                                         arr_file_id_rec_num = *ptr_data++;\r
1153                                                 } else\r
1154                                                 {\r
1155                                                         /* if tag length is not 3 */\r
1156                                                         /* ignoring bytes       */\r
1157                                                         //      ptr_data = ptr_data + 4;\r
1158                                                         dbg("Useless security attributes, so jump to next tag");\r
1159                                                         ptr_data = ptr_data + (*ptr_data + 1);\r
1160                                                 }\r
1161                                         } else\r
1162                                         {\r
1163                                                 dbg("INVALID FCP received[0x%x] - DEbug!", *ptr_data);\r
1164                                                 free(recordData);\r
1165                                                 return;\r
1166                                         }\r
1167 \r
1168                                         dbg("Current ptr_data value is [%x]", *ptr_data);\r
1169 \r
1170                                         /* file size excluding structural info*/\r
1171                                         if (*ptr_data == 0x80)\r
1172                                         {\r
1173                                                 /* for EF file size is body of file and for Linear or cyclic it is\r
1174                                                  * number of recXsizeof(one record)\r
1175                                                  */\r
1176                                                 /* increment to next byte */\r
1177                                                 ptr_data++;\r
1178                                                 /* length is 1 byte - value is 2 bytes or more */\r
1179                                                 ptr_data++;\r
1180                                                 memcpy(&file_size, ptr_data, 2);\r
1181                                                 /* swap bytes */\r
1182                                                 SWAPBYTES16(file_size);\r
1183                                                 ptr_data = ptr_data + 2;\r
1184                                         } else\r
1185                                         {\r
1186                                                 dbg("INVALID FCP received - DEbug!");\r
1187                                                 free(recordData);\r
1188                                                 return;\r
1189                                         }\r
1190 \r
1191                                         /* total file size including structural info*/\r
1192                                         if (*ptr_data == 0x81)\r
1193                                         {\r
1194                                                 int len;\r
1195                                                 /* increment to next byte */\r
1196                                                 ptr_data++;\r
1197                                                 /* length */\r
1198                                                 len = *ptr_data;\r
1199                                                 /* ignored bytes */\r
1200                                                 ptr_data = ptr_data + 3;\r
1201                                         } else\r
1202                                         {\r
1203                                                 dbg("INVALID FCP received - DEbug!");\r
1204                                                 /* 0x81 is optional tag?? check out! so do not return -1 from here! */\r
1205                                                 /* return -1; */\r
1206                                         }\r
1207                                         /*short file identifier ignored*/\r
1208                                         if (*ptr_data == 0x88)\r
1209                                         {\r
1210                                                 dbg("0x88: Do Nothing");\r
1211                                                 /*DO NOTHING*/\r
1212                                         }\r
1213                                 } else\r
1214                                 {\r
1215                                         dbg("INVALID FCP received - DEbug!");\r
1216                                         free(recordData);\r
1217                                         return;\r
1218                                 }\r
1219                         } else if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)\r
1220                         {\r
1221                                 unsigned char gsm_specific_file_data_len = 0;\r
1222                                 /*      ignore RFU byte1 and byte2 */\r
1223                                 ptr_data++;\r
1224                                 ptr_data++;\r
1225                                 /*      file size */\r
1226                                 //file_size = p_info->response_len;\r
1227                                 memcpy(&file_size, ptr_data, 2);\r
1228                                 /* swap bytes */\r
1229                                 SWAPBYTES16(file_size);\r
1230                                 /*      parsed file size */\r
1231                                 ptr_data = ptr_data + 2;\r
1232                                 /*  file id  */\r
1233                                 memcpy(&file_id, ptr_data, 2);\r
1234                                 SWAPBYTES16(file_id);\r
1235                                 dbg(" FILE id --> [%x]", file_id);\r
1236                                 ptr_data = ptr_data + 2;\r
1237                                 /* save file type - transparent, linear fixed or cyclic */\r
1238                                 file_type_tag = (*(ptr_data + 7));\r
1239 \r
1240                                 switch (*ptr_data)\r
1241                                 {\r
1242                                         case 0x0:\r
1243                                                 /* RFU file type */\r
1244                                                 dbg(" RFU file type- not handled - Debug!");\r
1245                                                 break;\r
1246                                         case 0x1:\r
1247                                                 /* MF file type */\r
1248                                                 dbg(" MF file type - not handled - Debug!");\r
1249                                                 break;\r
1250                                         case 0x2:\r
1251                                                 /* DF file type */\r
1252                                                 dbg(" DF file type - not handled - Debug!");\r
1253                                                 break;\r
1254                                         case 0x4:\r
1255                                                 /* EF file type */\r
1256                                                 dbg(" EF file type [%d] ", file_type_tag);\r
1257                                                 /*      increment to next byte */\r
1258                                                 ptr_data++;\r
1259 \r
1260                                                 if (file_type_tag == 0x00 || file_type_tag == 0x01)\r
1261                                                 {\r
1262                                                         /* increament to next byte as this byte is RFU */\r
1263                                                         ptr_data++;\r
1264                                                         file_type =\r
1265                                                                         (file_type_tag == 0x00) ? SIM_FTYPE_TRANSPARENT : SIM_FTYPE_LINEAR_FIXED;\r
1266                                                 } else\r
1267                                                 {\r
1268                                                         /* increment to next byte */\r
1269                                                         ptr_data++;\r
1270                                                         /*      For a cyclic EF all bits except bit 7 are RFU; b7=1 indicates that */\r
1271                                                         /* the INCREASE command is allowed on the selected cyclic file. */\r
1272                                                         file_type = SIM_FTYPE_CYCLIC;\r
1273                                                 }\r
1274                                                 /* bytes 9 to 11 give SIM file access conditions */\r
1275                                                 ptr_data++;\r
1276                                                 /* byte 10 has one nibble that is RF U and another for INCREASE which is not used currently */\r
1277                                                 ptr_data++;\r
1278                                                 /* byte 11 is invalidate and rehabilate nibbles */\r
1279                                                 ptr_data++;\r
1280                                                 /* byte 12 - file status */\r
1281                                                 ptr_data++;\r
1282                                                 /* byte 13 - GSM specific data */\r
1283                                                 gsm_specific_file_data_len = *ptr_data;\r
1284                                                 ptr_data++;\r
1285                                                 /*      byte 14 - structure of EF - transparent or linear or cyclic , already saved above */\r
1286                                                 ptr_data++;\r
1287                                                 /* byte 15 - length of record for linear and cyclic , for transparent it is set to 0x00. */\r
1288                                                 record_len = *ptr_data;\r
1289                                                 dbg("record length[%d], file size[%d]", record_len, file_size);\r
1290 \r
1291                                                 if (record_len != 0)\r
1292                                                         num_of_records = (file_size / record_len);\r
1293 \r
1294                                                 dbg("Number of records [%d]", num_of_records);\r
1295                                                 break;\r
1296 \r
1297                                         default:\r
1298                                                 dbg(" not handled file type");\r
1299                                                 break;\r
1300                                 }\r
1301                         }\r
1302                         else\r
1303                         {\r
1304                                 dbg(" Card Type - UNKNOWN  [%d]", tcore_sim_get_type(co_sim));\r
1305                         }\r
1306 \r
1307                         dbg("req ef[0x%x] resp ef[0x%x] size[%ld] Type[0x%x] NumOfRecords[%ld] RecordLen[%ld]",\r
1308                                         file_meta->file_id, file_id, file_size, file_type, num_of_records, record_len);\r
1309 \r
1310                         file_meta->file_type = file_type;\r
1311                         file_meta->data_size = file_size;\r
1312                         file_meta->rec_length = record_len;\r
1313                         file_meta->rec_count = num_of_records;\r
1314                         file_meta->current_index = 0; //reset for new record type EF\r
1315                         rt = SIM_ACCESS_SUCCESS;\r
1316                         free(recordData);\r
1317                 }\r
1318                 else\r
1319                 {\r
1320                         /*2. SIM access fail case*/\r
1321                         dbg("error to get ef[0x%x]", file_meta->file_id);\r
1322                         dbg("error to get ef[0x%x] (file_meta->file_id) ", file_meta->file_id);\r
1323                         rt = _decode_status_word(sw1, sw2);\r
1324                 }\r
1325                 ur = tcore_user_request_ref(ur);\r
1326                 \r
1327                 dbg("Calling _next_from_get_file_info");\r
1328                 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);\r
1329                 tcore_at_tok_free(tokens);\r
1330         }\r
1331         else\r
1332         {\r
1333                 dbg("RESPONSE NOK");\r
1334                 dbg("error to get ef[0x%x]", file_meta->file_id);\r
1335                 dbg("error to get ef[0x%x] (file_meta->file_id) ", file_meta->file_id);\r
1336                 rt = SIM_ACCESS_FAILED;\r
1337 \r
1338                 ur = tcore_user_request_ref(ur);\r
1339                 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);\r
1340         }\r
1341         dbg(" Function exit");\r
1342 }\r
1343 \r
1344 static void _response_get_file_data(TcorePending *p, int data_len, const void *data, void *user_data)\r
1345 {\r
1346         const TcoreATResponse *resp = data;\r
1347         UserRequest *ur = NULL;\r
1348         CoreObject *co_sim = NULL;\r
1349         struct s_sim_property *file_meta = NULL;\r
1350         GSList *tokens=NULL;\r
1351         enum tel_sim_access_result rt;\r
1352         struct tel_sim_imsi imsi;\r
1353         struct tel_sim_ecc ecc;\r
1354         struct tel_sim_msisdn msisdn;\r
1355         struct tel_sim_opl opl;\r
1356         struct tel_sim_pnn pnn;\r
1357         gboolean dr = FALSE;\r
1358         const char *line = NULL;\r
1359         char *res = NULL;\r
1360         char *tmp = NULL;\r
1361         int res_len;\r
1362         int sw1 = 0;\r
1363         int sw2 = 0;\r
1364 \r
1365         dbg(" Function entry ");\r
1366 \r
1367         co_sim = tcore_pending_ref_core_object(p);\r
1368         ur = tcore_pending_ref_user_request(p);\r
1369         file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);\r
1370 \r
1371         if(resp->success > 0)\r
1372         {\r
1373                 dbg("RESPONSE OK");\r
1374                 if(resp->lines)\r
1375                 {\r
1376                         line = (const char*)resp->lines->data;\r
1377                         tokens = tcore_at_tok_new(line);\r
1378                         if (g_slist_length(tokens) != 3)\r
1379                         {\r
1380                                 msg("invalid message");\r
1381                                 tcore_at_tok_free(tokens);\r
1382                                 return;\r
1383                         }\r
1384                 }\r
1385                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
1386                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
1387                 res  = g_slist_nth_data(tokens, 2);\r
1388 \r
1389                 res_len = strlen((const char*)res);\r
1390                 tmp = calloc(1, res_len-1);\r
1391                 memcpy(tmp, res+1, res_len-2);\r
1392                 dbg("tmp: %s", tmp);\r
1393 \r
1394                 res = util_hexStringToBytes(tmp);\r
1395                 res_len = strlen((const char*)res);\r
1396                 dbg("res: %s res_len: %d", res, res_len);\r
1397 \r
1398                 if((sw1 == 0x90 && sw2 == 0x00) || sw1 == 0x91)\r
1399                 {\r
1400                         rt = SIM_ACCESS_SUCCESS;\r
1401                         file_meta->files.result = rt;\r
1402                         dbg("file_meta->file_id : %x", file_meta->file_id);\r
1403 \r
1404                         switch (file_meta->file_id)\r
1405                         {\r
1406                                 case SIM_EF_IMSI:\r
1407                                 {\r
1408                                         dbg("res: %s", res);\r
1409                                         dr = tcore_sim_decode_imsi(&imsi, (unsigned char*)res, res_len);\r
1410                                         if (dr == FALSE)\r
1411                                         {\r
1412                                                 dbg("imsi decoding failed");\r
1413                                         } else\r
1414                                         {\r
1415                                                 _sim_check_identity(co_sim,&imsi);\r
1416                                                 tcore_sim_set_imsi(co_sim,&imsi);\r
1417                                         }\r
1418                                         break;\r
1419                                 }\r
1420                                 case SIM_EF_ICCID:\r
1421                                         dr = tcore_sim_decode_iccid(&file_meta->files.data.iccid, (unsigned char*)res, res_len);\r
1422                                         break;\r
1423 \r
1424                                 case SIM_EF_ELP:/*  2G EF -  2 bytes decoding*/\r
1425                                 case SIM_EF_USIM_LI: /* 3G EF - 2 bytes decoding*/\r
1426                                 case SIM_EF_USIM_PL:/*  3G EF - same as EFELP, so 2  byte decoding*/\r
1427                                 case SIM_EF_LP:/*  1 byte encoding*/\r
1428                                         if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM && file_meta->file_id == SIM_EF_LP)\r
1429                                         {\r
1430                                                  /*2G LP(0x6F05) has 1 byte for each language*/\r
1431                                                 dr = tcore_sim_decode_lp(&file_meta->files.data.language, (unsigned char*)res, res_len);\r
1432                                         } else\r
1433                                         {\r
1434                                                  /*3G LI(0x6F05)/PL(0x2F05), 2G ELP(0x2F05) has 2 bytes for each language*/\r
1435                                                 dr = tcore_sim_decode_li(file_meta->file_id, &file_meta->files.data.language, (unsigned char*)res, res_len);\r
1436                                         }\r
1437                                         break;\r
1438                                 case SIM_EF_SPN:\r
1439                                         dr = tcore_sim_decode_spn(&file_meta->files.data.spn, (unsigned char*)res, res_len);\r
1440                                         break;\r
1441                                 case SIM_EF_SPDI:\r
1442                                         dr = tcore_sim_decode_spdi(&file_meta->files.data.spdi, (unsigned char*)res, res_len);\r
1443                                         break;\r
1444                                 case SIM_EF_ECC:\r
1445                                         if(tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)\r
1446                                         {\r
1447                                                 dr = tcore_sim_decode_ecc(&file_meta->files.data.ecc, (unsigned char*)res, res_len);\r
1448                                         } else if(tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)\r
1449                                         {\r
1450                                                 dbg("decode w/ index [%d]",file_meta->current_index);\r
1451                                                 memset(&ecc, 0x00, sizeof(struct tel_sim_ecc));\r
1452                                                 dr = tcore_sim_decode_uecc(&ecc, (unsigned char*)res, res_len);\r
1453                                                 if (dr == TRUE)\r
1454                                                 {\r
1455                                                         memcpy( &file_meta->files.data.ecc.ecc[file_meta->files.data.ecc.ecc_count], &ecc, sizeof(struct tel_sim_ecc) );\r
1456                                                         file_meta->files.data.ecc.ecc_count++;\r
1457                                                 }\r
1458                                         } else\r
1459                                         {\r
1460                                                 dbg("err not handled tcore_sim_get_type(o)[%d] in here",tcore_sim_get_type(co_sim));\r
1461                                         }\r
1462                                         break;\r
1463                                 case SIM_EF_MSISDN :\r
1464                                         dbg("decode w/ index [%d]",file_meta->current_index);\r
1465                                         memset(&msisdn, 0x00, sizeof(struct tel_sim_msisdn));\r
1466                                         dr = tcore_sim_decode_msisdn(&msisdn, (unsigned char*)res, res_len);\r
1467                                         if (dr == TRUE)\r
1468                                         {\r
1469                                                 memcpy( &file_meta->files.data.msisdn_list.msisdn[file_meta->files.data.msisdn_list.count], &msisdn, sizeof(struct tel_sim_msisdn) );\r
1470                                                 file_meta->files.data.msisdn_list.count++;\r
1471                                         }\r
1472                                         break;\r
1473                                 case SIM_EF_OPL:\r
1474                                         dbg("decode w/ index [%d]",file_meta->current_index);\r
1475                                         memset(&opl, 0x00, sizeof(struct tel_sim_opl));\r
1476                                         dr = tcore_sim_decode_opl(&opl, (unsigned char*)res, res_len);\r
1477                                         if (dr == TRUE)\r
1478                                         {\r
1479                                                 memcpy( &file_meta->files.data.opl.opl[file_meta->files.data.opl.opl_count], &opl, sizeof(struct tel_sim_opl) );\r
1480                                                 file_meta->files.data.opl.opl_count++;\r
1481                                         }\r
1482                                         break;\r
1483                                 case SIM_EF_PNN:\r
1484                                         dbg("decode w/ index [%d]",file_meta->current_index);\r
1485                                         memset(&pnn, 0x00, sizeof(struct tel_sim_pnn));\r
1486                                         dr = tcore_sim_decode_pnn(&pnn, (unsigned char*)res, res_len);\r
1487                                         if (dr == TRUE)\r
1488                                         {\r
1489                                                 memcpy( &file_meta->files.data.pnn.pnn[file_meta->files.data.pnn.pnn_count], &opl, sizeof(struct tel_sim_pnn) );\r
1490                                                 file_meta->files.data.pnn.pnn_count++;\r
1491                                         }\r
1492                                         break;\r
1493                                 case SIM_EF_OPLMN_ACT:\r
1494                                         dr = tcore_sim_decode_oplmnwact(&file_meta->files.data.opwa, (unsigned char*)res, res_len);\r
1495                                         break;\r
1496                                 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:\r
1497                                         dr = tcore_sim_decode_cff(&file_meta->files.data.cf, (unsigned char*)res, res_len);\r
1498                                         break;\r
1499                                 case SIM_EF_CPHS_VOICE_MSG_WAITING:\r
1500                                         dr = tcore_sim_decode_vmwf(&file_meta->files.data.mw.mw_data_u.cphs_mw, (unsigned char*)res, res_len);\r
1501                                         break;\r
1502                                 case SIM_EF_USIM_MWIS:\r
1503                                         dr = tcore_sim_decode_mwis(&file_meta->files.data.mw.mw_data_u.mw, (unsigned char*)res, res_len);\r
1504                                         break;\r
1505                                 case SIM_EF_USIM_CFIS:\r
1506                                         dr = tcore_sim_decode_cfis(&file_meta->files.data.cf, (unsigned char*)res, res_len);\r
1507                                         break;\r
1508                                 case SIM_EF_CPHS_SERVICE_STRING_TABLE:\r
1509                                         dbg(" not handled -SIM_EF_CPHS_SERVICE_STRING_TABLE ");\r
1510                                         break;\r
1511                                 case SIM_EF_CPHS_OPERATOR_NAME_STRING:\r
1512                                         dr = tcore_sim_decode_ons((unsigned char*)&file_meta->files.data.cphs_net.full_name, (unsigned char*)res, res_len);\r
1513                                         dbg(" file_meta->files.result[%d],file_meta->files.data.cphs_net.full_name[%s]", file_meta->files.result, file_meta->files.data.cphs_net.full_name);\r
1514                                         break;\r
1515                                 case SIM_EF_CPHS_CPHS_INFO:\r
1516                                         dr = tcore_sim_decode_cphs_info(&file_meta->files.data.cphs, (unsigned char*)res, res_len);\r
1517                                         break;\r
1518                                 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:\r
1519                                         dr = tcore_sim_decode_short_ons((unsigned char*)&file_meta->files.data.cphs_net.short_name, (unsigned char*)res, res_len);\r
1520                                         break;\r
1521                                 default:\r
1522                                         dbg("File Decoding Failed - not handled File[0x%x]", file_meta->file_id);\r
1523                                         dr = 0;\r
1524                                         break;\r
1525                         }\r
1526                 }\r
1527                 else\r
1528                 {\r
1529                         rt =  _decode_status_word(sw1, sw2);\r
1530                         file_meta->files.result = rt;\r
1531                 }\r
1532                 free(tmp);\r
1533                 tcore_at_tok_free(tokens);\r
1534         }\r
1535         else\r
1536         {\r
1537                 dbg("RESPONSE NOK");\r
1538                 dbg("error to get ef[0x%x]", file_meta->file_id);\r
1539                 rt = SIM_ACCESS_FAILED;\r
1540         }\r
1541         ur = tcore_user_request_ref(ur);\r
1542         \r
1543         dbg("Calling _next_from_get_file_data");\r
1544         _next_from_get_file_data(tcore_pending_ref_core_object(p), ur, rt, dr);\r
1545         dbg(" Function exit");\r
1546 }\r
1547 \r
1548 static void _on_response_get_retry_count(TcorePending *p, int data_len, const void *data, void *user_data)\r
1549 {\r
1550         const TcoreATResponse *resp = data;\r
1551         UserRequest *ur = NULL;\r
1552         CoreObject *co_sim = NULL;\r
1553         struct s_sim_property *sp = NULL;\r
1554         GSList *tokens=NULL;\r
1555         const char *line = NULL;\r
1556         struct tresp_sim_verify_pins v_pin = {0,};\r
1557         struct tresp_sim_verify_puks v_puk = {0,};\r
1558         struct tresp_sim_change_pins change_pin = {0,};\r
1559         struct tresp_sim_disable_facility dis_facility = {0,};\r
1560         struct tresp_sim_enable_facility en_facility = {0,};\r
1561         int lock_type = 0;\r
1562         int attempts_left = 0;\r
1563         int time_penalty = 0;\r
1564 \r
1565         dbg(" Function entry ");\r
1566 \r
1567         co_sim = tcore_pending_ref_core_object(p);\r
1568         sp = tcore_sim_ref_userdata(co_sim);\r
1569         ur = tcore_pending_ref_user_request(p);\r
1570 \r
1571         if(resp->success > 0)\r
1572         {\r
1573                 dbg("RESPONSE OK");\r
1574                 if(resp->lines)\r
1575                 {\r
1576                         line = (const char*)resp->lines->data;\r
1577                         tokens = tcore_at_tok_new(line);\r
1578                         if (g_slist_length(tokens) < 3)\r
1579                         {\r
1580                                 msg("invalid message");\r
1581                                 tcore_at_tok_free(tokens);\r
1582                                 return;\r
1583                         }\r
1584                 }\r
1585                 lock_type = atoi(g_slist_nth_data(tokens, 0));\r
1586                 attempts_left = atoi(g_slist_nth_data(tokens, 1));\r
1587                 time_penalty = atoi(g_slist_nth_data(tokens, 2));\r
1588 \r
1589                 dbg("lock_type = %d, attempts_left = %d, time_penalty = %d",\r
1590                 lock_type,attempts_left,time_penalty);\r
1591 \r
1592                 switch (sp->current_sec_op)\r
1593                 {\r
1594                         case SEC_PIN1_VERIFY:\r
1595                         case SEC_PIN2_VERIFY:\r
1596                         case SEC_SIM_VERIFY:\r
1597                         case SEC_ADM_VERIFY:\r
1598                                 v_pin.result = SIM_INCORRECT_PASSWORD;\r
1599                                 v_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1600                                 v_pin.retry_count = attempts_left;\r
1601                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1602                                                 sizeof(struct tresp_sim_verify_pins), &v_pin);\r
1603                                 break;\r
1604                         case SEC_PUK1_VERIFY:\r
1605                         case SEC_PUK2_VERIFY:\r
1606                                 v_puk.result = SIM_INCORRECT_PASSWORD;\r
1607                                 v_puk.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1608                                 v_puk.retry_count = attempts_left;\r
1609                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1610                                                 sizeof(struct tresp_sim_verify_puks), &v_puk);\r
1611                                 break;\r
1612                         case SEC_PIN1_CHANGE:\r
1613                         case SEC_PIN2_CHANGE:\r
1614                                 change_pin.result = SIM_INCORRECT_PASSWORD;\r
1615                                 change_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1616                                 change_pin.retry_count = attempts_left;\r
1617                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1618                                                 sizeof(struct tresp_sim_change_pins), &change_pin);\r
1619                                 break;\r
1620                         case SEC_PIN1_DISABLE:\r
1621                         case SEC_PIN2_DISABLE:\r
1622                         case SEC_FDN_DISABLE:\r
1623                         case SEC_SIM_DISABLE:\r
1624                         case SEC_NET_DISABLE:\r
1625                         case SEC_NS_DISABLE:\r
1626                         case SEC_SP_DISABLE:\r
1627                         case SEC_CP_DISABLE:\r
1628                                 dis_facility.result = SIM_INCORRECT_PASSWORD;\r
1629                                 dis_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1630                                 dis_facility.retry_count = attempts_left;\r
1631                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1632                                                 sizeof(struct tresp_sim_disable_facility), &dis_facility);\r
1633                                 break;\r
1634                         case SEC_PIN1_ENABLE:\r
1635                         case SEC_PIN2_ENABLE:\r
1636                         case SEC_FDN_ENABLE:\r
1637                         case SEC_SIM_ENABLE:\r
1638                         case SEC_NET_ENABLE:\r
1639                         case SEC_NS_ENABLE:\r
1640                         case SEC_SP_ENABLE:\r
1641                         case SEC_CP_ENABLE:\r
1642                                 en_facility.result = SIM_INCORRECT_PASSWORD;\r
1643                                 en_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1644                                 en_facility.retry_count =  attempts_left;\r
1645                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1646                                                 sizeof(struct tresp_sim_enable_facility), &en_facility);\r
1647                                 break;\r
1648                         default:\r
1649                                 dbg("not handled sec op[%d]", sp->current_sec_op);\r
1650                                 break;\r
1651                 }\r
1652                 tcore_at_tok_free(tokens);\r
1653         }\r
1654         dbg(" Function exit");\r
1655 }\r
1656 \r
1657 static gboolean _get_sim_type(CoreObject *o)\r
1658 {\r
1659         TcoreHal* hal= NULL;\r
1660         TcoreATRequest *req= NULL;\r
1661         TcorePending *pending = NULL;\r
1662         UserRequest *ur = NULL;\r
1663         char *cmd_str = NULL;\r
1664 \r
1665         dbg(" Function entry ");\r
1666 \r
1667         hal = tcore_object_get_hal(o);\r
1668         pending = tcore_pending_new(o, 0);\r
1669 \r
1670         cmd_str = g_strdup_printf("AT+XUICC?");\r
1671         req = tcore_at_request_new(cmd_str, "+XUICC:", TCORE_AT_SINGLELINE);\r
1672 \r
1673         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1674 \r
1675         tcore_pending_set_request_data(pending, 0, req);\r
1676         tcore_pending_set_response_callback(pending, _response_get_sim_type, hal);\r
1677         tcore_pending_link_user_request(pending, ur);\r
1678         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1679         tcore_hal_send_request(hal, pending);\r
1680 \r
1681         free(cmd_str);\r
1682         dbg(" Function exit");\r
1683         return TRUE;\r
1684 }\r
1685 \r
1686 static TReturn _get_file_info(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef)\r
1687 {\r
1688         TcoreHal* hal= NULL;\r
1689         TcorePending *pending = NULL;\r
1690         struct s_sim_property file_meta={0,};\r
1691         char *cmd_str = NULL;\r
1692         int trt = 0;\r
1693 \r
1694         dbg(" Function entry ");\r
1695 \r
1696         file_meta.file_id = ef;\r
1697         dbg("file_meta.file_id: %d", file_meta.file_id);\r
1698         hal = tcore_object_get_hal(o);\r
1699         dbg("hal: %x", hal);\r
1700         pending = tcore_pending_new(o, 0);\r
1701 \r
1702         trt = tcore_user_request_set_metainfo(ur, sizeof(struct s_sim_property), &file_meta);\r
1703         dbg("trt[%d]",trt);\r
1704         cmd_str = g_strdup_printf("AT+CRSM=192, %d", ef);                       /*command - 192 : GET RESPONSE*/\r
1705         dbg("cmd_str: %x", cmd_str);\r
1706 \r
1707         pending = tcore_at_pending_new(o, cmd_str, "+CRSM:", TCORE_AT_SINGLELINE, _response_get_file_info, NULL);\r
1708         tcore_pending_link_user_request(pending, ur);\r
1709         tcore_hal_send_request(hal, pending);\r
1710 \r
1711         free(cmd_str);\r
1712         dbg(" Function exit");\r
1713         return TCORE_RETURN_SUCCESS;\r
1714 }\r
1715 \r
1716 static gboolean _get_file_data(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int offset, const int length)\r
1717 {\r
1718         TcoreHal* hal= NULL;\r
1719         TcoreATRequest *req= NULL;\r
1720         TcorePending *pending = NULL;\r
1721         char *cmd_str = NULL;\r
1722         int p1 = 0;\r
1723         int p2 = 0;\r
1724         int p3 = 0;\r
1725 \r
1726         dbg(" Function entry ");\r
1727         hal = tcore_object_get_hal(o);\r
1728         pending = tcore_pending_new(o, 0);\r
1729 \r
1730         dbg("file_id: %x", ef);\r
1731 \r
1732         p1 = (unsigned char)(offset & 0xFF00) >> 8;\r
1733         p2 = (unsigned char)offset & 0x00FF; //offset low\r
1734         p3 = (unsigned char)length;\r
1735 \r
1736         cmd_str = g_strdup_printf("AT+CRSM=176, %d, %d, %d, %d", ef,p1,p2,p3);                  /*command - 176 : READ BINARY*/\r
1737 \r
1738         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
1739 \r
1740         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1741 \r
1742         tcore_pending_set_request_data(pending, 0, req);\r
1743         tcore_pending_set_response_callback(pending, _response_get_file_data, hal);\r
1744         tcore_pending_link_user_request(pending, ur);\r
1745         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1746 \r
1747         tcore_hal_send_request(hal, pending);\r
1748 \r
1749         free(cmd_str);\r
1750         dbg(" Function exit");\r
1751         return TRUE;\r
1752 }\r
1753 \r
1754 static gboolean _get_file_record(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int index, const int length)\r
1755 {\r
1756 \r
1757         TcoreHal* hal= NULL;\r
1758         TcoreATRequest *req= NULL;\r
1759         TcorePending *pending = NULL;\r
1760         char *cmd_str = NULL;\r
1761         int p1 = 0;\r
1762         int p2 = 0;\r
1763         int p3 = 0;\r
1764         dbg(" Function entry ");\r
1765 \r
1766         hal = tcore_object_get_hal(o);\r
1767         pending = tcore_pending_new(o, 0);\r
1768 \r
1769         p1 = (unsigned char)index;\r
1770         p2 = (unsigned char)0x04;               /* 0x4 for absolute mode  */\r
1771         p3 = (unsigned char)length;\r
1772 \r
1773         cmd_str = g_strdup_printf("AT+CRSM=178, %d, %d, %d, %d", ef,p1,p2,p3);                  /*command - 178 : READ RECORD*/\r
1774 \r
1775         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
1776 \r
1777         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1778 \r
1779         tcore_pending_set_request_data(pending, 0, req);\r
1780         tcore_pending_set_response_callback(pending, _response_get_file_data, hal);\r
1781         tcore_pending_link_user_request(pending, ur);\r
1782         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1783 \r
1784         tcore_hal_send_request(hal, pending);\r
1785 \r
1786         free(cmd_str);\r
1787         dbg(" Function exit");\r
1788         return TRUE;\r
1789 }\r
1790 \r
1791 static TReturn _get_retry_count(CoreObject *o, UserRequest *ur)\r
1792 {\r
1793         TcoreHal* hal= NULL;\r
1794         TcoreATRequest *req= NULL;\r
1795         TcorePending *pending = NULL;\r
1796         char *cmd_str = NULL;\r
1797         int     lock_type = 0;\r
1798         struct s_sim_property *sp = NULL;\r
1799         const struct treq_sim_get_lock_info *req_data= NULL;\r
1800 \r
1801         dbg(" Function entry ");\r
1802 \r
1803         hal = tcore_object_get_hal(o);\r
1804         pending = tcore_pending_new(o, 0);\r
1805         req_data = tcore_user_request_ref_data(ur, NULL);\r
1806         sp = tcore_sim_ref_userdata(o);\r
1807 \r
1808         switch (sp->current_sec_op)\r
1809         {\r
1810                 case SEC_PIN1_VERIFY:\r
1811                 case SEC_PIN1_CHANGE:\r
1812                 case SEC_PIN1_ENABLE:\r
1813                 case SEC_PIN1_DISABLE:\r
1814                         lock_type = 1;\r
1815                         break;\r
1816                 case SEC_PIN2_VERIFY:\r
1817                 case SEC_PIN2_CHANGE:\r
1818                 case SEC_PIN2_ENABLE:\r
1819                 case SEC_PIN2_DISABLE:\r
1820                 case SEC_FDN_ENABLE:\r
1821                 case SEC_FDN_DISABLE:\r
1822                         lock_type = 2;\r
1823                         break;\r
1824                 case SEC_PUK1_VERIFY:\r
1825                         lock_type = 3;\r
1826                         break;\r
1827                 case SEC_PUK2_VERIFY:\r
1828                         lock_type = 4;\r
1829                         break;\r
1830                 case SEC_NET_ENABLE:\r
1831                 case SEC_NET_DISABLE:\r
1832                         lock_type = 5;\r
1833                         break;\r
1834                 case SEC_NS_ENABLE:\r
1835                 case SEC_NS_DISABLE:\r
1836                         lock_type = 6;\r
1837                         break;\r
1838                 case SEC_SP_ENABLE:\r
1839                 case SEC_SP_DISABLE:\r
1840                         lock_type = 7;\r
1841                         break;\r
1842                 case SEC_CP_ENABLE:\r
1843                 case SEC_CP_DISABLE:\r
1844                         lock_type = 8;\r
1845                         break;\r
1846                 case SEC_ADM_VERIFY:\r
1847                         lock_type = 9;\r
1848                         break;\r
1849                 default:\r
1850                         break;\r
1851         }\r
1852 \r
1853         cmd_str = g_strdup_printf("AT+XPINCNT=%d", lock_type);\r
1854         req = tcore_at_request_new(cmd_str, "+XPINCNT:", TCORE_AT_SINGLELINE);\r
1855         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1856 \r
1857         tcore_pending_set_request_data(pending, 0, req);\r
1858         tcore_pending_set_response_callback(pending, _on_response_get_retry_count, hal);\r
1859         tcore_pending_link_user_request(pending, ur);\r
1860         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1861         tcore_hal_send_request(hal, pending);\r
1862 \r
1863         free(cmd_str);\r
1864         dbg(" Function exit");\r
1865         return TCORE_RETURN_SUCCESS;\r
1866 }\r
1867 \r
1868 \r
1869 static gboolean on_event_facility_lock_status(CoreObject *o, const void *event_info, void *user_data)\r
1870 {\r
1871         struct s_sim_property *sp = NULL;\r
1872         char *line = NULL;\r
1873         GSList *tokens=NULL;\r
1874         GSList *lines = NULL;\r
1875 \r
1876         dbg("Function entry");\r
1877         return TRUE;\r
1878 \r
1879         sp = tcore_sim_ref_userdata(o);\r
1880         lines = (GSList*)event_info;\r
1881         if (1 != g_slist_length(lines))\r
1882         {\r
1883                 dbg("unsolicited msg but multiple line");\r
1884                 goto OUT;\r
1885         }\r
1886         line  = (char*)(lines->data);\r
1887         tokens = tcore_at_tok_new(line);\r
1888         if (g_slist_length(tokens) != 1)\r
1889         {\r
1890                 msg("invalid message");\r
1891                 tcore_at_tok_free(tokens);\r
1892                 return TRUE;\r
1893         }\r
1894 \r
1895 OUT:\r
1896         dbg(" Function exit");\r
1897         if(NULL!=tokens)\r
1898                 tcore_at_tok_free(tokens);\r
1899         return TRUE;\r
1900 }\r
1901 \r
1902 \r
1903 static gboolean on_event_pin_status(CoreObject *o, const void *event_info, void *user_data)\r
1904 {\r
1905         UserRequest *ur = NULL;\r
1906         struct s_sim_property *sp = NULL;\r
1907         enum tel_sim_status sim_status = SIM_STATUS_INITIALIZING;\r
1908         GSList *tokens=NULL;\r
1909         GSList *lines = NULL;\r
1910         const char *line = NULL;\r
1911         int sim_state = 0;\r
1912 \r
1913         dbg(" Function entry ");\r
1914 \r
1915         sp = tcore_sim_ref_userdata(o);\r
1916 \r
1917         lines = (GSList*)event_info;\r
1918         if (1 != g_slist_length(lines))\r
1919         {\r
1920                 dbg("unsolicited msg but multiple line");\r
1921                 goto OUT;\r
1922         }\r
1923         line  = (char*)(lines->data);\r
1924 \r
1925         tokens = tcore_at_tok_new(line);\r
1926         if (g_slist_length(tokens) != 1)\r
1927         {\r
1928                 msg("invalid message");\r
1929                 tcore_at_tok_free(tokens);\r
1930                 return TRUE;\r
1931         }\r
1932         sim_state = atoi(g_slist_nth_data(tokens, 0));\r
1933 \r
1934         switch (sim_state)\r
1935         {\r
1936                 case 0:                                                                                                         //sim state = SIM not present\r
1937                         sim_status = SIM_STATUS_CARD_NOT_PRESENT;\r
1938                         dbg( "NO SIM");\r
1939                         break;\r
1940                 case 1:                                                                                                         //sim state = PIN verification needed\r
1941                         sim_status = SIM_STATUS_PIN_REQUIRED;\r
1942                         dbg( " PIN required");\r
1943                         break;\r
1944                 case 2:                                                                                                         //sim state = PIN verification not needed \96 Ready\r
1945                 case 3:                                                                                                         //sim state = PIN verified \96 Ready\r
1946                         sim_status = SIM_STATUS_INITIALIZING;\r
1947                         dbg(" Inside PIN disabled at BOOT UP");\r
1948                         break;\r
1949                 case 4:                                                                                                         //sim state = PUK verification needed\r
1950                         sim_status = SIM_STATUS_PUK_REQUIRED;\r
1951                         dbg(" PUK required");\r
1952                         break;\r
1953                 case 5:                                                                                                         //sim state = SIM permanently blocked\r
1954                         sim_status = SIM_STATUS_CARD_BLOCKED;\r
1955                         dbg(" Card permanently blocked");\r
1956                         break;\r
1957                 case 6:                                                                                                         //sim state = SIM error\r
1958                         sim_status = SIM_STATUS_CARD_ERROR;\r
1959                         dbg( "SIM card error ");\r
1960                         break;\r
1961                 case 7:                                                                                                         //sim state = ready for attach (+COPS)\r
1962                         sim_status = SIM_STATUS_INIT_COMPLETED;\r
1963                         dbg( "Modem init completed");\r
1964                         break;\r
1965                 case 8:                                                                                                         //sim state = SIM Technical Problem\r
1966                         sim_status = SIM_STATUS_CARD_ERROR;\r
1967                         dbg( "SIM unavailable");\r
1968                         break;\r
1969                 case 9:                                                                                                         //sim state = SIM removed\r
1970                         sim_status = SIM_STATUS_CARD_REMOVED;\r
1971                         dbg( "SIM removed");\r
1972                         break;\r
1973                 case 99:                                                                                                                //sim state = SIM State Unknown\r
1974                         sim_status = SIM_STATUS_UNKNOWN;\r
1975                         dbg( "SIM State Unknown");\r
1976                         break;\r
1977                 case 12:\r
1978                         dbg( "SIM Status : %d", sim_status);\r
1979                         goto OUT;\r
1980                 default:\r
1981                         dbg(" not handled SEC lock type ");\r
1982                         break;\r
1983         }\r
1984 \r
1985         switch (sim_status)\r
1986         {\r
1987                 case SIM_STATUS_INIT_COMPLETED:\r
1988                         ur = tcore_user_request_new(NULL, NULL); //this is for using ur metainfo set/ref functionality.\r
1989                         _get_file_info(o, ur, SIM_EF_IMSI);\r
1990                         break;\r
1991                 case SIM_STATUS_INITIALIZING:\r
1992                 case SIM_STATUS_PIN_REQUIRED:\r
1993                 case SIM_STATUS_PUK_REQUIRED:\r
1994                 case SIM_STATUS_CARD_BLOCKED:\r
1995                 case SIM_STATUS_NCK_REQUIRED:\r
1996                 case SIM_STATUS_NSCK_REQUIRED:\r
1997                 case SIM_STATUS_SPCK_REQUIRED:\r
1998                 case SIM_STATUS_CCK_REQUIRED:\r
1999                 case SIM_STATUS_LOCK_REQUIRED:\r
2000                         if( sp->first_recv_status == SIM_STATUS_UNKNOWN )\r
2001                         {\r
2002                                 dbg("first received sim status[%d]",sim_status);\r
2003                                 sp->first_recv_status = sim_status;\r
2004                                 _get_sim_type(o);\r
2005                         } else {\r
2006                                 dbg("second or later received lock status[%d]",sim_status);\r
2007                                 if ( tcore_sim_get_status(o) != SIM_STATUS_INIT_COMPLETED )\r
2008                                 {\r
2009                                         dbg("sim is not init complete in telephony side yet");\r
2010                                         _sim_status_update(o,sim_status);\r
2011                                 }\r
2012                         }\r
2013                         break;\r
2014                 case SIM_STATUS_CARD_REMOVED:\r
2015                 case SIM_STATUS_CARD_NOT_PRESENT:\r
2016                 case SIM_STATUS_CARD_ERROR:\r
2017                         if (sim_status == SIM_STATUS_CARD_NOT_PRESENT && tcore_sim_get_status(o) != SIM_STATUS_UNKNOWN)\r
2018                         {\r
2019                                 dbg("[SIM]SIM CARD REMOVED!!");\r
2020                                 sim_status = SIM_STATUS_CARD_REMOVED;\r
2021                         }\r
2022                         _sim_status_update(o,sim_status);\r
2023                         break;\r
2024                 default:\r
2025                         dbg("not handled status[%d]", sim_status);\r
2026 \r
2027                         break;\r
2028                 }\r
2029 OUT:\r
2030         dbg(" Function exit");\r
2031         if(NULL!=tokens)\r
2032                 tcore_at_tok_free(tokens);\r
2033         return TRUE;\r
2034 }\r
2035 \r
2036 \r
2037 \r
2038 static void on_response_verify_pins(TcorePending *p, int data_len, const void *data, void *user_data)\r
2039 {\r
2040         const TcoreATResponse *resp = data;\r
2041         UserRequest *ur = NULL;\r
2042         CoreObject *co_sim = NULL;\r
2043         struct s_sim_property *sp = NULL;\r
2044         GSList *tokens=NULL;\r
2045         struct tresp_sim_verify_pins res;\r
2046         GQueue *queue= NULL;\r
2047         const char *line;\r
2048         int err;\r
2049 \r
2050         dbg(" Function entry ");\r
2051 \r
2052         co_sim = tcore_pending_ref_core_object(p);\r
2053         sp = tcore_sim_ref_userdata(co_sim);\r
2054         ur = tcore_pending_ref_user_request(p);\r
2055 \r
2056         memset(&res, 0, sizeof(struct tresp_sim_verify_pins));\r
2057 \r
2058         if(resp->success > 0)\r
2059         {\r
2060                 dbg("RESPONSE OK");\r
2061                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2062                 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2063                 if (res.pin_type == SIM_PTYPE_PIN1 || res.pin_type == SIM_PTYPE_SIM)\r
2064                 {\r
2065                         if (tcore_sim_get_status(co_sim) != SIM_STATUS_INIT_COMPLETED)\r
2066                                 _sim_status_update(co_sim, SIM_STATUS_INITIALIZING);\r
2067                 }\r
2068                 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PINS,     sizeof(struct tresp_sim_verify_pins), &res);\r
2069         }\r
2070         else\r
2071         {\r
2072                 dbg("RESPONSE NOK");\r
2073                 line = (const char*)resp->final_response;\r
2074                 tokens = tcore_at_tok_new(line);\r
2075                 if (g_slist_length(tokens) < 1)\r
2076                 {\r
2077                         dbg("err cause not specified or string corrupted");\r
2078                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2079                 }\r
2080                 else\r
2081                 {\r
2082                         err = atoi(g_slist_nth_data(tokens, 0));\r
2083                         dbg("on_response_verify_pins: err = %d", err);\r
2084                         queue = tcore_object_ref_user_data(co_sim);\r
2085                         ur = tcore_user_request_ref(ur);\r
2086                         _get_retry_count(co_sim, ur);\r
2087                 }\r
2088                 tcore_at_tok_free(tokens);\r
2089         }\r
2090         dbg(" Function exit");\r
2091 }\r
2092 \r
2093 static void on_response_verify_puks(TcorePending *p, int data_len, const void *data, void *user_data)\r
2094 {\r
2095         const TcoreATResponse *resp = data;\r
2096         UserRequest *ur = NULL;\r
2097         CoreObject *co_sim = NULL;\r
2098         struct s_sim_property *sp = NULL;\r
2099         GSList *tokens=NULL;\r
2100         struct tresp_sim_verify_puks res;\r
2101         GQueue *queue= NULL;\r
2102         const char *line;\r
2103         int err;\r
2104 \r
2105         dbg(" Function entry ");\r
2106 \r
2107         co_sim = tcore_pending_ref_core_object(p);\r
2108         sp = tcore_sim_ref_userdata(co_sim);\r
2109         ur = tcore_pending_ref_user_request(p);\r
2110 \r
2111         memset(&res, 0, sizeof(struct tresp_sim_verify_pins));\r
2112 \r
2113         if(resp->success > 0)\r
2114         {\r
2115                 dbg("RESPONSE OK");\r
2116                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2117                 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2118                 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PUKS,     sizeof(struct tresp_sim_verify_pins), &res);\r
2119         }\r
2120         else\r
2121         {\r
2122                 dbg("RESPONSE NOK");\r
2123                 line = (const char*)resp->final_response;\r
2124                 tokens = tcore_at_tok_new(line);\r
2125 \r
2126                 if (g_slist_length(tokens) < 1)\r
2127                 {\r
2128                         dbg("err cause not specified or string corrupted");\r
2129                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2130                 }\r
2131                 else\r
2132                 {\r
2133                         err = atoi(g_slist_nth_data(tokens, 0));\r
2134                         queue = tcore_object_ref_user_data(co_sim);\r
2135                         ur = tcore_user_request_ref(ur);\r
2136                         _get_retry_count(co_sim, ur);\r
2137                 }\r
2138                 tcore_at_tok_free(tokens);\r
2139         }\r
2140         dbg(" Function exit");\r
2141 }\r
2142 \r
2143 static void on_response_change_pins(TcorePending *p, int data_len, const void *data, void *user_data)\r
2144 {\r
2145         const TcoreATResponse *resp = data;\r
2146         UserRequest *ur = NULL;\r
2147         CoreObject *co_sim = NULL;\r
2148         struct s_sim_property *sp = NULL;\r
2149         GSList *tokens=NULL;\r
2150         struct tresp_sim_change_pins res;\r
2151         GQueue *queue;\r
2152         const char *line;\r
2153         int err;\r
2154 \r
2155         dbg(" Function entry ");\r
2156 \r
2157         co_sim = tcore_pending_ref_core_object(p);\r
2158         sp = tcore_sim_ref_userdata(co_sim);\r
2159         ur = tcore_pending_ref_user_request(p);\r
2160 \r
2161         memset(&res, 0, sizeof(struct tresp_sim_change_pins));\r
2162 \r
2163         if(resp->success > 0)\r
2164         {\r
2165                 dbg("RESPONSE OK");\r
2166                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2167                 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2168                 tcore_user_request_send_response(ur, TRESP_SIM_CHANGE_PINS,sizeof(struct tresp_sim_change_pins), &res);\r
2169         }\r
2170         else\r
2171         {\r
2172                 dbg("RESPONSE NOK");\r
2173                 line = (const char*)resp->final_response;\r
2174                 tokens = tcore_at_tok_new(line);\r
2175 \r
2176                 if (g_slist_length(tokens) < 1)\r
2177                 {\r
2178                         dbg("err cause not specified or string corrupted");\r
2179                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2180                 }\r
2181                 else\r
2182                 {\r
2183                         err = atoi(g_slist_nth_data(tokens, 0));\r
2184                         queue = tcore_object_ref_user_data(co_sim);\r
2185                         ur = tcore_user_request_ref(ur);\r
2186                         _get_retry_count(co_sim, ur);\r
2187                 }\r
2188                 tcore_at_tok_free(tokens);\r
2189         }\r
2190         dbg(" Function exit");\r
2191 }\r
2192 \r
2193 static void on_response_get_facility_status(TcorePending *p, int data_len, const void *data, void *user_data)\r
2194 {\r
2195         const TcoreATResponse *resp = data;\r
2196         UserRequest *ur = NULL;\r
2197         CoreObject *co_sim = NULL;\r
2198         struct s_sim_property *sp = NULL;\r
2199         GSList *tokens=NULL;\r
2200         struct tresp_sim_get_facility_status res;\r
2201         const char *line;\r
2202 \r
2203         dbg(" Function entry ");\r
2204 \r
2205         co_sim = tcore_pending_ref_core_object(p);\r
2206         sp = tcore_sim_ref_userdata(co_sim);\r
2207         ur = tcore_pending_ref_user_request(p);\r
2208 \r
2209         memset(&res, 0, sizeof(struct tresp_sim_get_facility_status));\r
2210 \r
2211         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2212         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2213 \r
2214         if(resp->success > 0)\r
2215         {\r
2216                 dbg("RESPONSE OK");\r
2217                 if(resp->lines) {\r
2218                         line = (const char*)resp->lines->data;\r
2219                         tokens = tcore_at_tok_new(line);\r
2220                         if (g_slist_length(tokens) != 1)\r
2221                         {\r
2222                                 msg("invalid message");\r
2223                                 tcore_at_tok_free(tokens);\r
2224                                 return;\r
2225                         }\r
2226                 }\r
2227                 res.b_enable = atoi(g_slist_nth_data(tokens, 0));\r
2228 \r
2229         }\r
2230         else\r
2231         {\r
2232                 dbg("RESPONSE NOK");\r
2233                 res.result = SIM_INCOMPATIBLE_PIN_OPERATION;\r
2234         }\r
2235 \r
2236         if (ur)\r
2237         {\r
2238                 tcore_user_request_send_response(ur, TRESP_SIM_GET_FACILITY_STATUS,\r
2239                                 sizeof(struct tresp_sim_get_facility_status), &res);\r
2240         }\r
2241         tcore_at_tok_free(tokens);\r
2242         dbg(" Function exit");\r
2243 }\r
2244 \r
2245 static void on_response_enable_facility(TcorePending *p, int data_len, const void *data, void *user_data)\r
2246 {\r
2247         const TcoreATResponse *resp = data;\r
2248         UserRequest *ur = NULL;\r
2249         CoreObject *co_sim = NULL;\r
2250         struct s_sim_property *sp = NULL;\r
2251         GSList *tokens=NULL;\r
2252         struct tresp_sim_enable_facility res;\r
2253         GQueue *queue;\r
2254         const char *line;\r
2255 \r
2256         dbg(" Function entry ");\r
2257 \r
2258         co_sim = tcore_pending_ref_core_object(p);\r
2259         sp = tcore_sim_ref_userdata(co_sim);\r
2260         ur = tcore_pending_ref_user_request(p);\r
2261 \r
2262         memset(&res, 0, sizeof(struct tresp_sim_enable_facility));\r
2263 \r
2264         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2265         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2266 \r
2267         if(resp->success > 0)\r
2268         {\r
2269                 dbg("RESPONSE OK");\r
2270                 if(resp->lines)\r
2271                 {\r
2272                         line = (const char*)resp->lines->data;\r
2273                         tokens = tcore_at_tok_new(line);\r
2274                         if (g_slist_length(tokens) != 1)\r
2275                         {\r
2276                                 msg("invalid message");\r
2277                                 tcore_at_tok_free(tokens);\r
2278                                 return;\r
2279                         }\r
2280                 }\r
2281                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2282                 if (ur)\r
2283                 {\r
2284                         tcore_user_request_send_response(ur, TRESP_SIM_ENABLE_FACILITY,\r
2285                                 sizeof(struct tresp_sim_enable_facility), &res);\r
2286                 }\r
2287                 tcore_at_tok_free(tokens);\r
2288         }\r
2289         else\r
2290         {\r
2291                 dbg("RESPONSE NOK");\r
2292                 queue = tcore_object_ref_user_data(co_sim);\r
2293                 ur = tcore_user_request_ref(ur);\r
2294                 _get_retry_count(co_sim, ur);\r
2295         }\r
2296         dbg(" Function exit");\r
2297 }\r
2298 \r
2299 static void on_response_disable_facility(TcorePending *p, int data_len, const void *data, void *user_data)\r
2300 {\r
2301         const TcoreATResponse *resp = data;\r
2302         UserRequest *ur = NULL;\r
2303         CoreObject *co_sim = NULL;\r
2304         struct s_sim_property *sp = NULL;\r
2305         GSList *tokens=NULL;\r
2306         struct tresp_sim_disable_facility res;\r
2307         GQueue *queue;\r
2308         const char *line;\r
2309 \r
2310         dbg(" Function entry ");\r
2311 \r
2312         co_sim = tcore_pending_ref_core_object(p);\r
2313         sp = tcore_sim_ref_userdata(co_sim);\r
2314         ur = tcore_pending_ref_user_request(p);\r
2315 \r
2316         memset(&res, 0, sizeof(struct tresp_sim_disable_facility));\r
2317 \r
2318         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2319         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2320 \r
2321         if(resp->success > 0)\r
2322         {\r
2323                 dbg("RESPONSE OK");\r
2324                 if(resp->lines) {\r
2325                         line = (const char*)resp->lines->data;\r
2326                         tokens = tcore_at_tok_new(line);\r
2327                         if (g_slist_length(tokens) != 1)\r
2328                         {\r
2329                                 msg("invalid message");\r
2330                                 tcore_at_tok_free(tokens);\r
2331                                 return;\r
2332                         }\r
2333                 }\r
2334                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2335                 if (ur)\r
2336                 {\r
2337                         tcore_user_request_send_response(ur, TRESP_SIM_DISABLE_FACILITY,\r
2338                                 sizeof(struct tresp_sim_disable_facility), &res);\r
2339                 }\r
2340                 tcore_at_tok_free(tokens);\r
2341         }\r
2342         else\r
2343         {\r
2344                 dbg("RESPONSE NOK");\r
2345                 queue = tcore_object_ref_user_data(co_sim);\r
2346                 ur = tcore_user_request_ref(ur);\r
2347                 _get_retry_count(co_sim, ur);\r
2348         }\r
2349         dbg(" Function exit");\r
2350 }\r
2351 \r
2352 static void on_response_get_lock_info(TcorePending *    p, int data_len, const void *data, void *user_data)\r
2353 {\r
2354         const TcoreATResponse *resp = data;\r
2355         UserRequest *ur = NULL;\r
2356         CoreObject *co_sim = NULL;\r
2357         struct s_sim_property *sp = NULL;\r
2358         GSList *tokens=NULL;\r
2359         const char *line;\r
2360         struct tresp_sim_verify_pins v_pin = {0,};\r
2361         struct tresp_sim_verify_puks v_puk = {0,};\r
2362         struct tresp_sim_change_pins change_pin = {0,};\r
2363         struct tresp_sim_disable_facility dis_facility = {0,};\r
2364         struct tresp_sim_enable_facility en_facility = {0,};\r
2365         int lock_type;\r
2366         int attempts_left = 0;\r
2367         int time_penalty = 0;\r
2368 \r
2369         dbg(" Function entry ");\r
2370 \r
2371         co_sim = tcore_pending_ref_core_object(p);\r
2372         sp = tcore_sim_ref_userdata(co_sim);\r
2373         ur = tcore_pending_ref_user_request(p);\r
2374 \r
2375         if(resp->success > 0)\r
2376         {\r
2377                 dbg("RESPONSE OK");\r
2378                 if(resp->lines) {\r
2379                         line = (const char*)resp->lines->data;\r
2380                         tokens = tcore_at_tok_new(line);\r
2381                         if (g_slist_length(tokens) != 3)\r
2382                         {\r
2383                                 msg("invalid message");\r
2384                                 tcore_at_tok_free(tokens);\r
2385                                 return;\r
2386                         }\r
2387                 }\r
2388                 lock_type = atoi(g_slist_nth_data(tokens, 0));\r
2389                 attempts_left = atoi(g_slist_nth_data(tokens, 1));\r
2390                 time_penalty = atoi(g_slist_nth_data(tokens, 2));\r
2391 \r
2392                 switch (sp->current_sec_op)\r
2393                 {\r
2394                         case SEC_PIN1_VERIFY:\r
2395                         case SEC_PIN2_VERIFY:\r
2396                         case SEC_SIM_VERIFY:\r
2397                         case SEC_ADM_VERIFY:\r
2398                                 v_pin.result = SIM_INCORRECT_PASSWORD;\r
2399                                 v_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2400                                 v_pin.retry_count = attempts_left;\r
2401                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2402                                                 sizeof(struct tresp_sim_verify_pins), &v_pin);\r
2403                                 break;\r
2404                         case SEC_PUK1_VERIFY:\r
2405                         case SEC_PUK2_VERIFY:\r
2406                                 v_puk.result = SIM_INCORRECT_PASSWORD;\r
2407                                 v_puk.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2408                                 v_puk.retry_count = attempts_left;\r
2409                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2410                                                 sizeof(struct tresp_sim_verify_puks), &v_puk);\r
2411                                 break;\r
2412                         case SEC_PIN1_CHANGE:\r
2413                         case SEC_PIN2_CHANGE:\r
2414                                 change_pin.result = SIM_INCORRECT_PASSWORD;\r
2415                                 change_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2416                                 change_pin.retry_count = attempts_left;\r
2417                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2418                                                 sizeof(struct tresp_sim_change_pins), &change_pin);\r
2419                                 break;\r
2420                         case SEC_PIN1_DISABLE:\r
2421                         case SEC_PIN2_DISABLE:\r
2422                         case SEC_FDN_DISABLE:\r
2423                         case SEC_SIM_DISABLE:\r
2424                         case SEC_NET_DISABLE:\r
2425                         case SEC_NS_DISABLE:\r
2426                         case SEC_SP_DISABLE:\r
2427                         case SEC_CP_DISABLE:\r
2428                                 dis_facility.result = SIM_INCORRECT_PASSWORD;\r
2429                                 dis_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2430                                 dis_facility.retry_count = attempts_left;\r
2431                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2432                                                 sizeof(struct tresp_sim_disable_facility), &dis_facility);\r
2433                                 break;\r
2434                         case SEC_PIN1_ENABLE:\r
2435                         case SEC_PIN2_ENABLE:\r
2436                         case SEC_FDN_ENABLE:\r
2437                         case SEC_SIM_ENABLE:\r
2438                         case SEC_NET_ENABLE:\r
2439                         case SEC_NS_ENABLE:\r
2440                         case SEC_SP_ENABLE:\r
2441                         case SEC_CP_ENABLE:\r
2442                                 en_facility.result = SIM_INCORRECT_PASSWORD;\r
2443                                 en_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2444                                 en_facility.retry_count = attempts_left;\r
2445                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2446                                                 sizeof(struct tresp_sim_enable_facility), &en_facility);\r
2447                                 break;\r
2448                         default:\r
2449                                 dbg("not handled sec op[%d]", sp->current_sec_op);\r
2450                                 break;\r
2451                 }\r
2452                 tcore_at_tok_free(tokens);\r
2453         }\r
2454         dbg(" Function exit");\r
2455 }\r
2456 \r
2457 static void on_response_update_file(TcorePending *p, int data_len, const void *data, void *user_data)\r
2458 {\r
2459         const TcoreATResponse *resp = data;\r
2460         UserRequest *ur = NULL;\r
2461         CoreObject *co_sim = NULL;\r
2462         struct tresp_sim_set_callforwarding resp_cf = {0, };\r
2463         struct tresp_sim_set_language resp_language ={0,};\r
2464         struct s_sim_property *sp = NULL;\r
2465         GSList *tokens=NULL;\r
2466         enum tel_sim_access_result result;\r
2467         const char *line;\r
2468         int sw1 = 0;\r
2469         int sw2 = 0;\r
2470 \r
2471         dbg(" Function entry ");\r
2472 \r
2473         co_sim = tcore_pending_ref_core_object(p);\r
2474         sp = tcore_sim_ref_userdata(co_sim);\r
2475         ur = tcore_pending_ref_user_request(p);\r
2476 \r
2477         if(resp->success > 0)\r
2478         {\r
2479                 dbg("RESPONSE OK");\r
2480                 if(resp->lines)\r
2481                 {\r
2482                         line = (const char*)resp->lines->data;\r
2483                         tokens = tcore_at_tok_new(line);\r
2484                         if (g_slist_length(tokens) != 2)\r
2485                         {\r
2486                                 msg("invalid message");\r
2487                                 tcore_at_tok_free(tokens);\r
2488                                 return;\r
2489                         }\r
2490                 }\r
2491                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
2492                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
2493 \r
2494                 if((sw1 == 0x90 && sw2 == 0x00) ||sw1 == 0x91)\r
2495                 {\r
2496                         result = SIM_ACCESS_SUCCESS;\r
2497                 }else\r
2498                 {\r
2499                         result =  _decode_status_word(sw1, sw2);\r
2500                 }\r
2501         }else{\r
2502                 dbg("RESPONSE NOK");\r
2503                 result = SIM_ACCESS_FAILED;\r
2504         }\r
2505 \r
2506         switch(sp->file_id)\r
2507         {\r
2508                 case SIM_EF_CPHS_CALL_FORWARD_FLAGS :\r
2509                 case SIM_EF_USIM_CFIS :\r
2510                         tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_set_callforwarding), &resp_cf);\r
2511                         break;\r
2512                 case SIM_EF_ELP:\r
2513                 case SIM_EF_LP:\r
2514                 case SIM_EF_USIM_LI:\r
2515                 case SIM_EF_USIM_PL:\r
2516                         tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_set_language), &resp_language);\r
2517                         break;\r
2518                 default:\r
2519                         break;\r
2520         }\r
2521         tcore_at_tok_free(tokens);\r
2522         dbg(" Function exit");\r
2523 }\r
2524 \r
2525 static void on_response_transmit_apdu(TcorePending *p, int data_len, const void *data, void *user_data)\r
2526 {\r
2527         const TcoreATResponse *resp = data;\r
2528         UserRequest *ur = NULL;\r
2529         CoreObject *co_sim = NULL;\r
2530         struct s_sim_property *sp = NULL;\r
2531         GSList *tokens=NULL;\r
2532         struct tresp_sim_transmit_apdu res;\r
2533         const char *line;\r
2534 \r
2535         dbg(" Function entry ");\r
2536 \r
2537         co_sim = tcore_pending_ref_core_object(p);\r
2538         sp = tcore_sim_ref_userdata(co_sim);\r
2539         ur = tcore_pending_ref_user_request(p);\r
2540 \r
2541         memset(&res, 0, sizeof(struct tresp_sim_transmit_apdu));\r
2542 \r
2543         if(resp->success > 0)\r
2544         {\r
2545                 dbg("RESPONSE OK");\r
2546                 res.result = SIM_ACCESS_SUCCESS;\r
2547                 if(resp->lines)\r
2548                 {\r
2549                         line = (const char*)resp->lines->data;\r
2550                         tokens = tcore_at_tok_new(line);\r
2551                         if (g_slist_length(tokens) != 2)\r
2552                         {\r
2553                                 msg("invalid message");\r
2554                                 tcore_at_tok_free(tokens);\r
2555                                 return;\r
2556                         }\r
2557                 }\r
2558                 res.apdu_resp_length = atoi(g_slist_nth_data(tokens, 0));\r
2559                 strncpy((char *)res.apdu_resp, (const char *)g_slist_nth_data(tokens, 1), res.apdu_resp_length);\r
2560         }\r
2561         else\r
2562         {\r
2563                 dbg("RESPONSE NOK");\r
2564                 res.result = SIM_ACCESS_FAILED;\r
2565         }\r
2566         ur = tcore_pending_ref_user_request(p);\r
2567         if (ur)\r
2568         {\r
2569                 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_transmit_apdu), &res);\r
2570         }\r
2571         tcore_at_tok_free(tokens);\r
2572         dbg(" Function exit");\r
2573 }\r
2574 \r
2575 static TReturn s_verify_pins(CoreObject *o, UserRequest *ur)\r
2576 {\r
2577         TcoreHal* hal= NULL;\r
2578         TcoreATRequest *req = NULL;\r
2579         TcorePending *pending = NULL;\r
2580         char *cmd_str = NULL;\r
2581         const struct treq_sim_verify_pins *req_data = NULL;\r
2582         struct s_sim_property *sp = NULL;\r
2583 \r
2584         dbg(" Function entry ");\r
2585 \r
2586         hal = tcore_object_get_hal(o);\r
2587         sp = tcore_sim_ref_userdata(o);\r
2588         pending = tcore_pending_new(o, 0);\r
2589         req_data = tcore_user_request_ref_data(ur, NULL);\r
2590 \r
2591         if (!o || !ur)\r
2592                 return TCORE_RETURN_EINVAL;\r
2593 \r
2594         if (req_data->pin_type == SIM_PTYPE_PIN1)\r
2595         {\r
2596                 sp->current_sec_op = SEC_PIN1_VERIFY;\r
2597                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2598         }\r
2599         else if (req_data->pin_type == SIM_PTYPE_PIN2)\r
2600         {\r
2601                 sp->current_sec_op = SEC_PIN2_VERIFY;\r
2602                 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\"", req_data->pin);\r
2603         }\r
2604         else if (req_data->pin_type == SIM_PTYPE_SIM)\r
2605         {\r
2606                 sp->current_sec_op = SEC_SIM_VERIFY;\r
2607                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2608         }\r
2609         else if (req_data->pin_type == SIM_PTYPE_ADM)\r
2610         {\r
2611                 sp->current_sec_op = SEC_ADM_VERIFY;\r
2612                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2613         }\r
2614         else\r
2615         {\r
2616                 return TCORE_RETURN_EINVAL;\r
2617         }\r
2618 \r
2619         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2620 \r
2621         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2622 \r
2623         tcore_pending_set_request_data(pending, 0, req);\r
2624         tcore_pending_set_response_callback(pending, on_response_verify_pins, hal);\r
2625         tcore_pending_link_user_request(pending, ur);\r
2626         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2627         tcore_hal_send_request(hal, pending);\r
2628 \r
2629         free(cmd_str);\r
2630         dbg(" Function exit");\r
2631         return TCORE_RETURN_SUCCESS;\r
2632 }\r
2633 \r
2634 static TReturn s_verify_puks(CoreObject *o, UserRequest *ur)\r
2635 {\r
2636         TcoreHal* hal= NULL;\r
2637         TcoreATRequest *req= NULL;\r
2638         TcorePending *pending = NULL;\r
2639         char *cmd_str = NULL;\r
2640         const struct treq_sim_verify_puks *req_data;\r
2641         struct s_sim_property *sp = NULL;\r
2642 \r
2643         dbg(" Function entry ");\r
2644 \r
2645         hal = tcore_object_get_hal(o);\r
2646         sp = tcore_sim_ref_userdata(o);\r
2647         pending = tcore_pending_new(o, 0);\r
2648         req_data = tcore_user_request_ref_data(ur, NULL);\r
2649 \r
2650         if (!o || !ur)\r
2651                 return TCORE_RETURN_EINVAL;\r
2652 \r
2653         if(req_data->puk_type == SIM_PTYPE_PUK1)\r
2654         {\r
2655                 sp->current_sec_op = SEC_PUK1_VERIFY;\r
2656                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\", \"%s\"", req_data->puk, req_data->pin);\r
2657         }\r
2658         else if(req_data->puk_type == SIM_PTYPE_PUK2)\r
2659         {\r
2660                 sp->current_sec_op = SEC_PUK2_VERIFY;\r
2661                 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\", \"%s\"", req_data->puk, req_data->pin);\r
2662         }\r
2663         else\r
2664         {\r
2665                 return TCORE_RETURN_EINVAL;\r
2666         }\r
2667         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2668 \r
2669         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2670 \r
2671         tcore_pending_set_request_data(pending, 0, req);\r
2672         tcore_pending_set_response_callback(pending, on_response_verify_puks, hal);\r
2673         tcore_pending_link_user_request(pending, ur);\r
2674         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2675         tcore_hal_send_request(hal, pending);\r
2676 \r
2677         free(cmd_str);\r
2678         dbg(" Function exit");\r
2679         return TCORE_RETURN_SUCCESS;\r
2680 }\r
2681 \r
2682 static TReturn s_change_pins(CoreObject *o, UserRequest *ur)\r
2683 {\r
2684         TcoreHal* hal= NULL;\r
2685         TcoreATRequest *req= NULL;\r
2686         TcorePending *pending = NULL;\r
2687         char *cmd_str = NULL;\r
2688         const struct treq_sim_change_pins *req_data;\r
2689         struct s_sim_property *sp = NULL;\r
2690         char *pin1 = "SC";\r
2691         char *pin2 = "P2";\r
2692 \r
2693         dbg(" Function entry ");\r
2694 \r
2695         hal = tcore_object_get_hal(o);\r
2696         sp = tcore_sim_ref_userdata(o);\r
2697         pending = tcore_pending_new(o, 0);\r
2698         req_data = tcore_user_request_ref_data(ur, NULL);\r
2699 \r
2700         if (!o || !ur)\r
2701                 return TCORE_RETURN_EINVAL;\r
2702                 \r
2703         if(req_data->type == SIM_PTYPE_PIN1)\r
2704         {\r
2705                 sp->current_sec_op = SEC_PIN1_CHANGE;\r
2706                 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", pin1, req_data->old_pin, req_data->new_pin);\r
2707 \r
2708         }\r
2709         else if(req_data->type == SIM_PTYPE_PIN2)\r
2710         {\r
2711                 sp->current_sec_op = SEC_PIN2_CHANGE;\r
2712                 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", pin2, req_data->old_pin, req_data->new_pin);\r
2713         }\r
2714         else\r
2715         {\r
2716                 return TCORE_RETURN_EINVAL;\r
2717         }\r
2718         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2719 \r
2720         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2721 \r
2722         tcore_pending_set_request_data(pending, 0, req);\r
2723         tcore_pending_set_response_callback(pending, on_response_change_pins, hal);\r
2724         tcore_pending_link_user_request(pending, ur);\r
2725         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2726         tcore_hal_send_request(hal, pending);\r
2727 \r
2728         free(cmd_str);\r
2729         dbg(" Function exit");\r
2730         return TCORE_RETURN_SUCCESS;\r
2731 }\r
2732 \r
2733 static TReturn s_get_facility_status(CoreObject *o, UserRequest *ur)\r
2734 {\r
2735         TcoreHal* hal= NULL;\r
2736         TcoreATRequest *req= NULL;\r
2737         TcorePending *pending = NULL;\r
2738         char *cmd_str = NULL;\r
2739         const struct treq_sim_get_facility_status *req_data;\r
2740         struct s_sim_property *sp = NULL;\r
2741         char *fac = "SC";\r
2742         int mode = 2;           /* 0:unlock, 1:lock, 2:query*/\r
2743 \r
2744         dbg(" Function entry ");\r
2745 \r
2746         hal = tcore_object_get_hal(o);\r
2747         sp = tcore_sim_ref_userdata(o);\r
2748         pending = tcore_pending_new(o, 0);\r
2749         req_data = tcore_user_request_ref_data(ur, NULL);\r
2750 \r
2751         if (!o || !ur)\r
2752                 return TCORE_RETURN_EINVAL;\r
2753 \r
2754         if(req_data->type == SIM_FACILITY_PS)\r
2755         {\r
2756                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2757         }else if(req_data->type == SIM_FACILITY_SC)\r
2758         {\r
2759                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2760         }else if(req_data->type == SIM_FACILITY_FD)\r
2761         {\r
2762                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2763         }else if(req_data->type == SIM_FACILITY_PN)\r
2764         {\r
2765                 fac = "PN";                                                             /*Network Personalization*/\r
2766         }else if(req_data->type == SIM_FACILITY_PU)\r
2767         {\r
2768                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2769         }else if(req_data->type == SIM_FACILITY_PP)\r
2770         {\r
2771                 fac = "PP";                                                             /*service Provider Personalization*/\r
2772         }else if(req_data->type == SIM_FACILITY_PC)\r
2773         {\r
2774                 fac = "PC";                                                             /*Corporate Personalization*/\r
2775         }else\r
2776         {\r
2777                 return TCORE_RETURN_EINVAL;\r
2778         }\r
2779         cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d", fac, mode);\r
2780         req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);\r
2781 \r
2782         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2783 \r
2784         tcore_pending_set_request_data(pending, 0, req);\r
2785         tcore_pending_set_response_callback(pending, on_response_get_facility_status, hal);\r
2786         tcore_pending_link_user_request(pending, ur);\r
2787         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2788         tcore_hal_send_request(hal, pending);\r
2789 \r
2790         free(cmd_str);\r
2791         dbg(" Function exit");\r
2792         return TCORE_RETURN_SUCCESS;\r
2793 }\r
2794 \r
2795 static TReturn s_enable_facility(CoreObject *o, UserRequest *ur)\r
2796 {\r
2797         TcoreHal* hal = NULL;\r
2798         TcoreATRequest *req = NULL;\r
2799         TcorePending *pending = NULL;\r
2800         char *cmd_str = NULL;\r
2801         const struct treq_sim_enable_facility *req_data;\r
2802         struct s_sim_property *sp = NULL;\r
2803         char *fac = "SC";\r
2804         int mode = 1;           /* 0:unlock, 1:lock, 2:query*/\r
2805 \r
2806         dbg(" Function entry ");\r
2807 \r
2808         hal = tcore_object_get_hal(o);\r
2809         sp = tcore_sim_ref_userdata(o);\r
2810         pending = tcore_pending_new(o, 0);\r
2811         req_data = tcore_user_request_ref_data(ur, NULL);\r
2812 \r
2813         if (!o || !ur)\r
2814                 return TCORE_RETURN_EINVAL;\r
2815 \r
2816         if(req_data->type == SIM_FACILITY_PS)\r
2817         {\r
2818                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2819                 sp->current_sec_op = SEC_SIM_ENABLE;\r
2820         }else if(req_data->type == SIM_FACILITY_SC)\r
2821         {\r
2822                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2823                 sp->current_sec_op = SEC_PIN1_ENABLE;\r
2824         }else if(req_data->type == SIM_FACILITY_FD)\r
2825         {\r
2826                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2827                 sp->current_sec_op = SEC_FDN_ENABLE;\r
2828         }else if(req_data->type == SIM_FACILITY_PN)\r
2829         {\r
2830                 fac = "PN";                                                             /*Network Personalization*/\r
2831                 sp->current_sec_op = SEC_NET_ENABLE;\r
2832         }else if(req_data->type == SIM_FACILITY_PU)\r
2833         {\r
2834                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2835                 sp->current_sec_op = SEC_NS_ENABLE;\r
2836         }else if(req_data->type == SIM_FACILITY_PP)\r
2837         {\r
2838                 fac = "PP";                                                             /*service Provider Personalization*/\r
2839                 sp->current_sec_op = SEC_SP_ENABLE;\r
2840         }else if(req_data->type == SIM_FACILITY_PC)\r
2841         {\r
2842                 fac = "PC";                                                             /*Corporate Personalization*/\r
2843                 sp->current_sec_op = SEC_CP_ENABLE;\r
2844         }else\r
2845         {\r
2846                 return TCORE_RETURN_EINVAL;\r
2847         }\r
2848         cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d, \"%s\"", fac, mode, req_data->password);\r
2849         req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);\r
2850 \r
2851         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2852 \r
2853         tcore_pending_set_request_data(pending, 0, req);\r
2854         tcore_pending_set_response_callback(pending, on_response_enable_facility, hal);\r
2855         tcore_pending_link_user_request(pending, ur);\r
2856         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2857         tcore_hal_send_request(hal, pending);\r
2858 \r
2859         free(cmd_str);\r
2860         dbg(" Function exit");\r
2861         return TCORE_RETURN_SUCCESS;\r
2862 }\r
2863 \r
2864 static TReturn s_disable_facility(CoreObject *o, UserRequest *ur)\r
2865 {\r
2866         TcoreHal* hal;\r
2867         TcoreATRequest *req;\r
2868         TcorePending *pending = NULL;\r
2869         char *cmd_str = NULL;\r
2870         const struct treq_sim_enable_facility *req_data;\r
2871         struct s_sim_property *sp = NULL;\r
2872         char *fac = "SC";\r
2873         int mode = 0;           /* 0:unlock, 1:lock, 2:query*/\r
2874 \r
2875         dbg(" Function entry ");\r
2876 \r
2877         hal = tcore_object_get_hal(o);\r
2878         sp = tcore_sim_ref_userdata(o);\r
2879         pending = tcore_pending_new(o, 0);\r
2880         req_data = tcore_user_request_ref_data(ur, NULL);\r
2881 \r
2882         if (!o || !ur)\r
2883                 return TCORE_RETURN_EINVAL;\r
2884 \r
2885         if(req_data->type == SIM_FACILITY_PS)\r
2886         {\r
2887                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2888                 sp->current_sec_op = SEC_SIM_DISABLE;\r
2889         }else if(req_data->type == SIM_FACILITY_SC)\r
2890         {\r
2891                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2892                 sp->current_sec_op = SEC_PIN1_DISABLE;\r
2893         }else if(req_data->type == SIM_FACILITY_FD)\r
2894         {\r
2895                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2896                 sp->current_sec_op = SEC_FDN_DISABLE;\r
2897         }else if(req_data->type == SIM_FACILITY_PN)\r
2898         {\r
2899                 fac = "PN";                                                             /*Network Personalization*/\r
2900                 sp->current_sec_op = SEC_NET_DISABLE;\r
2901         }else if(req_data->type == SIM_FACILITY_PU)\r
2902         {\r
2903                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2904                 sp->current_sec_op = SEC_NS_DISABLE;\r
2905         }else if(req_data->type == SIM_FACILITY_PP)\r
2906         {\r
2907                 fac = "PP";                                                             /*service Provider Personalization*/\r
2908                 sp->current_sec_op = SEC_SP_DISABLE;\r
2909         }else if(req_data->type == SIM_FACILITY_PC)\r
2910         {\r
2911                 fac = "PC";                                                             /*Corporate Personalization*/\r
2912                 sp->current_sec_op = SEC_CP_DISABLE;\r
2913         }else\r
2914         {\r
2915                 return TCORE_RETURN_EINVAL;\r
2916         }\r
2917         cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d, \"%s\"", fac, mode, req_data->password);\r
2918         req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);\r
2919 \r
2920         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2921 \r
2922         tcore_pending_set_request_data(pending, 0, req);\r
2923         tcore_pending_set_response_callback(pending, on_response_disable_facility, hal);\r
2924         tcore_pending_link_user_request(pending, ur);\r
2925         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2926         tcore_hal_send_request(hal, pending);\r
2927 \r
2928         free(cmd_str);\r
2929         dbg(" Function exit");\r
2930         return TCORE_RETURN_SUCCESS;\r
2931 }\r
2932 \r
2933 static TReturn s_get_lock_info(CoreObject *o, UserRequest *ur)\r
2934 {\r
2935         TcoreHal* hal = NULL;\r
2936         TcoreATRequest *req = NULL;\r
2937         TcorePending *pending = NULL;\r
2938         char *cmd_str = NULL;\r
2939         char    *lock_type = NULL;\r
2940         const struct treq_sim_get_lock_info *req_data;\r
2941         struct s_sim_property *sp = NULL;\r
2942 \r
2943         dbg(" Function entry ");\r
2944 \r
2945         hal = tcore_object_get_hal(o);\r
2946         sp = tcore_sim_ref_userdata(o);\r
2947         pending = tcore_pending_new(o, 0);\r
2948         req_data = tcore_user_request_ref_data(ur, NULL);\r
2949 \r
2950         if (!o || !ur)\r
2951                 return TCORE_RETURN_EINVAL;\r
2952 \r
2953         switch (req_data->type)\r
2954         {\r
2955                 case SIM_FACILITY_PS:\r
2956                         lock_type = "PS";\r
2957                         break;\r
2958                 case SIM_FACILITY_SC:\r
2959                         lock_type = "SC";\r
2960                         break;\r
2961                 case SIM_FACILITY_FD:\r
2962                         lock_type = "FD";\r
2963                         break;\r
2964                 case SIM_FACILITY_PN:\r
2965                         lock_type = "PN";\r
2966                         break;\r
2967                 case SIM_FACILITY_PU:\r
2968                         lock_type = "PU";\r
2969                         break;\r
2970                 case SIM_FACILITY_PP:\r
2971                         lock_type = "PP";\r
2972                         break;\r
2973                 case SIM_FACILITY_PC:\r
2974                         lock_type = "PC";\r
2975                         break;\r
2976                 default:\r
2977                         break;\r
2978         }\r
2979         cmd_str = g_strdup_printf("AT+XPINCNT =\"%s\"", lock_type);\r
2980         req = tcore_at_request_new(cmd_str, "+XPINCNT:", TCORE_AT_SINGLELINE);\r
2981 \r
2982         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2983 \r
2984         tcore_pending_set_request_data(pending, 0, req);\r
2985         tcore_pending_set_response_callback(pending, on_response_get_lock_info, hal);\r
2986         tcore_pending_link_user_request(pending, ur);\r
2987         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2988         tcore_hal_send_request(hal, pending);\r
2989 \r
2990         free(cmd_str);\r
2991         dbg(" Function exit");\r
2992         return TCORE_RETURN_SUCCESS;\r
2993 }\r
2994 \r
2995 static TReturn s_read_file(CoreObject *o, UserRequest *ur)\r
2996 {\r
2997         TReturn api_ret = TCORE_RETURN_SUCCESS;\r
2998         enum tcore_request_command command;\r
2999         command = tcore_user_request_get_command(ur);\r
3000 \r
3001         dbg(" Function entry ");\r
3002 \r
3003         if (!o || !ur)\r
3004                 return TCORE_RETURN_EINVAL;\r
3005 \r
3006         switch (command)\r
3007         {\r
3008                 case TREQ_SIM_GET_ECC:\r
3009                         api_ret = _get_file_info(o, ur, SIM_EF_ECC);\r
3010                         break;\r
3011                 case TREQ_SIM_GET_LANGUAGE:\r
3012                         if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
3013                                 api_ret = _get_file_info(o, ur, SIM_EF_ELP);\r
3014                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
3015                                 api_ret = _get_file_info(o, ur, SIM_EF_LP);\r
3016                         else\r
3017                                 api_ret = TCORE_RETURN_ENOSYS;\r
3018                         break;\r
3019                 case TREQ_SIM_GET_ICCID:\r
3020                         api_ret = _get_file_info(o, ur, SIM_EF_ICCID);\r
3021                         break;\r
3022                 case TREQ_SIM_GET_MAILBOX:\r
3023                         if(tcore_sim_get_cphs_status(o))\r
3024                                 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_MAILBOX_NUMBERS);\r
3025                         else\r
3026                                 api_ret = _get_file_info(o, ur, SIM_EF_MBDN);\r
3027                         break;\r
3028                 case TREQ_SIM_GET_CALLFORWARDING:\r
3029                         if(tcore_sim_get_cphs_status(o))\r
3030                                 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CALL_FORWARD_FLAGS);\r
3031                         else\r
3032                                 api_ret = _get_file_info(o, ur, SIM_EF_USIM_CFIS);\r
3033                         break;\r
3034                 case TREQ_SIM_GET_MESSAGEWAITING:\r
3035                         if(tcore_sim_get_cphs_status(o))\r
3036                                 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_VOICE_MSG_WAITING);\r
3037                         else\r
3038                                 api_ret = _get_file_info(o, ur, SIM_EF_USIM_MWIS);\r
3039                         break;\r
3040                 case TREQ_SIM_GET_CPHS_INFO:\r
3041                         api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CPHS_INFO);\r
3042                         break;\r
3043                 case TREQ_SIM_GET_MSISDN:\r
3044                         api_ret = _get_file_info(o, ur, SIM_EF_MSISDN);\r
3045                         break;\r
3046                 case TREQ_SIM_GET_SPN:\r
3047                         dbg("enter case SPN");\r
3048                         api_ret = _get_file_info(o, ur, SIM_EF_SPN);\r
3049                         break;\r
3050                 case TREQ_SIM_GET_SPDI:\r
3051                         api_ret = _get_file_info(o, ur, SIM_EF_SPDI);\r
3052                         break;\r
3053                 case TREQ_SIM_GET_OPL:\r
3054                         api_ret = _get_file_info(o, ur, SIM_EF_OPL);\r
3055                         break;\r
3056                 case TREQ_SIM_GET_PNN:\r
3057                         api_ret = _get_file_info(o, ur, SIM_EF_PNN);\r
3058                         break;\r
3059                 case TREQ_SIM_GET_CPHS_NETNAME:\r
3060                         api_ret = _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_STRING);\r
3061                         break;\r
3062                 case TREQ_SIM_GET_OPLMNWACT:\r
3063                         api_ret = _get_file_info(o, ur, SIM_EF_OPLMN_ACT);\r
3064                         break;\r
3065                 default:\r
3066                         dbg("error - not handled read treq command[%d]", command);\r
3067                         api_ret = TCORE_RETURN_EINVAL;\r
3068                         break;\r
3069         }\r
3070         dbg(" Function exit");\r
3071         return api_ret;\r
3072 }\r
3073 \r
3074 static TReturn s_update_file(CoreObject *o, UserRequest *ur)\r
3075 {\r
3076         TcoreHal* hal;\r
3077         TcoreATRequest *req;\r
3078         TcorePending *pending = NULL;\r
3079         char *cmd_str = NULL;\r
3080         TReturn api_ret = TCORE_RETURN_SUCCESS;\r
3081         char *encoded_data = NULL;\r
3082         int encoded_len = 0;\r
3083         enum tcore_request_command command;\r
3084         enum tel_sim_file_id ef = SIM_EF_INVALID;\r
3085         const struct treq_sim_set_callforwarding *cf;\r
3086         const struct treq_sim_set_language *cl;\r
3087         int p1 = 0;\r
3088         int p2 = 0;\r
3089         int p3 = 0;\r
3090         int cmd = 0;\r
3091         int length = 0;\r
3092         struct tel_sim_language sim_language;\r
3093 \r
3094         command = tcore_user_request_get_command(ur);\r
3095 \r
3096         dbg(" Function entry ");\r
3097 \r
3098         hal = tcore_object_get_hal(o);\r
3099         pending = tcore_pending_new(o, 0);\r
3100 \r
3101         if (!o || !ur)\r
3102                 return TCORE_RETURN_EINVAL;\r
3103 \r
3104         switch (command) {\r
3105                 case TREQ_SIM_SET_LANGUAGE:\r
3106                         cl = tcore_user_request_ref_data(ur, NULL);\r
3107                         memset(&sim_language, 0x00, sizeof(struct tel_sim_language));\r
3108                         cmd = 214;\r
3109                         p1 = 0;\r
3110                         p2 = 0;\r
3111                         p3 = 1;\r
3112                         sim_language.language_count = 1;\r
3113                         sim_language.language[0] = cl->language;\r
3114                         length = 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                                 encoded_data = tcore_sim_encode_lp(&length, &sim_language);\r
3120                                 dbg("%d ---", encoded_data[0]);\r
3121                         }\r
3122                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
3123                         {\r
3124                                 dbg("3G");\r
3125                                 ef = SIM_EF_LP;\r
3126                                 encoded_data = tcore_sim_encode_li(&length, &sim_language);\r
3127                                 dbg("encoded_data %s", encoded_data);\r
3128                         }\r
3129                         else\r
3130                         {\r
3131                                 api_ret = TCORE_RETURN_ENOSYS;\r
3132                         }\r
3133                         break;\r
3134 \r
3135                 case TREQ_SIM_SET_CALLFORWARDING:\r
3136                         cf = tcore_user_request_ref_data(ur, NULL);\r
3137                         if(tcore_sim_get_cphs_status(o))\r
3138                         {\r
3139                                 encoded_data = tcore_sim_encode_cff((const struct tel_sim_callforwarding*)cf);\r
3140                                 ef = SIM_EF_CPHS_CALL_FORWARD_FLAGS;\r
3141                                 p1 = 0;\r
3142                                 p2 = 0;\r
3143                                 p3 = strlen(encoded_data);\r
3144                                 cmd = 214;                              /*command - 214 : UPDATE BINARY*/\r
3145                         } else\r
3146                         {\r
3147                                 encoded_data = tcore_sim_encode_cfis(&encoded_len, (const struct tel_sim_callforwarding*)cf);\r
3148                                 ef = SIM_EF_USIM_CFIS;\r
3149                                 p1 = 1;\r
3150                                 p2 = 0x04;\r
3151                                 p3 = encoded_len;\r
3152                                 cmd = 220;                              /*command - 220 : UPDATE RECORD*/\r
3153                         }\r
3154                         break;\r
3155 \r
3156                 default:\r
3157                         dbg("error - not handled update treq command[%d]", command);\r
3158                         api_ret = TCORE_RETURN_EINVAL;\r
3159                         break;\r
3160         }\r
3161         cmd_str = g_strdup_printf("AT+CRSM=%d,%d,%d,%d,%d,\"%s\"", cmd,ef,p1,p2,p3, encoded_data);\r
3162         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
3163 \r
3164         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
3165 \r
3166         tcore_pending_set_request_data(pending, 0, req);\r
3167         tcore_pending_set_response_callback(pending, on_response_update_file, hal);\r
3168         tcore_pending_link_user_request(pending, ur);\r
3169         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
3170 \r
3171         tcore_hal_send_request(hal, pending);\r
3172         if(NULL != encoded_data){\r
3173                 g_free(encoded_data);\r
3174         }\r
3175         free(cmd_str);\r
3176         dbg(" Function exit");\r
3177         return TCORE_RETURN_SUCCESS;\r
3178 }\r
3179 \r
3180 static TReturn s_transmit_apdu(CoreObject *o, UserRequest *ur)\r
3181 {\r
3182         TcoreHal* hal= NULL;\r
3183         TcoreATRequest *req= NULL;\r
3184         TcorePending *pending = NULL;\r
3185         char *cmd_str = NULL;\r
3186         const struct treq_sim_transmit_apdu *req_data;\r
3187         dbg(" Function entry ");\r
3188 \r
3189         hal = tcore_object_get_hal(o);\r
3190         pending = tcore_pending_new(o, 0);\r
3191         req_data = tcore_user_request_ref_data(ur, NULL);\r
3192 \r
3193         if (!o || !ur)\r
3194                 return TCORE_RETURN_EINVAL;\r
3195 \r
3196         cmd_str = g_strdup_printf("AT+CSIM=%d,\"%s\"", req_data->apdu_length, req_data->apdu);\r
3197 \r
3198         req = tcore_at_request_new(cmd_str, "+CSIM:", TCORE_AT_SINGLELINE);\r
3199 \r
3200         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
3201 \r
3202         tcore_pending_set_request_data(pending, 0, req);\r
3203         tcore_pending_set_response_callback(pending, on_response_transmit_apdu, hal);\r
3204         tcore_pending_link_user_request(pending, ur);\r
3205         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
3206         tcore_hal_send_request(hal, pending);\r
3207 \r
3208         free(cmd_str);\r
3209         dbg(" Function exit");\r
3210         return TCORE_RETURN_SUCCESS;\r
3211 }\r
3212 \r
3213 static struct tcore_sim_operations sim_ops =\r
3214 {\r
3215                 .verify_pins = s_verify_pins,\r
3216                 .verify_puks = s_verify_puks,\r
3217                 .change_pins = s_change_pins,\r
3218                 .get_facility_status = s_get_facility_status,\r
3219                 .enable_facility = s_enable_facility,\r
3220                 .disable_facility = s_disable_facility,\r
3221                 .get_lock_info = s_get_lock_info,\r
3222                 .read_file = s_read_file,\r
3223                 .update_file = s_update_file,\r
3224                 .transmit_apdu = s_transmit_apdu,\r
3225                 /*ToDo - Need to be implemented in Phase-2*/\r
3226                 /*.get_atr = s_get_atr,\r
3227                 .req_authentication = s_req_authentication*/\r
3228 };\r
3229 \r
3230 gboolean s_sim_init(TcorePlugin *p, TcoreHal *h)\r
3231 {\r
3232         CoreObject *o;\r
3233         struct s_sim_property *file_meta = NULL;\r
3234         GQueue *work_queue;\r
3235 \r
3236         dbg("entry");\r
3237 \r
3238         o = tcore_sim_new(p, "sim", &sim_ops, h);\r
3239 \r
3240         if (!o)\r
3241                 return FALSE;\r
3242 \r
3243         file_meta = calloc(sizeof(struct s_sim_property),1);\r
3244         if (!file_meta)\r
3245                 return FALSE;\r
3246 \r
3247         work_queue = g_queue_new();\r
3248         tcore_object_link_user_data(o, work_queue);\r
3249 \r
3250         file_meta->first_recv_status = SIM_STATUS_UNKNOWN;\r
3251         tcore_sim_link_userdata(o, file_meta);\r
3252         \r
3253         tcore_object_add_callback(o, "+XLOCK", on_event_facility_lock_status, NULL);\r
3254         tcore_object_add_callback(o, "+XSIM", on_event_pin_status, NULL);\r
3255 \r
3256         dbg("exit");\r
3257         return TRUE;\r
3258 }\r
3259 \r
3260 void s_sim_exit(TcorePlugin *p)\r
3261 {\r
3262         CoreObject *o;\r
3263 \r
3264         o = tcore_plugin_ref_core_object(p, "sim");\r
3265         if (!o)\r
3266                 return;\r
3267         tcore_sim_free(o);\r
3268 }