4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: Ja-young Gu <jygu@samsung.com>
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
12 * http://www.apache.org/licenses/LICENSE-2.0
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.
25 #include "tapi_common.h"
26 #include "TapiUtility.h"
33 static int _tel_check_tapi_state()
38 static int _tel_check_sim_state(TapiHandle *handle)
41 GVariant *sync_gv = NULL;
42 int api_err = TAPI_API_SUCCESS;
43 TelSimCardStatus_t init_status = 0;
46 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
47 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetInitStatus", NULL, NULL,
48 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
51 g_variant_get(sync_gv, "(ib)", &init_status, &changed);
52 dbg("init_status[%d]",init_status);
55 case TAPI_SIM_STATUS_CARD_NOT_PRESENT :
56 case TAPI_SIM_STATUS_CARD_REMOVED :
57 api_err = TAPI_API_SIM_NOT_FOUND;
59 case TAPI_SIM_STATUS_CARD_BLOCKED :
60 case TAPI_SIM_STATUS_CARD_ERROR :
61 api_err = TAPI_API_SIM_CARD_ERROR;
63 case TAPI_SIM_STATUS_SIM_INITIALIZING :
64 api_err = TAPI_API_SIM_NOT_INITIALIZED;
66 case TAPI_SIM_STATUS_SIM_INIT_COMPLETED :
67 api_err = TAPI_API_SUCCESS;
69 case TAPI_SIM_STATUS_SIM_PIN_REQUIRED :
70 case TAPI_SIM_STATUS_SIM_PUK_REQUIRED :
71 case TAPI_SIM_STATUS_SIM_NCK_REQUIRED :
72 case TAPI_SIM_STATUS_SIM_NSCK_REQUIRED :
73 case TAPI_SIM_STATUS_SIM_SPCK_REQUIRED :
74 case TAPI_SIM_STATUS_SIM_CCK_REQUIRED :
75 case TAPI_SIM_STATUS_SIM_LOCK_REQUIRED :
76 api_err = TAPI_API_SIM_LOCKED;
78 case TAPI_SIM_STATUS_UNKNOWN:
79 api_err = TAPI_API_SERVICE_NOT_READY;
82 dbg("not handled status[%d] in here",init_status);
86 dbg( "g_dbus_conn failed in _tel_check_sim_state. error (%s)", gerr->message);
88 return TAPI_API_OPERATION_FAILED;
90 dbg("api_err[%d]", api_err);
94 static void on_response_get_sim_iccid(GObject *source_object, GAsyncResult *res, gpointer user_data)
97 GDBusConnection *conn = NULL;
98 GVariant *dbus_result;
100 struct tapi_resp_data *evt_cb_data = user_data;
101 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
102 TelSimIccIdInfo_t iccid_info;
105 dbg("Func Entrance");
106 memset(&iccid_info, 0, sizeof(TelSimIccIdInfo_t));
108 conn = G_DBUS_CONNECTION (source_object);
109 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
114 if (evt_cb_data->cb_fn) {
115 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
125 g_variant_get(dbus_result, "(is)", &result, &iccid);
126 iccid_info.icc_length = strlen((const char*)iccid);
127 if(iccid_info.icc_length > TAPI_SIM_ICCID_LEN_MAX){
128 dbg("current tapi support 20 byte but received length[%d] so changed");
129 iccid_info.icc_length = TAPI_SIM_ICCID_LEN_MAX;
131 memcpy(iccid_info.icc_num, iccid, iccid_info.icc_length);
133 if (evt_cb_data->cb_fn) {
134 evt_cb_data->cb_fn(evt_cb_data->handle, result, &iccid_info, evt_cb_data->user_data);
140 static void on_response_get_sim_language(GObject *source_object, GAsyncResult *res,
143 GError *error = NULL;
144 GDBusConnection *conn = NULL;
145 GVariant *dbus_result;
147 struct tapi_resp_data *evt_cb_data = user_data;
148 TelSimLanguagePreferenceCode_t lang = TAPI_SIM_LP_LANG_UNSPECIFIED;
149 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
151 dbg("Func Entrance");
152 conn = G_DBUS_CONNECTION (source_object);
153 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
157 if (evt_cb_data->cb_fn) {
158 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
168 g_variant_get(dbus_result, "(ii)", &result, &lang);
170 if (evt_cb_data->cb_fn) {
171 evt_cb_data->cb_fn(evt_cb_data->handle, result, &lang, evt_cb_data->user_data);
177 static void on_response_set_sim_language(GObject *source_object, GAsyncResult *res,
180 GError *error = NULL;
181 GDBusConnection *conn = NULL;
182 GVariant *dbus_result;
184 struct tapi_resp_data *evt_cb_data = user_data;
185 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
187 dbg("Func Entrance");
188 conn = G_DBUS_CONNECTION (source_object);
189 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
193 if (evt_cb_data->cb_fn) {
194 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
204 g_variant_get(dbus_result, "(i)", &result);
206 if (evt_cb_data->cb_fn) {
207 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
213 static void on_response_get_sim_callforwarding_info(GObject *source_object, GAsyncResult *res,
216 GError *error = NULL;
217 GDBusConnection *conn = NULL;
218 GVariant *dbus_result;
219 GVariant *value = NULL;
220 GVariantIter *cphs_iter = NULL;
221 GVariantIter *iter = NULL;
222 GVariantIter *iter_row = NULL;
223 const gchar *key = NULL;
224 const gchar *str_value = NULL;
225 struct tapi_resp_data *evt_cb_data = user_data;
226 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
227 TelSimCallForwardingResp_t cf;
230 memset(&cf, 0, sizeof(TelSimCallForwardingResp_t));
232 dbg("Func Entrance");
233 conn = G_DBUS_CONNECTION (source_object);
234 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
238 if (evt_cb_data->cb_fn) {
239 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
248 dbg("dbus_result format(%s)", g_variant_get_type_string(dbus_result));
249 g_variant_get(dbus_result, "(ibaa{sv}a{sv})", &result, &cf.b_cphs, &iter, &cphs_iter);
252 while (g_variant_iter_loop(cphs_iter, "{sv}", &key, &value)) {
253 if (!g_strcmp0(key, "b_line1")) {
254 cf.cphs_cf.b_line1 = g_variant_get_boolean(value);
256 if (!g_strcmp0(key, "b_line2")) {
257 cf.cphs_cf.b_line2 = g_variant_get_boolean(value);
259 if (!g_strcmp0(key, "b_fax")) {
260 cf.cphs_cf.b_fax = g_variant_get_boolean(value);
262 if (!g_strcmp0(key, "b_data")) {
263 cf.cphs_cf.b_data = g_variant_get_boolean(value);
267 cf.cf_list.profile_count = g_variant_iter_n_children(iter);
269 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
270 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
271 if (!g_strcmp0(key, "rec_index")) {
272 cf.cf_list.cf[i].rec_index = g_variant_get_int32(value);
274 if (!g_strcmp0(key, "msp_num")) {
275 cf.cf_list.cf[i].msp_num = g_variant_get_byte(value);
277 if (!g_strcmp0(key, "cfu_status")) {
278 cf.cf_list.cf[i].cfu_status = g_variant_get_byte(value);
280 if (!g_strcmp0(key, "cfu_num")) {
281 str_value = g_variant_get_string(value, NULL);
282 snprintf(cf.cf_list.cf[i].cfu_num, strlen((const char*) str_value) + 1, "%s", str_value);
284 if (!g_strcmp0(key, "ton")) {
285 cf.cf_list.cf[i].ton = g_variant_get_int32(value);
287 if (!g_strcmp0(key, "npi")) {
288 cf.cf_list.cf[i].npi = g_variant_get_int32(value);
290 if (!g_strcmp0(key, "cc2_id")) {
291 cf.cf_list.cf[i].cc2_id = g_variant_get_byte(value);
293 if (!g_strcmp0(key, "ext7_id")) {
294 cf.cf_list.cf[i].ext7_id = g_variant_get_byte(value);
298 g_variant_iter_free(iter_row);
300 g_variant_iter_free(iter);
303 if (evt_cb_data->cb_fn) {
304 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cf, evt_cb_data->user_data);
310 static void on_response_set_sim_callforwarding_info(GObject *source_object, GAsyncResult *res,
313 GError *error = NULL;
314 GDBusConnection *conn = NULL;
315 GVariant *dbus_result;
317 struct tapi_resp_data *evt_cb_data = user_data;
318 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
320 dbg("Func Entrance");
321 conn = G_DBUS_CONNECTION (source_object);
322 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
326 if (evt_cb_data->cb_fn) {
327 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
337 g_variant_get(dbus_result, "(i)", &result);
339 if (evt_cb_data->cb_fn) {
340 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
347 static void on_response_get_sim_messagewaiting_info(GObject *source_object, GAsyncResult *res,
350 GError *error = NULL;
351 GDBusConnection *conn = NULL;
352 GVariant *dbus_result;
353 GVariant *value = NULL;
354 GVariantIter *cphs_iter = NULL;
355 GVariantIter *iter = NULL;
356 GVariantIter *iter_row = NULL;
357 const gchar *key = NULL;
358 struct tapi_resp_data *evt_cb_data = user_data;
359 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
360 TelSimMessageWaitingResp_t mw;
363 dbg("Func Entrance");
364 memset(&mw, 0, sizeof(TelSimMessageWaitingResp_t));
366 conn = G_DBUS_CONNECTION (source_object);
367 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
371 if (evt_cb_data->cb_fn) {
372 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
382 dbg("dbus_result format(%s)", g_variant_get_type_string(dbus_result));
383 g_variant_get(dbus_result, "(ibaa{sv}a{sv})", &result, &mw.b_cphs, &iter, &cphs_iter);
386 while (g_variant_iter_loop(cphs_iter, "{sv}", &key, &value)) {
387 if (!g_strcmp0(key, "b_voice1")) {
388 mw.cphs_mw.b_voice1 = g_variant_get_boolean(value);
390 if (!g_strcmp0(key, "b_voice2")) {
391 mw.cphs_mw.b_voice2 = g_variant_get_boolean(value);
393 if (!g_strcmp0(key, "b_fax")) {
394 mw.cphs_mw.b_fax = g_variant_get_boolean(value);
396 if (!g_strcmp0(key, "b_data")) {
397 mw.cphs_mw.b_data = g_variant_get_boolean(value);
402 mw.mw_list.profile_count = g_variant_iter_n_children(iter);
404 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
405 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
406 if (!g_strcmp0(key, "rec_index")) {
407 mw.mw_list.mw[i].rec_index = g_variant_get_int32(value);
409 if (!g_strcmp0(key, "indicator_status")) {
410 mw.mw_list.mw[i].indicator_status = g_variant_get_byte(value);
412 if (!g_strcmp0(key, "voice_count")) {
413 mw.mw_list.mw[i].voice_count = g_variant_get_int32(value);
415 if (!g_strcmp0(key, "fax_count")) {
416 mw.mw_list.mw[i].fax_count = g_variant_get_int32(value);
418 if (!g_strcmp0(key, "email_count")) {
419 mw.mw_list.mw[i].email_count = g_variant_get_int32(value);
421 if (!g_strcmp0(key, "other_count")) {
422 mw.mw_list.mw[i].other_count = g_variant_get_int32(value);
424 if (!g_strcmp0(key, "video_count")) {
425 mw.mw_list.mw[i].video_count = g_variant_get_int32(value);
429 g_variant_iter_free(iter_row);
431 g_variant_iter_free(iter);
434 if (evt_cb_data->cb_fn) {
435 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mw, evt_cb_data->user_data);
441 static void on_response_set_sim_messagewaiting_info(GObject *source_object, GAsyncResult *res,
444 GError *error = NULL;
445 GDBusConnection *conn = NULL;
446 GVariant *dbus_result;
448 struct tapi_resp_data *evt_cb_data = user_data;
449 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
451 dbg("Func Entrance");
452 conn = G_DBUS_CONNECTION (source_object);
453 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
457 if (evt_cb_data->cb_fn) {
458 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
468 g_variant_get(dbus_result, "(i)", &result);
470 if (evt_cb_data->cb_fn) {
471 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
477 static void on_response_get_sim_mailbox_info(GObject *source_object, GAsyncResult *res,
480 GError *error = NULL;
481 GDBusConnection *conn = NULL;
482 GVariant *dbus_result;
483 GVariant *value = NULL;
484 GVariantIter *iter = NULL;
485 GVariantIter *iter_row = NULL;
486 const gchar *key = NULL;
487 const gchar *str_value = NULL;
488 struct tapi_resp_data *evt_cb_data = user_data;
489 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
490 TelSimMailboxList_t list;
494 dbg("Func Entrance");
495 memset(&list, 0, sizeof(TelSimMailboxList_t));
497 conn = G_DBUS_CONNECTION (source_object);
498 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
502 if (evt_cb_data->cb_fn) {
503 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
513 g_variant_get(dbus_result, "(ibaa{sv})", &result, &b_cphs, &iter);
514 list.count = g_variant_iter_n_children(iter);
517 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
518 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
519 list.list[i].b_cphs = b_cphs;
521 if (!g_strcmp0(key, "rec_index")) {
522 list.list[i].rec_index = g_variant_get_int32(value);
524 if (!g_strcmp0(key, "profile_num")) {
525 list.list[i].profile_num = g_variant_get_int32(value);
527 if (!g_strcmp0(key, "mb_type")) {
528 list.list[i].mb_type = g_variant_get_int32(value);
530 if (!g_strcmp0(key, "alpha_id_max_len")) {
531 list.list[i].alpha_id_max_len = g_variant_get_int32(value);
533 if (!g_strcmp0(key, "alpha_id")) {
534 str_value = g_variant_get_string(value, NULL);
535 snprintf(list.list[i].alpha_id, strlen((const char*)str_value) + 1, "%s", str_value);
537 if (!g_strcmp0(key, "ton")) {
538 list.list[i].ton = g_variant_get_int32(value);
540 if (!g_strcmp0(key, "npi")) {
541 list.list[i].npi = g_variant_get_int32(value);
543 if (!g_strcmp0(key, "num")) {
544 str_value = g_variant_get_string(value, NULL);
545 snprintf(list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
547 if (!g_strcmp0(key, "cc_id")) {
548 list.list[i].cc_id = g_variant_get_byte(value);
550 if (!g_strcmp0(key, "ext1_id")) {
551 list.list[i].ext1_id = g_variant_get_byte(value);
555 g_variant_iter_free(iter_row);
557 g_variant_iter_free(iter);
559 if (evt_cb_data->cb_fn) {
560 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
566 static void on_response_set_sim_mailbox_info(GObject *source_object, GAsyncResult *res,
569 GError *error = NULL;
570 GDBusConnection *conn = NULL;
571 GVariant *dbus_result;
573 struct tapi_resp_data *evt_cb_data = user_data;
574 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
576 dbg("Func Entrance");
577 conn = G_DBUS_CONNECTION (source_object);
578 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
582 if (evt_cb_data->cb_fn) {
583 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
593 g_variant_get(dbus_result, "(i)", &result);
595 if (evt_cb_data->cb_fn) {
596 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
602 static void on_response_get_sim_cphs_info(GObject *source_object, GAsyncResult *res,
605 GError *error = NULL;
606 GDBusConnection *conn = NULL;
607 GVariant *dbus_result;
609 struct tapi_resp_data *evt_cb_data = user_data;
610 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
611 TelSimCphsInfo_t cphs;
613 dbg("Func Entrance");
614 memset(&cphs, 0, sizeof(TelSimCphsInfo_t));
616 conn = G_DBUS_CONNECTION (source_object);
617 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
621 if (evt_cb_data->cb_fn) {
622 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
632 g_variant_get(dbus_result, "(iibbbbb)", &result, &cphs.CphsPhase,
633 &cphs.CphsServiceTable.bOperatorNameShortForm, &cphs.CphsServiceTable.bMailBoxNumbers,
634 &cphs.CphsServiceTable.bServiceStringTable,
635 &cphs.CphsServiceTable.bCustomerServiceProfile,
636 &cphs.CphsServiceTable.bInformationNumbers);
638 if (evt_cb_data->cb_fn) {
639 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cphs, evt_cb_data->user_data);
645 static void on_response_get_sim_msisdn(GObject *source_object, GAsyncResult *res,
648 GError *error = NULL;
649 GDBusConnection *conn = NULL;
650 GVariant *dbus_result;
651 GVariant *value = NULL;
652 GVariantIter *iter = NULL;
653 GVariantIter *iter_row = NULL;
654 const gchar *key = NULL;
655 const gchar *str_value = NULL;
656 struct tapi_resp_data *evt_cb_data = user_data;
657 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
658 TelSimMsisdnList_t list;
661 dbg("Func Entrance");
662 memset(&list, 0, sizeof(TelSimMsisdnList_t));
664 conn = G_DBUS_CONNECTION (source_object);
665 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
669 if (evt_cb_data->cb_fn) {
670 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
680 g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
681 list.count = g_variant_iter_n_children(iter);
683 /*this can be changed regarding concept*/
685 dbg("current list.count[%d] but we fixed maximum with 3", list.count);
688 /*this can be changed regarding concept*/
691 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
692 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
693 if (!g_strcmp0(key, "name")) {
694 str_value = g_variant_get_string(value, NULL);
695 snprintf(list.list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
697 if (!g_strcmp0(key, "number")) {
698 str_value = g_variant_get_string(value, NULL);
699 snprintf(list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
703 g_variant_iter_free(iter_row);
704 /*this can be changed regarding concept*/
707 /*this can be changed regarding concept*/
709 g_variant_iter_free(iter);
711 dbg("msisdn count[%d]", list.count);
712 for(i =0; i < list.count; i++){
713 dbg("msisdn[%d]-name[%s]number[%s]",i,list.list[i].name, list.list[i].num);
716 if (evt_cb_data->cb_fn) {
717 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
723 static void on_response_get_sim_oplmnwact(GObject *source_object, GAsyncResult *res,
726 GError *error = NULL;
727 GDBusConnection *conn = NULL;
728 GVariant *dbus_result;
729 GVariant *value = NULL;
730 GVariantIter *iter = NULL;
731 GVariantIter *iter_row = NULL;
732 const gchar *key = NULL;
733 const gchar *str_value = NULL;
734 struct tapi_resp_data *evt_cb_data = user_data;
735 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
736 TelSimOplmnwactList_t list;
739 dbg("Func Entrance");
740 memset(&list, 0, sizeof(TelSimOplmnwactList_t));
742 conn = G_DBUS_CONNECTION (source_object);
743 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
747 if (evt_cb_data->cb_fn) {
748 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
758 g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
759 list.count = g_variant_iter_n_children(iter);
762 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
763 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
764 if (!g_strcmp0(key, "plmn")) {
765 str_value = g_variant_get_string(value, NULL);
766 snprintf(list.list[i].plmn, strlen((const char*)str_value) + 1, "%s", str_value);
768 if (!g_strcmp0(key, "b_umst")) {
769 list.list[i].b_umts = g_variant_get_boolean(value);
771 if (!g_strcmp0(key, "b_gsm")) {
772 list.list[i].b_gsm = g_variant_get_boolean(value);
776 g_variant_iter_free(iter_row);
778 g_variant_iter_free(iter);
780 if (evt_cb_data->cb_fn) {
781 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
787 static void on_response_get_sim_spn(GObject *source_object, GAsyncResult *res,
790 GError *error = NULL;
791 GDBusConnection *conn = NULL;
792 GVariant *dbus_result;
794 struct tapi_resp_data *evt_cb_data = user_data;
795 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
796 TelSimSpn_t spn_info;
800 memset(&spn_info, 0, sizeof(TelSimSpn_t));
802 dbg("Func Entrance");
803 conn = G_DBUS_CONNECTION (source_object);
804 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
808 if (evt_cb_data->cb_fn) {
809 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
819 g_variant_get(dbus_result, "(iys)", &result, &dc, &spn);
821 dbg("result[%d]", result);
822 if ( result == TAPI_SIM_ACCESS_SUCCESS) {
823 dbg("spn[%s], display condition[0x%x]", spn, dc);
824 spn_info.display_condition = dc;
825 snprintf((char *)spn_info.spn, strlen((const char*)spn)+1, "%s", spn);
828 if (evt_cb_data->cb_fn) {
829 evt_cb_data->cb_fn(evt_cb_data->handle, result, &spn_info, evt_cb_data->user_data);
835 static void on_response_get_sim_cphs_netname(GObject *source_object, GAsyncResult *res,
838 GError *error = NULL;
839 GDBusConnection *conn = NULL;
840 GVariant *dbus_result;
842 struct tapi_resp_data *evt_cb_data = user_data;
843 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
844 TelSimCphsNetName_t cphs_net;
845 gchar *full_name = NULL;
846 gchar *short_name = NULL;
848 memset(&cphs_net, 0, sizeof(TelSimCphsNetName_t));
850 dbg("Func Entrance");
851 conn = G_DBUS_CONNECTION (source_object);
852 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
856 if (evt_cb_data->cb_fn) {
857 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
867 g_variant_get(dbus_result, "(iss)", &result, &full_name, &short_name);
869 dbg("result[%d]", result);
870 if ( result == TAPI_SIM_ACCESS_SUCCESS) {
871 dbg("full name[%s], short name[%s]", full_name, short_name);
872 snprintf((char *)cphs_net.full_name, strlen((const char*)full_name)+1, "%s", full_name);
873 snprintf((char *)cphs_net.short_name, strlen((const char*)short_name)+1, "%s", short_name);
876 if (evt_cb_data->cb_fn) {
877 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cphs_net, evt_cb_data->user_data);
883 static void on_response_req_sim_authentication(GObject *source_object, GAsyncResult *res,
886 GError *error = NULL;
887 GDBusConnection *conn = NULL;
888 GVariant *dbus_result;
890 GVariantIter *iter = NULL;
891 GVariant *ak_gv = NULL;
892 GVariant *cp_gv = NULL;
893 GVariant *it_gv = NULL;
894 GVariant *resp_gv = NULL;
898 GVariant *resp = NULL;
902 struct tapi_resp_data *evt_cb_data = user_data;
903 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
904 TelSimAuthenticationResponse_t auth_resp;
906 dbg("Func Entrance");
907 memset(&auth_resp, 0, sizeof(TelSimAuthenticationResponse_t));
909 conn = G_DBUS_CONNECTION (source_object);
910 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
914 if (evt_cb_data->cb_fn) {
915 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
925 dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));
926 g_variant_get(dbus_result, "(iii@v@v@v@v)", &result, &auth_resp.auth_type,
927 &auth_resp.auth_result, &ak_gv, &cp_gv, &it_gv, &resp_gv);
929 ak = g_variant_get_variant(ak_gv);
930 g_variant_get(ak, "ay", &iter);
931 while (g_variant_iter_loop(iter, "y", &rt_i)) {
932 auth_resp.authentication_key[i] = rt_i;
933 dbg("auth_resp.authentication_key[%d]=[0x%02x]", i, auth_resp.authentication_key[i]);
936 auth_resp.authentication_key_length = i;
937 g_variant_iter_free(iter);
940 cp = g_variant_get_variant(cp_gv);
941 g_variant_get(cp, "ay", &iter);
942 while (g_variant_iter_loop(iter, "y", &rt_i)) {
943 auth_resp.cipher_data[i] = rt_i;
944 dbg("auth_resp.cipher_data[%d]=[0x%02x]", i, auth_resp.cipher_data[i]);
947 auth_resp.cipher_length = i;
948 g_variant_iter_free(iter);
951 it = g_variant_get_variant(it_gv);
952 g_variant_get(it, "ay", &iter);
953 while (g_variant_iter_loop(iter, "y", &rt_i)) {
954 auth_resp.integrity_data[i] = rt_i;
955 dbg("auth_resp.integrity_data[%d]=[0x%02x]", i, auth_resp.integrity_data[i]);
958 auth_resp.integrity_length = i;
959 g_variant_iter_free(iter);
962 resp = g_variant_get_variant(resp_gv);
963 g_variant_get(resp, "ay", &iter);
964 while (g_variant_iter_loop(iter, "y", &rt_i)) {
965 auth_resp.resp_data[i] = rt_i;
966 dbg("auth_resp.resp_data[%d]=[0x%02x]", i, auth_resp.resp_data[i]);
969 auth_resp.resp_length = i;
970 g_variant_iter_free(iter);
973 if (evt_cb_data->cb_fn) {
974 evt_cb_data->cb_fn(evt_cb_data->handle, result, &auth_resp, evt_cb_data->user_data);
980 static void on_response_verify_sim_pins(GObject *source_object, GAsyncResult *res,
983 GError *error = NULL;
984 GDBusConnection *conn = NULL;
985 GVariant *dbus_result;
987 struct tapi_resp_data *evt_cb_data = user_data;
988 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
989 TelSimSecResult_t sec_rt;
991 dbg("Func Entrance");
992 memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
994 conn = G_DBUS_CONNECTION (source_object);
995 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
999 if (evt_cb_data->cb_fn) {
1000 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1004 g_error_free(error);
1010 g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1012 if (evt_cb_data->cb_fn) {
1013 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1019 static void on_response_verify_sim_puks(GObject *source_object, GAsyncResult *res,
1022 GError *error = NULL;
1023 GDBusConnection *conn = NULL;
1024 GVariant *dbus_result;
1026 struct tapi_resp_data *evt_cb_data = user_data;
1027 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1028 TelSimSecResult_t sec_rt;
1030 dbg("Func Entrance");
1031 memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1033 conn = G_DBUS_CONNECTION (source_object);
1034 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1035 CHECK_DEINIT(error);
1038 if (evt_cb_data->cb_fn) {
1039 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1043 g_error_free(error);
1049 g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1051 if (evt_cb_data->cb_fn) {
1052 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1058 static void on_response_change_sim_pins(GObject *source_object, GAsyncResult *res,
1061 GError *error = NULL;
1062 GDBusConnection *conn = NULL;
1063 GVariant *dbus_result;
1065 struct tapi_resp_data *evt_cb_data = user_data;
1066 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1067 TelSimSecResult_t sec_rt;
1069 dbg("Func Entrance");
1070 memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1072 conn = G_DBUS_CONNECTION (source_object);
1073 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1074 CHECK_DEINIT(error);
1077 if (evt_cb_data->cb_fn) {
1078 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1082 g_error_free(error);
1088 g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1090 if (evt_cb_data->cb_fn) {
1091 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1097 static void on_response_disable_sim_facility(GObject *source_object, GAsyncResult *res,
1100 GError *error = NULL;
1101 GDBusConnection *conn = NULL;
1102 GVariant *dbus_result;
1104 struct tapi_resp_data *evt_cb_data = user_data;
1105 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1106 TelSimFacilityResult_t f_rt;
1108 dbg("Func Entrance");
1109 memset(&f_rt, 0, sizeof(TelSimFacilityResult_t));
1111 conn = G_DBUS_CONNECTION (source_object);
1112 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1113 CHECK_DEINIT(error);
1116 if (evt_cb_data->cb_fn) {
1117 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1121 g_error_free(error);
1127 g_variant_get(dbus_result, "(iii)", &result, &f_rt.type, &f_rt.retry_count);
1129 if (evt_cb_data->cb_fn) {
1130 evt_cb_data->cb_fn(evt_cb_data->handle, result, &f_rt, evt_cb_data->user_data);
1136 static void on_response_enable_sim_facility(GObject *source_object, GAsyncResult *res,
1139 GError *error = NULL;
1140 GDBusConnection *conn = NULL;
1141 GVariant *dbus_result;
1143 struct tapi_resp_data *evt_cb_data = user_data;
1144 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1145 TelSimFacilityResult_t f_rt;
1147 dbg("Func Entrance");
1148 memset(&f_rt, 0, sizeof(TelSimFacilityResult_t));
1150 conn = G_DBUS_CONNECTION (source_object);
1151 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1152 CHECK_DEINIT(error);
1155 if (evt_cb_data->cb_fn) {
1156 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1160 g_error_free(error);
1166 g_variant_get(dbus_result, "(iii)", &result, &f_rt.type, &f_rt.retry_count);
1168 if (evt_cb_data->cb_fn) {
1169 evt_cb_data->cb_fn(evt_cb_data->handle, result, &f_rt, evt_cb_data->user_data);
1175 static void on_response_get_sim_facility(GObject *source_object, GAsyncResult *res,
1178 GError *error = NULL;
1179 GDBusConnection *conn = NULL;
1180 GVariant *dbus_result;
1182 struct tapi_resp_data *evt_cb_data = user_data;
1183 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1184 TelSimFacilityInfo_t fi;
1186 dbg("Func Entrance");
1187 memset(&fi, 0, sizeof(TelSimFacilityInfo_t));
1189 conn = G_DBUS_CONNECTION (source_object);
1190 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1191 CHECK_DEINIT(error);
1194 if (evt_cb_data->cb_fn) {
1195 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1199 g_error_free(error);
1205 g_variant_get(dbus_result, "(iii)", &result, &fi.type, &fi.f_status);
1207 if (evt_cb_data->cb_fn) {
1208 evt_cb_data->cb_fn(evt_cb_data->handle, result, &fi, evt_cb_data->user_data);
1214 static void on_response_get_sim_lock_info(GObject *source_object, GAsyncResult *res,
1217 GError *error = NULL;
1218 GDBusConnection *conn = NULL;
1219 GVariant *dbus_result;
1221 struct tapi_resp_data *evt_cb_data = user_data;
1222 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1223 TelSimLockInfo_t lock;
1225 dbg("Func Entrance");
1226 memset(&lock, 0, sizeof(TelSimLockInfo_t));
1228 conn = G_DBUS_CONNECTION (source_object);
1229 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1230 CHECK_DEINIT(error);
1233 if (evt_cb_data->cb_fn) {
1234 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1238 g_error_free(error);
1244 g_variant_get(dbus_result, "(iiii)", &result, &lock.lock_type, &lock.lock_status,
1247 if (evt_cb_data->cb_fn) {
1248 evt_cb_data->cb_fn(evt_cb_data->handle, result, &lock, evt_cb_data->user_data);
1254 static void on_response_req_sim_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data)
1256 GError *error = NULL;
1257 GDBusConnection *conn = NULL;
1258 GVariant *dbus_result;
1260 GVariantIter *iter = NULL;
1261 GVariant *param_gv = NULL;
1262 GVariant *inner_gv = NULL;
1264 unsigned short i = 0;
1266 struct tapi_resp_data *evt_cb_data = user_data;
1267 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1268 TelSimApduResp_t r_apdu;
1270 dbg("Func Entrance");
1271 memset(&r_apdu, 0, sizeof(TelSimApduResp_t));
1273 conn = G_DBUS_CONNECTION (source_object);
1274 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1275 CHECK_DEINIT(error);
1278 if (evt_cb_data->cb_fn) {
1279 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1283 g_error_free(error);
1289 /* dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
1290 g_variant_get(dbus_result, "(i@v)", &result, ¶m_gv);
1291 inner_gv = g_variant_get_variant(param_gv);
1293 g_variant_get(inner_gv, "ay", &iter);
1294 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1295 r_apdu.apdu_resp[i] = rt_i;
1298 r_apdu.apdu_resp_len = i;
1299 dbg("r_apdu.apdu_resp_len=[%d]", r_apdu.apdu_resp_len);
1300 g_variant_iter_free(iter);
1301 g_variant_unref(inner_gv);
1302 g_variant_unref(param_gv);
1304 if (evt_cb_data->cb_fn) {
1305 evt_cb_data->cb_fn(evt_cb_data->handle, result, &r_apdu, evt_cb_data->user_data);
1311 static void on_response_req_sim_atr(GObject *source_object, GAsyncResult *res, gpointer user_data)
1313 GError *error = NULL;
1314 GDBusConnection *conn = NULL;
1315 GVariant *dbus_result;
1317 GVariantIter *iter = NULL;
1318 GVariant *param_gv = NULL;
1319 GVariant *inner_gv = NULL;
1321 unsigned short i = 0;
1323 struct tapi_resp_data *evt_cb_data = user_data;
1324 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1325 TelSimAtrResp_t r_atr;
1327 dbg("Func Entrance");
1328 memset(&r_atr, 0, sizeof(TelSimAtrResp_t));
1330 conn = G_DBUS_CONNECTION (source_object);
1331 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1332 CHECK_DEINIT(error);
1335 if (evt_cb_data->cb_fn) {
1336 evt_cb_data->cb_fn(evt_cb_data->handle, -1, NULL, evt_cb_data->user_data);
1340 g_error_free(error);
1346 dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));
1347 g_variant_get(dbus_result, "(i@v)", &result, ¶m_gv);
1348 inner_gv = g_variant_get_variant(param_gv);
1350 g_variant_get(inner_gv, "ay", &iter);
1351 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1352 r_atr.atr_resp[i] = rt_i;
1355 r_atr.atr_resp_len = i;
1356 dbg("r_atr.atr_resp_len=[%d]", r_atr.atr_resp_len);
1357 g_variant_iter_free(iter);
1358 g_variant_unref(inner_gv);
1359 g_variant_unref(param_gv);
1361 if (evt_cb_data->cb_fn) {
1362 evt_cb_data->cb_fn(evt_cb_data->handle, result, &r_atr, evt_cb_data->user_data);
1368 EXPORT_API int tel_get_sim_init_info(TapiHandle *handle, TelSimCardStatus_t *sim_status,
1371 GError *gerr = NULL;
1372 GVariant *sync_gv = NULL;
1373 int api_err = TAPI_API_SUCCESS;
1374 TelSimCardStatus_t init_status = 0;
1375 int changed = FALSE;
1377 dbg("Func Entrance");
1378 if (_tel_check_tapi_state() != 0)
1379 return TAPI_API_SERVICE_NOT_READY;
1381 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1382 TAPI_RETURN_VAL_IF_FAIL(sim_status, TAPI_API_INVALID_PTR);
1383 TAPI_RETURN_VAL_IF_FAIL(card_changed, TAPI_API_INVALID_PTR);
1385 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1386 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetInitStatus", NULL, NULL,
1387 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1390 g_variant_get(sync_gv, "(ib)", &init_status, &changed);
1391 *sim_status = init_status;
1392 *card_changed = changed;
1393 dbg("init_status[%d]",init_status);
1394 dbg("changed[%d]",changed);
1396 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1398 return TAPI_API_OPERATION_FAILED;
1400 g_variant_unref(sync_gv);
1404 EXPORT_API int tel_get_sim_type(TapiHandle *handle, TelSimCardType_t *card_type)
1406 GError *gerr = NULL;
1407 GVariant *sync_gv = NULL;
1410 dbg("Func Entrance");
1412 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1413 TAPI_RETURN_VAL_IF_FAIL(card_type, TAPI_API_INVALID_PTR);
1415 if (_tel_check_tapi_state() != 0)
1416 return TAPI_API_SERVICE_NOT_READY;
1418 sim_ret = _tel_check_sim_state(handle);
1419 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1422 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1423 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetCardType", NULL, NULL,
1424 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1427 g_variant_get(sync_gv, "(i)", card_type);
1429 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1431 return TAPI_API_OPERATION_FAILED;
1433 g_variant_unref(sync_gv);
1434 return TAPI_API_SUCCESS;
1437 EXPORT_API int tel_get_sim_imsi(TapiHandle *handle, TelSimImsiInfo_t *imsi)
1439 GError *gerr = NULL;
1440 GVariant *sync_gv = NULL;
1441 gchar *gplmn = NULL;
1442 gchar *gmsin = NULL;
1445 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1447 dbg("Func Entrance");
1448 if (_tel_check_tapi_state() != 0)
1449 return TAPI_API_SERVICE_NOT_READY;
1451 sim_ret =_tel_check_sim_state(handle);
1452 if (sim_ret != TAPI_API_SUCCESS)
1455 TAPI_RETURN_VAL_IF_FAIL(imsi, TAPI_API_INVALID_PTR);
1457 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1458 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetIMSI", NULL, NULL,
1459 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1462 dbg("imsi type_format(%s)", g_variant_get_type_string(sync_gv));
1463 g_variant_get(sync_gv, "(ss)", &gplmn, &gmsin);
1465 dbg("gplmn[%s],gmsin[%s]",gplmn,gmsin);
1466 snprintf(imsi->szMcc, 3 + 1, "%s", gplmn);
1467 snprintf(imsi->szMnc, strlen((const char*)gplmn) - 3 + 1, "%s", &gplmn[3]);
1468 snprintf(imsi->szMsin, strlen((const char*)gmsin) + 1, "%s", gmsin);
1470 dbg("imsi->szMnc[%s]", imsi->szMnc);
1471 dbg("imsi->szMcc[%s]", imsi->szMcc);
1475 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1477 return TAPI_API_OPERATION_FAILED;
1479 g_variant_unref(sync_gv);
1480 return TAPI_API_SUCCESS;
1483 EXPORT_API int tel_get_sim_ecc(TapiHandle *handle, TelSimEccList_t *ecc)
1485 GError *gerr = NULL;
1487 GVariant *value = NULL;
1488 GVariantIter *iter = NULL;
1489 GVariantIter *iter_row = NULL;
1490 const gchar *key = NULL;
1491 const gchar *str_value = NULL;
1495 dbg("Func Entrance");
1496 memset(ecc, 0, sizeof(TelSimEccList_t));
1497 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1498 TAPI_RETURN_VAL_IF_FAIL(ecc, TAPI_API_INVALID_PTR);
1500 sim_ret =_tel_check_sim_state(handle);
1501 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1504 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1505 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetECC", NULL, NULL,
1506 G_DBUS_CALL_FLAGS_NONE, -1, NULL, &gerr);
1509 /* dbg("ecc type_format(%s)", g_variant_get_type_string(sync_gv));*/
1510 g_variant_get(sync_gv, "(aa{sv})", &iter);
1511 ecc->ecc_count = g_variant_iter_n_children(iter);
1512 dbg("ecc->ecc_count[%d]",ecc->ecc_count);
1514 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1515 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
1516 if (!g_strcmp0(key, "name")) {
1517 str_value = g_variant_get_string(value, NULL);
1518 snprintf(ecc->list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
1520 if (!g_strcmp0(key, "number")) {
1521 str_value = g_variant_get_string(value, NULL);
1522 snprintf(ecc->list[i].number, strlen((const char*)str_value) + 1, "%s", str_value);
1524 if (!g_strcmp0(key, "category")) {
1525 ecc->list[i].category = g_variant_get_int32(value);
1529 g_variant_iter_free(iter_row);
1531 g_variant_iter_free(iter);
1533 dbg( "g_dbus_conn failed. error (%s)", gerr->message);
1535 return TAPI_API_OPERATION_FAILED;
1537 return TAPI_API_SUCCESS;
1540 EXPORT_API int tel_get_sim_iccid(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1542 struct tapi_resp_data *evt_cb_data = NULL;
1545 dbg("Func Entrance ");
1546 if (_tel_check_tapi_state() != 0)
1547 return TAPI_API_SERVICE_NOT_READY;
1549 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1551 sim_ret =_tel_check_sim_state(handle);
1552 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1555 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1557 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1558 DBUS_TELEPHONY_SIM_INTERFACE, "GetICCID", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
1559 on_response_get_sim_iccid, evt_cb_data);
1561 return TAPI_API_SUCCESS;
1564 EXPORT_API int tel_get_sim_language(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1566 struct tapi_resp_data *evt_cb_data = NULL;
1569 dbg("Func Entrance ");
1570 if (_tel_check_tapi_state() != 0)
1571 return TAPI_API_SERVICE_NOT_READY;
1573 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1575 sim_ret =_tel_check_sim_state(handle);
1576 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1579 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1581 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1582 DBUS_TELEPHONY_SIM_INTERFACE, "GetLanguage", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1583 handle->ca, on_response_get_sim_language, evt_cb_data);
1585 return TAPI_API_SUCCESS;
1588 EXPORT_API int tel_set_sim_language(TapiHandle *handle, TelSimLanguagePreferenceCode_t language,
1589 tapi_response_cb callback, void *user_data)
1591 struct tapi_resp_data *evt_cb_data = NULL;
1592 GVariant *param = NULL;
1595 dbg("Func Entrance w/ lang[%d]",language);
1596 if (_tel_check_tapi_state() != 0)
1597 return TAPI_API_SERVICE_NOT_READY;
1599 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1601 sim_ret =_tel_check_sim_state(handle);
1602 if (sim_ret != TAPI_API_SUCCESS)
1605 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1607 param = g_variant_new("(i)", language);
1609 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1610 DBUS_TELEPHONY_SIM_INTERFACE, "SetLanguage", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1611 handle->ca, on_response_set_sim_language, evt_cb_data);
1613 return TAPI_API_SUCCESS;
1616 EXPORT_API int tel_get_sim_callforwarding_info(TapiHandle *handle, tapi_response_cb callback,
1619 struct tapi_resp_data *evt_cb_data = NULL;
1622 dbg("Func Entrance ");
1623 if (_tel_check_tapi_state() != 0)
1624 return TAPI_API_SERVICE_NOT_READY;
1626 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1628 sim_ret =_tel_check_sim_state(handle);
1629 if (sim_ret != TAPI_API_SUCCESS)
1632 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1634 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1635 DBUS_TELEPHONY_SIM_INTERFACE, "GetCallForwarding", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
1636 -1, handle->ca, on_response_get_sim_callforwarding_info, evt_cb_data);
1638 return TAPI_API_SUCCESS;
1641 EXPORT_API int tel_set_sim_callforwarding_info(TapiHandle *handle, TelSimCallForwardingReq_t *req_cf,
1642 tapi_response_cb callback, void *user_data)
1644 struct tapi_resp_data *evt_cb_data = NULL;
1645 GVariant *param = NULL;
1647 gchar *g_number = NULL;
1649 if (_tel_check_tapi_state() != 0)
1650 return TAPI_API_SERVICE_NOT_READY;
1652 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1654 sim_ret =_tel_check_sim_state(handle);
1655 if (sim_ret != TAPI_API_SUCCESS)
1658 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1660 g_number = calloc(strlen((const char*)&req_cf->cf_data_u.cf.cfu_num)+1, 1);
1662 g_free(evt_cb_data);
1663 return TAPI_API_SYSTEM_OUT_OF_MEM;
1666 memcpy((void*)g_number, (const void*)&req_cf->cf_data_u.cf.cfu_num, strlen((const char*)&req_cf->cf_data_u.cf.cfu_num));
1668 param = g_variant_new("(biiyiisiibbbb)",
1670 req_cf->cf_data_u.cf.rec_index,
1671 req_cf->cf_data_u.cf.msp_num,
1672 req_cf->cf_data_u.cf.cfu_status,
1673 req_cf->cf_data_u.cf.ton,
1674 req_cf->cf_data_u.cf.npi,
1676 req_cf->cf_data_u.cf.cc2_id,
1677 req_cf->cf_data_u.cf.ext7_id,
1678 req_cf->cf_data_u.cphs_cf.b_line1,
1679 req_cf->cf_data_u.cphs_cf.b_line2,
1680 req_cf->cf_data_u.cphs_cf.b_fax,
1681 req_cf->cf_data_u.cphs_cf.b_data);
1683 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1684 DBUS_TELEPHONY_SIM_INTERFACE, "SetCallForwarding", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1685 handle->ca, on_response_set_sim_callforwarding_info, evt_cb_data);
1690 return TAPI_API_SUCCESS;
1693 EXPORT_API int tel_get_sim_messagewaiting_info(TapiHandle *handle, tapi_response_cb callback,
1696 struct tapi_resp_data *evt_cb_data = NULL;
1699 dbg("Func Entrance ");
1700 if (_tel_check_tapi_state() != 0)
1701 return TAPI_API_SERVICE_NOT_READY;
1703 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1705 sim_ret =_tel_check_sim_state(handle);
1706 if (sim_ret != TAPI_API_SUCCESS)
1709 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1711 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1712 DBUS_TELEPHONY_SIM_INTERFACE, "GetMessageWaiting", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
1713 -1, handle->ca, on_response_get_sim_messagewaiting_info, evt_cb_data);
1715 return TAPI_API_SUCCESS;
1718 EXPORT_API int tel_set_sim_messagewaiting_info(TapiHandle *handle, TelSimMessageWaitingReq_t *req_mw,
1719 tapi_response_cb callback, void *user_data)
1721 struct tapi_resp_data *evt_cb_data = NULL;
1722 GVariant *param = NULL;
1725 if (_tel_check_tapi_state() != 0)
1726 return TAPI_API_SERVICE_NOT_READY;
1728 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1730 sim_ret =_tel_check_sim_state(handle);
1731 if (sim_ret != TAPI_API_SUCCESS)
1734 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1736 dbg("b_cphs[%d], rec_index[%d], indicator_status[0x%x], voice_count[%d], fax_count[%d], email_count[%d], other_count[%d], video_count[%d], b_voice1[%d],b_voice2[%d],b_fax[%d], b_data[%d]",
1738 req_mw->mw_data_u.mw.rec_index,
1739 req_mw->mw_data_u.mw.indicator_status,
1740 req_mw->mw_data_u.mw.voice_count,
1741 req_mw->mw_data_u.mw.fax_count,
1742 req_mw->mw_data_u.mw.email_count,
1743 req_mw->mw_data_u.mw.other_count,
1744 req_mw->mw_data_u.mw.video_count,
1745 req_mw->mw_data_u.cphs_mw.b_voice1,
1746 req_mw->mw_data_u.cphs_mw.b_voice2,
1747 req_mw->mw_data_u.cphs_mw.b_fax,
1748 req_mw->mw_data_u.cphs_mw.b_data);
1750 param = g_variant_new("(biyiiiiibbbb)",
1752 req_mw->mw_data_u.mw.rec_index,
1753 req_mw->mw_data_u.mw.indicator_status,
1754 req_mw->mw_data_u.mw.voice_count,
1755 req_mw->mw_data_u.mw.fax_count,
1756 req_mw->mw_data_u.mw.email_count,
1757 req_mw->mw_data_u.mw.other_count,
1758 req_mw->mw_data_u.mw.video_count,
1759 req_mw->mw_data_u.cphs_mw.b_voice1,
1760 req_mw->mw_data_u.cphs_mw.b_voice2,
1761 req_mw->mw_data_u.cphs_mw.b_fax,
1762 req_mw->mw_data_u.cphs_mw.b_data);
1764 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1765 DBUS_TELEPHONY_SIM_INTERFACE, "SetMessageWaiting", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1766 handle->ca, on_response_set_sim_messagewaiting_info, evt_cb_data);
1768 return TAPI_API_SUCCESS;
1771 EXPORT_API int tel_get_sim_mailbox_info(TapiHandle *handle, tapi_response_cb callback,
1774 struct tapi_resp_data *evt_cb_data = NULL;
1777 dbg("Func Entrance ");
1778 if (_tel_check_tapi_state() != 0)
1779 return TAPI_API_SERVICE_NOT_READY;
1781 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1783 sim_ret =_tel_check_sim_state(handle);
1784 if (sim_ret != TAPI_API_SUCCESS)
1787 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1789 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1790 DBUS_TELEPHONY_SIM_INTERFACE, "GetMailbox", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1791 handle->ca, on_response_get_sim_mailbox_info, evt_cb_data);
1793 return TAPI_API_SUCCESS;
1796 EXPORT_API int tel_set_sim_mailbox_info(TapiHandle *handle, TelSimMailBoxNumber_t *req_mb,
1797 tapi_response_cb callback, void *user_data)
1799 struct tapi_resp_data *evt_cb_data = NULL;
1800 GVariant *param = NULL;
1802 gchar *g_alpha = NULL;
1803 gchar *g_number = NULL;
1805 if (_tel_check_tapi_state() != 0)
1806 return TAPI_API_SERVICE_NOT_READY;
1808 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1810 sim_ret =_tel_check_sim_state(handle);
1811 if (sim_ret != TAPI_API_SUCCESS)
1814 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1816 g_alpha = calloc(strlen((const char*)&req_mb->alpha_id)+1, 1);
1818 g_free(evt_cb_data);
1819 return TAPI_API_SYSTEM_OUT_OF_MEM;
1822 memcpy((void*)g_alpha, (const void*)&req_mb->alpha_id, strlen((const char*)&req_mb->alpha_id));
1824 g_number = calloc(strlen((const char*)&req_mb->num)+1, 1);
1827 g_free(evt_cb_data);
1828 return TAPI_API_SYSTEM_OUT_OF_MEM;
1831 memcpy((void*)g_number, (const void*)&req_mb->num, strlen((const char*)&req_mb->num));
1833 dbg("req_mb->b_cphs[%d], req_mb->rec_index[%d], req_mb->profile_num[%d], req_mb->mb_type[%d], req_mb->alpha_id_max_len[%d],req_mb->alpha_id[%s]",
1836 req_mb->profile_num,
1838 req_mb->alpha_id_max_len,
1841 dbg("req_mb->ton[%d],req_mb->npi[%d],g_number[%s],req_mb->cc_id[%d],req_mb->ext1_id[%d]",
1848 param = g_variant_new("(biiiisiisii)",
1852 req_mb->profile_num,
1853 req_mb->alpha_id_max_len,
1861 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1862 DBUS_TELEPHONY_SIM_INTERFACE, "SetMailbox", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1863 handle->ca, on_response_set_sim_mailbox_info, evt_cb_data);
1871 return TAPI_API_SUCCESS;
1874 EXPORT_API int tel_get_sim_cphs_info(TapiHandle *handle, tapi_response_cb callback,
1877 struct tapi_resp_data *evt_cb_data = NULL;
1880 dbg("Func Entrance ");
1881 if (_tel_check_tapi_state() != 0)
1882 return TAPI_API_SERVICE_NOT_READY;
1884 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1886 sim_ret =_tel_check_sim_state(handle);
1887 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1890 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1892 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1893 DBUS_TELEPHONY_SIM_INTERFACE, "GetCPHSInfo", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
1894 on_response_get_sim_cphs_info, evt_cb_data);
1896 return TAPI_API_SUCCESS;
1899 EXPORT_API int tel_get_sim_msisdn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1901 struct tapi_resp_data *evt_cb_data = NULL;
1904 dbg("Func Entrance ");
1905 if (_tel_check_tapi_state() != 0)
1906 return TAPI_API_SERVICE_NOT_READY;
1908 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1910 sim_ret =_tel_check_sim_state(handle);
1911 if (sim_ret != TAPI_API_SUCCESS)
1914 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1916 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1917 DBUS_TELEPHONY_SIM_INTERFACE, "GetMSISDN", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
1918 on_response_get_sim_msisdn, evt_cb_data);
1920 return TAPI_API_SUCCESS;
1923 EXPORT_API int tel_get_sim_oplmnwact(TapiHandle *handle, tapi_response_cb callback,
1926 struct tapi_resp_data *evt_cb_data = NULL;
1929 dbg("Func Entrance ");
1930 if (_tel_check_tapi_state() != 0)
1931 return TAPI_API_SERVICE_NOT_READY;
1933 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1935 sim_ret =_tel_check_sim_state(handle);
1936 if (sim_ret != TAPI_API_SUCCESS)
1939 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1941 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1942 DBUS_TELEPHONY_SIM_INTERFACE, "GetOplmnwact", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1943 handle->ca, on_response_get_sim_oplmnwact, evt_cb_data);
1945 return TAPI_API_SUCCESS;
1948 EXPORT_API int tel_get_sim_spn(TapiHandle *handle, tapi_response_cb callback,
1951 struct tapi_resp_data *evt_cb_data = NULL;
1954 dbg("Func Entrance ");
1955 if (_tel_check_tapi_state() != 0)
1956 return TAPI_API_SERVICE_NOT_READY;
1958 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1960 sim_ret =_tel_check_sim_state(handle);
1961 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
1964 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1966 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1967 DBUS_TELEPHONY_SIM_INTERFACE, "GetSpn", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1968 handle->ca, on_response_get_sim_spn, evt_cb_data);
1970 return TAPI_API_SUCCESS;
1973 EXPORT_API int tel_get_sim_cphs_netname(TapiHandle *handle, tapi_response_cb callback,
1976 struct tapi_resp_data *evt_cb_data = NULL;
1979 dbg("Func Entrance ");
1980 if (_tel_check_tapi_state() != 0)
1981 return TAPI_API_SERVICE_NOT_READY;
1983 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1985 sim_ret =_tel_check_sim_state(handle);
1986 if (sim_ret != TAPI_API_SUCCESS)
1989 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1991 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1992 DBUS_TELEPHONY_SIM_INTERFACE, "GetCphsNetName", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
1993 handle->ca, on_response_get_sim_cphs_netname, evt_cb_data);
1995 return TAPI_API_SUCCESS;
1998 EXPORT_API int tel_req_sim_authentication(TapiHandle *handle,
1999 TelSimAuthenticationData_t *authentication_data, tapi_response_cb callback, void *user_data)
2001 struct tapi_resp_data *evt_cb_data = NULL;
2002 GVariantBuilder *builder = NULL;
2003 GVariant *param = NULL;
2004 GVariant *rand_gv = NULL;
2005 GVariant *autn_gv = NULL;
2009 dbg("Func Entrance ");
2010 if (_tel_check_tapi_state() != 0)
2011 return TAPI_API_SERVICE_NOT_READY;
2013 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2015 sim_ret =_tel_check_sim_state(handle);
2016 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2019 TAPI_RETURN_VAL_IF_FAIL(authentication_data, TAPI_API_INVALID_PTR);
2021 if (authentication_data->auth_type > TAPI_SIM_AUTH_TYPE_3G)
2022 return TAPI_API_INVALID_INPUT;
2024 if (authentication_data->rand_length == 0)
2025 return TAPI_API_INVALID_INPUT;
2027 if (authentication_data->auth_type != TAPI_SIM_AUTH_TYPE_GSM
2028 && authentication_data->autn_length == 0)
2029 return TAPI_API_INVALID_INPUT;
2031 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2033 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2034 for (i = 0; i < authentication_data->rand_length; i++) {
2035 dbg("authentication_data->rand_data[%d][0x%02x]", i,authentication_data->rand_data[i]);
2036 g_variant_builder_add(builder, "y", authentication_data->rand_data[i]);
2038 rand_gv = g_variant_builder_end(builder);
2040 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2041 for (i = 0; i < authentication_data->autn_length; i++) {
2042 dbg("authentication_data->autn_data[%d][0x%02x]", i,authentication_data->autn_data[i]);
2043 g_variant_builder_add(builder, "y", authentication_data->autn_data[i]);
2045 autn_gv = g_variant_builder_end(builder);
2047 param = g_variant_new("(ivv)", authentication_data->auth_type, rand_gv, autn_gv);
2048 /*g_variant_builder_unref (builder);*/
2050 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2051 DBUS_TELEPHONY_SIM_INTERFACE, "Authentication", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2052 handle->ca, on_response_req_sim_authentication, evt_cb_data);
2054 return TAPI_API_SUCCESS;
2057 EXPORT_API int tel_verifiy_sim_pins(TapiHandle *handle, const TelSimSecPw_t *pin_data,
2058 tapi_response_cb callback, void *user_data)
2060 struct tapi_resp_data *evt_cb_data = NULL;
2061 GVariant *param = NULL;
2065 dbg("Func Entrance");
2066 if (_tel_check_tapi_state() != 0)
2067 return TAPI_API_SERVICE_NOT_READY;
2069 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2071 sim_ret =_tel_check_sim_state(handle);
2072 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2075 TAPI_RETURN_VAL_IF_FAIL(pin_data, TAPI_API_INVALID_PTR);
2076 TAPI_RETURN_VAL_IF_FAIL(pin_data->pw, TAPI_API_INVALID_PTR);
2078 dbg("pin type[%d]", pin_data->type);
2079 if (pin_data->type != TAPI_SIM_PTYPE_PIN1 && pin_data->type != TAPI_SIM_PTYPE_PIN2
2080 && pin_data->type != TAPI_SIM_PTYPE_SIM)
2081 return TAPI_API_INVALID_INPUT;
2083 if ((pin_data->pw_len < 4) || (pin_data->pw_len > 8))
2084 return TAPI_API_INVALID_INPUT;
2086 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2088 gpw = calloc(pin_data->pw_len+1, 1);
2090 g_free(evt_cb_data);
2091 return TAPI_API_SYSTEM_OUT_OF_MEM;
2094 memcpy((void*)gpw, (const void*)pin_data->pw, pin_data->pw_len);
2096 param = g_variant_new("(is)", pin_data->type, gpw);
2098 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2099 DBUS_TELEPHONY_SIM_INTERFACE, "VerifySec", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2100 handle->ca, on_response_verify_sim_pins, evt_cb_data);
2105 return TAPI_API_SUCCESS;
2108 EXPORT_API int tel_verify_sim_puks(TapiHandle *handle, const TelSimSecPw_t *puk_data,
2109 const TelSimSecPw_t *new_pin_data, tapi_response_cb callback, void *user_data)
2111 struct tapi_resp_data *evt_cb_data = NULL;
2112 GVariant *param = NULL;
2117 dbg("Func Entrance");
2118 if (_tel_check_tapi_state() != 0)
2119 return TAPI_API_SERVICE_NOT_READY;
2121 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2123 sim_ret =_tel_check_sim_state(handle);
2124 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2127 TAPI_RETURN_VAL_IF_FAIL((puk_data != NULL && new_pin_data != NULL), TAPI_API_INVALID_PTR);
2128 TAPI_RETURN_VAL_IF_FAIL((puk_data->pw != NULL && new_pin_data->pw != NULL), TAPI_API_INVALID_PTR);
2130 dbg("puk type[%d] pin type[%d]", puk_data->type, new_pin_data->type);
2131 if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 && puk_data->type != TAPI_SIM_PTYPE_PUK2)
2132 || (new_pin_data->type != TAPI_SIM_PTYPE_PIN1 && new_pin_data->type != TAPI_SIM_PTYPE_PIN2))
2133 return TAPI_API_INVALID_INPUT;
2135 if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 || new_pin_data->type != TAPI_SIM_PTYPE_PIN1)
2136 && (puk_data->type != TAPI_SIM_PTYPE_PUK2 || new_pin_data->type != TAPI_SIM_PTYPE_PIN2))
2137 return TAPI_API_INVALID_INPUT;
2139 if ((puk_data->pw_len < 4) || (puk_data->pw_len > 8) || (new_pin_data->pw_len < 4)
2140 || (new_pin_data->pw_len > 8))
2141 return TAPI_API_INVALID_INPUT;
2143 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2145 gpin = calloc(new_pin_data->pw_len+1, 1);
2147 g_free(evt_cb_data);
2148 return TAPI_API_SYSTEM_OUT_OF_MEM;
2151 gpuk = calloc(puk_data->pw_len+1, 1);
2153 g_free(evt_cb_data);
2155 return TAPI_API_SYSTEM_OUT_OF_MEM;
2158 memcpy((void*)gpin, (const void*)new_pin_data->pw, new_pin_data->pw_len);
2159 memcpy((void*)gpuk, (const void*)puk_data->pw, puk_data->pw_len);
2161 param = g_variant_new("(iss)", puk_data->type, gpuk, gpin);
2163 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2164 DBUS_TELEPHONY_SIM_INTERFACE, "VerifyPUK", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2165 handle->ca, on_response_verify_sim_puks, evt_cb_data);
2173 return TAPI_API_SUCCESS;
2176 EXPORT_API int tel_change_sim_pins(TapiHandle *handle, const TelSimSecPw_t *old_pin,
2177 const TelSimSecPw_t *new_pin, tapi_response_cb callback, void *user_data)
2179 struct tapi_resp_data *evt_cb_data = NULL;
2180 GVariant *param = NULL;
2181 gchar *gpin_o = NULL;
2182 gchar *gpin_n = NULL;
2185 dbg("Func Entrance");
2186 if (_tel_check_tapi_state() != 0)
2187 return TAPI_API_SERVICE_NOT_READY;
2189 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2191 sim_ret =_tel_check_sim_state(handle);
2192 if (sim_ret != TAPI_API_SUCCESS)
2195 TAPI_RETURN_VAL_IF_FAIL((old_pin != NULL && new_pin != NULL), TAPI_API_INVALID_PTR);
2196 TAPI_RETURN_VAL_IF_FAIL((old_pin->pw != NULL && new_pin->pw != NULL), TAPI_API_INVALID_PTR);
2198 dbg("old_pin type[%d],new_pin type[%d]", old_pin->type, new_pin->type);
2199 if ((old_pin->type != TAPI_SIM_PTYPE_PIN1) && (old_pin->type != TAPI_SIM_PTYPE_PIN2)
2200 && (new_pin->type != TAPI_SIM_PTYPE_PIN1) && (new_pin->type != TAPI_SIM_PTYPE_PIN2))
2201 return TAPI_API_INVALID_INPUT;
2203 if (old_pin->type != new_pin->type)
2204 return TAPI_API_INVALID_INPUT;
2206 if ((old_pin->pw_len < 4) || (old_pin->pw_len > 8))
2207 return TAPI_API_INVALID_INPUT;
2209 if ((new_pin->pw_len < 4) || (new_pin->pw_len > 8))
2210 return TAPI_API_INVALID_INPUT;
2212 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2214 gpin_o = calloc(old_pin->pw_len+1, 1);
2216 g_free(evt_cb_data);
2217 return TAPI_API_SYSTEM_OUT_OF_MEM;
2220 gpin_n = calloc(new_pin->pw_len+1, 1);
2223 g_free(evt_cb_data);
2224 return TAPI_API_SYSTEM_OUT_OF_MEM;
2227 memcpy((void*)gpin_o, (const void*)old_pin->pw, old_pin->pw_len);
2228 memcpy((void*)gpin_n, (const void*)new_pin->pw, new_pin->pw_len);
2230 param = g_variant_new("(iss)", old_pin->type, gpin_o, gpin_n);
2231 dbg("old_pin len[%d],new_pin len[%d]", old_pin->pw_len, new_pin->pw_len);
2233 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2234 DBUS_TELEPHONY_SIM_INTERFACE, "ChangePIN", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2235 handle->ca, on_response_change_sim_pins, evt_cb_data);
2243 return TAPI_API_SUCCESS;
2246 EXPORT_API int tel_disable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw,
2247 tapi_response_cb callback, void *user_data)
2249 struct tapi_resp_data *evt_cb_data = NULL;
2250 GVariant *param = NULL;
2254 dbg("Func Entrance");
2255 if (_tel_check_tapi_state() != 0)
2256 return TAPI_API_SERVICE_NOT_READY;
2258 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2260 sim_ret =_tel_check_sim_state(handle);
2261 if (sim_ret != TAPI_API_SUCCESS)
2264 TAPI_RETURN_VAL_IF_FAIL(pw, TAPI_API_INVALID_PTR);
2265 TAPI_RETURN_VAL_IF_FAIL(pw->pw, TAPI_API_INVALID_PTR);
2267 dbg("facility type[%d]", pw->lock_type);
2268 if(pw->lock_type < TAPI_SIM_LOCK_PS || pw->lock_type >TAPI_SIM_LOCK_PC)
2269 return TAPI_API_INVALID_INPUT;
2270 if ((pw->lock_type < TAPI_SIM_LOCK_PN) && ((pw->pw_len < 4) || (pw->pw_len > 8)) )
2271 return TAPI_API_INVALID_INPUT;
2272 if ((pw->lock_type > TAPI_SIM_LOCK_FD) && (pw->pw_len < 6) )
2273 return TAPI_API_INVALID_INPUT;
2275 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2277 gpw = calloc(pw->pw_len+1, 1);
2279 g_free(evt_cb_data);
2280 return TAPI_API_SYSTEM_OUT_OF_MEM;
2283 memcpy((void*)gpw, (const void*)pw->pw, pw->pw_len);
2285 param = g_variant_new("(is)", pw->lock_type, gpw);
2287 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2288 DBUS_TELEPHONY_SIM_INTERFACE, "DisableFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE,
2289 -1, handle->ca, on_response_disable_sim_facility, evt_cb_data);
2294 return TAPI_API_SUCCESS;
2297 EXPORT_API int tel_enable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw,
2298 tapi_response_cb callback, void *user_data)
2300 struct tapi_resp_data *evt_cb_data = NULL;
2301 GVariant *param = NULL;
2305 dbg("Func Entrance");
2306 if (_tel_check_tapi_state() != 0)
2307 return TAPI_API_SERVICE_NOT_READY;
2309 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2311 sim_ret =_tel_check_sim_state(handle);
2312 if (sim_ret != TAPI_API_SUCCESS)
2315 TAPI_RETURN_VAL_IF_FAIL(pw, TAPI_API_INVALID_PTR);
2316 TAPI_RETURN_VAL_IF_FAIL(pw->pw, TAPI_API_INVALID_PTR);
2318 dbg("facility type[%d]", pw->lock_type);
2319 if(pw->lock_type < TAPI_SIM_LOCK_PS || pw->lock_type >TAPI_SIM_LOCK_PC)
2320 return TAPI_API_INVALID_INPUT;
2321 if ((pw->lock_type < TAPI_SIM_LOCK_PN) && ((pw->pw_len < 4) || (pw->pw_len > 8)) )
2322 return TAPI_API_INVALID_INPUT;
2323 if ((pw->lock_type > TAPI_SIM_LOCK_FD) && (pw->pw_len < 6) )
2324 return TAPI_API_INVALID_INPUT;
2326 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2328 gpw = calloc(pw->pw_len+1, 1);
2330 g_free(evt_cb_data);
2331 return TAPI_API_SYSTEM_OUT_OF_MEM;
2334 memcpy((void*)gpw, (const void*)pw->pw, pw->pw_len);
2336 param = g_variant_new("(is)", pw->lock_type, gpw);
2338 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2339 DBUS_TELEPHONY_SIM_INTERFACE, "EnableFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2340 handle->ca, on_response_enable_sim_facility, evt_cb_data);
2345 return TAPI_API_SUCCESS;
2348 EXPORT_API int tel_get_sim_facility(TapiHandle *handle, TelSimLockType_t type,
2349 tapi_response_cb callback, void *user_data)
2351 struct tapi_resp_data *evt_cb_data = NULL;
2352 GVariant *param = NULL;
2355 dbg("Func Entrance");
2356 if (_tel_check_tapi_state() != 0)
2357 return TAPI_API_SERVICE_NOT_READY;
2359 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2361 sim_ret =_tel_check_sim_state(handle);
2362 if (sim_ret != TAPI_API_SUCCESS)
2365 dbg("facility type[%d]", type);
2366 if(type < TAPI_SIM_LOCK_PS || type >TAPI_SIM_LOCK_PC)
2367 return TAPI_API_INVALID_INPUT;
2369 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2371 param = g_variant_new("(i)", type);
2373 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2374 DBUS_TELEPHONY_SIM_INTERFACE, "GetFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2375 handle->ca, on_response_get_sim_facility, evt_cb_data);
2377 return TAPI_API_SUCCESS;
2380 EXPORT_API int tel_get_sim_lock_info(TapiHandle *handle, TelSimLockType_t type,
2381 tapi_response_cb callback, void *user_data)
2383 struct tapi_resp_data *evt_cb_data = NULL;
2384 GVariant *param = NULL;
2387 dbg("Func Entrance");
2388 if (_tel_check_tapi_state() != 0)
2389 return TAPI_API_SERVICE_NOT_READY;
2391 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2393 sim_ret =_tel_check_sim_state(handle);
2394 if (sim_ret != TAPI_API_SUCCESS && sim_ret != TAPI_API_SIM_LOCKED)
2397 dbg("lock type[%d]", type);
2398 if(type < TAPI_SIM_LOCK_PS || type >TAPI_SIM_LOCK_PC)
2399 return TAPI_API_INVALID_INPUT;
2401 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2403 param = g_variant_new("(i)", type);
2405 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2406 DBUS_TELEPHONY_SIM_INTERFACE, "GetLockInfo", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2407 handle->ca, on_response_get_sim_lock_info, evt_cb_data);
2409 return TAPI_API_SUCCESS;
2412 EXPORT_API int tel_req_sim_apdu(TapiHandle *handle, TelSimApdu_t* apdu_data,
2413 tapi_response_cb callback, void *user_data)
2415 struct tapi_resp_data *evt_cb_data = NULL;
2416 GVariantBuilder *builder = NULL;
2417 GVariant *param = NULL;
2418 GVariant *inner_gv = NULL;
2422 dbg("Func Entrance");
2423 if (_tel_check_tapi_state() != 0)
2424 return TAPI_API_SERVICE_NOT_READY;
2426 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2428 sim_ret =_tel_check_sim_state(handle);
2429 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2432 TAPI_RETURN_VAL_IF_FAIL(apdu_data, TAPI_API_INVALID_PTR);
2433 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2435 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2436 for (i = 0; i < apdu_data->apdu_len; i++) {
2437 dbg("apdu_data->apdu[%d][0x%02x]", i,apdu_data->apdu[i]);
2438 g_variant_builder_add(builder, "y", apdu_data->apdu[i]);
2440 inner_gv = g_variant_builder_end(builder);
2441 param = g_variant_new("(v)", inner_gv);
2442 /*g_variant_builder_unref (builder);*/
2444 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2445 DBUS_TELEPHONY_SIM_INTERFACE, "TransferAPDU", param, NULL, G_DBUS_CALL_FLAGS_NONE, -1,
2446 handle->ca, on_response_req_sim_apdu, evt_cb_data);
2448 return TAPI_API_SUCCESS;
2451 EXPORT_API int tel_req_sim_atr(TapiHandle *handle, tapi_response_cb callback, void *user_data)
2453 struct tapi_resp_data *evt_cb_data = NULL;
2456 dbg("Func Entrance");
2457 if (_tel_check_tapi_state() != 0)
2458 return TAPI_API_SERVICE_NOT_READY;
2460 TAPI_RETURN_VAL_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2462 sim_ret =_tel_check_sim_state(handle);
2463 if (sim_ret == TAPI_API_SIM_CARD_ERROR || sim_ret == TAPI_API_SIM_NOT_FOUND)
2466 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2468 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2469 DBUS_TELEPHONY_SIM_INTERFACE, "GetATR", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, -1, handle->ca,
2470 on_response_req_sim_atr, evt_cb_data);
2472 return TAPI_API_SUCCESS;