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 = util_removeQuotes(hexData);
 952                         recordData = util_hexStringToBytes(tmp);\r
 953                         util_hex_dump("    ", strlen(hexData)/2, recordData);
 954                         free(tmp);\r
 955         \r
 956                         ptr_data = (unsigned char *)recordData;\r
 957                         if (tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)\r
 958                         {\r
 959                                 /*\r
 960                                  ETSI TS 102 221 v7.9.0\r
 961                                  - Response Data\r
 962                                  '62'   FCP template tag\r
 963                                  - Response for an EF\r
 964                                  '82'   M       File Descriptor\r
 965                                  '83'   M       File Identifier\r
 966                                  'A5'   O       Proprietary information\r
 967                                  '8A'   M       Life Cycle Status Integer\r
 968                                  '8B', '8C' or 'AB'     C1      Security attributes\r
 969                                  '80'   M       File size\r
 970                                  '81'   O       Total file size\r
 971                                  '88'   O       Short File Identifier (SFI)\r
 972                                  */\r
 973 \r
 974                                 /* rsim.res_len  has complete data length received  */\r
 975 \r
 976                                 /* FCP template tag - File Control Parameters tag*/\r
 977                                 if (*ptr_data == 0x62)\r
 978                                 {\r
 979                                         /* parse complete FCP tag*/\r
 980                                         /* increment to next byte */\r
 981                                         ptr_data++;\r
 982                                         tag_len = *ptr_data++;\r
 983                                         dbg("tag_len: %02x", tag_len);\r
 984                                         /* FCP file descriptor - file type, accessibility, DF, ADF etc*/\r
 985                                         if (*ptr_data == 0x82)\r
 986                                         {\r
 987                                                 /* increment to next byte */\r
 988                                                 ptr_data++;\r
 989                                                 /* 2 or 5 value*/\r
 990                                                 ptr_data++;\r
 991                                                 /*      unsigned char file_desc_len = *ptr_data++;*/\r
 992                                                 /*      dbg("file descriptor length: [%d]", file_desc_len);*/\r
 993                                                 /* TBD:  currently capture only file type : ignore sharable, non sharable, working, internal etc*/\r
 994                                                 /* consider only last 3 bits*/\r
 995                                                 dbg("file_type_tag: %02x", file_type_tag);\r
 996                                                 file_type_tag = file_type_tag & (*ptr_data);\r
 997                                                 dbg("file_type_tag: %02x", file_type_tag);\r
 998 \r
 999                                                 switch (file_type_tag)\r
1000                                                 {\r
1001                                                         /* increment to next byte */\r
1002                                                         //ptr_data++;\r
1003                                                         case 0x1:\r
1004                                                                 dbg("Getting FileType: [Transparent file type]");\r
1005                                                                 file_type = SIM_FTYPE_TRANSPARENT;\r
1006 \r
1007                                                                 /* increment to next byte */\r
1008                                                                 ptr_data++;\r
1009                                                                 /* increment to next byte */\r
1010                                                                 ptr_data++;\r
1011                                                                 break;\r
1012 \r
1013                                                         case 0x2:\r
1014                                                                 dbg("Getting FileType: [Linear fixed file type]");\r
1015                                                                 /* increment to next byte */\r
1016                                                                 ptr_data++;\r
1017                                                                 /*      data coding byte - value 21 */\r
1018                                                                 ptr_data++;\r
1019                                                                 /*      2bytes */\r
1020                                                                 memcpy(&record_len, ptr_data, 2);\r
1021                                                                 /* swap bytes */\r
1022                                                                 SWAPBYTES16(record_len);\r
1023                                                                 ptr_data = ptr_data + 2;\r
1024                                                                 num_of_records = *ptr_data++;\r
1025                                                                 /* Data lossy conversation from enum (int) to unsigned char */\r
1026                                                                 file_type = SIM_FTYPE_LINEAR_FIXED;\r
1027                                                                 break;\r
1028 \r
1029                                                         case 0x6:\r
1030                                                                 dbg(" Cyclic fixed file type");\r
1031                                                                 /* increment to next byte */\r
1032                                                                 ptr_data++;\r
1033                                                                 /*      data coding byte - value 21 */\r
1034                                                                 ptr_data++;\r
1035                                                                 /*      2bytes */\r
1036                                                                 memcpy(&record_len, ptr_data, 2);\r
1037                                                                 /* swap bytes  */\r
1038                                                                 SWAPBYTES16(record_len);\r
1039                                                                 ptr_data = ptr_data + 2;\r
1040                                                                 num_of_records = *ptr_data++;\r
1041                                                                 file_type = SIM_FTYPE_CYCLIC;\r
1042                                                                 break;\r
1043 \r
1044                                                 default:\r
1045                                                         dbg("not handled file type [0x%x]", *ptr_data);\r
1046                                                         break;\r
1047                                                 }\r
1048                                         } else\r
1049                                         {\r
1050                                                 dbg("INVALID FCP received - DEbug!");\r
1051                                                 return;\r
1052                                         }\r
1053 \r
1054                                         /*File identifier - file id?? */ // 0x84,0x85,0x86 etc are currently ignored and not handled\r
1055                                         if (*ptr_data == 0x83)\r
1056                                         {\r
1057                                                 /* increment to next byte */\r
1058                                                 ptr_data++;\r
1059                                                 file_id_len = *ptr_data++;\r
1060                                                 dbg("file_id_len: %02x", file_id_len);\r
1061 \r
1062                                                 memcpy(&file_id, ptr_data, file_id_len);\r
1063                                                 dbg("file_id: %x", file_id);\r
1064 \r
1065                                                 /* swap bytes    */\r
1066                                                 SWAPBYTES16(file_id);\r
1067                                                 dbg("file_id: %x", file_id);\r
1068 \r
1069                                                 ptr_data = ptr_data + 2;\r
1070                                                 dbg("Getting FileID=[0x%x]", file_id);\r
1071                                         } else\r
1072                                         {\r
1073                                                 dbg("INVALID FCP received - DEbug!");\r
1074                                                 free(recordData);\r
1075                                                 return;\r
1076                                         }\r
1077 \r
1078                                         /*      proprietary information  */\r
1079                                         if (*ptr_data == 0xA5)\r
1080                                         {\r
1081                                                 unsigned short prop_len;\r
1082                                                 /* increment to next byte */\r
1083                                                 ptr_data++;\r
1084 \r
1085                                                 /* length */\r
1086                                                 prop_len = *ptr_data;\r
1087                                                 dbg("prop_len: %02x", prop_len);\r
1088 \r
1089                                                 /* skip data */\r
1090                                                 ptr_data = ptr_data + prop_len + 1;\r
1091                                         } else\r
1092                                         {\r
1093                                                 dbg("INVALID FCP received - DEbug!");\r
1094                                         }\r
1095 \r
1096                                         /* life cycle status integer [8A][length:0x01][status]*/\r
1097                                         /*\r
1098                                          status info b8~b1\r
1099                                          00000000 : No information given\r
1100                                          00000001 : creation state\r
1101                                          00000011 : initialization state\r
1102                                          000001-1 : operation state -activated\r
1103                                          000001-0 : operation state -deactivated\r
1104                                          000011-- : Termination state\r
1105                                          b8~b5 !=0, b4~b1=X : Proprietary\r
1106                                          Any other value : RFU\r
1107                                          */\r
1108                                         if (*ptr_data == 0x8A)\r
1109                                         {\r
1110                                                 /* increment to next byte */\r
1111                                                 ptr_data++;\r
1112                                                 /* length - value 1 */\r
1113                                                 ptr_data++;\r
1114 \r
1115                                                 switch (*ptr_data) {\r
1116                                                         case 0x04:\r
1117                                                         case 0x06:\r
1118                                                                 dbg("<RX> operation state -deactivated");\r
1119                                                                 ptr_data++;\r
1120                                                                 break;\r
1121                                                         case 0x05:\r
1122                                                         case 0x07:\r
1123                                                                 dbg("<RX> operation state -activated");\r
1124                                                                 ptr_data++;\r
1125                                                                 break;\r
1126                                                         default:\r
1127                                                                 dbg("<RX> DEBUG! LIFE CYCLE STATUS =[0x%x]",*ptr_data);\r
1128                                                                 ptr_data++;\r
1129                                                                 break;\r
1130                                                 }\r
1131                                         }\r
1132 \r
1133                                         /* related to security attributes : currently not handled*/\r
1134                                         if (*ptr_data == 0x86 || *ptr_data == 0x8B || *ptr_data == 0x8C || *ptr_data == 0xAB)\r
1135                                         {\r
1136                                                 /* increment to next byte */\r
1137                                                 ptr_data++;\r
1138                                                 /* if tag length is 3 */\r
1139                                                 if (*ptr_data == 0x03)\r
1140                                                 {\r
1141                                                         /* increment to next byte */\r
1142                                                         ptr_data++;\r
1143                                                         /* EFARR file id */\r
1144                                                         memcpy(&arr_file_id, ptr_data, 2);\r
1145                                                         /* swap byes */\r
1146                                                         SWAPBYTES16(arr_file_id);\r
1147                                                         ptr_data = ptr_data + 2;\r
1148                                                         arr_file_id_rec_num = *ptr_data++;\r
1149                                                 } else\r
1150                                                 {\r
1151                                                         /* if tag length is not 3 */\r
1152                                                         /* ignoring bytes       */\r
1153                                                         //      ptr_data = ptr_data + 4;\r
1154                                                         dbg("Useless security attributes, so jump to next tag");\r
1155                                                         ptr_data = ptr_data + (*ptr_data + 1);\r
1156                                                 }\r
1157                                         } else\r
1158                                         {\r
1159                                                 dbg("INVALID FCP received[0x%x] - DEbug!", *ptr_data);\r
1160                                                 free(recordData);\r
1161                                                 return;\r
1162                                         }\r
1163 \r
1164                                         dbg("Current ptr_data value is [%x]", *ptr_data);\r
1165 \r
1166                                         /* file size excluding structural info*/\r
1167                                         if (*ptr_data == 0x80)\r
1168                                         {\r
1169                                                 /* for EF file size is body of file and for Linear or cyclic it is\r
1170                                                  * number of recXsizeof(one record)\r
1171                                                  */\r
1172                                                 /* increment to next byte */\r
1173                                                 ptr_data++;\r
1174                                                 /* length is 1 byte - value is 2 bytes or more */\r
1175                                                 ptr_data++;\r
1176                                                 memcpy(&file_size, ptr_data, 2);\r
1177                                                 /* swap bytes */\r
1178                                                 SWAPBYTES16(file_size);\r
1179                                                 ptr_data = ptr_data + 2;\r
1180                                         } else\r
1181                                         {\r
1182                                                 dbg("INVALID FCP received - DEbug!");\r
1183                                                 free(recordData);\r
1184                                                 return;\r
1185                                         }\r
1186 \r
1187                                         /* total file size including structural info*/\r
1188                                         if (*ptr_data == 0x81)\r
1189                                         {\r
1190                                                 int len;\r
1191                                                 /* increment to next byte */\r
1192                                                 ptr_data++;\r
1193                                                 /* length */\r
1194                                                 len = *ptr_data;\r
1195                                                 /* ignored bytes */\r
1196                                                 ptr_data = ptr_data + 3;\r
1197                                         } else\r
1198                                         {\r
1199                                                 dbg("INVALID FCP received - DEbug!");\r
1200                                                 /* 0x81 is optional tag?? check out! so do not return -1 from here! */\r
1201                                                 /* return -1; */\r
1202                                         }\r
1203                                         /*short file identifier ignored*/\r
1204                                         if (*ptr_data == 0x88)\r
1205                                         {\r
1206                                                 dbg("0x88: Do Nothing");\r
1207                                                 /*DO NOTHING*/\r
1208                                         }\r
1209                                 } else\r
1210                                 {\r
1211                                         dbg("INVALID FCP received - DEbug!");\r
1212                                         free(recordData);\r
1213                                         return;\r
1214                                 }\r
1215                         } else if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)\r
1216                         {\r
1217                                 unsigned char gsm_specific_file_data_len = 0;\r
1218                                 /*      ignore RFU byte1 and byte2 */\r
1219                                 ptr_data++;\r
1220                                 ptr_data++;\r
1221                                 /*      file size */\r
1222                                 //file_size = p_info->response_len;\r
1223                                 memcpy(&file_size, ptr_data, 2);\r
1224                                 /* swap bytes */\r
1225                                 SWAPBYTES16(file_size);\r
1226                                 /*      parsed file size */\r
1227                                 ptr_data = ptr_data + 2;\r
1228                                 /*  file id  */\r
1229                                 memcpy(&file_id, ptr_data, 2);\r
1230                                 SWAPBYTES16(file_id);\r
1231                                 dbg(" FILE id --> [%x]", file_id);\r
1232                                 ptr_data = ptr_data + 2;\r
1233                                 /* save file type - transparent, linear fixed or cyclic */\r
1234                                 file_type_tag = (*(ptr_data + 7));\r
1235 \r
1236                                 switch (*ptr_data)\r
1237                                 {\r
1238                                         case 0x0:\r
1239                                                 /* RFU file type */\r
1240                                                 dbg(" RFU file type- not handled - Debug!");\r
1241                                                 break;\r
1242                                         case 0x1:\r
1243                                                 /* MF file type */\r
1244                                                 dbg(" MF file type - not handled - Debug!");\r
1245                                                 break;\r
1246                                         case 0x2:\r
1247                                                 /* DF file type */\r
1248                                                 dbg(" DF file type - not handled - Debug!");\r
1249                                                 break;\r
1250                                         case 0x4:\r
1251                                                 /* EF file type */\r
1252                                                 dbg(" EF file type [%d] ", file_type_tag);\r
1253                                                 /*      increment to next byte */\r
1254                                                 ptr_data++;\r
1255 \r
1256                                                 if (file_type_tag == 0x00 || file_type_tag == 0x01)\r
1257                                                 {\r
1258                                                         /* increament to next byte as this byte is RFU */\r
1259                                                         ptr_data++;\r
1260                                                         file_type =\r
1261                                                                         (file_type_tag == 0x00) ? SIM_FTYPE_TRANSPARENT : SIM_FTYPE_LINEAR_FIXED;\r
1262                                                 } else\r
1263                                                 {\r
1264                                                         /* increment to next byte */\r
1265                                                         ptr_data++;\r
1266                                                         /*      For a cyclic EF all bits except bit 7 are RFU; b7=1 indicates that */\r
1267                                                         /* the INCREASE command is allowed on the selected cyclic file. */\r
1268                                                         file_type = SIM_FTYPE_CYCLIC;\r
1269                                                 }\r
1270                                                 /* bytes 9 to 11 give SIM file access conditions */\r
1271                                                 ptr_data++;\r
1272                                                 /* byte 10 has one nibble that is RF U and another for INCREASE which is not used currently */\r
1273                                                 ptr_data++;\r
1274                                                 /* byte 11 is invalidate and rehabilate nibbles */\r
1275                                                 ptr_data++;\r
1276                                                 /* byte 12 - file status */\r
1277                                                 ptr_data++;\r
1278                                                 /* byte 13 - GSM specific data */\r
1279                                                 gsm_specific_file_data_len = *ptr_data;\r
1280                                                 ptr_data++;\r
1281                                                 /*      byte 14 - structure of EF - transparent or linear or cyclic , already saved above */\r
1282                                                 ptr_data++;\r
1283                                                 /* byte 15 - length of record for linear and cyclic , for transparent it is set to 0x00. */\r
1284                                                 record_len = *ptr_data;\r
1285                                                 dbg("record length[%d], file size[%d]", record_len, file_size);\r
1286 \r
1287                                                 if (record_len != 0)\r
1288                                                         num_of_records = (file_size / record_len);\r
1289 \r
1290                                                 dbg("Number of records [%d]", num_of_records);\r
1291                                                 break;\r
1292 \r
1293                                         default:\r
1294                                                 dbg(" not handled file type");\r
1295                                                 break;\r
1296                                 }\r
1297                         }\r
1298                         else\r
1299                         {\r
1300                                 dbg(" Card Type - UNKNOWN  [%d]", tcore_sim_get_type(co_sim));\r
1301                         }\r
1302 \r
1303                         dbg("req ef[0x%x] resp ef[0x%x] size[%ld] Type[0x%x] NumOfRecords[%ld] RecordLen[%ld]",\r
1304                                         file_meta->file_id, file_id, file_size, file_type, num_of_records, record_len);\r
1305 \r
1306                         file_meta->file_type = file_type;\r
1307                         file_meta->data_size = file_size;\r
1308                         file_meta->rec_length = record_len;\r
1309                         file_meta->rec_count = num_of_records;\r
1310                         file_meta->current_index = 0; //reset for new record type EF\r
1311                         rt = SIM_ACCESS_SUCCESS;\r
1312                         free(recordData);\r
1313                 }\r
1314                 else\r
1315                 {\r
1316                         /*2. SIM access fail case*/\r
1317                         dbg("error to get ef[0x%x]", file_meta->file_id);\r
1318                         dbg("error to get ef[0x%x] (file_meta->file_id) ", file_meta->file_id);\r
1319                         rt = _decode_status_word(sw1, sw2);\r
1320                 }\r
1321                 ur = tcore_user_request_ref(ur);\r
1322                 \r
1323                 dbg("Calling _next_from_get_file_info");\r
1324                 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);\r
1325                 tcore_at_tok_free(tokens);\r
1326         }\r
1327         else\r
1328         {\r
1329                 dbg("RESPONSE NOK");\r
1330                 dbg("error to get ef[0x%x]", file_meta->file_id);\r
1331                 dbg("error to get ef[0x%x] (file_meta->file_id) ", file_meta->file_id);\r
1332                 rt = SIM_ACCESS_FAILED;\r
1333 \r
1334                 ur = tcore_user_request_ref(ur);\r
1335                 _next_from_get_file_info(co_sim, ur, file_meta->file_id, rt);\r
1336         }\r
1337         dbg(" Function exit");\r
1338 }\r
1339 \r
1340 static void _response_get_file_data(TcorePending *p, int data_len, const void *data, void *user_data)\r
1341 {\r
1342         const TcoreATResponse *resp = data;\r
1343         UserRequest *ur = NULL;\r
1344         CoreObject *co_sim = NULL;\r
1345         struct s_sim_property *file_meta = NULL;\r
1346         GSList *tokens=NULL;\r
1347         enum tel_sim_access_result rt;\r
1348         struct tel_sim_imsi imsi;\r
1349         struct tel_sim_ecc ecc;\r
1350         struct tel_sim_msisdn msisdn;\r
1351         struct tel_sim_opl opl;\r
1352         struct tel_sim_pnn pnn;\r
1353         gboolean dr = FALSE;\r
1354         const char *line = NULL;\r
1355         char *res = NULL;\r
1356         char *tmp = NULL;\r
1357         int res_len;\r
1358         int sw1 = 0;\r
1359         int sw2 = 0;\r
1360 \r
1361         dbg(" Function entry ");\r
1362 \r
1363         co_sim = tcore_pending_ref_core_object(p);\r
1364         ur = tcore_pending_ref_user_request(p);\r
1365         file_meta = (struct s_sim_property*)tcore_user_request_ref_metainfo(ur, NULL);\r
1366 \r
1367         if(resp->success > 0)\r
1368         {\r
1369                 dbg("RESPONSE OK");\r
1370                 if(resp->lines)\r
1371                 {\r
1372                         line = (const char*)resp->lines->data;\r
1373                         tokens = tcore_at_tok_new(line);\r
1374                         if (g_slist_length(tokens) != 3)\r
1375                         {\r
1376                                 msg("invalid message");\r
1377                                 tcore_at_tok_free(tokens);\r
1378                                 return;\r
1379                         }\r
1380                 }\r
1381                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
1382                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
1383                 res  = g_slist_nth_data(tokens, 2);\r
1384 \r
1385                 tmp = util_removeQuotes(res);
1386                 res = util_hexStringToBytes(tmp);\r
1387                 res_len = strlen((const char*)res);\r
1388                 dbg("res: %s res_len: %d", res, res_len);\r
1389 \r
1390                 if((sw1 == 0x90 && sw2 == 0x00) || sw1 == 0x91)\r
1391                 {\r
1392                         rt = SIM_ACCESS_SUCCESS;\r
1393                         file_meta->files.result = rt;\r
1394                         dbg("file_meta->file_id : %x", file_meta->file_id);\r
1395 \r
1396                         switch (file_meta->file_id)\r
1397                         {\r
1398                                 case SIM_EF_IMSI:\r
1399                                 {\r
1400                                         dbg("res: %s", res);\r
1401                                         dr = tcore_sim_decode_imsi(&imsi, (unsigned char*)res, res_len);\r
1402                                         if (dr == FALSE)\r
1403                                         {\r
1404                                                 dbg("imsi decoding failed");\r
1405                                         } else\r
1406                                         {\r
1407                                                 _sim_check_identity(co_sim,&imsi);\r
1408                                                 tcore_sim_set_imsi(co_sim,&imsi);\r
1409                                         }\r
1410                                         break;\r
1411                                 }\r
1412                                 case SIM_EF_ICCID:\r
1413                                         dr = tcore_sim_decode_iccid(&file_meta->files.data.iccid, (unsigned char*)res, res_len);\r
1414                                         break;\r
1415 \r
1416                                 case SIM_EF_ELP:/*  2G EF -  2 bytes decoding*/\r
1417                                 case SIM_EF_USIM_LI: /* 3G EF - 2 bytes decoding*/\r
1418                                 case SIM_EF_USIM_PL:/*  3G EF - same as EFELP, so 2  byte decoding*/\r
1419                                 case SIM_EF_LP:/*  1 byte encoding*/\r
1420                                         if (tcore_sim_get_type(co_sim) == SIM_TYPE_GSM && file_meta->file_id == SIM_EF_LP)\r
1421                                         {\r
1422                                                  /*2G LP(0x6F05) has 1 byte for each language*/\r
1423                                                 dr = tcore_sim_decode_lp(&file_meta->files.data.language, (unsigned char*)res, res_len);\r
1424                                         } else\r
1425                                         {\r
1426                                                  /*3G LI(0x6F05)/PL(0x2F05), 2G ELP(0x2F05) has 2 bytes for each language*/\r
1427                                                 dr = tcore_sim_decode_li(file_meta->file_id, &file_meta->files.data.language, (unsigned char*)res, res_len);\r
1428                                         }\r
1429                                         break;\r
1430                                 case SIM_EF_SPN:\r
1431                                         dr = tcore_sim_decode_spn(&file_meta->files.data.spn, (unsigned char*)res, res_len);\r
1432                                         break;\r
1433                                 case SIM_EF_SPDI:\r
1434                                         dr = tcore_sim_decode_spdi(&file_meta->files.data.spdi, (unsigned char*)res, res_len);\r
1435                                         break;\r
1436                                 case SIM_EF_ECC:\r
1437                                         if(tcore_sim_get_type(co_sim) == SIM_TYPE_GSM)\r
1438                                         {\r
1439                                                 dr = tcore_sim_decode_ecc(&file_meta->files.data.ecc, (unsigned char*)res, res_len);\r
1440                                         } else if(tcore_sim_get_type(co_sim) == SIM_TYPE_USIM)\r
1441                                         {\r
1442                                                 dbg("decode w/ index [%d]",file_meta->current_index);\r
1443                                                 memset(&ecc, 0x00, sizeof(struct tel_sim_ecc));\r
1444                                                 dr = tcore_sim_decode_uecc(&ecc, (unsigned char*)res, res_len);\r
1445                                                 if (dr == TRUE)\r
1446                                                 {\r
1447                                                         memcpy( &file_meta->files.data.ecc.ecc[file_meta->files.data.ecc.ecc_count], &ecc, sizeof(struct tel_sim_ecc) );\r
1448                                                         file_meta->files.data.ecc.ecc_count++;\r
1449                                                 }\r
1450                                         } else\r
1451                                         {\r
1452                                                 dbg("err not handled tcore_sim_get_type(o)[%d] in here",tcore_sim_get_type(co_sim));\r
1453                                         }\r
1454                                         break;\r
1455                                 case SIM_EF_MSISDN :\r
1456                                         dbg("decode w/ index [%d]",file_meta->current_index);\r
1457                                         memset(&msisdn, 0x00, sizeof(struct tel_sim_msisdn));\r
1458                                         dr = tcore_sim_decode_msisdn(&msisdn, (unsigned char*)res, res_len);\r
1459                                         if (dr == TRUE)\r
1460                                         {\r
1461                                                 memcpy( &file_meta->files.data.msisdn_list.msisdn[file_meta->files.data.msisdn_list.count], &msisdn, sizeof(struct tel_sim_msisdn) );\r
1462                                                 file_meta->files.data.msisdn_list.count++;\r
1463                                         }\r
1464                                         break;\r
1465                                 case SIM_EF_OPL:\r
1466                                         dbg("decode w/ index [%d]",file_meta->current_index);\r
1467                                         memset(&opl, 0x00, sizeof(struct tel_sim_opl));\r
1468                                         dr = tcore_sim_decode_opl(&opl, (unsigned char*)res, res_len);\r
1469                                         if (dr == TRUE)\r
1470                                         {\r
1471                                                 memcpy( &file_meta->files.data.opl.opl[file_meta->files.data.opl.opl_count], &opl, sizeof(struct tel_sim_opl) );\r
1472                                                 file_meta->files.data.opl.opl_count++;\r
1473                                         }\r
1474                                         break;\r
1475                                 case SIM_EF_PNN:\r
1476                                         dbg("decode w/ index [%d]",file_meta->current_index);\r
1477                                         memset(&pnn, 0x00, sizeof(struct tel_sim_pnn));\r
1478                                         dr = tcore_sim_decode_pnn(&pnn, (unsigned char*)res, res_len);\r
1479                                         if (dr == TRUE)\r
1480                                         {\r
1481                                                 memcpy( &file_meta->files.data.pnn.pnn[file_meta->files.data.pnn.pnn_count], &opl, sizeof(struct tel_sim_pnn) );\r
1482                                                 file_meta->files.data.pnn.pnn_count++;\r
1483                                         }\r
1484                                         break;\r
1485                                 case SIM_EF_OPLMN_ACT:\r
1486                                         dr = tcore_sim_decode_oplmnwact(&file_meta->files.data.opwa, (unsigned char*)res, res_len);\r
1487                                         break;\r
1488                                 case SIM_EF_CPHS_CALL_FORWARD_FLAGS:\r
1489                                         dr = tcore_sim_decode_cff(&file_meta->files.data.cf, (unsigned char*)res, res_len);\r
1490                                         break;\r
1491                                 case SIM_EF_CPHS_VOICE_MSG_WAITING:\r
1492                                         dr = tcore_sim_decode_vmwf(&file_meta->files.data.mw.mw_data_u.cphs_mw, (unsigned char*)res, res_len);\r
1493                                         break;\r
1494                                 case SIM_EF_USIM_MWIS:\r
1495                                         dr = tcore_sim_decode_mwis(&file_meta->files.data.mw.mw_data_u.mw, (unsigned char*)res, res_len);\r
1496                                         break;\r
1497                                 case SIM_EF_USIM_CFIS:\r
1498                                         dr = tcore_sim_decode_cfis(&file_meta->files.data.cf, (unsigned char*)res, res_len);\r
1499                                         break;\r
1500                                 case SIM_EF_CPHS_SERVICE_STRING_TABLE:\r
1501                                         dbg(" not handled -SIM_EF_CPHS_SERVICE_STRING_TABLE ");\r
1502                                         break;\r
1503                                 case SIM_EF_CPHS_OPERATOR_NAME_STRING:\r
1504                                         dr = tcore_sim_decode_ons((unsigned char*)&file_meta->files.data.cphs_net.full_name, (unsigned char*)res, res_len);\r
1505                                         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
1506                                         break;\r
1507                                 case SIM_EF_CPHS_CPHS_INFO:\r
1508                                         dr = tcore_sim_decode_cphs_info(&file_meta->files.data.cphs, (unsigned char*)res, res_len);\r
1509                                         break;\r
1510                                 case SIM_EF_CPHS_OPERATOR_NAME_SHORT_FORM_STRING:\r
1511                                         dr = tcore_sim_decode_short_ons((unsigned char*)&file_meta->files.data.cphs_net.short_name, (unsigned char*)res, res_len);\r
1512                                         break;\r
1513                                 default:\r
1514                                         dbg("File Decoding Failed - not handled File[0x%x]", file_meta->file_id);\r
1515                                         dr = 0;\r
1516                                         break;\r
1517                         }\r
1518                 }\r
1519                 else\r
1520                 {\r
1521                         rt =  _decode_status_word(sw1, sw2);\r
1522                         file_meta->files.result = rt;\r
1523                 }\r
1524                 free(tmp);\r
1525                 tcore_at_tok_free(tokens);\r
1526         }\r
1527         else\r
1528         {\r
1529                 dbg("RESPONSE NOK");\r
1530                 dbg("error to get ef[0x%x]", file_meta->file_id);\r
1531                 rt = SIM_ACCESS_FAILED;\r
1532         }\r
1533         ur = tcore_user_request_ref(ur);\r
1534         \r
1535         dbg("Calling _next_from_get_file_data");\r
1536         _next_from_get_file_data(tcore_pending_ref_core_object(p), ur, rt, dr);\r
1537         dbg(" Function exit");\r
1538 }\r
1539 \r
1540 static void _on_response_get_retry_count(TcorePending *p, int data_len, const void *data, void *user_data)\r
1541 {\r
1542         const TcoreATResponse *resp = data;\r
1543         UserRequest *ur = NULL;\r
1544         CoreObject *co_sim = NULL;\r
1545         struct s_sim_property *sp = NULL;\r
1546         GSList *tokens=NULL;\r
1547         const char *line = NULL;\r
1548         struct tresp_sim_verify_pins v_pin = {0,};\r
1549         struct tresp_sim_verify_puks v_puk = {0,};\r
1550         struct tresp_sim_change_pins change_pin = {0,};\r
1551         struct tresp_sim_disable_facility dis_facility = {0,};\r
1552         struct tresp_sim_enable_facility en_facility = {0,};\r
1553         int lock_type = 0;\r
1554         int attempts_left = 0;\r
1555         int time_penalty = 0;\r
1556 \r
1557         dbg(" Function entry ");\r
1558 \r
1559         co_sim = tcore_pending_ref_core_object(p);\r
1560         sp = tcore_sim_ref_userdata(co_sim);\r
1561         ur = tcore_pending_ref_user_request(p);\r
1562 \r
1563         if(resp->success > 0)\r
1564         {\r
1565                 dbg("RESPONSE OK");\r
1566                 if(resp->lines)\r
1567                 {\r
1568                         line = (const char*)resp->lines->data;\r
1569                         tokens = tcore_at_tok_new(line);\r
1570                         if (g_slist_length(tokens) < 3)\r
1571                         {\r
1572                                 msg("invalid message");\r
1573                                 tcore_at_tok_free(tokens);\r
1574                                 return;\r
1575                         }\r
1576                 }\r
1577                 lock_type = atoi(g_slist_nth_data(tokens, 0));\r
1578                 attempts_left = atoi(g_slist_nth_data(tokens, 1));\r
1579                 time_penalty = atoi(g_slist_nth_data(tokens, 2));\r
1580 \r
1581                 dbg("lock_type = %d, attempts_left = %d, time_penalty = %d",\r
1582                 lock_type,attempts_left,time_penalty);\r
1583 \r
1584                 switch (sp->current_sec_op)\r
1585                 {\r
1586                         case SEC_PIN1_VERIFY:\r
1587                         case SEC_PIN2_VERIFY:\r
1588                         case SEC_SIM_VERIFY:\r
1589                         case SEC_ADM_VERIFY:\r
1590                                 v_pin.result = SIM_INCORRECT_PASSWORD;\r
1591                                 v_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1592                                 v_pin.retry_count = attempts_left;\r
1593                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1594                                                 sizeof(struct tresp_sim_verify_pins), &v_pin);\r
1595                                 break;\r
1596                         case SEC_PUK1_VERIFY:\r
1597                         case SEC_PUK2_VERIFY:\r
1598                                 v_puk.result = SIM_INCORRECT_PASSWORD;\r
1599                                 v_puk.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1600                                 v_puk.retry_count = attempts_left;\r
1601                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1602                                                 sizeof(struct tresp_sim_verify_puks), &v_puk);\r
1603                                 break;\r
1604                         case SEC_PIN1_CHANGE:\r
1605                         case SEC_PIN2_CHANGE:\r
1606                                 change_pin.result = SIM_INCORRECT_PASSWORD;\r
1607                                 change_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1608                                 change_pin.retry_count = attempts_left;\r
1609                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1610                                                 sizeof(struct tresp_sim_change_pins), &change_pin);\r
1611                                 break;\r
1612                         case SEC_PIN1_DISABLE:\r
1613                         case SEC_PIN2_DISABLE:\r
1614                         case SEC_FDN_DISABLE:\r
1615                         case SEC_SIM_DISABLE:\r
1616                         case SEC_NET_DISABLE:\r
1617                         case SEC_NS_DISABLE:\r
1618                         case SEC_SP_DISABLE:\r
1619                         case SEC_CP_DISABLE:\r
1620                                 dis_facility.result = SIM_INCORRECT_PASSWORD;\r
1621                                 dis_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1622                                 dis_facility.retry_count = attempts_left;\r
1623                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1624                                                 sizeof(struct tresp_sim_disable_facility), &dis_facility);\r
1625                                 break;\r
1626                         case SEC_PIN1_ENABLE:\r
1627                         case SEC_PIN2_ENABLE:\r
1628                         case SEC_FDN_ENABLE:\r
1629                         case SEC_SIM_ENABLE:\r
1630                         case SEC_NET_ENABLE:\r
1631                         case SEC_NS_ENABLE:\r
1632                         case SEC_SP_ENABLE:\r
1633                         case SEC_CP_ENABLE:\r
1634                                 en_facility.result = SIM_INCORRECT_PASSWORD;\r
1635                                 en_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
1636                                 en_facility.retry_count =  attempts_left;\r
1637                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
1638                                                 sizeof(struct tresp_sim_enable_facility), &en_facility);\r
1639                                 break;\r
1640                         default:\r
1641                                 dbg("not handled sec op[%d]", sp->current_sec_op);\r
1642                                 break;\r
1643                 }\r
1644                 tcore_at_tok_free(tokens);\r
1645         }\r
1646         dbg(" Function exit");\r
1647 }\r
1648 \r
1649 static gboolean _get_sim_type(CoreObject *o)\r
1650 {\r
1651         TcoreHal* hal= NULL;\r
1652         TcoreATRequest *req= NULL;\r
1653         TcorePending *pending = NULL;\r
1654         UserRequest *ur = NULL;\r
1655         char *cmd_str = NULL;\r
1656 \r
1657         dbg(" Function entry ");\r
1658 \r
1659         hal = tcore_object_get_hal(o);\r
1660         pending = tcore_pending_new(o, 0);\r
1661 \r
1662         cmd_str = g_strdup_printf("AT+XUICC?");\r
1663         req = tcore_at_request_new(cmd_str, "+XUICC:", TCORE_AT_SINGLELINE);\r
1664 \r
1665         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1666 \r
1667         tcore_pending_set_request_data(pending, 0, req);\r
1668         tcore_pending_set_response_callback(pending, _response_get_sim_type, hal);\r
1669         tcore_pending_link_user_request(pending, ur);\r
1670         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1671         tcore_hal_send_request(hal, pending);\r
1672 \r
1673         free(cmd_str);\r
1674         dbg(" Function exit");\r
1675         return TRUE;\r
1676 }\r
1677 \r
1678 static TReturn _get_file_info(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef)\r
1679 {\r
1680         TcoreHal* hal= NULL;\r
1681         TcorePending *pending = NULL;\r
1682         struct s_sim_property file_meta={0,};\r
1683         char *cmd_str = NULL;\r
1684         int trt = 0;\r
1685 \r
1686         dbg(" Function entry ");\r
1687 \r
1688         file_meta.file_id = ef;\r
1689         dbg("file_meta.file_id: %d", file_meta.file_id);\r
1690         hal = tcore_object_get_hal(o);\r
1691         dbg("hal: %x", hal);\r
1692         pending = tcore_pending_new(o, 0);\r
1693 \r
1694         trt = tcore_user_request_set_metainfo(ur, sizeof(struct s_sim_property), &file_meta);\r
1695         dbg("trt[%d]",trt);\r
1696         cmd_str = g_strdup_printf("AT+CRSM=192, %d", ef);                       /*command - 192 : GET RESPONSE*/\r
1697         dbg("cmd_str: %x", cmd_str);\r
1698 \r
1699         pending = tcore_at_pending_new(o, cmd_str, "+CRSM:", TCORE_AT_SINGLELINE, _response_get_file_info, NULL);\r
1700         tcore_pending_link_user_request(pending, ur);\r
1701         tcore_hal_send_request(hal, pending);\r
1702 \r
1703         free(cmd_str);\r
1704         dbg(" Function exit");\r
1705         return TCORE_RETURN_SUCCESS;\r
1706 }\r
1707 \r
1708 static gboolean _get_file_data(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int offset, const int length)\r
1709 {\r
1710         TcoreHal* hal= NULL;\r
1711         TcoreATRequest *req= NULL;\r
1712         TcorePending *pending = NULL;\r
1713         char *cmd_str = NULL;\r
1714         int p1 = 0;\r
1715         int p2 = 0;\r
1716         int p3 = 0;\r
1717 \r
1718         dbg(" Function entry ");\r
1719         hal = tcore_object_get_hal(o);\r
1720         pending = tcore_pending_new(o, 0);\r
1721 \r
1722         dbg("file_id: %x", ef);\r
1723 \r
1724         p1 = (unsigned char)(offset & 0xFF00) >> 8;\r
1725         p2 = (unsigned char)offset & 0x00FF; //offset low\r
1726         p3 = (unsigned char)length;\r
1727 \r
1728         cmd_str = g_strdup_printf("AT+CRSM=176, %d, %d, %d, %d", ef,p1,p2,p3);                  /*command - 176 : READ BINARY*/\r
1729 \r
1730         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
1731 \r
1732         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1733 \r
1734         tcore_pending_set_request_data(pending, 0, req);\r
1735         tcore_pending_set_response_callback(pending, _response_get_file_data, hal);\r
1736         tcore_pending_link_user_request(pending, ur);\r
1737         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1738 \r
1739         tcore_hal_send_request(hal, pending);\r
1740 \r
1741         free(cmd_str);\r
1742         dbg(" Function exit");\r
1743         return TRUE;\r
1744 }\r
1745 \r
1746 static gboolean _get_file_record(CoreObject *o, UserRequest *ur, const enum tel_sim_file_id ef, const int index, const int length)\r
1747 {\r
1748 \r
1749         TcoreHal* hal= NULL;\r
1750         TcoreATRequest *req= NULL;\r
1751         TcorePending *pending = NULL;\r
1752         char *cmd_str = NULL;\r
1753         int p1 = 0;\r
1754         int p2 = 0;\r
1755         int p3 = 0;\r
1756         dbg(" Function entry ");\r
1757 \r
1758         hal = tcore_object_get_hal(o);\r
1759         pending = tcore_pending_new(o, 0);\r
1760 \r
1761         p1 = (unsigned char)index;\r
1762         p2 = (unsigned char)0x04;               /* 0x4 for absolute mode  */\r
1763         p3 = (unsigned char)length;\r
1764 \r
1765         cmd_str = g_strdup_printf("AT+CRSM=178, %d, %d, %d, %d", ef,p1,p2,p3);                  /*command - 178 : READ RECORD*/\r
1766 \r
1767         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
1768 \r
1769         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1770 \r
1771         tcore_pending_set_request_data(pending, 0, req);\r
1772         tcore_pending_set_response_callback(pending, _response_get_file_data, hal);\r
1773         tcore_pending_link_user_request(pending, ur);\r
1774         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1775 \r
1776         tcore_hal_send_request(hal, pending);\r
1777 \r
1778         free(cmd_str);\r
1779         dbg(" Function exit");\r
1780         return TRUE;\r
1781 }\r
1782 \r
1783 static TReturn _get_retry_count(CoreObject *o, UserRequest *ur)\r
1784 {\r
1785         TcoreHal* hal= NULL;\r
1786         TcoreATRequest *req= NULL;\r
1787         TcorePending *pending = NULL;\r
1788         char *cmd_str = NULL;\r
1789         int     lock_type = 0;\r
1790         struct s_sim_property *sp = NULL;\r
1791         const struct treq_sim_get_lock_info *req_data= NULL;\r
1792 \r
1793         dbg(" Function entry ");\r
1794 \r
1795         hal = tcore_object_get_hal(o);\r
1796         pending = tcore_pending_new(o, 0);\r
1797         req_data = tcore_user_request_ref_data(ur, NULL);\r
1798         sp = tcore_sim_ref_userdata(o);\r
1799 \r
1800         switch (sp->current_sec_op)\r
1801         {\r
1802                 case SEC_PIN1_VERIFY:\r
1803                 case SEC_PIN1_CHANGE:\r
1804                 case SEC_PIN1_ENABLE:\r
1805                 case SEC_PIN1_DISABLE:\r
1806                         lock_type = 1;\r
1807                         break;\r
1808                 case SEC_PIN2_VERIFY:\r
1809                 case SEC_PIN2_CHANGE:\r
1810                 case SEC_PIN2_ENABLE:\r
1811                 case SEC_PIN2_DISABLE:\r
1812                 case SEC_FDN_ENABLE:\r
1813                 case SEC_FDN_DISABLE:\r
1814                         lock_type = 2;\r
1815                         break;\r
1816                 case SEC_PUK1_VERIFY:\r
1817                         lock_type = 3;\r
1818                         break;\r
1819                 case SEC_PUK2_VERIFY:\r
1820                         lock_type = 4;\r
1821                         break;\r
1822                 case SEC_NET_ENABLE:\r
1823                 case SEC_NET_DISABLE:\r
1824                         lock_type = 5;\r
1825                         break;\r
1826                 case SEC_NS_ENABLE:\r
1827                 case SEC_NS_DISABLE:\r
1828                         lock_type = 6;\r
1829                         break;\r
1830                 case SEC_SP_ENABLE:\r
1831                 case SEC_SP_DISABLE:\r
1832                         lock_type = 7;\r
1833                         break;\r
1834                 case SEC_CP_ENABLE:\r
1835                 case SEC_CP_DISABLE:\r
1836                         lock_type = 8;\r
1837                         break;\r
1838                 case SEC_ADM_VERIFY:\r
1839                         lock_type = 9;\r
1840                         break;\r
1841                 default:\r
1842                         break;\r
1843         }\r
1844 \r
1845         cmd_str = g_strdup_printf("AT+XPINCNT=%d", lock_type);\r
1846         req = tcore_at_request_new(cmd_str, "+XPINCNT:", TCORE_AT_SINGLELINE);\r
1847         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1848 \r
1849         tcore_pending_set_request_data(pending, 0, req);\r
1850         tcore_pending_set_response_callback(pending, _on_response_get_retry_count, hal);\r
1851         tcore_pending_link_user_request(pending, ur);\r
1852         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
1853         tcore_hal_send_request(hal, pending);\r
1854 \r
1855         free(cmd_str);\r
1856         dbg(" Function exit");\r
1857         return TCORE_RETURN_SUCCESS;\r
1858 }\r
1859 \r
1860 \r
1861 static gboolean on_event_facility_lock_status(CoreObject *o, const void *event_info, void *user_data)\r
1862 {\r
1863         struct s_sim_property *sp = NULL;\r
1864         char *line = NULL;\r
1865         GSList *tokens=NULL;\r
1866         GSList *lines = NULL;\r
1867 \r
1868         dbg("Function entry");\r
1869         return TRUE;\r
1870 \r
1871         sp = tcore_sim_ref_userdata(o);\r
1872         lines = (GSList*)event_info;\r
1873         if (1 != g_slist_length(lines))\r
1874         {\r
1875                 dbg("unsolicited msg but multiple line");\r
1876                 goto OUT;\r
1877         }\r
1878         line  = (char*)(lines->data);\r
1879         tokens = tcore_at_tok_new(line);\r
1880         if (g_slist_length(tokens) != 1)\r
1881         {\r
1882                 msg("invalid message");\r
1883                 tcore_at_tok_free(tokens);\r
1884                 return TRUE;\r
1885         }\r
1886 \r
1887 OUT:\r
1888         dbg(" Function exit");\r
1889         if(NULL!=tokens)\r
1890                 tcore_at_tok_free(tokens);\r
1891         return TRUE;\r
1892 }\r
1893 \r
1894 \r
1895 static gboolean on_event_pin_status(CoreObject *o, const void *event_info, void *user_data)\r
1896 {\r
1897         UserRequest *ur = NULL;\r
1898         struct s_sim_property *sp = NULL;\r
1899         enum tel_sim_status sim_status = SIM_STATUS_INITIALIZING;\r
1900         GSList *tokens=NULL;\r
1901         GSList *lines = NULL;\r
1902         const char *line = NULL;\r
1903         int sim_state = 0;\r
1904 \r
1905         dbg(" Function entry ");\r
1906 \r
1907         sp = tcore_sim_ref_userdata(o);\r
1908 \r
1909         lines = (GSList*)event_info;\r
1910         if (1 != g_slist_length(lines))\r
1911         {\r
1912                 dbg("unsolicited msg but multiple line");\r
1913                 goto OUT;\r
1914         }\r
1915         line  = (char*)(lines->data);\r
1916 \r
1917         tokens = tcore_at_tok_new(line);\r
1918         if (g_slist_length(tokens) != 1)\r
1919         {\r
1920                 msg("invalid message");\r
1921                 tcore_at_tok_free(tokens);\r
1922                 return TRUE;\r
1923         }\r
1924         sim_state = atoi(g_slist_nth_data(tokens, 0));\r
1925 \r
1926         switch (sim_state)\r
1927         {\r
1928                 case 0:                                                                                                         //sim state = SIM not present\r
1929                         sim_status = SIM_STATUS_CARD_NOT_PRESENT;\r
1930                         dbg( "NO SIM");\r
1931                         break;\r
1932                 case 1:                                                                                                         //sim state = PIN verification needed\r
1933                         sim_status = SIM_STATUS_PIN_REQUIRED;\r
1934                         dbg( " PIN required");\r
1935                         break;\r
1936                 case 2:                                                                                                         //sim state = PIN verification not needed \96 Ready\r
1937                 case 3:                                                                                                         //sim state = PIN verified \96 Ready\r
1938                         sim_status = SIM_STATUS_INITIALIZING;\r
1939                         dbg(" Inside PIN disabled at BOOT UP");\r
1940                         break;\r
1941                 case 4:                                                                                                         //sim state = PUK verification needed\r
1942                         sim_status = SIM_STATUS_PUK_REQUIRED;\r
1943                         dbg(" PUK required");\r
1944                         break;\r
1945                 case 5:                                                                                                         //sim state = SIM permanently blocked\r
1946                         sim_status = SIM_STATUS_CARD_BLOCKED;\r
1947                         dbg(" Card permanently blocked");\r
1948                         break;\r
1949                 case 6:                                                                                                         //sim state = SIM error\r
1950                         sim_status = SIM_STATUS_CARD_ERROR;\r
1951                         dbg( "SIM card error ");\r
1952                         break;\r
1953                 case 7:                                                                                                         //sim state = ready for attach (+COPS)\r
1954                         sim_status = SIM_STATUS_INIT_COMPLETED;\r
1955                         dbg( "Modem init completed");\r
1956                         break;\r
1957                 case 8:                                                                                                         //sim state = SIM Technical Problem\r
1958                         sim_status = SIM_STATUS_CARD_ERROR;\r
1959                         dbg( "SIM unavailable");\r
1960                         break;\r
1961                 case 9:                                                                                                         //sim state = SIM removed\r
1962                         sim_status = SIM_STATUS_CARD_REMOVED;\r
1963                         dbg( "SIM removed");\r
1964                         break;\r
1965                 case 99:                                                                                                                //sim state = SIM State Unknown\r
1966                         sim_status = SIM_STATUS_UNKNOWN;\r
1967                         dbg( "SIM State Unknown");\r
1968                         break;\r
1969                 case 12:\r
1970                         dbg( "SIM Status : %d", sim_status);\r
1971                         goto OUT;\r
1972                 default:\r
1973                         dbg(" not handled SEC lock type ");\r
1974                         break;\r
1975         }\r
1976 \r
1977         switch (sim_status)\r
1978         {\r
1979                 case SIM_STATUS_INIT_COMPLETED:\r
1980                         ur = tcore_user_request_new(NULL, NULL); //this is for using ur metainfo set/ref functionality.\r
1981                         _get_file_info(o, ur, SIM_EF_IMSI);\r
1982                         break;\r
1983                 case SIM_STATUS_INITIALIZING:\r
1984                 case SIM_STATUS_PIN_REQUIRED:\r
1985                 case SIM_STATUS_PUK_REQUIRED:\r
1986                 case SIM_STATUS_CARD_BLOCKED:\r
1987                 case SIM_STATUS_NCK_REQUIRED:\r
1988                 case SIM_STATUS_NSCK_REQUIRED:\r
1989                 case SIM_STATUS_SPCK_REQUIRED:\r
1990                 case SIM_STATUS_CCK_REQUIRED:\r
1991                 case SIM_STATUS_LOCK_REQUIRED:\r
1992                         if( sp->first_recv_status == SIM_STATUS_UNKNOWN )\r
1993                         {\r
1994                                 dbg("first received sim status[%d]",sim_status);\r
1995                                 sp->first_recv_status = sim_status;\r
1996                                 _get_sim_type(o);\r
1997                         } else {\r
1998                                 dbg("second or later received lock status[%d]",sim_status);\r
1999                                 if ( tcore_sim_get_status(o) != SIM_STATUS_INIT_COMPLETED )\r
2000                                 {\r
2001                                         dbg("sim is not init complete in telephony side yet");\r
2002                                         _sim_status_update(o,sim_status);\r
2003                                 }\r
2004                         }\r
2005                         break;\r
2006                 case SIM_STATUS_CARD_REMOVED:\r
2007                 case SIM_STATUS_CARD_NOT_PRESENT:\r
2008                 case SIM_STATUS_CARD_ERROR:\r
2009                         if (sim_status == SIM_STATUS_CARD_NOT_PRESENT && tcore_sim_get_status(o) != SIM_STATUS_UNKNOWN)\r
2010                         {\r
2011                                 dbg("[SIM]SIM CARD REMOVED!!");\r
2012                                 sim_status = SIM_STATUS_CARD_REMOVED;\r
2013                         }\r
2014                         _sim_status_update(o,sim_status);\r
2015                         break;\r
2016                 default:\r
2017                         dbg("not handled status[%d]", sim_status);\r
2018 \r
2019                         break;\r
2020                 }\r
2021 OUT:\r
2022         dbg(" Function exit");\r
2023         if(NULL!=tokens)\r
2024                 tcore_at_tok_free(tokens);\r
2025         return TRUE;\r
2026 }\r
2027 \r
2028 \r
2029 \r
2030 static void on_response_verify_pins(TcorePending *p, int data_len, const void *data, void *user_data)\r
2031 {\r
2032         const TcoreATResponse *resp = data;\r
2033         UserRequest *ur = NULL;\r
2034         CoreObject *co_sim = NULL;\r
2035         struct s_sim_property *sp = NULL;\r
2036         GSList *tokens=NULL;\r
2037         struct tresp_sim_verify_pins res;\r
2038         GQueue *queue= NULL;\r
2039         const char *line;\r
2040         int err;\r
2041 \r
2042         dbg(" Function entry ");\r
2043 \r
2044         co_sim = tcore_pending_ref_core_object(p);\r
2045         sp = tcore_sim_ref_userdata(co_sim);\r
2046         ur = tcore_pending_ref_user_request(p);\r
2047 \r
2048         memset(&res, 0, sizeof(struct tresp_sim_verify_pins));\r
2049 \r
2050         if(resp->success > 0)\r
2051         {\r
2052                 dbg("RESPONSE OK");\r
2053                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2054                 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2055                 if (res.pin_type == SIM_PTYPE_PIN1 || res.pin_type == SIM_PTYPE_SIM)\r
2056                 {\r
2057                         if (tcore_sim_get_status(co_sim) != SIM_STATUS_INIT_COMPLETED)\r
2058                                 _sim_status_update(co_sim, SIM_STATUS_INITIALIZING);\r
2059                 }\r
2060                 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PINS,     sizeof(struct tresp_sim_verify_pins), &res);\r
2061         }\r
2062         else\r
2063         {\r
2064                 dbg("RESPONSE NOK");\r
2065                 line = (const char*)resp->final_response;\r
2066                 tokens = tcore_at_tok_new(line);\r
2067                 if (g_slist_length(tokens) < 1)\r
2068                 {\r
2069                         dbg("err cause not specified or string corrupted");\r
2070                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2071                 }\r
2072                 else\r
2073                 {\r
2074                         err = atoi(g_slist_nth_data(tokens, 0));\r
2075                         dbg("on_response_verify_pins: err = %d", err);\r
2076                         queue = tcore_object_ref_user_data(co_sim);\r
2077                         ur = tcore_user_request_ref(ur);\r
2078                         _get_retry_count(co_sim, ur);\r
2079                 }\r
2080                 tcore_at_tok_free(tokens);\r
2081         }\r
2082         dbg(" Function exit");\r
2083 }\r
2084 \r
2085 static void on_response_verify_puks(TcorePending *p, int data_len, const void *data, void *user_data)\r
2086 {\r
2087         const TcoreATResponse *resp = data;\r
2088         UserRequest *ur = NULL;\r
2089         CoreObject *co_sim = NULL;\r
2090         struct s_sim_property *sp = NULL;\r
2091         GSList *tokens=NULL;\r
2092         struct tresp_sim_verify_puks res;\r
2093         GQueue *queue= NULL;\r
2094         const char *line;\r
2095         int err;\r
2096 \r
2097         dbg(" Function entry ");\r
2098 \r
2099         co_sim = tcore_pending_ref_core_object(p);\r
2100         sp = tcore_sim_ref_userdata(co_sim);\r
2101         ur = tcore_pending_ref_user_request(p);\r
2102 \r
2103         memset(&res, 0, sizeof(struct tresp_sim_verify_pins));\r
2104 \r
2105         if(resp->success > 0)\r
2106         {\r
2107                 dbg("RESPONSE OK");\r
2108                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2109                 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2110                 tcore_user_request_send_response(ur, TRESP_SIM_VERIFY_PUKS,     sizeof(struct tresp_sim_verify_pins), &res);\r
2111         }\r
2112         else\r
2113         {\r
2114                 dbg("RESPONSE NOK");\r
2115                 line = (const char*)resp->final_response;\r
2116                 tokens = tcore_at_tok_new(line);\r
2117 \r
2118                 if (g_slist_length(tokens) < 1)\r
2119                 {\r
2120                         dbg("err cause not specified or string corrupted");\r
2121                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2122                 }\r
2123                 else\r
2124                 {\r
2125                         err = atoi(g_slist_nth_data(tokens, 0));\r
2126                         queue = tcore_object_ref_user_data(co_sim);\r
2127                         ur = tcore_user_request_ref(ur);\r
2128                         _get_retry_count(co_sim, ur);\r
2129                 }\r
2130                 tcore_at_tok_free(tokens);\r
2131         }\r
2132         dbg(" Function exit");\r
2133 }\r
2134 \r
2135 static void on_response_change_pins(TcorePending *p, int data_len, const void *data, void *user_data)\r
2136 {\r
2137         const TcoreATResponse *resp = data;\r
2138         UserRequest *ur = NULL;\r
2139         CoreObject *co_sim = NULL;\r
2140         struct s_sim_property *sp = NULL;\r
2141         GSList *tokens=NULL;\r
2142         struct tresp_sim_change_pins res;\r
2143         GQueue *queue;\r
2144         const char *line;\r
2145         int err;\r
2146 \r
2147         dbg(" Function entry ");\r
2148 \r
2149         co_sim = tcore_pending_ref_core_object(p);\r
2150         sp = tcore_sim_ref_userdata(co_sim);\r
2151         ur = tcore_pending_ref_user_request(p);\r
2152 \r
2153         memset(&res, 0, sizeof(struct tresp_sim_change_pins));\r
2154 \r
2155         if(resp->success > 0)\r
2156         {\r
2157                 dbg("RESPONSE OK");\r
2158                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2159                 res.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2160                 tcore_user_request_send_response(ur, TRESP_SIM_CHANGE_PINS,sizeof(struct tresp_sim_change_pins), &res);\r
2161         }\r
2162         else\r
2163         {\r
2164                 dbg("RESPONSE NOK");\r
2165                 line = (const char*)resp->final_response;\r
2166                 tokens = tcore_at_tok_new(line);\r
2167 \r
2168                 if (g_slist_length(tokens) < 1)\r
2169                 {\r
2170                         dbg("err cause not specified or string corrupted");\r
2171                     res.result = TCORE_RETURN_3GPP_ERROR;\r
2172                 }\r
2173                 else\r
2174                 {\r
2175                         err = atoi(g_slist_nth_data(tokens, 0));\r
2176                         queue = tcore_object_ref_user_data(co_sim);\r
2177                         ur = tcore_user_request_ref(ur);\r
2178                         _get_retry_count(co_sim, ur);\r
2179                 }\r
2180                 tcore_at_tok_free(tokens);\r
2181         }\r
2182         dbg(" Function exit");\r
2183 }\r
2184 \r
2185 static void on_response_get_facility_status(TcorePending *p, int data_len, const void *data, void *user_data)\r
2186 {\r
2187         const TcoreATResponse *resp = data;\r
2188         UserRequest *ur = NULL;\r
2189         CoreObject *co_sim = NULL;\r
2190         struct s_sim_property *sp = NULL;\r
2191         GSList *tokens=NULL;\r
2192         struct tresp_sim_get_facility_status res;\r
2193         const char *line;\r
2194 \r
2195         dbg(" Function entry ");\r
2196 \r
2197         co_sim = tcore_pending_ref_core_object(p);\r
2198         sp = tcore_sim_ref_userdata(co_sim);\r
2199         ur = tcore_pending_ref_user_request(p);\r
2200 \r
2201         memset(&res, 0, sizeof(struct tresp_sim_get_facility_status));\r
2202 \r
2203         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2204         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2205 \r
2206         if(resp->success > 0)\r
2207         {\r
2208                 dbg("RESPONSE OK");\r
2209                 if(resp->lines) {\r
2210                         line = (const char*)resp->lines->data;\r
2211                         tokens = tcore_at_tok_new(line);\r
2212                         if (g_slist_length(tokens) != 1)\r
2213                         {\r
2214                                 msg("invalid message");\r
2215                                 tcore_at_tok_free(tokens);\r
2216                                 return;\r
2217                         }\r
2218                 }\r
2219                 res.b_enable = atoi(g_slist_nth_data(tokens, 0));\r
2220 \r
2221         }\r
2222         else\r
2223         {\r
2224                 dbg("RESPONSE NOK");\r
2225                 res.result = SIM_INCOMPATIBLE_PIN_OPERATION;\r
2226         }\r
2227 \r
2228         if (ur)\r
2229         {\r
2230                 tcore_user_request_send_response(ur, TRESP_SIM_GET_FACILITY_STATUS,\r
2231                                 sizeof(struct tresp_sim_get_facility_status), &res);\r
2232         }\r
2233         tcore_at_tok_free(tokens);\r
2234         dbg(" Function exit");\r
2235 }\r
2236 \r
2237 static void on_response_enable_facility(TcorePending *p, int data_len, const void *data, void *user_data)\r
2238 {\r
2239         const TcoreATResponse *resp = data;\r
2240         UserRequest *ur = NULL;\r
2241         CoreObject *co_sim = NULL;\r
2242         struct s_sim_property *sp = NULL;\r
2243         GSList *tokens=NULL;\r
2244         struct tresp_sim_enable_facility res;\r
2245         GQueue *queue;\r
2246         const char *line;\r
2247 \r
2248         dbg(" Function entry ");\r
2249 \r
2250         co_sim = tcore_pending_ref_core_object(p);\r
2251         sp = tcore_sim_ref_userdata(co_sim);\r
2252         ur = tcore_pending_ref_user_request(p);\r
2253 \r
2254         memset(&res, 0, sizeof(struct tresp_sim_enable_facility));\r
2255 \r
2256         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2257         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2258 \r
2259         if(resp->success > 0)\r
2260         {\r
2261                 dbg("RESPONSE OK");\r
2262                 if(resp->lines)\r
2263                 {\r
2264                         line = (const char*)resp->lines->data;\r
2265                         tokens = tcore_at_tok_new(line);\r
2266                         if (g_slist_length(tokens) != 1)\r
2267                         {\r
2268                                 msg("invalid message");\r
2269                                 tcore_at_tok_free(tokens);\r
2270                                 return;\r
2271                         }\r
2272                 }\r
2273                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2274                 if (ur)\r
2275                 {\r
2276                         tcore_user_request_send_response(ur, TRESP_SIM_ENABLE_FACILITY,\r
2277                                 sizeof(struct tresp_sim_enable_facility), &res);\r
2278                 }\r
2279                 tcore_at_tok_free(tokens);\r
2280         }\r
2281         else\r
2282         {\r
2283                 dbg("RESPONSE NOK");\r
2284                 queue = tcore_object_ref_user_data(co_sim);\r
2285                 ur = tcore_user_request_ref(ur);\r
2286                 _get_retry_count(co_sim, ur);\r
2287         }\r
2288         dbg(" Function exit");\r
2289 }\r
2290 \r
2291 static void on_response_disable_facility(TcorePending *p, int data_len, const void *data, void *user_data)\r
2292 {\r
2293         const TcoreATResponse *resp = data;\r
2294         UserRequest *ur = NULL;\r
2295         CoreObject *co_sim = NULL;\r
2296         struct s_sim_property *sp = NULL;\r
2297         GSList *tokens=NULL;\r
2298         struct tresp_sim_disable_facility res;\r
2299         GQueue *queue;\r
2300         const char *line;\r
2301 \r
2302         dbg(" Function entry ");\r
2303 \r
2304         co_sim = tcore_pending_ref_core_object(p);\r
2305         sp = tcore_sim_ref_userdata(co_sim);\r
2306         ur = tcore_pending_ref_user_request(p);\r
2307 \r
2308         memset(&res, 0, sizeof(struct tresp_sim_disable_facility));\r
2309 \r
2310         res.result = SIM_PIN_OPERATION_SUCCESS;\r
2311         res.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2312 \r
2313         if(resp->success > 0)\r
2314         {\r
2315                 dbg("RESPONSE OK");\r
2316                 if(resp->lines) {\r
2317                         line = (const char*)resp->lines->data;\r
2318                         tokens = tcore_at_tok_new(line);\r
2319                         if (g_slist_length(tokens) != 1)\r
2320                         {\r
2321                                 msg("invalid message");\r
2322                                 tcore_at_tok_free(tokens);\r
2323                                 return;\r
2324                         }\r
2325                 }\r
2326                 res.result = SIM_PIN_OPERATION_SUCCESS;\r
2327                 if (ur)\r
2328                 {\r
2329                         tcore_user_request_send_response(ur, TRESP_SIM_DISABLE_FACILITY,\r
2330                                 sizeof(struct tresp_sim_disable_facility), &res);\r
2331                 }\r
2332                 tcore_at_tok_free(tokens);\r
2333         }\r
2334         else\r
2335         {\r
2336                 dbg("RESPONSE NOK");\r
2337                 queue = tcore_object_ref_user_data(co_sim);\r
2338                 ur = tcore_user_request_ref(ur);\r
2339                 _get_retry_count(co_sim, ur);\r
2340         }\r
2341         dbg(" Function exit");\r
2342 }\r
2343 \r
2344 static void on_response_get_lock_info(TcorePending *    p, int data_len, const void *data, void *user_data)\r
2345 {\r
2346         const TcoreATResponse *resp = data;\r
2347         UserRequest *ur = NULL;\r
2348         CoreObject *co_sim = NULL;\r
2349         struct s_sim_property *sp = NULL;\r
2350         GSList *tokens=NULL;\r
2351         const char *line;\r
2352         struct tresp_sim_verify_pins v_pin = {0,};\r
2353         struct tresp_sim_verify_puks v_puk = {0,};\r
2354         struct tresp_sim_change_pins change_pin = {0,};\r
2355         struct tresp_sim_disable_facility dis_facility = {0,};\r
2356         struct tresp_sim_enable_facility en_facility = {0,};\r
2357         int lock_type;\r
2358         int attempts_left = 0;\r
2359         int time_penalty = 0;\r
2360 \r
2361         dbg(" Function entry ");\r
2362 \r
2363         co_sim = tcore_pending_ref_core_object(p);\r
2364         sp = tcore_sim_ref_userdata(co_sim);\r
2365         ur = tcore_pending_ref_user_request(p);\r
2366 \r
2367         if(resp->success > 0)\r
2368         {\r
2369                 dbg("RESPONSE OK");\r
2370                 if(resp->lines) {\r
2371                         line = (const char*)resp->lines->data;\r
2372                         tokens = tcore_at_tok_new(line);\r
2373                         if (g_slist_length(tokens) != 3)\r
2374                         {\r
2375                                 msg("invalid message");\r
2376                                 tcore_at_tok_free(tokens);\r
2377                                 return;\r
2378                         }\r
2379                 }\r
2380                 lock_type = atoi(g_slist_nth_data(tokens, 0));\r
2381                 attempts_left = atoi(g_slist_nth_data(tokens, 1));\r
2382                 time_penalty = atoi(g_slist_nth_data(tokens, 2));\r
2383 \r
2384                 switch (sp->current_sec_op)\r
2385                 {\r
2386                         case SEC_PIN1_VERIFY:\r
2387                         case SEC_PIN2_VERIFY:\r
2388                         case SEC_SIM_VERIFY:\r
2389                         case SEC_ADM_VERIFY:\r
2390                                 v_pin.result = SIM_INCORRECT_PASSWORD;\r
2391                                 v_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2392                                 v_pin.retry_count = attempts_left;\r
2393                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2394                                                 sizeof(struct tresp_sim_verify_pins), &v_pin);\r
2395                                 break;\r
2396                         case SEC_PUK1_VERIFY:\r
2397                         case SEC_PUK2_VERIFY:\r
2398                                 v_puk.result = SIM_INCORRECT_PASSWORD;\r
2399                                 v_puk.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2400                                 v_puk.retry_count = attempts_left;\r
2401                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2402                                                 sizeof(struct tresp_sim_verify_puks), &v_puk);\r
2403                                 break;\r
2404                         case SEC_PIN1_CHANGE:\r
2405                         case SEC_PIN2_CHANGE:\r
2406                                 change_pin.result = SIM_INCORRECT_PASSWORD;\r
2407                                 change_pin.pin_type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2408                                 change_pin.retry_count = attempts_left;\r
2409                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2410                                                 sizeof(struct tresp_sim_change_pins), &change_pin);\r
2411                                 break;\r
2412                         case SEC_PIN1_DISABLE:\r
2413                         case SEC_PIN2_DISABLE:\r
2414                         case SEC_FDN_DISABLE:\r
2415                         case SEC_SIM_DISABLE:\r
2416                         case SEC_NET_DISABLE:\r
2417                         case SEC_NS_DISABLE:\r
2418                         case SEC_SP_DISABLE:\r
2419                         case SEC_CP_DISABLE:\r
2420                                 dis_facility.result = SIM_INCORRECT_PASSWORD;\r
2421                                 dis_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2422                                 dis_facility.retry_count = attempts_left;\r
2423                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2424                                                 sizeof(struct tresp_sim_disable_facility), &dis_facility);\r
2425                                 break;\r
2426                         case SEC_PIN1_ENABLE:\r
2427                         case SEC_PIN2_ENABLE:\r
2428                         case SEC_FDN_ENABLE:\r
2429                         case SEC_SIM_ENABLE:\r
2430                         case SEC_NET_ENABLE:\r
2431                         case SEC_NS_ENABLE:\r
2432                         case SEC_SP_ENABLE:\r
2433                         case SEC_CP_ENABLE:\r
2434                                 en_facility.result = SIM_INCORRECT_PASSWORD;\r
2435                                 en_facility.type = _sim_get_current_pin_facility(sp->current_sec_op);\r
2436                                 en_facility.retry_count = attempts_left;\r
2437                                 tcore_user_request_send_response(ur, _find_resp_command(ur),\r
2438                                                 sizeof(struct tresp_sim_enable_facility), &en_facility);\r
2439                                 break;\r
2440                         default:\r
2441                                 dbg("not handled sec op[%d]", sp->current_sec_op);\r
2442                                 break;\r
2443                 }\r
2444                 tcore_at_tok_free(tokens);\r
2445         }\r
2446         dbg(" Function exit");\r
2447 }\r
2448 \r
2449 static void on_response_update_file(TcorePending *p, int data_len, const void *data, void *user_data)\r
2450 {\r
2451         const TcoreATResponse *resp = data;\r
2452         UserRequest *ur = NULL;\r
2453         CoreObject *co_sim = NULL;\r
2454         struct tresp_sim_set_callforwarding resp_cf = {0, };\r
2455         struct tresp_sim_set_language resp_language ={0,};\r
2456         struct s_sim_property *sp = NULL;\r
2457         GSList *tokens=NULL;\r
2458         enum tel_sim_access_result result;\r
2459         const char *line;\r
2460         int sw1 = 0;\r
2461         int sw2 = 0;\r
2462 \r
2463         dbg(" Function entry ");\r
2464 \r
2465         co_sim = tcore_pending_ref_core_object(p);\r
2466         sp = tcore_sim_ref_userdata(co_sim);\r
2467         ur = tcore_pending_ref_user_request(p);\r
2468 \r
2469         if(resp->success > 0)\r
2470         {\r
2471                 dbg("RESPONSE OK");\r
2472                 if(resp->lines)\r
2473                 {\r
2474                         line = (const char*)resp->lines->data;\r
2475                         tokens = tcore_at_tok_new(line);\r
2476                         if (g_slist_length(tokens) != 2)\r
2477                         {\r
2478                                 msg("invalid message");\r
2479                                 tcore_at_tok_free(tokens);\r
2480                                 return;\r
2481                         }\r
2482                 }\r
2483                 sw1 = atoi(g_slist_nth_data(tokens, 0));\r
2484                 sw2 = atoi(g_slist_nth_data(tokens, 1));\r
2485 \r
2486                 if((sw1 == 0x90 && sw2 == 0x00) ||sw1 == 0x91)\r
2487                 {\r
2488                         result = SIM_ACCESS_SUCCESS;\r
2489                 }else\r
2490                 {\r
2491                         result =  _decode_status_word(sw1, sw2);\r
2492                 }\r
2493         }else{\r
2494                 dbg("RESPONSE NOK");\r
2495                 result = SIM_ACCESS_FAILED;\r
2496         }\r
2497 \r
2498         switch(sp->file_id)\r
2499         {\r
2500                 case SIM_EF_CPHS_CALL_FORWARD_FLAGS :\r
2501                 case SIM_EF_USIM_CFIS :\r
2502                         tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_set_callforwarding), &resp_cf);\r
2503                         break;\r
2504                 case SIM_EF_ELP:\r
2505                 case SIM_EF_LP:\r
2506                 case SIM_EF_USIM_LI:\r
2507                 case SIM_EF_USIM_PL:\r
2508                         tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_set_language), &resp_language);\r
2509                         break;\r
2510                 default:\r
2511                         dbg("Invalid File ID - %d", sp->file_id)
2512                         break;\r
2513         }\r
2514         tcore_at_tok_free(tokens);\r
2515         dbg(" Function exit");\r
2516 }\r
2517 \r
2518 static void on_response_transmit_apdu(TcorePending *p, int data_len, const void *data, void *user_data)\r
2519 {\r
2520         const TcoreATResponse *resp = data;\r
2521         UserRequest *ur = NULL;\r
2522         CoreObject *co_sim = NULL;\r
2523         struct s_sim_property *sp = NULL;\r
2524         GSList *tokens=NULL;\r
2525         struct tresp_sim_transmit_apdu res;\r
2526         const char *line;\r
2527 \r
2528         dbg(" Function entry ");\r
2529 \r
2530         co_sim = tcore_pending_ref_core_object(p);\r
2531         sp = tcore_sim_ref_userdata(co_sim);\r
2532         ur = tcore_pending_ref_user_request(p);\r
2533 \r
2534         memset(&res, 0, sizeof(struct tresp_sim_transmit_apdu));\r
2535 \r
2536         if(resp->success > 0)\r
2537         {\r
2538                 dbg("RESPONSE OK");\r
2539                 res.result = SIM_ACCESS_SUCCESS;\r
2540                 if(resp->lines)\r
2541                 {\r
2542                         line = (const char*)resp->lines->data;\r
2543                         tokens = tcore_at_tok_new(line);\r
2544                         if (g_slist_length(tokens) != 2)\r
2545                         {\r
2546                                 msg("invalid message");\r
2547                                 tcore_at_tok_free(tokens);\r
2548                                 return;\r
2549                         }\r
2550                 }\r
2551                 res.apdu_resp_length = atoi(g_slist_nth_data(tokens, 0));\r
2552                 strncpy((char *)res.apdu_resp, (const char *)g_slist_nth_data(tokens, 1), res.apdu_resp_length);\r
2553         }\r
2554         else\r
2555         {\r
2556                 dbg("RESPONSE NOK");\r
2557                 res.result = SIM_ACCESS_FAILED;\r
2558         }\r
2559         ur = tcore_pending_ref_user_request(p);\r
2560         if (ur)\r
2561         {\r
2562                 tcore_user_request_send_response(ur, _find_resp_command(ur), sizeof(struct tresp_sim_transmit_apdu), &res);\r
2563         }\r
2564         tcore_at_tok_free(tokens);\r
2565         dbg(" Function exit");\r
2566 }\r
2567 \r
2568 static TReturn s_verify_pins(CoreObject *o, UserRequest *ur)\r
2569 {\r
2570         TcoreHal* hal= NULL;\r
2571         TcoreATRequest *req = NULL;\r
2572         TcorePending *pending = NULL;\r
2573         char *cmd_str = NULL;\r
2574         const struct treq_sim_verify_pins *req_data = NULL;\r
2575         struct s_sim_property *sp = NULL;\r
2576 \r
2577         dbg(" Function entry ");\r
2578 \r
2579         hal = tcore_object_get_hal(o);\r
2580         sp = tcore_sim_ref_userdata(o);\r
2581         pending = tcore_pending_new(o, 0);\r
2582         req_data = tcore_user_request_ref_data(ur, NULL);\r
2583 \r
2584         if (!o || !ur)\r
2585                 return TCORE_RETURN_EINVAL;\r
2586 \r
2587         if (req_data->pin_type == SIM_PTYPE_PIN1)\r
2588         {\r
2589                 sp->current_sec_op = SEC_PIN1_VERIFY;\r
2590                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2591         }\r
2592         else if (req_data->pin_type == SIM_PTYPE_PIN2)\r
2593         {\r
2594                 sp->current_sec_op = SEC_PIN2_VERIFY;\r
2595                 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\"", req_data->pin);\r
2596         }\r
2597         else if (req_data->pin_type == SIM_PTYPE_SIM)\r
2598         {\r
2599                 sp->current_sec_op = SEC_SIM_VERIFY;\r
2600                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2601         }\r
2602         else if (req_data->pin_type == SIM_PTYPE_ADM)\r
2603         {\r
2604                 sp->current_sec_op = SEC_ADM_VERIFY;\r
2605                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\"", req_data->pin);\r
2606         }\r
2607         else\r
2608         {\r
2609                 return TCORE_RETURN_EINVAL;\r
2610         }\r
2611 \r
2612         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2613 \r
2614         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2615 \r
2616         tcore_pending_set_request_data(pending, 0, req);\r
2617         tcore_pending_set_response_callback(pending, on_response_verify_pins, hal);\r
2618         tcore_pending_link_user_request(pending, ur);\r
2619         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2620         tcore_hal_send_request(hal, pending);\r
2621 \r
2622         free(cmd_str);\r
2623         dbg(" Function exit");\r
2624         return TCORE_RETURN_SUCCESS;\r
2625 }\r
2626 \r
2627 static TReturn s_verify_puks(CoreObject *o, UserRequest *ur)\r
2628 {\r
2629         TcoreHal* hal= NULL;\r
2630         TcoreATRequest *req= NULL;\r
2631         TcorePending *pending = NULL;\r
2632         char *cmd_str = NULL;\r
2633         const struct treq_sim_verify_puks *req_data;\r
2634         struct s_sim_property *sp = NULL;\r
2635 \r
2636         dbg(" Function entry ");\r
2637 \r
2638         hal = tcore_object_get_hal(o);\r
2639         sp = tcore_sim_ref_userdata(o);\r
2640         pending = tcore_pending_new(o, 0);\r
2641         req_data = tcore_user_request_ref_data(ur, NULL);\r
2642 \r
2643         if (!o || !ur)\r
2644                 return TCORE_RETURN_EINVAL;\r
2645 \r
2646         if(req_data->puk_type == SIM_PTYPE_PUK1)\r
2647         {\r
2648                 sp->current_sec_op = SEC_PUK1_VERIFY;\r
2649                 cmd_str = g_strdup_printf("AT+CPIN=\"%s\", \"%s\"", req_data->puk, req_data->pin);\r
2650         }\r
2651         else if(req_data->puk_type == SIM_PTYPE_PUK2)\r
2652         {\r
2653                 sp->current_sec_op = SEC_PUK2_VERIFY;\r
2654                 cmd_str = g_strdup_printf("AT+CPIN2=\"%s\", \"%s\"", req_data->puk, req_data->pin);\r
2655         }\r
2656         else\r
2657         {\r
2658                 return TCORE_RETURN_EINVAL;\r
2659         }\r
2660         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2661 \r
2662         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2663 \r
2664         tcore_pending_set_request_data(pending, 0, req);\r
2665         tcore_pending_set_response_callback(pending, on_response_verify_puks, hal);\r
2666         tcore_pending_link_user_request(pending, ur);\r
2667         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2668         tcore_hal_send_request(hal, pending);\r
2669 \r
2670         free(cmd_str);\r
2671         dbg(" Function exit");\r
2672         return TCORE_RETURN_SUCCESS;\r
2673 }\r
2674 \r
2675 static TReturn s_change_pins(CoreObject *o, UserRequest *ur)\r
2676 {\r
2677         TcoreHal* hal= NULL;\r
2678         TcoreATRequest *req= NULL;\r
2679         TcorePending *pending = NULL;\r
2680         char *cmd_str = NULL;\r
2681         const struct treq_sim_change_pins *req_data;\r
2682         struct s_sim_property *sp = NULL;\r
2683         char *pin1 = "SC";\r
2684         char *pin2 = "P2";\r
2685 \r
2686         dbg(" Function entry ");\r
2687 \r
2688         hal = tcore_object_get_hal(o);\r
2689         sp = tcore_sim_ref_userdata(o);\r
2690         pending = tcore_pending_new(o, 0);\r
2691         req_data = tcore_user_request_ref_data(ur, NULL);\r
2692 \r
2693         if (!o || !ur)\r
2694                 return TCORE_RETURN_EINVAL;\r
2695                 \r
2696         if(req_data->type == SIM_PTYPE_PIN1)\r
2697         {\r
2698                 sp->current_sec_op = SEC_PIN1_CHANGE;\r
2699                 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", pin1, req_data->old_pin, req_data->new_pin);\r
2700 \r
2701         }\r
2702         else if(req_data->type == SIM_PTYPE_PIN2)\r
2703         {\r
2704                 sp->current_sec_op = SEC_PIN2_CHANGE;\r
2705                 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", pin2, req_data->old_pin, req_data->new_pin);\r
2706         }\r
2707         else\r
2708         {\r
2709                 return TCORE_RETURN_EINVAL;\r
2710         }\r
2711         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2712 \r
2713         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2714 \r
2715         tcore_pending_set_request_data(pending, 0, req);\r
2716         tcore_pending_set_response_callback(pending, on_response_change_pins, hal);\r
2717         tcore_pending_link_user_request(pending, ur);\r
2718         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2719         tcore_hal_send_request(hal, pending);\r
2720 \r
2721         free(cmd_str);\r
2722         dbg(" Function exit");\r
2723         return TCORE_RETURN_SUCCESS;\r
2724 }\r
2725 \r
2726 static TReturn s_get_facility_status(CoreObject *o, UserRequest *ur)\r
2727 {\r
2728         TcoreHal* hal= NULL;\r
2729         TcoreATRequest *req= NULL;\r
2730         TcorePending *pending = NULL;\r
2731         char *cmd_str = NULL;\r
2732         const struct treq_sim_get_facility_status *req_data;\r
2733         struct s_sim_property *sp = NULL;\r
2734         char *fac = "SC";\r
2735         int mode = 2;           /* 0:unlock, 1:lock, 2:query*/\r
2736 \r
2737         dbg(" Function entry ");\r
2738 \r
2739         hal = tcore_object_get_hal(o);\r
2740         sp = tcore_sim_ref_userdata(o);\r
2741         pending = tcore_pending_new(o, 0);\r
2742         req_data = tcore_user_request_ref_data(ur, NULL);\r
2743 \r
2744         if (!o || !ur)\r
2745                 return TCORE_RETURN_EINVAL;\r
2746 \r
2747         if(req_data->type == SIM_FACILITY_PS)\r
2748         {\r
2749                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2750         }else if(req_data->type == SIM_FACILITY_SC)\r
2751         {\r
2752                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2753         }else if(req_data->type == SIM_FACILITY_FD)\r
2754         {\r
2755                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2756         }else if(req_data->type == SIM_FACILITY_PN)\r
2757         {\r
2758                 fac = "PN";                                                             /*Network Personalization*/\r
2759         }else if(req_data->type == SIM_FACILITY_PU)\r
2760         {\r
2761                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2762         }else if(req_data->type == SIM_FACILITY_PP)\r
2763         {\r
2764                 fac = "PP";                                                             /*service Provider Personalization*/\r
2765         }else if(req_data->type == SIM_FACILITY_PC)\r
2766         {\r
2767                 fac = "PC";                                                             /*Corporate Personalization*/\r
2768         }else\r
2769         {\r
2770                 return TCORE_RETURN_EINVAL;\r
2771         }\r
2772         cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d", fac, mode);\r
2773         req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);\r
2774 \r
2775         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2776 \r
2777         tcore_pending_set_request_data(pending, 0, req);\r
2778         tcore_pending_set_response_callback(pending, on_response_get_facility_status, hal);\r
2779         tcore_pending_link_user_request(pending, ur);\r
2780         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2781         tcore_hal_send_request(hal, pending);\r
2782 \r
2783         free(cmd_str);\r
2784         dbg(" Function exit");\r
2785         return TCORE_RETURN_SUCCESS;\r
2786 }\r
2787 \r
2788 static TReturn s_enable_facility(CoreObject *o, UserRequest *ur)\r
2789 {\r
2790         TcoreHal* hal = NULL;\r
2791         TcoreATRequest *req = NULL;\r
2792         TcorePending *pending = NULL;\r
2793         char *cmd_str = NULL;\r
2794         const struct treq_sim_enable_facility *req_data;\r
2795         struct s_sim_property *sp = NULL;\r
2796         char *fac = "SC";\r
2797         int mode = 1;           /* 0:unlock, 1:lock, 2:query*/\r
2798 \r
2799         dbg(" Function entry ");\r
2800 \r
2801         hal = tcore_object_get_hal(o);\r
2802         sp = tcore_sim_ref_userdata(o);\r
2803         pending = tcore_pending_new(o, 0);\r
2804         req_data = tcore_user_request_ref_data(ur, NULL);\r
2805 \r
2806         if (!o || !ur)\r
2807                 return TCORE_RETURN_EINVAL;\r
2808 \r
2809         if(req_data->type == SIM_FACILITY_PS)\r
2810         {\r
2811                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2812                 sp->current_sec_op = SEC_SIM_ENABLE;\r
2813         }else if(req_data->type == SIM_FACILITY_SC)\r
2814         {\r
2815                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2816                 sp->current_sec_op = SEC_PIN1_ENABLE;\r
2817         }else if(req_data->type == SIM_FACILITY_FD)\r
2818         {\r
2819                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2820                 sp->current_sec_op = SEC_FDN_ENABLE;\r
2821         }else if(req_data->type == SIM_FACILITY_PN)\r
2822         {\r
2823                 fac = "PN";                                                             /*Network Personalization*/\r
2824                 sp->current_sec_op = SEC_NET_ENABLE;\r
2825         }else if(req_data->type == SIM_FACILITY_PU)\r
2826         {\r
2827                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2828                 sp->current_sec_op = SEC_NS_ENABLE;\r
2829         }else if(req_data->type == SIM_FACILITY_PP)\r
2830         {\r
2831                 fac = "PP";                                                             /*service Provider Personalization*/\r
2832                 sp->current_sec_op = SEC_SP_ENABLE;\r
2833         }else if(req_data->type == SIM_FACILITY_PC)\r
2834         {\r
2835                 fac = "PC";                                                             /*Corporate Personalization*/\r
2836                 sp->current_sec_op = SEC_CP_ENABLE;\r
2837         }else\r
2838         {\r
2839                 return TCORE_RETURN_EINVAL;\r
2840         }\r
2841         cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d, \"%s\"", fac, mode, req_data->password);\r
2842         req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);\r
2843 \r
2844         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2845 \r
2846         tcore_pending_set_request_data(pending, 0, req);\r
2847         tcore_pending_set_response_callback(pending, on_response_enable_facility, hal);\r
2848         tcore_pending_link_user_request(pending, ur);\r
2849         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2850         tcore_hal_send_request(hal, pending);\r
2851 \r
2852         free(cmd_str);\r
2853         dbg(" Function exit");\r
2854         return TCORE_RETURN_SUCCESS;\r
2855 }\r
2856 \r
2857 static TReturn s_disable_facility(CoreObject *o, UserRequest *ur)\r
2858 {\r
2859         TcoreHal* hal;\r
2860         TcoreATRequest *req;\r
2861         TcorePending *pending = NULL;\r
2862         char *cmd_str = NULL;\r
2863         const struct treq_sim_enable_facility *req_data;\r
2864         struct s_sim_property *sp = NULL;\r
2865         char *fac = "SC";\r
2866         int mode = 0;           /* 0:unlock, 1:lock, 2:query*/\r
2867 \r
2868         dbg(" Function entry ");\r
2869 \r
2870         hal = tcore_object_get_hal(o);\r
2871         sp = tcore_sim_ref_userdata(o);\r
2872         pending = tcore_pending_new(o, 0);\r
2873         req_data = tcore_user_request_ref_data(ur, NULL);\r
2874 \r
2875         if (!o || !ur)\r
2876                 return TCORE_RETURN_EINVAL;\r
2877 \r
2878         if(req_data->type == SIM_FACILITY_PS)\r
2879         {\r
2880                 fac = "PS";                                                             /*PH-SIM, Lock PHone to SIM/UICC card*/\r
2881                 sp->current_sec_op = SEC_SIM_DISABLE;\r
2882         }else if(req_data->type == SIM_FACILITY_SC)\r
2883         {\r
2884                 fac = "SC";                                                             /*Lock SIM/UICC card, simply PIN1*/\r
2885                 sp->current_sec_op = SEC_PIN1_DISABLE;\r
2886         }else if(req_data->type == SIM_FACILITY_FD)\r
2887         {\r
2888                 fac = "FD";                                                             /*Fixed Dialing Number feature, need PIN2*/\r
2889                 sp->current_sec_op = SEC_FDN_DISABLE;\r
2890         }else if(req_data->type == SIM_FACILITY_PN)\r
2891         {\r
2892                 fac = "PN";                                                             /*Network Personalization*/\r
2893                 sp->current_sec_op = SEC_NET_DISABLE;\r
2894         }else if(req_data->type == SIM_FACILITY_PU)\r
2895         {\r
2896                 fac = "PU";                                                             /*network sUbset Personalization*/\r
2897                 sp->current_sec_op = SEC_NS_DISABLE;\r
2898         }else if(req_data->type == SIM_FACILITY_PP)\r
2899         {\r
2900                 fac = "PP";                                                             /*service Provider Personalization*/\r
2901                 sp->current_sec_op = SEC_SP_DISABLE;\r
2902         }else if(req_data->type == SIM_FACILITY_PC)\r
2903         {\r
2904                 fac = "PC";                                                             /*Corporate Personalization*/\r
2905                 sp->current_sec_op = SEC_CP_DISABLE;\r
2906         }else\r
2907         {\r
2908                 return TCORE_RETURN_EINVAL;\r
2909         }\r
2910         cmd_str = g_strdup_printf("AT+CLCK=\"%s\", %d, \"%s\"", fac, mode, req_data->password);\r
2911         req = tcore_at_request_new(cmd_str, "+CLCK:", TCORE_AT_SINGLELINE);\r
2912 \r
2913         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2914 \r
2915         tcore_pending_set_request_data(pending, 0, req);\r
2916         tcore_pending_set_response_callback(pending, on_response_disable_facility, hal);\r
2917         tcore_pending_link_user_request(pending, ur);\r
2918         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2919         tcore_hal_send_request(hal, pending);\r
2920 \r
2921         free(cmd_str);\r
2922         dbg(" Function exit");\r
2923         return TCORE_RETURN_SUCCESS;\r
2924 }\r
2925 \r
2926 static TReturn s_get_lock_info(CoreObject *o, UserRequest *ur)\r
2927 {\r
2928         TcoreHal* hal = NULL;\r
2929         TcoreATRequest *req = NULL;\r
2930         TcorePending *pending = NULL;\r
2931         char *cmd_str = NULL;\r
2932         char    *lock_type = NULL;\r
2933         const struct treq_sim_get_lock_info *req_data;\r
2934         struct s_sim_property *sp = NULL;\r
2935 \r
2936         dbg(" Function entry ");\r
2937 \r
2938         hal = tcore_object_get_hal(o);\r
2939         sp = tcore_sim_ref_userdata(o);\r
2940         pending = tcore_pending_new(o, 0);\r
2941         req_data = tcore_user_request_ref_data(ur, NULL);\r
2942 \r
2943         if (!o || !ur)\r
2944                 return TCORE_RETURN_EINVAL;\r
2945 \r
2946         switch (req_data->type)\r
2947         {\r
2948                 case SIM_FACILITY_PS:\r
2949                         lock_type = "PS";\r
2950                         break;\r
2951                 case SIM_FACILITY_SC:\r
2952                         lock_type = "SC";\r
2953                         break;\r
2954                 case SIM_FACILITY_FD:\r
2955                         lock_type = "FD";\r
2956                         break;\r
2957                 case SIM_FACILITY_PN:\r
2958                         lock_type = "PN";\r
2959                         break;\r
2960                 case SIM_FACILITY_PU:\r
2961                         lock_type = "PU";\r
2962                         break;\r
2963                 case SIM_FACILITY_PP:\r
2964                         lock_type = "PP";\r
2965                         break;\r
2966                 case SIM_FACILITY_PC:\r
2967                         lock_type = "PC";\r
2968                         break;\r
2969                 default:\r
2970                         break;\r
2971         }\r
2972         cmd_str = g_strdup_printf("AT+XPINCNT =\"%s\"", lock_type);\r
2973         req = tcore_at_request_new(cmd_str, "+XPINCNT:", TCORE_AT_SINGLELINE);\r
2974 \r
2975         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2976 \r
2977         tcore_pending_set_request_data(pending, 0, req);\r
2978         tcore_pending_set_response_callback(pending, on_response_get_lock_info, hal);\r
2979         tcore_pending_link_user_request(pending, ur);\r
2980         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
2981         tcore_hal_send_request(hal, pending);\r
2982 \r
2983         free(cmd_str);\r
2984         dbg(" Function exit");\r
2985         return TCORE_RETURN_SUCCESS;\r
2986 }\r
2987 \r
2988 static TReturn s_read_file(CoreObject *o, UserRequest *ur)\r
2989 {\r
2990         TReturn api_ret = TCORE_RETURN_SUCCESS;\r
2991         enum tcore_request_command command;\r
2992         command = tcore_user_request_get_command(ur);\r
2993 \r
2994         dbg(" Function entry ");\r
2995 \r
2996         if (!o || !ur)\r
2997                 return TCORE_RETURN_EINVAL;\r
2998 \r
2999         switch (command)\r
3000         {\r
3001                 case TREQ_SIM_GET_ECC:\r
3002                         api_ret = _get_file_info(o, ur, SIM_EF_ECC);\r
3003                         break;\r
3004                 case TREQ_SIM_GET_LANGUAGE:\r
3005                         if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
3006                                 api_ret = _get_file_info(o, ur, SIM_EF_ELP);\r
3007                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
3008                                 api_ret = _get_file_info(o, ur, SIM_EF_LP);\r
3009                         else\r
3010                                 api_ret = TCORE_RETURN_ENOSYS;\r
3011                         break;\r
3012                 case TREQ_SIM_GET_ICCID:\r
3013                         api_ret = _get_file_info(o, ur, SIM_EF_ICCID);\r
3014                         break;\r
3015                 case TREQ_SIM_GET_MAILBOX:\r
3016                         if(tcore_sim_get_cphs_status(o))\r
3017                                 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_MAILBOX_NUMBERS);\r
3018                         else\r
3019                                 api_ret = _get_file_info(o, ur, SIM_EF_MBDN);\r
3020                         break;\r
3021                 case TREQ_SIM_GET_CALLFORWARDING:\r
3022                         if(tcore_sim_get_cphs_status(o))\r
3023                                 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CALL_FORWARD_FLAGS);\r
3024                         else\r
3025                                 api_ret = _get_file_info(o, ur, SIM_EF_USIM_CFIS);\r
3026                         break;\r
3027                 case TREQ_SIM_GET_MESSAGEWAITING:\r
3028                         if(tcore_sim_get_cphs_status(o))\r
3029                                 api_ret = _get_file_info(o, ur, SIM_EF_CPHS_VOICE_MSG_WAITING);\r
3030                         else\r
3031                                 api_ret = _get_file_info(o, ur, SIM_EF_USIM_MWIS);\r
3032                         break;\r
3033                 case TREQ_SIM_GET_CPHS_INFO:\r
3034                         api_ret = _get_file_info(o, ur, SIM_EF_CPHS_CPHS_INFO);\r
3035                         break;\r
3036                 case TREQ_SIM_GET_MSISDN:\r
3037                         api_ret = _get_file_info(o, ur, SIM_EF_MSISDN);\r
3038                         break;\r
3039                 case TREQ_SIM_GET_SPN:\r
3040                         dbg("enter case SPN");\r
3041                         api_ret = _get_file_info(o, ur, SIM_EF_SPN);\r
3042                         break;\r
3043                 case TREQ_SIM_GET_SPDI:\r
3044                         api_ret = _get_file_info(o, ur, SIM_EF_SPDI);\r
3045                         break;\r
3046                 case TREQ_SIM_GET_OPL:\r
3047                         api_ret = _get_file_info(o, ur, SIM_EF_OPL);\r
3048                         break;\r
3049                 case TREQ_SIM_GET_PNN:\r
3050                         api_ret = _get_file_info(o, ur, SIM_EF_PNN);\r
3051                         break;\r
3052                 case TREQ_SIM_GET_CPHS_NETNAME:\r
3053                         api_ret = _get_file_info(o, ur, SIM_EF_CPHS_OPERATOR_NAME_STRING);\r
3054                         break;\r
3055                 case TREQ_SIM_GET_OPLMNWACT:\r
3056                         api_ret = _get_file_info(o, ur, SIM_EF_OPLMN_ACT);\r
3057                         break;\r
3058                 default:\r
3059                         dbg("error - not handled read treq command[%d]", command);\r
3060                         api_ret = TCORE_RETURN_EINVAL;\r
3061                         break;\r
3062         }\r
3063         dbg(" Function exit");\r
3064         return api_ret;\r
3065 }\r
3066 \r
3067 static TReturn s_update_file(CoreObject *o, UserRequest *ur)\r
3068 {\r
3069         TcoreHal* hal;\r
3070         TcoreATRequest *req;\r
3071         TcorePending *pending = NULL;\r
3072         char *cmd_str = NULL;\r
3073         TReturn api_ret = TCORE_RETURN_SUCCESS;\r
3074         char *encoded_data = NULL;\r
3075         int encoded_len = 0;\r
3076         enum tcore_request_command command;\r
3077         enum tel_sim_file_id ef = SIM_EF_INVALID;\r
3078         const struct treq_sim_set_callforwarding *cf;\r
3079         const struct treq_sim_set_language *cl;\r
3080         int p1 = 0;\r
3081         int p2 = 0;\r
3082         int p3 = 0;\r
3083         int cmd = 0;\r
3084         int out_length = 0;
3085         struct tel_sim_language sim_language;\r
3086 \r
3087         command = tcore_user_request_get_command(ur);\r
3088 \r
3089         dbg(" Function entry ");\r
3090 \r
3091         hal = tcore_object_get_hal(o);\r
3092         pending = tcore_pending_new(o, 0);\r
3093 \r
3094         if (!o || !ur)\r
3095         {
3096                 return TCORE_RETURN_EINVAL;\r
3097         }
3098 \r
3099         switch (command)
3100         {
3101                 case TREQ_SIM_SET_LANGUAGE:\r
3102                         cl = tcore_user_request_ref_data(ur, NULL);\r
3103                         memset(&sim_language, 0x00, sizeof(struct tel_sim_language));\r
3104                         cmd = 214;\r
3105
3106                         sim_language.language_count = 1;\r
3107                         sim_language.language[0] = cl->language;\r
3108                         dbg("language %d", cl->language);
3109
3110                         if (tcore_sim_get_type(o) == SIM_TYPE_GSM)\r
3111                         {\r
3112                                 int i;
3113                                 dbg("2G");\r
3114                                 ef = SIM_EF_ELP;\r
3115                                 encoded_data = tcore_sim_encode_li(&out_length, &sim_language);
3116                                 p1 = 0;
3117                                 p2 = 0;
3118                                 p3 = out_length;
3119                                 for(i=0; i<out_length; i++)
3120                                 {
3121                                         dbg("encoded_data - %d ---", encoded_data[i]);
3122                                 }
3123                                 dbg("encoded_data - %s ---", encoded_data);
3124                                 dbg("out_length - %d ---", out_length);
3125                         }\r
3126                         else if (tcore_sim_get_type(o) == SIM_TYPE_USIM)\r
3127                         {\r
3128                                 int i;
3129                                 dbg("3G");\r
3130                                 ef = SIM_EF_LP;\r
3131                                 encoded_data = tcore_sim_encode_li(&out_length, &sim_language);
3132                                 p1 = 0;
3133                                 p2 = 0;
3134                                 p3 = out_length;
3135                                 for(i=0; i<out_length; i++)
3136                                 {
3137                                         dbg("encoded_data - %d ---", encoded_data[i]);
3138                                 }
3139                                 dbg("out_length - %d ---", out_length);
3140                         }\r
3141                         else\r
3142                         {\r
3143                                 api_ret = TCORE_RETURN_ENOSYS;\r
3144                         }\r
3145                         break;\r
3146 \r
3147                 case TREQ_SIM_SET_CALLFORWARDING:\r
3148                         cf = tcore_user_request_ref_data(ur, NULL);\r
3149                         if(tcore_sim_get_cphs_status(o))\r
3150                         {\r
3151                                 encoded_data = tcore_sim_encode_cff((const struct tel_sim_callforwarding*)cf);\r
3152                                 ef = SIM_EF_CPHS_CALL_FORWARD_FLAGS;\r
3153                                 p1 = 0;\r
3154                                 p2 = 0;\r
3155                                 p3 = strlen(encoded_data);\r
3156                                 cmd = 214;                              /*command - 214 : UPDATE BINARY*/\r
3157                         } else\r
3158                         {\r
3159                                 encoded_data = tcore_sim_encode_cfis(&encoded_len, (const struct tel_sim_callforwarding*)cf);\r
3160                                 ef = SIM_EF_USIM_CFIS;\r
3161                                 p1 = 1;\r
3162                                 p2 = 0x04;\r
3163                                 p3 = encoded_len;\r
3164                                 cmd = 220;                              /*command - 220 : UPDATE RECORD*/\r
3165                         }\r
3166                         break;\r
3167 \r
3168                 default:\r
3169                         dbg("error - not handled update treq command[%d]", command);\r
3170                         api_ret = TCORE_RETURN_EINVAL;\r
3171                         break;\r
3172         }\r
3173         cmd_str = g_strdup_printf("AT+CRSM=%d,%d,%d,%d,%d,\"%s\"", cmd,ef,p1,p2,p3, encoded_data);\r
3174         req = tcore_at_request_new(cmd_str, "+CRSM:", TCORE_AT_SINGLELINE);\r
3175 \r
3176         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
3177 \r
3178         tcore_pending_set_request_data(pending, 0, req);\r
3179         tcore_pending_set_response_callback(pending, on_response_update_file, hal);\r
3180         tcore_pending_link_user_request(pending, ur);\r
3181         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
3182 \r
3183         tcore_hal_send_request(hal, pending);\r
3184         if(NULL != encoded_data){\r
3185                 g_free(encoded_data);\r
3186         }\r
3187         free(cmd_str);\r
3188         dbg(" Function exit");\r
3189         return TCORE_RETURN_SUCCESS;\r
3190 }\r
3191 \r
3192 static TReturn s_transmit_apdu(CoreObject *o, UserRequest *ur)\r
3193 {\r
3194         TcoreHal* hal= NULL;\r
3195         TcoreATRequest *req= NULL;\r
3196         TcorePending *pending = NULL;\r
3197         char *cmd_str = NULL;\r
3198         const struct treq_sim_transmit_apdu *req_data;\r
3199         dbg(" Function entry ");\r
3200 \r
3201         hal = tcore_object_get_hal(o);\r
3202         pending = tcore_pending_new(o, 0);\r
3203         req_data = tcore_user_request_ref_data(ur, NULL);\r
3204 \r
3205         if (!o || !ur)\r
3206                 return TCORE_RETURN_EINVAL;\r
3207 \r
3208         cmd_str = g_strdup_printf("AT+CSIM=%d,\"%s\"", req_data->apdu_length, req_data->apdu);\r
3209 \r
3210         req = tcore_at_request_new(cmd_str, "+CSIM:", TCORE_AT_SINGLELINE);\r
3211 \r
3212         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
3213 \r
3214         tcore_pending_set_request_data(pending, 0, req);\r
3215         tcore_pending_set_response_callback(pending, on_response_transmit_apdu, hal);\r
3216         tcore_pending_link_user_request(pending, ur);\r
3217         tcore_pending_set_send_callback(pending, on_confirmation_sim_message_send, NULL);\r
3218         tcore_hal_send_request(hal, pending);\r
3219 \r
3220         free(cmd_str);\r
3221         dbg(" Function exit");\r
3222         return TCORE_RETURN_SUCCESS;\r
3223 }\r
3224 \r
3225 static struct tcore_sim_operations sim_ops =\r
3226 {\r
3227                 .verify_pins = s_verify_pins,\r
3228                 .verify_puks = s_verify_puks,\r
3229                 .change_pins = s_change_pins,\r
3230                 .get_facility_status = s_get_facility_status,\r
3231                 .enable_facility = s_enable_facility,\r
3232                 .disable_facility = s_disable_facility,\r
3233                 .get_lock_info = s_get_lock_info,\r
3234                 .read_file = s_read_file,\r
3235                 .update_file = s_update_file,\r
3236                 .transmit_apdu = s_transmit_apdu,\r
3237                 /*ToDo - Need to be implemented in Phase-2*/\r
3238                 /*.get_atr = s_get_atr,\r
3239                 .req_authentication = s_req_authentication*/\r
3240 };\r
3241 \r
3242 gboolean s_sim_init(TcorePlugin *p, TcoreHal *h)\r
3243 {\r
3244         CoreObject *o;\r
3245         struct s_sim_property *file_meta = NULL;\r
3246         GQueue *work_queue;\r
3247 \r
3248         dbg("entry");\r
3249 \r
3250         o = tcore_sim_new(p, "sim", &sim_ops, h);\r
3251 \r
3252         if (!o)\r
3253                 return FALSE;\r
3254 \r
3255         file_meta = calloc(sizeof(struct s_sim_property),1);\r
3256         if (!file_meta)\r
3257                 return FALSE;\r
3258 \r
3259         work_queue = g_queue_new();\r
3260         tcore_object_link_user_data(o, work_queue);\r
3261 \r
3262         file_meta->first_recv_status = SIM_STATUS_UNKNOWN;\r
3263         tcore_sim_link_userdata(o, file_meta);\r
3264         \r
3265         tcore_object_add_callback(o, "+XLOCK", on_event_facility_lock_status, NULL);\r
3266         tcore_object_add_callback(o, "+XSIM", on_event_pin_status, NULL);\r
3267 \r
3268         dbg("exit");\r
3269         return TRUE;\r
3270 }\r
3271 \r
3272 void s_sim_exit(TcorePlugin *p)\r
3273 {\r
3274         CoreObject *o;\r
3275 \r
3276         o = tcore_plugin_ref_core_object(p, "sim");\r
3277         if (!o)\r
3278                 return;\r
3279         tcore_sim_free(o);\r
3280 }