src/tapi_proxy_sim.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include <vconf.h>
  26
  27 #include "tel_cs_conn.h"
  28 #include "tapi_proxy.h"
  29 #include "TelDefines.h"
  30 #include "TelUtility.h"
  31 #include "TelSim.h"
  32 #include "TapiUtility.h"
  33
  34 extern tapi_dbus_connection_name conn_name;
  35
  36 static int _tel_check_tapi_state()
  37 {
  38         int vconf_ret = 0;
  39         int tapi_state = 0;
  40
  41         vconf_ret = vconf_get_int(VCONFKEY_TELEPHONY_TAPI_STATE, (int*) &tapi_state);
  42
  43         if (vconf_ret != 0 || tapi_state !=1) {
  44                 TAPI_LIB_DEBUG(LEVEL_ALERT,"FAIL TO GET VCONFKEY_TELEPHONY_TAPI_STATE or SERVICE NOT READY");
  45                 return TAPI_API_SERVICE_NOT_READY;
  46         }
  47         return 0;
  48 }
  49
  50 EXPORT_API int tel_get_sim_init_info(TelSimCardStatus_t *sim_status, int *card_changed)
  51 {
  52         TS_BOOL ret = FALSE;
  53         int api_err = TAPI_API_SUCCESS;
  54         int vconf_ret = 0;
  55         TelSimCardStatus_t CardStatus = 0;
  56
  57         TAPI_RETURN_VAL_IF_FAIL(sim_status, TAPI_API_INVALID_PTR);
  58
  59         if(_tel_check_tapi_state() != 0 )
  60                 return TAPI_API_SERVICE_NOT_READY;
  61
  62         /* for reducing dbus connection request on boot time - start */
  63         vconf_ret = vconf_get_int(VCONFKEY_TELEPHONY_SIM_CHV, (int*) &CardStatus);
  64
  65         if (vconf_ret != 0) {
  66                 TAPI_LIB_DEBUG(LEVEL_ALERT,"FAIL TO GET VCONFKEY_TELEPHONY_SIM_CHV ");
  67                 return TAPI_API_SERVICE_NOT_READY;
  68         }
  69
  70         TAPI_LIB_DEBUG(LEVEL_ALERT,"VCONFKEY_TELEPHONY_SIM_CHV api ret[%d], return value[%d] ",vconf_ret,CardStatus);
  71
  72         if (CardStatus != TAPI_SIM_STATUS_SIM_INIT_COMPLETED) {
  73                 *sim_status = CardStatus;
  74                 if (card_changed != NULL)
  75                         *card_changed = 0;
  76
  77                 return api_err;
  78         }
  79         /* for reducing dbus connection request on boot time - end */
  80         TAPI_GLIB_INIT_PARAMS();
  81
  82         if (FALSE == tapi_check_dbus_status()) {
  83                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
  84         }
  85
  86         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
  87
  88         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETSIMINITINFO, in_param1, in_param2, in_param3,
  89                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
  90
  91         if (TRUE == ret) {
  92                 api_err = g_array_index(out_param1, int ,0);
  93                 if(api_err == TAPI_API_SUCCESS) {
  94                         *sim_status = g_array_index(out_param2, TelSimCardStatus_t ,0);
  95                         if (card_changed != NULL)
  96                                 *card_changed = g_array_index(out_param3, int ,0);
  97                 }
  98         } else {
  99                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 100         }
 101
 102         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 103
 104         return api_err;
 105 }
 106
 107 EXPORT_API int tel_verifiy_sim_pins(const TelSimSecPw_t *pin_data, int *req_id)
 108 {
 109         TS_BOOL ret = FALSE;
 110         int api_err = TAPI_API_SUCCESS;
 111
 112         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
 113         TAPI_RETURN_VAL_IF_FAIL(pin_data , TAPI_API_INVALID_PTR);
 114         TAPI_RETURN_VAL_IF_FAIL(pin_data->pw , TAPI_API_INVALID_PTR);
 115
 116         if(_tel_check_tapi_state() != 0 )
 117                 return TAPI_API_SERVICE_NOT_READY;
 118
 119         if (conn_name.length_of_name == 0) {
 120                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 121                 return TAPI_API_OPERATION_FAILED;
 122         }
 123
 124         TAPI_GLIB_INIT_PARAMS();
 125
 126         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Type [%d]", pin_data->type);
 127
 128         if (pin_data->type != TAPI_SIM_PTYPE_PIN1 && pin_data->type != TAPI_SIM_PTYPE_PIN2 && pin_data->type
 129                         != TAPI_SIM_PTYPE_SIM) {
 130                 return TAPI_API_INVALID_INPUT;
 131         }
 132
 133         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Code [%s]", pin_data->pw);
 134         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Code length[%d]", pin_data->pw_len);
 135
 136         if (((pin_data->type == TAPI_SIM_PTYPE_PIN1) || (pin_data->type == TAPI_SIM_PTYPE_PIN2) || (pin_data->type
 137                         == TAPI_SIM_PTYPE_SIM)) && ((pin_data->pw_len < 4) || (pin_data->pw_len > 8))) {
 138                 return TAPI_API_INVALID_INPUT;
 139         }
 140
 141         if (FALSE == tapi_check_dbus_status()) {
 142                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 143         }
 144
 145         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 146
 147         g_array_append_vals(in_param1, pin_data, sizeof(TelSimSecPw_t));
 148         g_array_append_vals(in_param2, pin_data->pw, pin_data->pw_len);
 149         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 150
 151         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_VERIFYSEC, in_param1, in_param2, in_param3, in_param4,
 152                         &out_param1, &out_param2, &out_param3, &out_param4);
 153
 154         if (TRUE == ret) {
 155                 api_err = g_array_index(out_param1, int ,0);
 156
 157                 if(api_err == TAPI_API_SUCCESS )
 158                         *req_id = g_array_index(out_param2, int ,0);
 159                 else
 160                         *req_id = INVALID_REQUEST_ID;
 161         } else {
 162                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 163         }
 164
 165         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 166
 167         return api_err;
 168 }
 169
 170 EXPORT_API int tel_verify_sim_puks(const TelSimSecPw_t *puk_data, const TelSimSecPw_t *new_pin_data, int *req_id)
 171 {
 172         TS_BOOL ret = FALSE;
 173         int api_err = TAPI_API_SUCCESS;
 174
 175         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
 176         TAPI_RETURN_VAL_IF_FAIL((puk_data != NULL && new_pin_data != NULL), TAPI_API_INVALID_PTR);
 177         TAPI_RETURN_VAL_IF_FAIL((puk_data->pw != NULL && new_pin_data->pw != NULL), TAPI_API_INVALID_PTR);
 178
 179         if(_tel_check_tapi_state() != 0 )
 180                 return TAPI_API_SERVICE_NOT_READY;
 181
 182         if (conn_name.length_of_name == 0) {
 183                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 184                 return TAPI_API_OPERATION_FAILED;
 185         }
 186
 187         TAPI_GLIB_INIT_PARAMS();
 188
 189         TAPI_LIB_DEBUG(LEVEL_ALERT, "Unblock PIN Type [%d]", puk_data->type);
 190         TAPI_LIB_DEBUG(LEVEL_ALERT, "New PIN Type [%d]", new_pin_data->type);
 191
 192         if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 && puk_data->type != TAPI_SIM_PTYPE_PUK2) || (new_pin_data->type
 193                         != TAPI_SIM_PTYPE_PIN1 && new_pin_data->type != TAPI_SIM_PTYPE_PIN2)) {
 194                 return TAPI_API_INVALID_INPUT;
 195         }
 196
 197         if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 || new_pin_data->type != TAPI_SIM_PTYPE_PIN1) && (puk_data->type
 198                         != TAPI_SIM_PTYPE_PUK2 || new_pin_data->type != TAPI_SIM_PTYPE_PIN2)) {
 199                 return TAPI_API_INVALID_INPUT;
 200         }
 201
 202         //pin and puk code length validation check
 203         if ((puk_data->pw_len < 4) || (puk_data->pw_len > 8) || (new_pin_data->pw_len < 4) || (new_pin_data->pw_len > 8)) {
 204                 return TAPI_API_INVALID_INPUT;
 205         }
 206
 207         TAPI_LIB_DEBUG(LEVEL_ALERT, "Unblock PIN Code [%s]", puk_data->pw);
 208         TAPI_LIB_DEBUG(LEVEL_ALERT, "New PIN Code [%s]", new_pin_data->pw);
 209
 210         if (FALSE == tapi_check_dbus_status()) {
 211                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 212         }
 213
 214         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 215
 216         g_array_append_vals(in_param1, puk_data, sizeof(TelSimSecPw_t));
 217         g_array_append_vals(in_param1, new_pin_data, sizeof(TelSimSecPw_t));
 218         g_array_append_vals(in_param2, puk_data->pw, puk_data->pw_len);
 219         g_array_append_vals(in_param3, new_pin_data->pw, new_pin_data->pw_len);
 220         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 221
 222         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_VERIFYPUK, in_param1, in_param2, in_param3, in_param4,
 223                         &out_param1, &out_param2, &out_param3, &out_param4);
 224
 225         if (TRUE == ret) {
 226                 api_err = g_array_index(out_param1, int ,0);
 227                 if(api_err == TAPI_API_SUCCESS )
 228                         *req_id = g_array_index(out_param2, int ,0);
 229                 else
 230                         *req_id = INVALID_REQUEST_ID;
 231         } else {
 232                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 233         }
 234
 235         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 236
 237         return api_err;
 238 }
 239
 240 EXPORT_API int tel_change_sim_pins(const TelSimSecPw_t *old_pin, const TelSimSecPw_t *new_pin, int *req_id)
 241 {
 242         TS_BOOL ret = FALSE;
 243         int api_err = TAPI_API_SUCCESS;
 244
 245         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
 246         TAPI_RETURN_VAL_IF_FAIL((old_pin != NULL && new_pin != NULL) , TAPI_API_INVALID_PTR);
 247         TAPI_RETURN_VAL_IF_FAIL((old_pin->pw != NULL && new_pin->pw != NULL) , TAPI_API_INVALID_PTR);
 248
 249         if(_tel_check_tapi_state() != 0 )
 250                 return TAPI_API_SERVICE_NOT_READY;
 251
 252         if (conn_name.length_of_name == 0) {
 253                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 254                 return TAPI_API_OPERATION_FAILED;
 255         }
 256
 257         TAPI_GLIB_INIT_PARAMS();
 258
 259         TAPI_LIB_DEBUG(LEVEL_ALERT, "old_pin->type[%d], new_pin->type[%d]",old_pin->type, new_pin->type);
 260
 261         if ((old_pin->type != TAPI_SIM_PTYPE_PIN1) && (old_pin->type != TAPI_SIM_PTYPE_PIN2) && (new_pin->type
 262                         != TAPI_SIM_PTYPE_PIN1) && (new_pin->type != TAPI_SIM_PTYPE_PIN2)) {
 263                 return TAPI_API_INVALID_INPUT;
 264         }
 265
 266         if (old_pin->type != new_pin->type) {
 267                 return TAPI_API_INVALID_INPUT;
 268         }
 269
 270         //Old Pin code length check
 271         if ((old_pin->pw_len < 4) || (old_pin->pw_len > 8)) {
 272                 return TAPI_API_INVALID_INPUT;
 273         }
 274
 275         //New Pin code length check
 276         if ((new_pin->pw_len < 4) || (new_pin->pw_len > 8)) {
 277                 return TAPI_API_INVALID_INPUT;
 278         }
 279
 280         TAPI_LIB_DEBUG(LEVEL_ALERT, "Old PIN Code [%s]", old_pin->pw);
 281         TAPI_LIB_DEBUG(LEVEL_ALERT, "New PIN Code [%s]", new_pin->pw);
 282
 283         if (FALSE == tapi_check_dbus_status()) {
 284                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 285         }
 286
 287         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 288
 289         g_array_append_vals(in_param1, old_pin, sizeof(TelSimSecPw_t));
 290         g_array_append_vals(in_param1, new_pin, sizeof(TelSimSecPw_t));
 291         g_array_append_vals(in_param2, old_pin->pw, sizeof(unsigned char) * (old_pin->pw_len));
 292         g_array_append_vals(in_param3, new_pin->pw, sizeof(unsigned char) * new_pin->pw_len);
 293         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 294
 295         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_CHANGEPIN, in_param1, in_param2, in_param3, in_param4,
 296                         &out_param1, &out_param2, &out_param3, &out_param4);
 297
 298         if (TRUE == ret) {
 299                 api_err = g_array_index(out_param1, int ,0);
 300                 if(api_err == TAPI_API_SUCCESS )
 301                         *req_id = g_array_index(out_param2, int ,0);
 302                 else
 303                         *req_id = INVALID_REQUEST_ID;
 304         } else {
 305                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 306         }
 307
 308         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 309
 310         return api_err;
 311 }
 312
 313 EXPORT_API int tel_get_sim_security_status(TelSimPinType_t type, TelSimPinStatus_t *status)
 314 {
 315         TS_BOOL ret = FALSE;
 316         int api_err = TAPI_API_SUCCESS;
 317
 318         TAPI_RETURN_VAL_IF_FAIL(status, TAPI_API_INVALID_PTR);
 319
 320         if(_tel_check_tapi_state() != 0 )
 321                 return TAPI_API_SERVICE_NOT_READY;
 322
 323         TAPI_GLIB_INIT_PARAMS();
 324
 325         if (FALSE == tapi_check_dbus_status()) {
 326                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 327         }
 328
 329         if ((type != TAPI_SIM_PTYPE_PIN1) && (type != TAPI_SIM_PTYPE_PIN2) && (type != TAPI_SIM_PTYPE_SIM)) {
 330                 return TAPI_API_INVALID_INPUT;
 331         }
 332
 333         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 334
 335         g_array_append_vals(in_param1, &type, sizeof(TelSimPinType_t));
 336
 337         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETSECSTATUS, in_param1, in_param2, in_param3, in_param4,
 338                         &out_param1, &out_param2, &out_param3, &out_param4);
 339
 340         if (TRUE == ret) {
 341                 api_err = g_array_index(out_param1, int ,0);
 342                 if(api_err == TAPI_API_SUCCESS ) {
 343                         *status = g_array_index(out_param2,TelSimPinStatus_t ,0);
 344                         TAPI_LIB_DEBUG(LEVEL_ALERT, "api_err[%d],PIN type[%d], Status[%d]",api_err, type,*status);
 345                 }
 346         } else {
 347                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 348         }
 349
 350         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 351
 352         return api_err;
 353 }
 354
 355 EXPORT_API int tel_disable_sim_security(TelSimSecPw_t *sec_data, int *req_id)
 356 {
 357         TS_BOOL ret = FALSE;
 358         int api_err = TAPI_API_SUCCESS;
 359
 360         TAPI_RETURN_VAL_IF_FAIL((sec_data != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
 361         TAPI_RETURN_VAL_IF_FAIL(sec_data->pw, TAPI_API_INVALID_PTR);
 362
 363         if(_tel_check_tapi_state() != 0 )
 364                 return TAPI_API_SERVICE_NOT_READY;
 365
 366         if (conn_name.length_of_name == 0) {
 367                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 368                 return TAPI_API_OPERATION_FAILED;
 369         }
 370
 371         TAPI_GLIB_INIT_PARAMS();
 372
 373         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Type [%d]", sec_data->type);
 374
 375         if ((sec_data->type != TAPI_SIM_PTYPE_PIN1) && (sec_data->type != TAPI_SIM_PTYPE_SIM)) {
 376                 return TAPI_API_INVALID_INPUT;
 377         }
 378
 379         if ((sec_data->pw_len < 4) || (sec_data->pw_len > 8)) {
 380                 return TAPI_API_INVALID_INPUT;
 381         }
 382
 383         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Code [%s]", sec_data->pw);
 384
 385         if (FALSE == tapi_check_dbus_status()) {
 386                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 387         }
 388
 389         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 390
 391         g_array_append_vals(in_param1, sec_data, sizeof(TelSimSecPw_t));
 392         g_array_append_vals(in_param2, sec_data->pw, sec_data->pw_len);
 393         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 394
 395         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_DISABLESEC, in_param1, in_param2, in_param3, in_param4,
 396                         &out_param1, &out_param2, &out_param3, &out_param4);
 397
 398         if (TRUE == ret) {
 399                 api_err = g_array_index(out_param1, int ,0);
 400                 if(api_err == TAPI_API_SUCCESS )
 401                         *req_id = g_array_index(out_param2, int ,0);
 402                 else
 403                         *req_id = INVALID_REQUEST_ID;
 404         } else {
 405                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 406         }
 407
 408         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 409
 410         return api_err;
 411 }
 412
 413 EXPORT_API int tel_enable_sim_security(TelSimSecPw_t *sec_data, int *req_id)
 414 {
 415         TS_BOOL ret = FALSE;
 416         int api_err = TAPI_API_SUCCESS;
 417
 418         TAPI_RETURN_VAL_IF_FAIL((sec_data != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
 419         TAPI_RETURN_VAL_IF_FAIL(sec_data->pw , TAPI_API_INVALID_PTR);
 420
 421         if(_tel_check_tapi_state() != 0 )
 422                 return TAPI_API_SERVICE_NOT_READY;
 423
 424         if (conn_name.length_of_name == 0) {
 425                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 426                 return TAPI_API_OPERATION_FAILED;
 427         }
 428
 429         TAPI_GLIB_INIT_PARAMS();
 430
 431         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Type [%d]", sec_data->type);
 432
 433         if ((sec_data->type != TAPI_SIM_PTYPE_PIN1) && (sec_data->type != TAPI_SIM_PTYPE_SIM)) {
 434                 return TAPI_API_INVALID_INPUT;
 435         }
 436
 437         if ((sec_data->pw_len < 4) || (sec_data->pw_len > 8)) {
 438                 return TAPI_API_INVALID_INPUT;
 439         }
 440
 441         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Code [%s]", sec_data->pw);
 442
 443         if (FALSE == tapi_check_dbus_status()) {
 444                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 445         }
 446
 447         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 448
 449         g_array_append_vals(in_param1, sec_data, sizeof(TelSimSecPw_t));
 450         g_array_append_vals(in_param2, sec_data->pw, sec_data->pw_len);
 451         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 452
 453         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_ENABLESEC, in_param1, in_param2, in_param3, in_param4,
 454                         &out_param1, &out_param2, &out_param3, &out_param4);
 455
 456         if (TRUE == ret) {
 457                 api_err = g_array_index(out_param1, int ,0);
 458                 if(api_err == TAPI_API_SUCCESS )
 459                         *req_id = g_array_index(out_param2, int ,0);
 460                 else
 461                         *req_id = INVALID_REQUEST_ID;
 462         } else {
 463                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 464         }
 465
 466         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 467
 468         return api_err;
 469 }
 470
 471 EXPORT_API int tel_get_sim_personalization_status(TelSimPersType_t type, int *req_id)
 472 {
 473         TS_BOOL ret = FALSE;
 474         int api_err = TAPI_API_SUCCESS;
 475
 476         if(_tel_check_tapi_state() != 0 )
 477                 return TAPI_API_SERVICE_NOT_READY;
 478
 479         TAPI_GLIB_INIT_PARAMS();
 480
 481         if (conn_name.length_of_name == 0) {
 482                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 483                 return TAPI_API_OPERATION_FAILED;
 484         }
 485
 486         if (FALSE == tapi_check_dbus_status()) {
 487                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 488         }
 489
 490         if ((type != TAPI_SIM_PERS_NET) && (type != TAPI_SIM_PERS_NS) && (type != TAPI_SIM_PERS_SP) && (type
 491                         != TAPI_SIM_PERS_CP)) {
 492                 return TAPI_API_INVALID_INPUT;
 493         }
 494
 495         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 496
 497         g_array_append_vals(in_param1, &type, sizeof(TelSimPersType_t));
 498         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 499
 500         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETPERSSTATUS, in_param1, in_param2, in_param3, in_param4,
 501                         &out_param1, &out_param2, &out_param3, &out_param4);
 502
 503         if (TRUE == ret) {
 504                 api_err = g_array_index(out_param1, int ,0);
 505                 if(api_err == TAPI_API_SUCCESS )
 506                         *req_id = g_array_index(out_param2, int ,0);
 507                 else
 508                         *req_id = INVALID_REQUEST_ID;
 509         } else {
 510                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 511         }
 512
 513         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 514
 515         return api_err;
 516 }
 517
 518 EXPORT_API int tel_disable_sim_personalization(TelSimPersPw_t *pers_data, int *req_id)
 519 {
 520         TS_BOOL ret = FALSE;
 521         int api_err = TAPI_API_SUCCESS;
 522
 523         TAPI_RETURN_VAL_IF_FAIL(pers_data, TAPI_API_INVALID_PTR);
 524         TAPI_RETURN_VAL_IF_FAIL(pers_data->pw, TAPI_API_INVALID_PTR);
 525
 526         if(_tel_check_tapi_state() != 0 )
 527                 return TAPI_API_SERVICE_NOT_READY;
 528
 529         if (conn_name.length_of_name == 0) {
 530                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 531                 return TAPI_API_OPERATION_FAILED;
 532         }
 533
 534         TAPI_GLIB_INIT_PARAMS();
 535
 536         TAPI_LIB_DEBUG(LEVEL_ALERT, "PIN Type [%d]", pers_data->type);
 537
 538         if ((pers_data->type != TAPI_SIM_PERS_NET) && (pers_data->type != TAPI_SIM_PERS_NS) && (pers_data->type
 539                         != TAPI_SIM_PERS_SP) && (pers_data->type != TAPI_SIM_PERS_CP)) {
 540                 return TAPI_API_INVALID_INPUT;
 541         }
 542
 543         //personalization code length check - need to fix
 544         if ((pers_data->pw_len < 6)) {
 545                 return TAPI_API_INVALID_INPUT;
 546         }
 547
 548         TAPI_LIB_DEBUG(LEVEL_ALERT, "Personalization Password[%s]", pers_data->pw);
 549
 550         if (FALSE == tapi_check_dbus_status()) {
 551                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 552         }
 553
 554         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 555
 556         g_array_append_vals(in_param1, pers_data, sizeof(TelSimPersPw_t));
 557         g_array_append_vals(in_param2, pers_data->pw, pers_data->pw_len);
 558         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 559
 560         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_DISABLEPERS, in_param1, in_param2, in_param3, in_param4,
 561                         &out_param1, &out_param2, &out_param3, &out_param4);
 562
 563         if (TRUE == ret) {
 564                 api_err = g_array_index(out_param1, int ,0);
 565                 if(api_err == TAPI_API_SUCCESS )
 566                         *req_id = g_array_index(out_param2, int ,0);
 567                 else
 568                         *req_id = INVALID_REQUEST_ID;
 569         } else {
 570                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 571         }
 572
 573         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 574
 575         return api_err;
 576 }
 577
 578 EXPORT_API int tel_enable_sim_personalization(TelSimPersPw_t *pers_data, int *req_id)
 579 {
 580         TS_BOOL ret = FALSE;
 581         int api_err = TAPI_API_SUCCESS;
 582
 583         TAPI_RETURN_VAL_IF_FAIL(pers_data, TAPI_API_INVALID_PTR);
 584         TAPI_RETURN_VAL_IF_FAIL(pers_data->pw , TAPI_API_INVALID_PTR);
 585
 586         if(_tel_check_tapi_state() != 0 )
 587                 return TAPI_API_SERVICE_NOT_READY;
 588
 589         if (conn_name.length_of_name == 0) {
 590                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 591                 return TAPI_API_OPERATION_FAILED;
 592         }
 593
 594         TAPI_GLIB_INIT_PARAMS();
 595
 596         TAPI_LIB_DEBUG(LEVEL_ALERT, "personalization type[%d]", pers_data->type);
 597
 598         if ((pers_data->type != TAPI_SIM_PERS_NET) && (pers_data->type != TAPI_SIM_PERS_NS) && (pers_data->type
 599                         != TAPI_SIM_PERS_SP) && (pers_data->type != TAPI_SIM_PERS_CP)) {
 600                 return TAPI_API_INVALID_INPUT;
 601         }
 602
 603         //personalization password length check - need to fix
 604         if ((pers_data->pw_len < 6)) {
 605                 return TAPI_API_INVALID_INPUT;
 606         }
 607
 608         TAPI_LIB_DEBUG(LEVEL_ALERT, "personalization password[%s]", pers_data->pw);
 609
 610         if (FALSE == tapi_check_dbus_status()) {
 611                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 612         }
 613
 614         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 615
 616         g_array_append_vals(in_param1, pers_data, sizeof(TelSimPersPw_t));
 617         g_array_append_vals(in_param2, pers_data->pw, pers_data->pw_len);
 618         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 619
 620         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_ENABLEPERS, in_param1, in_param2, in_param3, in_param4,
 621                         &out_param1, &out_param2, &out_param3, &out_param4);
 622
 623         if (TRUE == ret) {
 624                 api_err = g_array_index(out_param1, int ,0);
 625                 if(api_err == TAPI_API_SUCCESS )
 626                         *req_id = g_array_index(out_param2, int ,0);
 627                 else
 628                         *req_id = INVALID_REQUEST_ID;
 629         } else {
 630                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 631         }
 632
 633         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 634
 635         return api_err;
 636 }
 637
 638 EXPORT_API int tel_get_sim_fdn_status(int *fdn_status)
 639 {
 640         TS_BOOL ret = FALSE;
 641         int api_err = TAPI_API_SUCCESS;
 642
 643         TAPI_RETURN_VAL_IF_FAIL(fdn_status , TAPI_API_INVALID_PTR);
 644
 645         if(_tel_check_tapi_state() != 0 )
 646                 return TAPI_API_SERVICE_NOT_READY;
 647
 648         TAPI_GLIB_INIT_PARAMS();
 649
 650         if (FALSE == tapi_check_dbus_status()) {
 651                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 652         }
 653
 654         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 655
 656         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETFDNSTATUS, in_param1, in_param2, in_param3, in_param4,
 657                         &out_param1, &out_param2, &out_param3, &out_param4);
 658
 659         if (TRUE == ret) {
 660                 api_err = g_array_index(out_param1, int ,0);
 661                 if(api_err == TAPI_API_SUCCESS) {
 662                         *fdn_status = g_array_index(out_param2,TS_BOOL ,0);
 663                         TAPI_LIB_DEBUG(LEVEL_ALERT, "FDN Status [%d]", *fdn_status);
 664                 }
 665         }
 666         else {
 667                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 668         }
 669
 670         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 671         return api_err;
 672 }
 673
 674 EXPORT_API int tel_disable_sim_fdn(const unsigned char *pin2, int *pin2_len, int *req_id)
 675 {
 676         TS_BOOL ret = FALSE;
 677         int api_err = TAPI_API_SUCCESS;
 678
 679         TAPI_RETURN_VAL_IF_FAIL((pin2 != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
 680
 681         if(_tel_check_tapi_state() != 0 )
 682                 return TAPI_API_SERVICE_NOT_READY;
 683
 684         if (conn_name.length_of_name == 0) {
 685                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 686                 return TAPI_API_OPERATION_FAILED;
 687         }
 688
 689         TAPI_GLIB_INIT_PARAMS();
 690
 691         if (*pin2_len < 4 || *pin2_len > 8) {
 692                 return TAPI_API_INVALID_INPUT;
 693         }
 694
 695         TAPI_LIB_DEBUG(LEVEL_INFO, "password [%s]", pin2);
 696
 697         ret = tapi_check_dbus_status();
 698
 699         if (FALSE == ret) {
 700                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 701         }
 702
 703         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 704
 705         g_array_append_vals(in_param1, pin2, *pin2_len);
 706         g_array_append_vals(in_param2, pin2_len, sizeof(int));
 707         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 708
 709         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_DISABLEFDN, in_param1, in_param2, in_param3, in_param4,
 710                         &out_param1, &out_param2, &out_param3, &out_param4);
 711
 712         if (TRUE == ret) {
 713                 api_err = g_array_index(out_param1, int ,0);
 714                 if(api_err == TAPI_API_SUCCESS )
 715                         *req_id = g_array_index(out_param2, int ,0);
 716                 else
 717                         *req_id = INVALID_REQUEST_ID;
 718         } else {
 719                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 720         }
 721
 722         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 723
 724         return api_err;
 725 }
 726
 727 EXPORT_API int tel_enable_sim_fdn(const unsigned char *pin2, int *pin2_len, int *req_id)
 728 {
 729         TS_BOOL ret = FALSE;
 730         int api_err = TAPI_API_SUCCESS;
 731
 732         TAPI_RETURN_VAL_IF_FAIL((pin2 != NULL && pin2_len != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
 733
 734         if(_tel_check_tapi_state() != 0 )
 735                 return TAPI_API_SERVICE_NOT_READY;
 736
 737         if (conn_name.length_of_name == 0) {
 738                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 739                 return TAPI_API_OPERATION_FAILED;
 740         }
 741
 742         TAPI_GLIB_INIT_PARAMS();
 743
 744         if (*pin2_len < 4 || *pin2_len > 8) {
 745                 return TAPI_API_INVALID_INPUT;
 746         }
 747
 748         TAPI_LIB_DEBUG(LEVEL_INFO, "password [%s]", pin2);
 749
 750         ret = tapi_check_dbus_status();
 751
 752         if (FALSE == ret) {
 753                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 754         }
 755
 756         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 757
 758         g_array_append_vals(in_param1, pin2, *pin2_len);
 759         g_array_append_vals(in_param2, pin2_len, sizeof(int));
 760         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 761
 762         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_ENABLEFDN, in_param1, in_param2, in_param3, in_param4,
 763                         &out_param1, &out_param2, &out_param3, &out_param4);
 764
 765         if (TRUE == ret) {
 766                 api_err = g_array_index(out_param1, int ,0);
 767                 if(api_err == TAPI_API_SUCCESS )
 768                         *req_id = g_array_index(out_param2, int ,0);
 769                 else
 770                         *req_id = INVALID_REQUEST_ID;
 771         } else {
 772                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 773         }
 774
 775         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 776
 777         return api_err;
 778 }
 779
 780 EXPORT_API int tel_req_sim_access(const TelSimRSimReq_t *rsim_data, int *req_id)
 781 {
 782         TS_BOOL ret = FALSE;
 783         int api_err = TAPI_API_SUCCESS;
 784
 785         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
 786         TAPI_RETURN_VAL_IF_FAIL(rsim_data , TAPI_API_INVALID_PTR);
 787
 788         if(_tel_check_tapi_state() != 0 )
 789                 return TAPI_API_SERVICE_NOT_READY;
 790
 791         if (conn_name.length_of_name == 0) {
 792                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 793                 return TAPI_API_OPERATION_FAILED;
 794         }
 795
 796         /*      input param validation check    */
 797         TAPI_GLIB_INIT_PARAMS();
 798
 799         if (FALSE == tapi_check_dbus_status()) {
 800                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 801         }
 802
 803         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 804
 805         g_array_append_vals(in_param1, rsim_data, sizeof(TelSimRSimReq_t));
 806         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 807
 808         if ((rsim_data->rsim_cmd == TAPI_SIM_UPDATE_BINARY) || (rsim_data->rsim_cmd == TAPI_SIM_UPDATE_RECORD)) {
 809                 g_array_append_vals(in_param2, rsim_data->data, sizeof(char*) * rsim_data->p3);
 810         }
 811
 812         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_RSIMACCESS, in_param1, in_param2, in_param3, in_param4,
 813                         &out_param1, &out_param2, &out_param3, &out_param4);
 814
 815         if (TRUE == ret) {
 816                 api_err = g_array_index(out_param1, int ,0);
 817                 if(api_err == TAPI_API_SUCCESS )
 818                         *req_id = g_array_index(out_param2, int ,0);
 819                 else
 820                         *req_id = INVALID_REQUEST_ID;
 821         } else {
 822                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 823         }
 824
 825         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 826
 827         return api_err;
 828 }
 829
 830 EXPORT_API int tel_req_sim_apdu(TelSimApdu_t* apdu_data, int *req_id)
 831 {
 832         TS_BOOL ret = FALSE;
 833         int api_err = TAPI_API_SUCCESS;
 834
 835         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
 836         TAPI_RETURN_VAL_IF_FAIL(apdu_data , TAPI_API_INVALID_PTR);
 837
 838         if(_tel_check_tapi_state() != 0 )
 839                 return TAPI_API_SERVICE_NOT_READY;
 840
 841         if (conn_name.length_of_name == 0) {
 842                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 843                 return TAPI_API_OPERATION_FAILED;
 844         }
 845
 846         /*      input param validation check    */
 847         TAPI_GLIB_INIT_PARAMS();
 848
 849         if (FALSE == tapi_check_dbus_status()) {
 850                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 851         }
 852
 853         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 854
 855         g_array_append_vals(in_param1, apdu_data, sizeof(TelSimApdu_t));
 856         g_array_append_vals(in_param2, apdu_data->apdu, apdu_data->apdu_len);
 857         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 858
 859         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_APDU, in_param1, in_param2, in_param3, in_param4,
 860                         &out_param1, &out_param2, &out_param3, &out_param4);
 861
 862         if (TRUE == ret) {
 863                 api_err = g_array_index(out_param1, int ,0);
 864                 if(api_err == TAPI_API_SUCCESS )
 865                         *req_id = g_array_index(out_param2, int ,0);
 866                 else
 867                         *req_id = INVALID_REQUEST_ID;
 868         } else {
 869                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 870         }
 871
 872         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 873
 874         return api_err;
 875 }
 876
 877 EXPORT_API int tel_req_sim_atr(int *req_id)
 878 {
 879         TS_BOOL ret = FALSE;
 880         int api_err = TAPI_API_SUCCESS;
 881
 882         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
 883
 884         if(_tel_check_tapi_state() != 0 )
 885                 return TAPI_API_SERVICE_NOT_READY;
 886
 887         if (conn_name.length_of_name == 0) {
 888                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 889                 return TAPI_API_OPERATION_FAILED;
 890         }
 891
 892         /*      input param validation check    */
 893         TAPI_GLIB_INIT_PARAMS();
 894
 895         if (FALSE == tapi_check_dbus_status()) {
 896                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 897         }
 898
 899         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 900
 901         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 902
 903         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_ATR, in_param1, in_param2, in_param3, in_param4,
 904                         &out_param1, &out_param2, &out_param3, &out_param4);
 905
 906         if (TRUE == ret) {
 907                 api_err = g_array_index(out_param1, int ,0);
 908                 if(api_err == TAPI_API_SUCCESS )
 909                         *req_id = g_array_index(out_param2, int ,0);
 910                 else
 911                         *req_id = INVALID_REQUEST_ID;
 912         } else {
 913                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 914         }
 915
 916         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 917
 918         return api_err;
 919 }
 920
 921
 922 EXPORT_API int tel_get_sim_ecc(TelSimEccData_t *ecc_data, int *ecc_count)
 923 {
 924         TS_BOOL ret = FALSE;
 925         int api_err = TAPI_API_SUCCESS;
 926
 927         TAPI_RETURN_VAL_IF_FAIL((ecc_data != NULL && ecc_count != NULL) , TAPI_API_INVALID_PTR);
 928
 929         if(_tel_check_tapi_state() != 0 )
 930                 return TAPI_API_SERVICE_NOT_READY;
 931
 932         TAPI_GLIB_INIT_PARAMS();
 933
 934         if (FALSE == tapi_check_dbus_status()) {
 935                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 936         }
 937
 938         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 939
 940         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETECCINFO, in_param1, in_param2, in_param3, in_param4,
 941                         &out_param1, &out_param2, &out_param3, &out_param4);
 942
 943         if (TRUE == ret) {
 944                 api_err = g_array_index(out_param1, int ,0);
 945                 if(api_err == TAPI_API_SUCCESS ){
 946                         *ecc_data = g_array_index(out_param2, TelSimEccData_t ,0);
 947                         *ecc_count = g_array_index(out_param3, int ,0);
 948
 949                         TAPI_LIB_DEBUG(LEVEL_ALERT, "ECC count [%d]", *ecc_count);
 950                         TAPI_LIB_DEBUG(LEVEL_ALERT, "1st ECC data is  [%s]", ecc_data->EccInfo.szEcc1);
 951                         TAPI_LIB_DEBUG(LEVEL_ALERT, "1st UECC data is  [%s]", ecc_data->UeccInfo[0].szEcc);
 952                 }
 953         } else {
 954                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 955         }
 956
 957         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 958         return api_err;
 959 }
 960
 961 EXPORT_API int tel_get_sim_language(TelSimLanguageInfo_t *sim_language)
 962 {
 963         TS_BOOL ret = FALSE;
 964         int api_err = TAPI_API_SUCCESS;
 965
 966         TAPI_RETURN_VAL_IF_FAIL(sim_language, TAPI_API_INVALID_PTR);
 967
 968         if(_tel_check_tapi_state() != 0 )
 969                 return TAPI_API_SERVICE_NOT_READY;
 970
 971         TAPI_GLIB_INIT_PARAMS();
 972
 973         if (FALSE == tapi_check_dbus_status()) {
 974                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
 975         }
 976
 977         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 978
 979         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETLANGUAGEINFO, in_param1, in_param2, in_param3,
 980                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 981
 982         if (TRUE == ret) {
 983                 api_err = g_array_index(out_param1, int ,0);
 984                 if(api_err == TAPI_API_SUCCESS ){
 985                         *sim_language = g_array_index(out_param2, TelSimLanguageInfo_t ,0);
 986                         TAPI_LIB_DEBUG(LEVEL_ALERT, "Language count [%lu]", sim_language->LpCount);
 987                 }
 988         } else {
 989                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 990         }
 991
 992         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
 993         return api_err;
 994 }
 995
 996 EXPORT_API int tel_set_sim_language(TelSimLanguagePreferenceCode_t language, int *req_id)
 997 {
 998         TS_BOOL ret = FALSE;
 999         int api_err = TAPI_API_SUCCESS;
1000
1001         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
1002
1003         if(_tel_check_tapi_state() != 0 )
1004                 return TAPI_API_SERVICE_NOT_READY;
1005
1006         if (conn_name.length_of_name == 0) {
1007                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1008                 return TAPI_API_OPERATION_FAILED;
1009         }
1010
1011         if ( language > TAPI_SIM_LP_JAPANESE )
1012                 return TAPI_API_INVALID_INPUT;
1013
1014         TAPI_GLIB_INIT_PARAMS();
1015
1016         if (FALSE == tapi_check_dbus_status()) {
1017                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1018         }
1019
1020         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1021
1022         g_array_append_vals(in_param1, &language, sizeof(TelSimLanguagePreferenceCode_t));
1023         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1024
1025         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SETLANGUAGE, in_param1, in_param2, in_param3, in_param4,
1026                         &out_param1, &out_param2, &out_param3, &out_param4);
1027
1028         if (TRUE == ret) {
1029                 api_err = g_array_index(out_param1, int ,0);
1030                 if(api_err == TAPI_API_SUCCESS )
1031                         *req_id = g_array_index(out_param2, int ,0);
1032                 else
1033                         *req_id = INVALID_REQUEST_ID;
1034         } else {
1035                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1036         }
1037
1038         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1039
1040         return api_err;
1041 }
1042
1043 EXPORT_API int tel_get_sim_type(TelSimCardType_t *card_type)
1044 {
1045         TS_BOOL ret = FALSE;
1046         int api_err = TAPI_API_SUCCESS;
1047
1048         TAPI_RETURN_VAL_IF_FAIL(card_type, TAPI_API_INVALID_PTR);
1049
1050         if(_tel_check_tapi_state() != 0 )
1051                 return TAPI_API_SERVICE_NOT_READY;
1052
1053         TAPI_GLIB_INIT_PARAMS();
1054
1055         if (FALSE == tapi_check_dbus_status()) {
1056                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1057         }
1058
1059         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1060
1061         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETCARDTYPE, in_param1, in_param2, in_param3, in_param4,
1062                         &out_param1, &out_param2, &out_param3, &out_param4);
1063
1064         if (TRUE == ret) {
1065                 api_err = g_array_index(out_param1, int ,0);
1066                 if(api_err == TAPI_API_SUCCESS ) {
1067                         *card_type = g_array_index(out_param2,int ,0);
1068                         TAPI_LIB_DEBUG(LEVEL_ALERT, "Card type [%d]", *card_type);
1069                 }
1070         } else {
1071                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1072         }
1073
1074         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1075
1076         return api_err;
1077 }
1078
1079 EXPORT_API int tel_get_sim_imsi(TelSimImsiInfo_t *imsi)
1080 {
1081         TS_BOOL ret = FALSE;
1082         int api_err = TAPI_API_SUCCESS;
1083
1084         TAPI_RETURN_VAL_IF_FAIL(imsi , TAPI_API_INVALID_PTR);
1085
1086         if(_tel_check_tapi_state() != 0 )
1087                 return TAPI_API_SERVICE_NOT_READY;
1088
1089         TAPI_GLIB_INIT_PARAMS();
1090
1091         if (FALSE == tapi_check_dbus_status()) {
1092                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1093         }
1094
1095         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1096
1097         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETIMSIINFO, in_param1, in_param2, in_param3, in_param4,
1098                         &out_param1, &out_param2, &out_param3, &out_param4);
1099
1100         if (TRUE == ret) {
1101                 api_err = g_array_index(out_param1, int ,0);
1102                 if(api_err == TAPI_API_SUCCESS ) {
1103                         *imsi = g_array_index(out_param2, TelSimImsiInfo_t ,0);
1104                         TAPI_LIB_DEBUG(LEVEL_ALERT, "IMSI valid [%d]", imsi->bValid);
1105                 }
1106         } else {
1107                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1108         }
1109
1110         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1111
1112         return api_err;
1113 }
1114
1115 EXPORT_API int tel_get_sim_iccid(TelSimIccIdInfo_t *iccid)
1116 {
1117         TS_BOOL ret = FALSE;
1118         int api_err = TAPI_API_SUCCESS;
1119
1120         TAPI_RETURN_VAL_IF_FAIL(iccid , TAPI_API_INVALID_PTR);
1121
1122         if(_tel_check_tapi_state() != 0 )
1123                 return TAPI_API_SERVICE_NOT_READY;
1124
1125         TAPI_GLIB_INIT_PARAMS();
1126
1127         if (FALSE == tapi_check_dbus_status()) {
1128                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1129         }
1130
1131         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1132
1133         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETICCIDINFO, in_param1, in_param2, in_param3, in_param4,
1134                         &out_param1, &out_param2, &out_param3, &out_param4);
1135
1136         if (TRUE == ret) {
1137                 api_err = g_array_index(out_param1, int ,0);
1138                 if(api_err == TAPI_API_SUCCESS) {
1139                         *iccid = g_array_index(out_param2, TelSimIccIdInfo_t ,0);
1140                         TAPI_LIB_DEBUG(LEVEL_ALERT, "ICCID length[%d]", iccid->icc_length);
1141                 } else {
1142                         TAPI_LIB_DEBUG(LEVEL_ALERT, "api_err[%d]",api_err);
1143                 }
1144         } else  {
1145                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1146         }
1147
1148         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1149
1150         return api_err;
1151 }
1152
1153 EXPORT_API int tel_get_sim_mailbox_info(TelSimMailboxNumbers_s *mbox)
1154 {
1155         TS_BOOL ret = FALSE;
1156         int api_err = TAPI_API_SUCCESS;
1157
1158         TAPI_RETURN_VAL_IF_FAIL(mbox , TAPI_API_INVALID_PTR);
1159
1160         if(_tel_check_tapi_state() != 0 )
1161                 return TAPI_API_SERVICE_NOT_READY;
1162
1163         TAPI_GLIB_INIT_PARAMS();
1164
1165         if (FALSE == tapi_check_dbus_status()) {
1166                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1167         }
1168
1169         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1170
1171         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETMBINFO, in_param1, in_param2, in_param3,
1172                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1173
1174         if (TRUE == ret) {
1175                 api_err = g_array_index(out_param1, int ,0);
1176                 if(api_err == TAPI_API_SUCCESS) {
1177                         *mbox = g_array_index(out_param2, TelSimMailboxNumbers_s ,0);
1178                         TAPI_LIB_DEBUG(LEVEL_DEBUG, "chps?[%d]",mbox->b_cphs);
1179                 }
1180         } else {
1181                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1182         }
1183
1184         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1185
1186         return api_err;
1187 }
1188
1189 EXPORT_API int tel_get_sim_callforwarding_info(TelSimCallForwarding_s *cf)
1190 {
1191         TS_BOOL ret = FALSE;
1192         int api_err = TAPI_API_SUCCESS;
1193
1194         TAPI_RETURN_VAL_IF_FAIL(cf , TAPI_API_INVALID_PTR);
1195
1196         if(_tel_check_tapi_state() != 0 )
1197                 return TAPI_API_SERVICE_NOT_READY;
1198
1199         TAPI_GLIB_INIT_PARAMS();
1200
1201         if (FALSE == tapi_check_dbus_status()) {
1202                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1203         }
1204
1205         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1206
1207         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETCFINFO, in_param1, in_param2, in_param3, in_param4,
1208                         &out_param1, &out_param2, &out_param3, &out_param4);
1209
1210         if (TRUE == ret) {
1211                 api_err = g_array_index(out_param1, int ,0);
1212                 if(api_err == TAPI_API_SUCCESS ) {
1213                         *cf = g_array_index(out_param2, TelSimCallForwarding_s ,0);
1214                         TAPI_LIB_DEBUG(LEVEL_DEBUG, "chps?[%d]",cf->b_cphs);
1215                 }
1216         } else {
1217                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1218         }
1219
1220         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1221
1222         return api_err;
1223 }
1224
1225 EXPORT_API int tel_get_sim_messagewaiting_info(TelSimMessageWaiting_s *mw)
1226 {
1227         TS_BOOL ret = FALSE;
1228         int api_err = TAPI_API_SUCCESS;
1229
1230         TAPI_RETURN_VAL_IF_FAIL(mw , TAPI_API_INVALID_PTR);
1231
1232         if(_tel_check_tapi_state() != 0 )
1233                 return TAPI_API_SERVICE_NOT_READY;
1234
1235         TAPI_GLIB_INIT_PARAMS();
1236
1237         if (FALSE == tapi_check_dbus_status()) {
1238                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1239         }
1240
1241         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1242
1243         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETMWINFO, in_param1, in_param2, in_param3, in_param4,
1244                         &out_param1, &out_param2, &out_param3, &out_param4);
1245
1246         if (TRUE == ret) {
1247                 api_err = g_array_index(out_param1, int ,0);
1248                 if(api_err == TAPI_API_SUCCESS) {
1249                         *mw = g_array_index(out_param2, TelSimMessageWaiting_s ,0);
1250                         TAPI_LIB_DEBUG(LEVEL_DEBUG, "chps?[%d]",mw->b_cphs);
1251                 }
1252         } else {
1253                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1254         }
1255
1256         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1257
1258         return api_err;
1259 }
1260
1261 EXPORT_API int tel_get_sim_cphs_info(TelSimCphsLocalInfo_t *cphs)
1262 {
1263         TS_BOOL ret = FALSE;
1264         int api_err = TAPI_API_SUCCESS;
1265
1266         TAPI_RETURN_VAL_IF_FAIL(cphs , TAPI_API_INVALID_PTR);
1267
1268         if(_tel_check_tapi_state() != 0 )
1269                 return TAPI_API_SERVICE_NOT_READY;
1270
1271         TAPI_GLIB_INIT_PARAMS();
1272
1273         if (FALSE == tapi_check_dbus_status()) {
1274                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1275         }
1276
1277         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1278
1279         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETCPHSINFO, in_param1, in_param2, in_param3, in_param4,
1280                         &out_param1, &out_param2, &out_param3, &out_param4);
1281
1282         if (TRUE == ret) {
1283                 api_err = g_array_index(out_param1, int ,0);
1284                 if(api_err == TAPI_API_SUCCESS ) {
1285                         *cphs = g_array_index(out_param2, TelSimCphsLocalInfo_t ,0);
1286                         TAPI_LIB_DEBUG(LEVEL_DEBUG, "chps?[%d]",cphs->b_used);
1287                 }
1288         } else {
1289                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1290         }
1291
1292         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1293
1294         return api_err;
1295 }
1296
1297
1298 EXPORT_API int tel_get_sim_msisdn(TelSimSubscriberInfo_t *subscriber)
1299 {
1300         char *t_name, *t_num;
1301         int name_len, num_len;
1302         TAPI_RETURN_VAL_IF_FAIL(subscriber, TAPI_API_INVALID_PTR);
1303
1304         if(_tel_check_tapi_state() != 0 )
1305                 return TAPI_API_SERVICE_NOT_READY;
1306
1307         t_name = vconf_get_str(VCONFKEY_TELEPHONY_SUBSCRIBER_NAME);
1308         t_num = vconf_get_str(VCONFKEY_TELEPHONY_SUBSCRIBER_NUMBER);
1309
1310         if (t_name == NULL || t_num == NULL) {
1311                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "FAIL TO GET VCONFKEY");
1312                 return TAPI_API_OPERATION_FAILED;
1313         }
1314
1315         name_len = strlen(t_name);
1316         num_len = strlen(t_num);
1317
1318         if (name_len > TAPI_SIM_XDN_ALPHA_ID_MAX_LEN) {
1319                 strncpy(subscriber->name, t_name, TAPI_SIM_XDN_ALPHA_ID_MAX_LEN);
1320                 subscriber->name[TAPI_SIM_XDN_ALPHA_ID_MAX_LEN] = '\0';
1321         } else {
1322                 strncpy(subscriber->name, t_name, name_len);
1323                 subscriber->name[name_len] = '\0';
1324         }
1325
1326         if (num_len > TAPI_SIM_XDN_DIALING_NUMBER_LEN) {
1327                 strncpy(subscriber->num, t_num, TAPI_SIM_XDN_DIALING_NUMBER_LEN);
1328                 subscriber->num[TAPI_SIM_XDN_DIALING_NUMBER_LEN] = '\0';
1329         } else {
1330                 strncpy(subscriber->num, t_num, num_len);
1331                 subscriber->num[num_len] = '\0';
1332         }
1333         TAPI_LIB_DEBUG(LEVEL_DEBUG, "MSISDN name[%s]num[%s]",subscriber->name,subscriber->num);
1334
1335         return TAPI_API_SUCCESS;
1336 }
1337
1338 EXPORT_API int tel_get_sim_pb_init_info(int *init_completed, TelSimPbList_t *pb_list, int *first_index)
1339 {
1340         TS_BOOL ret = FALSE;
1341         int api_err = TAPI_API_SUCCESS;
1342         int vconf_ret = 0;
1343         int vconf_val = 0;
1344
1345         TAPI_RETURN_VAL_IF_FAIL((init_completed != NULL && pb_list != NULL && first_index != NULL), TAPI_API_INVALID_PTR);
1346
1347         if(_tel_check_tapi_state() != 0 )
1348                 return TAPI_API_SERVICE_NOT_READY;
1349
1350         vconf_ret = vconf_get_int(VCONFKEY_TELEPHONY_SIM_PB_INIT, &vconf_val);
1351
1352         TAPI_LIB_DEBUG(LEVEL_ALERT,"VCONFKEY_TELEPHONY_SIM_PB_INIT api ret[%d], return value[%d] ",vconf_ret,vconf_val);
1353
1354         if (vconf_val != 1) {
1355                 *init_completed = 0;
1356                 memset(pb_list, 0x00, sizeof(TelSimPbList_t));
1357                 *first_index = 0x00;
1358                 return api_err;
1359         }
1360
1361         TAPI_GLIB_INIT_PARAMS();
1362
1363         if (FALSE == tapi_check_dbus_status()) {
1364                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1365         }
1366
1367         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1368
1369         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETPBINITINFO, in_param1, in_param2, in_param3, in_param4,
1370                         &out_param1, &out_param2, &out_param3, &out_param4);
1371
1372         if (TRUE == ret) {
1373                 api_err = g_array_index(out_param1, int ,0);
1374                 if(api_err == TAPI_API_SUCCESS ){
1375                         *init_completed = g_array_index(out_param2, int, 0);
1376                         *pb_list = g_array_index(out_param3, TelSimPbList_t, 0);
1377                         *first_index = g_array_index(out_param4, int, 0);
1378                         TAPI_LIB_DEBUG(LEVEL_ALERT, "PB INIT Completed[%d]", *init_completed);
1379                         TAPI_LIB_DEBUG(LEVEL_ALERT, "First Valid Index [%d]", *first_index);
1380                 }
1381         } else {
1382                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1383         }
1384
1385         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1386         return api_err;
1387
1388 }
1389
1390 EXPORT_API int tel_get_sim_pb_count(TelSimPbFileType_t pb_type, int* req_id)
1391 {
1392         TS_BOOL ret = FALSE;
1393         int api_err = TAPI_API_SUCCESS;
1394
1395         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
1396
1397         if(_tel_check_tapi_state() != 0 )
1398                 return TAPI_API_SERVICE_NOT_READY;
1399
1400         if (conn_name.length_of_name == 0) {
1401                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1402                 return TAPI_API_OPERATION_FAILED;
1403         }
1404
1405         TAPI_GLIB_INIT_PARAMS();
1406
1407         TAPI_LIB_DEBUG(LEVEL_ALERT, "Storage type [%d]", pb_type);
1408
1409         if ((pb_type != TAPI_SIM_PB_EN) && (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_LDN) && (pb_type
1410                         != TAPI_SIM_PB_MSISDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN) && (pb_type
1411                         != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS)) {
1412                 return TAPI_API_INVALID_INPUT;
1413         }
1414
1415         if (FALSE == tapi_check_dbus_status()) {
1416                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1417         }
1418
1419         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1420
1421         g_array_append_vals(in_param1, &pb_type, sizeof(TelSimPbFileType_t));
1422         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1423
1424         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_PB_GETCOUNT, in_param1, in_param2, in_param3, in_param4,
1425                         &out_param1, &out_param2, &out_param3, &out_param4);
1426
1427         if (TRUE == ret) {
1428                 api_err = g_array_index(out_param1, int ,0);
1429                 if(api_err == TAPI_API_SUCCESS )
1430                         *req_id = g_array_index(out_param2, int ,0);
1431                 else
1432                         *req_id = INVALID_REQUEST_ID;
1433         } else {
1434                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1435         }
1436
1437         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1438
1439         return api_err;
1440 }
1441
1442 EXPORT_API int tel_get_sim_pb_meta_info(TelSimPbFileType_t pb_type, int* req_id)
1443 {
1444         TS_BOOL ret = FALSE;
1445         int api_err = TAPI_API_SUCCESS;
1446
1447         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
1448
1449         if(_tel_check_tapi_state() != 0 )
1450                 return TAPI_API_SERVICE_NOT_READY;
1451
1452         if (conn_name.length_of_name == 0) {
1453                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1454                 return TAPI_API_OPERATION_FAILED;
1455         }
1456
1457         TAPI_GLIB_INIT_PARAMS();
1458
1459         TAPI_LIB_DEBUG(LEVEL_ALERT, "Storage type [%d]", pb_type);
1460
1461         if ((pb_type != TAPI_SIM_PB_EN) && (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_LDN) && (pb_type
1462                         != TAPI_SIM_PB_MSISDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN) && (pb_type
1463                         != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS)) {
1464                 return TAPI_API_INVALID_INPUT;
1465         }
1466
1467         if (FALSE == tapi_check_dbus_status()) {
1468                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1469         }
1470
1471         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1472
1473         g_array_append_vals(in_param1, &pb_type, sizeof(TelSimPbFileType_t));
1474         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1475
1476         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_PB_GETMETAINFO, in_param1, in_param2, in_param3,
1477                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1478
1479         if (TRUE == ret) {
1480                 api_err = g_array_index(out_param1, int ,0);
1481                 if(api_err == TAPI_API_SUCCESS )
1482                         *req_id = g_array_index(out_param2, int ,0);
1483                 else
1484                         *req_id = INVALID_REQUEST_ID;
1485         } else {
1486                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1487         }
1488
1489         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1490
1491         return api_err;
1492 }
1493
1494 EXPORT_API int tel_get_sim_pb_3g_meta_info(int *req_id)
1495 {
1496         TS_BOOL ret = FALSE;
1497         int api_err = TAPI_API_SUCCESS;
1498
1499         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
1500
1501         if(_tel_check_tapi_state() != 0 )
1502                 return TAPI_API_SERVICE_NOT_READY;
1503
1504         if (conn_name.length_of_name == 0) {
1505                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1506                 return TAPI_API_OPERATION_FAILED;
1507         }
1508
1509         TAPI_GLIB_INIT_PARAMS();
1510
1511         if (FALSE == tapi_check_dbus_status()) {
1512                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1513         }
1514
1515         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1516
1517         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1518
1519         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_GETPBCAPABILITYINFO, in_param1, in_param2, in_param3,
1520                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1521
1522         if (TRUE == ret) {
1523                 api_err = g_array_index(out_param1, int ,0);
1524                 if(api_err == TAPI_API_SUCCESS )
1525                         *req_id = g_array_index(out_param2, int ,0);
1526                 else
1527                         *req_id = INVALID_REQUEST_ID;
1528         } else {
1529                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1530         }
1531
1532         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1533
1534         return api_err;
1535 }
1536
1537 EXPORT_API int tel_read_sim_pb_record(TelSimPbFileType_t pb_type, unsigned short index, int *req_id)
1538 {
1539         TS_BOOL ret = FALSE;
1540         int api_err = TAPI_API_SUCCESS;
1541
1542         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
1543
1544         if(_tel_check_tapi_state() != 0 )
1545                 return TAPI_API_SERVICE_NOT_READY;
1546
1547         if (conn_name.length_of_name == 0) {
1548                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1549                 return TAPI_API_OPERATION_FAILED;
1550         }
1551
1552         TAPI_GLIB_INIT_PARAMS();
1553
1554         TAPI_LIB_DEBUG(LEVEL_ALERT, "Storage type [%d]", pb_type);
1555         TAPI_LIB_DEBUG(LEVEL_ALERT, "Record Index [%d]", index);
1556
1557         if (index == 0) {
1558                 return TAPI_API_INVALID_INPUT;
1559         }
1560
1561         if ((pb_type != TAPI_SIM_PB_EN) && (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_LDN) && (pb_type
1562                         != TAPI_SIM_PB_MSISDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN) && (pb_type
1563                         != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS)) {
1564
1565                 return TAPI_API_INVALID_INPUT;
1566         }
1567
1568         if (FALSE == tapi_check_dbus_status()) {
1569                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1570         }
1571
1572         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1573
1574         g_array_append_vals(in_param1, &pb_type, sizeof(TelSimPbFileType_t));
1575         g_array_append_vals(in_param2, &index, sizeof(unsigned short));
1576         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1577
1578         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_PB_READRECORD, in_param1, in_param2, in_param3, in_param4,
1579                         &out_param1, &out_param2, &out_param3, &out_param4);
1580         if (TRUE == ret) {
1581                 api_err = g_array_index(out_param1, int ,0);
1582                 if(api_err == TAPI_API_SUCCESS )
1583                         *req_id = g_array_index(out_param2, int ,0);
1584                 else
1585                         *req_id = INVALID_REQUEST_ID;
1586         } else {
1587                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1588         }
1589
1590         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1591
1592         return api_err;
1593 }
1594
1595 EXPORT_API int tel_update_sim_pb_record(const TelSimPbRecordData_t *req_data, int *req_id)
1596 {
1597         TS_BOOL ret = FALSE;
1598         int api_err = TAPI_API_SUCCESS;
1599
1600         TAPI_RETURN_VAL_IF_FAIL((req_data != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
1601
1602         if(_tel_check_tapi_state() != 0 )
1603                 return TAPI_API_SERVICE_NOT_READY;
1604
1605         if (conn_name.length_of_name == 0) {
1606                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1607                 return TAPI_API_OPERATION_FAILED;
1608         }
1609
1610         TAPI_GLIB_INIT_PARAMS();
1611
1612         TAPI_LIB_DEBUG(LEVEL_INFO, "Storage type [%d]", req_data->StorageFileType);
1613         TAPI_LIB_DEBUG(LEVEL_INFO, "Record Index [%d]", req_data->Index);
1614
1615         if (req_data->Index == 0) {
1616                 return TAPI_API_INVALID_INPUT;
1617         }
1618
1619         if ((req_data->StorageFileType != TAPI_SIM_PB_EN) && (req_data->StorageFileType != TAPI_SIM_PB_FDN)
1620                         && (req_data->StorageFileType != TAPI_SIM_PB_LDN) && (req_data->StorageFileType != TAPI_SIM_PB_MSISDN)
1621                         && (req_data->StorageFileType != TAPI_SIM_PB_ADN) && (req_data->StorageFileType != TAPI_SIM_PB_SDN)
1622                         && (req_data->StorageFileType != TAPI_SIM_PB_3GSIM) && (req_data->StorageFileType != TAPI_SIM_PB_AAS)
1623                         && (req_data->StorageFileType != TAPI_SIM_PB_GAS)) {
1624                 return TAPI_API_INVALID_INPUT;
1625         }
1626
1627         if (FALSE == tapi_check_dbus_status()) {
1628                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1629         }
1630
1631         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1632
1633         g_array_append_vals(in_param1, req_data, sizeof(TelSimPbRecordData_t));
1634         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1635
1636         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_PB_UPDATERECORD, in_param1, in_param2, in_param3,
1637                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1638
1639         if (TRUE == ret) {
1640                 api_err = g_array_index(out_param1, int ,0);
1641                 if(api_err == TAPI_API_SUCCESS )
1642                         *req_id = g_array_index(out_param2, int ,0);
1643                 else
1644                         *req_id = INVALID_REQUEST_ID;
1645         } else {
1646                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1647         }
1648
1649         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1650
1651         return api_err;
1652 }
1653
1654 EXPORT_API int tel_delete_sim_pb_record(TelSimPbFileType_t pb_type, unsigned short index, int *req_id)
1655 {
1656         TS_BOOL ret = FALSE;
1657         int api_err = TAPI_API_SUCCESS;
1658
1659         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
1660
1661         if(_tel_check_tapi_state() != 0 )
1662                 return TAPI_API_SERVICE_NOT_READY;
1663
1664         if (conn_name.length_of_name == 0) {
1665                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1666                 return TAPI_API_OPERATION_FAILED;
1667         }
1668
1669         *req_id = INVALID_REQUEST_ID;
1670         TAPI_GLIB_INIT_PARAMS();
1671
1672         TAPI_LIB_DEBUG(LEVEL_INFO, "pb_type [%d]", pb_type);
1673         TAPI_LIB_DEBUG(LEVEL_INFO, "Record Index [%d]", index);
1674
1675         if ((pb_type != TAPI_SIM_PB_EN) && (pb_type != TAPI_SIM_PB_FDN) && (pb_type != TAPI_SIM_PB_LDN) && (pb_type
1676                         != TAPI_SIM_PB_MSISDN) && (pb_type != TAPI_SIM_PB_ADN) && (pb_type != TAPI_SIM_PB_SDN) && (pb_type
1677                         != TAPI_SIM_PB_3GSIM) && (pb_type != TAPI_SIM_PB_AAS) && (pb_type != TAPI_SIM_PB_GAS)) {
1678                 return TAPI_API_INVALID_INPUT;
1679         }
1680
1681         if (index == 0) {
1682                 return TAPI_API_INVALID_INPUT;
1683         }
1684
1685         if (FALSE == tapi_check_dbus_status()) {
1686                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1687         }
1688
1689         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1690
1691         g_array_append_vals(in_param1, &pb_type, sizeof(TelSimPbFileType_t));
1692         g_array_append_vals(in_param2, &index, sizeof(unsigned short));
1693         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1694
1695         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_PB_DELETERECORD, in_param1, in_param2, in_param3,
1696                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1697
1698         if (TRUE == ret) {
1699                 api_err = g_array_index(out_param1, int ,0);
1700                 if(api_err == TAPI_API_SUCCESS )
1701                         *req_id = g_array_index(out_param2, int ,0);
1702                 else
1703                         *req_id = INVALID_REQUEST_ID;
1704         } else {
1705                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1706         }
1707
1708         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1709
1710         return api_err;
1711 }
1712
1713 EXPORT_API int tel_req_sap_connection(TelSimSapConnect_t *req_data, int *req_id)
1714 {
1715         TS_BOOL ret = FALSE;
1716         int api_err = TAPI_API_SUCCESS;
1717
1718         TAPI_RETURN_VAL_IF_FAIL((req_data != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
1719
1720         if(_tel_check_tapi_state() != 0 )
1721                 return TAPI_API_SERVICE_NOT_READY;
1722
1723         if (conn_name.length_of_name == 0) {
1724                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1725                 return TAPI_API_OPERATION_FAILED;
1726         }
1727
1728         TAPI_GLIB_INIT_PARAMS();
1729
1730         TAPI_LIB_DEBUG(LEVEL_INFO, "Msg Id [%d]", req_data->MsgId);
1731         TAPI_LIB_DEBUG(LEVEL_INFO, "Msg Max Size [%d]", req_data->MaxMsgSize);
1732         TAPI_LIB_DEBUG(LEVEL_INFO, "Msg Connection status [%d]", req_data->ConnectionStatus);
1733
1734         if (FALSE == tapi_check_dbus_status()) {
1735                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1736         }
1737
1738         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1739
1740         g_array_append_vals(in_param1, req_data, sizeof(TelSimSapConnect_t));
1741         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1742
1743         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPCONNECTREQUEST, in_param1, in_param2, in_param3,
1744                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1745
1746         if (TRUE == ret) {
1747                 api_err = g_array_index(out_param1, int ,0);
1748                 if(api_err == TAPI_API_SUCCESS )
1749                         *req_id = g_array_index(out_param2, int ,0);
1750                 else
1751                         *req_id = INVALID_REQUEST_ID;
1752         } else {
1753                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1754         }
1755
1756         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1757
1758         return api_err;
1759 }
1760
1761 EXPORT_API int tel_req_sap_connection_status(int *req_id)
1762 {
1763         TS_BOOL ret = FALSE;
1764         int api_err = TAPI_API_SUCCESS;
1765
1766         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
1767
1768         if(_tel_check_tapi_state() != 0 )
1769                 return TAPI_API_SERVICE_NOT_READY;
1770
1771         if (conn_name.length_of_name == 0) {
1772                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1773                 return TAPI_API_OPERATION_FAILED;
1774         }
1775
1776         TAPI_GLIB_INIT_PARAMS();
1777
1778         if (FALSE == tapi_check_dbus_status()) {
1779                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1780         }
1781
1782         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1783
1784         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1785
1786         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPCONNECTSTATUS, in_param1, in_param2, in_param3,
1787                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1788
1789         if (TRUE == ret) {
1790                 api_err = g_array_index(out_param1, int ,0);
1791                 if(api_err == TAPI_API_SUCCESS )
1792                         *req_id = g_array_index(out_param2, int ,0);
1793                 else
1794                         *req_id = INVALID_REQUEST_ID;
1795         } else {
1796                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1797         }
1798
1799         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1800
1801         return api_err;
1802 }
1803
1804 EXPORT_API int tel_req_sap_transfer_atr(int *req_id)
1805 {
1806         TS_BOOL ret = FALSE;
1807         int api_err = TAPI_API_SUCCESS;
1808
1809         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
1810
1811         if(_tel_check_tapi_state() != 0 )
1812                 return TAPI_API_SERVICE_NOT_READY;
1813
1814         if (conn_name.length_of_name == 0) {
1815                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1816                 return TAPI_API_OPERATION_FAILED;
1817         }
1818
1819         TAPI_GLIB_INIT_PARAMS();
1820
1821         if (FALSE == tapi_check_dbus_status()) {
1822                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1823         }
1824
1825         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1826
1827         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1828
1829         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPATRREQUEST, in_param1, in_param2, in_param3, in_param4,
1830                         &out_param1, &out_param2, &out_param3, &out_param4);
1831
1832         if (TRUE == ret) {
1833                 api_err = g_array_index(out_param1, int ,0);
1834                 if(api_err == TAPI_API_SUCCESS )
1835                         *req_id = g_array_index(out_param2, int ,0);
1836                 else
1837                         *req_id = INVALID_REQUEST_ID;
1838         } else {
1839                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1840         }
1841
1842         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1843
1844         return api_err;
1845 }
1846
1847 EXPORT_API int tel_req_sap_transfer_apdu(TelSimSapApduData_t *apdu_data, int *req_id)
1848 {
1849         TS_BOOL ret = FALSE;
1850         int api_err = TAPI_API_SUCCESS;
1851
1852         TAPI_RETURN_VAL_IF_FAIL((apdu_data != NULL && req_id != NULL) , TAPI_API_INVALID_PTR);
1853
1854         if(_tel_check_tapi_state() != 0 )
1855                 return TAPI_API_SERVICE_NOT_READY;
1856
1857         if (conn_name.length_of_name == 0) {
1858                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1859                 return TAPI_API_OPERATION_FAILED;
1860         }
1861
1862         TAPI_GLIB_INIT_PARAMS();
1863
1864         TAPI_LIB_DEBUG(LEVEL_INFO, "APDU length [%d]", apdu_data->ApduLength);
1865         TAPI_LIB_DEBUG(LEVEL_INFO, "APDU data [%s]", apdu_data->Apdu);
1866
1867         if (FALSE == tapi_check_dbus_status()) {
1868                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1869         }
1870
1871         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1872
1873         g_array_append_vals(in_param1, apdu_data, sizeof(TelSimSapApduData_t));
1874         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1875
1876         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPTRANSFERAPDU, in_param1, in_param2, in_param3,
1877                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1878
1879         if (TRUE == ret) {
1880                 api_err = g_array_index(out_param1, int ,0);
1881                 if(api_err == TAPI_API_SUCCESS )
1882                         *req_id = g_array_index(out_param2, int ,0);
1883                 else
1884                         *req_id = INVALID_REQUEST_ID;
1885         } else {
1886                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1887         }
1888
1889         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1890
1891         return api_err;
1892 }
1893
1894 EXPORT_API int tel_req_sap_transport_protocol(TelSimSapProtocol_t protocol, int *req_id)
1895 {
1896         TS_BOOL ret = FALSE;
1897         int api_err = TAPI_API_SUCCESS;
1898
1899         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
1900
1901         if(_tel_check_tapi_state() != 0 )
1902                 return TAPI_API_SERVICE_NOT_READY;
1903
1904         if (conn_name.length_of_name == 0) {
1905                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1906                 return TAPI_API_OPERATION_FAILED;
1907         }
1908
1909         TAPI_GLIB_INIT_PARAMS();
1910
1911         TAPI_LIB_DEBUG(LEVEL_INFO, "SAP Protocol [%d]", protocol);
1912
1913         if ((TAPI_SIM_SAP_PROTOCOL_T0 != protocol) && (TAPI_SIM_SAP_PROTOCOL_T1 != protocol)) {
1914                 return TAPI_API_INVALID_INPUT;
1915         }
1916
1917         if (FALSE == tapi_check_dbus_status()) {
1918                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1919         }
1920
1921         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1922
1923         g_array_append_vals(in_param1, &protocol, sizeof(TelSimSapProtocol_t));
1924         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1925
1926         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPSETPROTOCOL, in_param1, in_param2, in_param3,
1927                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1928
1929         if (TRUE == ret) {
1930                 api_err = g_array_index(out_param1, int ,0);
1931                 if(api_err == TAPI_API_SUCCESS )
1932                         *req_id = g_array_index(out_param2, int ,0);
1933                 else
1934                         *req_id = INVALID_REQUEST_ID;
1935         } else {
1936                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1937         }
1938
1939         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1940
1941         return api_err;
1942 }
1943
1944 EXPORT_API int tel_req_sap_power_operation(TelSimSapMsgId_t req_data, int *req_id)
1945 {
1946         TS_BOOL ret = FALSE;
1947         int api_err = TAPI_API_SUCCESS;
1948
1949         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
1950
1951         if(_tel_check_tapi_state() != 0 )
1952                 return TAPI_API_SERVICE_NOT_READY;
1953
1954         if (conn_name.length_of_name == 0) {
1955                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
1956                 return TAPI_API_OPERATION_FAILED;
1957         }
1958
1959         TAPI_GLIB_INIT_PARAMS();
1960
1961         TAPI_LIB_DEBUG(LEVEL_INFO, "SAP Power Msg Id [%d]", req_data);
1962
1963         if ((req_data < TAPI_SIM_SAP_CONNECT_REQ) || (req_data > TAPI_SIM_SAP_SET_TRANSPORT_PROTOCOL_RESP)) {
1964                 return TAPI_API_INVALID_INPUT;
1965         }
1966
1967         if (FALSE == tapi_check_dbus_status()) {
1968                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
1969         }
1970
1971         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1972
1973         g_array_append_vals(in_param1, &req_data, sizeof(TelSimSapMsgId_t));
1974         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
1975
1976         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPSETSIMPOWER, in_param1, in_param2, in_param3,
1977                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
1978
1979         if (TRUE == ret) {
1980                 api_err = g_array_index(out_param1, int ,0);
1981                 if(api_err == TAPI_API_SUCCESS )
1982                         *req_id = g_array_index(out_param2, int ,0);
1983                 else
1984                         *req_id = INVALID_REQUEST_ID;
1985         } else {
1986                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
1987         }
1988
1989         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
1990
1991         return api_err;
1992 }
1993
1994 EXPORT_API int tel_req_sap_cardreader_status(int *req_id)
1995 {
1996         TS_BOOL ret = FALSE;
1997         int api_err = TAPI_API_SUCCESS;
1998
1999         TAPI_RETURN_VAL_IF_FAIL(req_id , TAPI_API_INVALID_PTR);
2000
2001         if(_tel_check_tapi_state() != 0 )
2002                 return TAPI_API_SERVICE_NOT_READY;
2003
2004         if (conn_name.length_of_name == 0) {
2005                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
2006                 return TAPI_API_OPERATION_FAILED;
2007         }
2008
2009         TAPI_GLIB_INIT_PARAMS();
2010
2011         if (FALSE == tapi_check_dbus_status()) {
2012                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
2013         }
2014
2015         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
2016
2017         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
2018
2019         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_SAPCARDREADERSTATUS, in_param1, in_param2, in_param3,
2020                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
2021
2022         if (TRUE == ret) {
2023                 api_err = g_array_index(out_param1, int ,0);
2024                 if(api_err == TAPI_API_SUCCESS )
2025                         *req_id = g_array_index(out_param2, int ,0);
2026                 else
2027                         *req_id = INVALID_REQUEST_ID;
2028         } else {
2029                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
2030         }
2031
2032         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
2033
2034         return api_err;
2035 }
2036
2037 EXPORT_API int tel_req_sim_authentication(TelSimAuthenticationData_t *authentication_data, int *req_id)
2038 {
2039         TS_BOOL ret = FALSE;
2040         int api_err = TAPI_API_SUCCESS;
2041
2042         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
2043         TAPI_RETURN_VAL_IF_FAIL(authentication_data, TAPI_API_INVALID_PTR);
2044
2045         if (authentication_data->auth_type < TAPI_SIM_AUTH_TYPE_IMS || authentication_data->auth_type > TAPI_SIM_AUTH_TYPE_3G)
2046                 return TAPI_API_INVALID_INPUT;
2047
2048         if (authentication_data->rand_length == 0)
2049                 return TAPI_API_INVALID_INPUT;
2050
2051         if (authentication_data->auth_type != TAPI_SIM_AUTH_TYPE_GSM    && authentication_data->autn_length == 0)
2052                 return TAPI_API_INVALID_INPUT;
2053
2054         if (_tel_check_tapi_state() != 0)
2055                 return TAPI_API_SERVICE_NOT_READY;
2056
2057         if (conn_name.length_of_name == 0) {
2058                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
2059                 return TAPI_API_OPERATION_FAILED;
2060         }
2061
2062         TAPI_GLIB_INIT_PARAMS();
2063
2064         TAPI_LIB_DEBUG(LEVEL_INFO, "rand_length[%d]", authentication_data->rand_length);
2065         TAPI_LIB_DEBUG(LEVEL_INFO, "rand_data[0][0x%x]", authentication_data->rand_data[0]);
2066
2067         if (authentication_data->autn_length) {
2068                 TAPI_LIB_DEBUG(LEVEL_INFO, "autn_length [%d]", authentication_data->autn_length);
2069                 TAPI_LIB_DEBUG(LEVEL_INFO, "autn_data[0][0x%x]", authentication_data->autn_data[0]);
2070         }
2071
2072         if (FALSE == tapi_check_dbus_status())
2073                 return TAPI_API_SYSTEM_RPC_LINK_DOWN;
2074
2075         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
2076
2077         g_array_append_vals(in_param1, authentication_data, sizeof(TelSimAuthenticationData_t));
2078         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
2079
2080         ret = tapi_send_request(TAPI_CS_SERVICE_SIM, TAPI_CS_SIM_AUTHENTICATION, in_param1, in_param2, in_param3,
2081                         in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
2082
2083         if (TRUE == ret) {
2084                 api_err = g_array_index(out_param1, int ,0);
2085                 if(api_err == TAPI_API_SUCCESS )
2086                         *req_id = g_array_index(out_param2, int ,0);
2087                 else
2088                         *req_id = INVALID_REQUEST_ID;
2089         } else {
2090                 api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
2091         }
2092
2093         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,out_param1,out_param2,out_param3,out_param4);
2094
2095         return api_err;
2096 }