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 #define DBUS_SIM_STATUS_ERROR "SIM STATUS ERROR"
34 #define DBUS_SIM_NOT_FOUND "SIM NOT FOUND"
35 #define DBUS_SIM_PERM_BLOCKED "SIM PERM BLOCKED"
36 #define DBUS_SIM_CARD_ERROR "SIM CARD ERROR"
37 #define DBUS_SIM_NOT_INITIALIZED "SIM NOT INITIALIZED"
38 #define DBUS_SIM_INIT_COMPLETED "SIM INIT COMPLETED"
39 #define DBUS_SIM_LOCKED "SIM LOCKED"
40 #define DBUS_SIM_NOT_READY "SIM NOT READY"
41 #define DBUS_SIM_RESPONSE_DATA_ERROR "SIM RESPONSE DATA ERROR"
42 #define DBUS_SIM_SERVICE_IS_DISABLED "SIM SERVICE IS DISABLED"
44 #define TAPI_SIM_CHECK_TAPI_STATE() {\
45 if (_tel_check_tapi_state() != 0) \
46 return TAPI_API_SERVICE_NOT_READY; \
49 #define TAPI_SIM_CHECK_ERR_MSG(error) { \
50 TapiResult_t ret = TAPI_API_OPERATION_FAILED; \
52 ret = __check_err_msg(error->message); \
53 g_error_free(error); \
58 #define TAPI_SIM_CALL_CBFUNC(evtcbdata, result, data) { \
59 if (evtcbdata->cb_fn) { \
60 evtcbdata->cb_fn(evtcbdata->handle, result, data, evtcbdata->user_data); \
64 #define TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evtcbdata) { \
65 TapiResult_t ret = TAPI_API_OPERATION_FAILED; \
67 ret = __check_err_msg(error->message); \
68 g_error_free(error); \
70 TAPI_SIM_CALL_CBFUNC(evtcbdata, ret, NULL); \
75 struct tapi_sim_resp_data {
76 struct tapi_resp_data tapi_resp;
77 TelSimTapiOperation_t op_type;
80 static TapiResult_t __check_err_msg(gchar* err_msg)
82 TapiResult_t ret = TAPI_API_OPERATION_FAILED;
86 err( "error from dbus layer. (%s)", err_msg);
88 if( strstr(err_msg, DBUS_SIM_NOT_FOUND) ) {
89 ret = TAPI_API_SIM_NOT_FOUND;
90 } else if( strstr(err_msg, DBUS_SIM_PERM_BLOCKED) ) {
91 ret = TAPI_API_SIM_PERM_BLOCKED;
92 } else if( strstr(err_msg, DBUS_SIM_CARD_ERROR) ) {
93 ret = TAPI_API_SIM_CARD_ERROR;
94 } else if( strstr(err_msg, DBUS_SIM_NOT_INITIALIZED) ) {
95 ret = TAPI_API_SIM_NOT_INITIALIZED;
96 } else if( strstr(err_msg, DBUS_SIM_INIT_COMPLETED) ) {
97 ret = TAPI_API_SUCCESS;
98 } else if( strstr(err_msg, DBUS_SIM_LOCKED) ) {
99 ret = TAPI_API_SIM_LOCKED;
100 } else if( strstr(err_msg, DBUS_SIM_NOT_READY) ) {
101 ret = TAPI_API_SERVICE_NOT_READY;
102 } else if( strstr(err_msg, DBUS_SIM_RESPONSE_DATA_ERROR) ) {
103 ret = TAPI_API_OPERATION_FAILED;
104 } else if( strstr(err_msg, DBUS_SIM_SERVICE_IS_DISABLED) ) {
105 ret = TAPI_API_SIM_SERVICE_IS_DISABLED;
107 ret = TAPI_API_OPERATION_FAILED;
113 static const gchar* __get_dbus_method_name(TelSimTapiOperation_t op_type)
116 case TAPI_SIM_GET_INIT_STATUS:
117 return "GetInitStatus";
119 case TAPI_SIM_GET_CARD_TYPE:
120 return "GetCardType";
122 case TAPI_SIM_GET_IMSI:
125 case TAPI_SIM_GET_ECC:
128 case TAPI_SIM_GET_ICCID:
131 case TAPI_SIM_GET_MSISDN:
134 case TAPI_SIM_GET_SPN:
137 case TAPI_SIM_GET_CPHS_NET_NAME:
138 return "GetCphsNetName";
140 case TAPI_SIM_TRANSFER_APDU:
141 return "TransferAPDU";
143 case TAPI_SIM_GET_ATR:
147 // below are not supported.
148 case TAPI_SIM_GET_LANGUAGE:
149 case TAPI_SIM_SET_LANGUAGE:
150 case TAPI_SIM_GET_CALL_FORWARDING:
151 case TAPI_SIM_SET_CALL_FORWARDING:
152 case TAPI_SIM_GET_MESSAGE_WAITING:
153 case TAPI_SIM_SET_MESSAGE_WAITING:
154 case TAPI_SIM_GET_MAILBOX:
155 case TAPI_SIM_SET_MAILBOX:
156 case TAPI_SIM_GET_CPHS_INFO:
157 case TAPI_SIM_GET_SVCT:
158 case TAPI_SIM_GET_OPLMWACT:
159 case TAPI_SIM_AUTHENTICATION:
160 case TAPI_SIM_VERIFY_SEC:
161 case TAPI_SIM_VERIFY_PUK:
162 case TAPI_SIM_CHANGE_PIN:
163 case TAPI_SIM_DISABLE_FACILITY:
164 case TAPI_SIM_ENABLE_FACILITY:
165 case TAPI_SIM_GET_FACILITY:
166 case TAPI_SIM_GET_LOCK_INFO:
167 case TAPI_SIM_GET_FIELDS:
168 case TAPI_SIM_STATUS:
169 case TAPI_SIM_REFRESHED:
171 return "NotSupported";
176 static GVariant* __make_dbus_req_data(TelSimTapiOperation_t op_type, TelSimRequestData_t *inparam)
178 GVariant *param = NULL;
180 case TAPI_SIM_GET_IMSI:
181 case TAPI_SIM_GET_ICCID:
182 case TAPI_SIM_GET_INIT_STATUS:
183 case TAPI_SIM_GET_MSISDN:
184 case TAPI_SIM_GET_SPN:
185 case TAPI_SIM_GET_CPHS_NET_NAME:
188 case TAPI_SIM_TRANSFER_APDU: {
189 GVariantBuilder *builder = NULL;
190 GVariant *inner_gv = NULL;
193 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
194 dbg("inparam->apdu.apdu_len=[%d]", inparam->apdu.apdu_len);
195 for (i = 0; i < inparam->apdu.apdu_len; i++) {
196 g_variant_builder_add(builder, "y", inparam->apdu.apdu[i]);
198 inner_gv = g_variant_builder_end(builder);
199 param = g_variant_new("(v)", inner_gv);
201 case TAPI_SIM_GET_ATR:
205 case TAPI_SIM_GET_CARD_TYPE:
206 case TAPI_SIM_GET_ECC:
207 case TAPI_SIM_GET_LANGUAGE:
208 case TAPI_SIM_SET_LANGUAGE:
209 case TAPI_SIM_GET_CALL_FORWARDING:
210 case TAPI_SIM_SET_CALL_FORWARDING:
211 case TAPI_SIM_GET_MESSAGE_WAITING:
212 case TAPI_SIM_SET_MESSAGE_WAITING:
213 case TAPI_SIM_GET_MAILBOX:
214 case TAPI_SIM_SET_MAILBOX:
215 case TAPI_SIM_GET_CPHS_INFO:
216 case TAPI_SIM_GET_SVCT:
217 case TAPI_SIM_GET_OPLMWACT:
218 case TAPI_SIM_AUTHENTICATION:
219 case TAPI_SIM_VERIFY_SEC:
220 case TAPI_SIM_VERIFY_PUK:
221 case TAPI_SIM_CHANGE_PIN:
222 case TAPI_SIM_DISABLE_FACILITY:
223 case TAPI_SIM_ENABLE_FACILITY:
224 case TAPI_SIM_GET_FACILITY:
225 case TAPI_SIM_GET_LOCK_INFO:
226 case TAPI_SIM_GET_FIELDS:
227 case TAPI_SIM_STATUS:
228 case TAPI_SIM_REFRESHED:
236 static TelSimAccessResult_t __get_dbus_resp_data(TelSimTapiOperation_t op_type, GVariant *sync_gv, TelSimResponseData_t *outparam)
238 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
239 GVariant *param_gv = NULL;
240 GVariant *inner_gv = NULL;
242 unsigned short i = 0;
244 GVariant *value = NULL;
245 GVariantIter *iter = NULL;
246 GVariantIter *iter_row = NULL;
247 const gchar *key = NULL;
248 const gchar *str_value = NULL;
251 case TAPI_SIM_GET_INIT_STATUS: {
252 g_variant_get(sync_gv, "(ib)", &outparam->init_info.card_status, &outparam->init_info.b_is_changed);
253 dbg("init_status[%d], changed[%d]", outparam->init_info.card_status, outparam->init_info.b_is_changed);
255 case TAPI_SIM_GET_CARD_TYPE: {
256 g_variant_get(sync_gv, "(i)", &outparam->card_type);
258 case TAPI_SIM_GET_ECC: {
259 g_variant_get(sync_gv, "(aa{sv})", &iter);
260 outparam->ecc_list.ecc_count = g_variant_iter_n_children(iter);
261 dbg("ecc_count[%d]",outparam->ecc_list.ecc_count);
263 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
264 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
265 if (!g_strcmp0(key, "name")) {
266 str_value = g_variant_get_string(value, NULL);
267 snprintf(outparam->ecc_list.list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
269 if (!g_strcmp0(key, "number")) {
270 str_value = g_variant_get_string(value, NULL);
271 snprintf(outparam->ecc_list.list[i].number, strlen((const char*)str_value) + 1, "%s", str_value);
273 if (!g_strcmp0(key, "category")) {
274 outparam->ecc_list.list[i].category = g_variant_get_int32(value);
278 g_variant_iter_free(iter_row);
280 g_variant_iter_free(iter);
282 case TAPI_SIM_GET_IMSI: {
288 g_variant_get(sync_gv, "(ss)", &gplmn, &gmsin);
290 gplmn_len = strlen((const char*)gplmn);
291 gmsin_len = strlen((const char*)gmsin);
293 if (gplmn_len >= 5 && gmsin_len >= 9) {
294 snprintf(outparam->imsi_info.szMcc, 3 + 1, "%s", gplmn);
295 snprintf(outparam->imsi_info.szMnc, gplmn_len - 3 + 1, "%s", &gplmn[3]);
296 snprintf(outparam->imsi_info.szMsin, gmsin_len + 1, "%s", gmsin);
298 memset(&outparam->imsi_info, 0, sizeof(TelSimImsiInfo_t));
301 case TAPI_SIM_GET_ICCID: {
304 g_variant_get(sync_gv, "(is)", &result, &iccid);
305 outparam->iccid_info.icc_length = strlen((const char*)iccid);
306 if(outparam->iccid_info.icc_length > TAPI_SIM_ICCID_LEN_MAX){
307 dbg("current tapi support 20 byte but received length[%d] so changed");
308 outparam->iccid_info.icc_length = TAPI_SIM_ICCID_LEN_MAX;
310 memcpy(outparam->iccid_info.icc_num, iccid, outparam->iccid_info.icc_length);
312 case TAPI_SIM_GET_MSISDN: {
313 g_variant_get(sync_gv, "(iaa{sv})", &result, &iter);
314 outparam->msisdn_list.count = g_variant_iter_n_children(iter);
316 /*this can be changed regarding concept*/
317 if(outparam->msisdn_list.count > 3){
318 dbg("current list.count[%d] but we fixed maximum with 3", outparam->msisdn_list.count);
319 outparam->msisdn_list.count = 3;
321 /*this can be changed regarding concept*/
324 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
325 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
326 if (!g_strcmp0(key, "name")) {
327 str_value = g_variant_get_string(value, NULL);
328 snprintf(outparam->msisdn_list.list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
330 if (!g_strcmp0(key, "number")) {
331 str_value = g_variant_get_string(value, NULL);
332 snprintf(outparam->msisdn_list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
336 g_variant_iter_free(iter_row);
337 /*this can be changed regarding concept*/
340 /*this can be changed regarding concept*/
342 g_variant_iter_free(iter);
344 dbg("msisdn count[%d]", outparam->msisdn_list.count);
345 for(i =0; i < outparam->msisdn_list.count; i++){
346 dbg("msisdn[%d]-name[%s]number[%s]",i,outparam->msisdn_list.list[i].name, outparam->msisdn_list.list[i].num);
349 case TAPI_SIM_GET_SPN: {
353 g_variant_get(sync_gv, "(iys)", &result, &dc, &spn);
354 dbg("result[%d]", result);
355 if ( result == TAPI_SIM_ACCESS_SUCCESS) {
356 dbg("spn[%s], display condition[0x%x]", spn, dc);
357 outparam->spn.display_condition = dc;
358 snprintf((char *)outparam->spn.spn, strlen((const char*)spn)+1, "%s", spn);
361 case TAPI_SIM_GET_CPHS_NET_NAME: {
362 gchar *full_name = NULL;
363 gchar *short_name = NULL;
365 g_variant_get(sync_gv, "(iss)", &result, &full_name, &short_name);
367 dbg("result[%d]", result);
368 if ( result == TAPI_SIM_ACCESS_SUCCESS) {
369 dbg("full name[%s], short name[%s]", full_name, short_name);
370 snprintf((char *)outparam->cphs_netname.full_name, strlen((const char*)full_name)+1, "%s", full_name);
371 snprintf((char *)outparam->cphs_netname.short_name, strlen((const char*)short_name)+1, "%s", short_name);
375 case TAPI_SIM_TRANSFER_APDU: {
376 g_variant_get(sync_gv, "(i@v)", &result, ¶m_gv);
377 inner_gv = g_variant_get_variant(param_gv);
379 g_variant_get(inner_gv, "ay", &iter);
380 while (g_variant_iter_loop(iter, "y", &rt_i)) {
381 outparam->apdu_resp.apdu_resp[i] = rt_i;
384 outparam->apdu_resp.apdu_resp_len = i;
385 dbg("r_apdu.apdu_resp_len=[%d]", outparam->apdu_resp.apdu_resp_len);
386 g_variant_iter_free(iter);
387 g_variant_unref(inner_gv);
388 g_variant_unref(param_gv);
390 case TAPI_SIM_GET_ATR: {
391 g_variant_get(sync_gv, "(i@v)", &result, ¶m_gv);
392 inner_gv = g_variant_get_variant(param_gv);
394 g_variant_get(inner_gv, "ay", &iter);
395 while (g_variant_iter_loop(iter, "y", &rt_i)) {
396 outparam->atr_resp.atr_resp[i] = rt_i;
399 outparam->atr_resp.atr_resp_len = i;
400 dbg("r_atr.atr_resp_len=[%d]", outparam->atr_resp.atr_resp_len);
401 g_variant_iter_free(iter);
402 g_variant_unref(inner_gv);
403 g_variant_unref(param_gv);
406 case TAPI_SIM_GET_LANGUAGE:break;
407 case TAPI_SIM_SET_LANGUAGE:break;
408 case TAPI_SIM_GET_CALL_FORWARDING:break;
409 case TAPI_SIM_SET_CALL_FORWARDING:break;
410 case TAPI_SIM_GET_MESSAGE_WAITING:break;
411 case TAPI_SIM_SET_MESSAGE_WAITING:break;
412 case TAPI_SIM_GET_MAILBOX:break;
413 case TAPI_SIM_SET_MAILBOX:break;
414 case TAPI_SIM_GET_CPHS_INFO:break;
415 case TAPI_SIM_GET_SVCT:break;
416 case TAPI_SIM_GET_OPLMWACT:break;
417 case TAPI_SIM_AUTHENTICATION:break;
418 case TAPI_SIM_VERIFY_SEC:break;
419 case TAPI_SIM_VERIFY_PUK:break;
420 case TAPI_SIM_CHANGE_PIN:break;
421 case TAPI_SIM_DISABLE_FACILITY:break;
422 case TAPI_SIM_ENABLE_FACILITY:break;
423 case TAPI_SIM_GET_FACILITY:break;
424 case TAPI_SIM_GET_LOCK_INFO:break;
425 case TAPI_SIM_GET_FIELDS:break; //for get various data at once
428 case TAPI_SIM_STATUS:break;
429 case TAPI_SIM_REFRESHED:break;
436 static int _tel_check_tapi_state()
441 static void on_response_get_sim_iccid(GObject *source_object, GAsyncResult *res, gpointer user_data)
443 GError *error = NULL;
444 GDBusConnection *conn = NULL;
445 GVariant *dbus_result;
447 struct tapi_resp_data *evt_cb_data = user_data;
448 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
449 TelSimIccIdInfo_t iccid_info;
452 dbg("Func Entrance");
453 memset(&iccid_info, 0, sizeof(TelSimIccIdInfo_t));
455 conn = G_DBUS_CONNECTION (source_object);
456 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
460 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
463 g_variant_get(dbus_result, "(is)", &result, &iccid);
464 iccid_info.icc_length = strlen((const char*)iccid);
465 if(iccid_info.icc_length > TAPI_SIM_ICCID_LEN_MAX){
466 dbg("current tapi support 20 byte but received length[%d] so changed");
467 iccid_info.icc_length = TAPI_SIM_ICCID_LEN_MAX;
469 memcpy(iccid_info.icc_num, iccid, iccid_info.icc_length);
471 TAPI_SIM_CALL_CBFUNC(evt_cb_data, result, &iccid_info);
475 static void on_response_get_sim_language(GObject *source_object, GAsyncResult *res,
478 GError *error = NULL;
479 GDBusConnection *conn = NULL;
480 GVariant *dbus_result;
482 struct tapi_resp_data *evt_cb_data = user_data;
483 TelSimLanguagePreferenceCode_t lang = TAPI_SIM_LP_LANG_UNSPECIFIED;
484 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
486 dbg("Func Entrance");
487 conn = G_DBUS_CONNECTION (source_object);
488 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
492 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
495 g_variant_get(dbus_result, "(ii)", &result, &lang);
497 if (evt_cb_data->cb_fn) {
498 evt_cb_data->cb_fn(evt_cb_data->handle, result, &lang, evt_cb_data->user_data);
504 static void on_response_set_sim_language(GObject *source_object, GAsyncResult *res,
507 GError *error = NULL;
508 GDBusConnection *conn = NULL;
509 GVariant *dbus_result;
511 struct tapi_resp_data *evt_cb_data = user_data;
512 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
514 dbg("Func Entrance");
515 conn = G_DBUS_CONNECTION (source_object);
516 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
520 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
523 g_variant_get(dbus_result, "(i)", &result);
525 if (evt_cb_data->cb_fn) {
526 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
532 static void on_response_get_sim_callforwarding_info(GObject *source_object, GAsyncResult *res,
535 GError *error = NULL;
536 GDBusConnection *conn = NULL;
537 GVariant *dbus_result;
538 GVariant *value = NULL;
539 GVariantIter *cphs_iter = NULL;
540 GVariantIter *iter = NULL;
541 GVariantIter *iter_row = NULL;
542 const gchar *key = NULL;
543 const gchar *str_value = NULL;
544 struct tapi_resp_data *evt_cb_data = user_data;
545 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
546 TelSimCallForwardingResp_t cf;
549 memset(&cf, 0, sizeof(TelSimCallForwardingResp_t));
551 dbg("Func Entrance");
552 conn = G_DBUS_CONNECTION (source_object);
553 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
557 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
559 dbg("dbus_result format(%s)", g_variant_get_type_string(dbus_result));
560 g_variant_get(dbus_result, "(ibaa{sv}a{sv})", &result, &cf.b_cphs, &iter, &cphs_iter);
563 while (g_variant_iter_loop(cphs_iter, "{sv}", &key, &value)) {
564 if (!g_strcmp0(key, "b_line1")) {
565 cf.cphs_cf.b_line1 = g_variant_get_boolean(value);
567 if (!g_strcmp0(key, "b_line2")) {
568 cf.cphs_cf.b_line2 = g_variant_get_boolean(value);
570 if (!g_strcmp0(key, "b_fax")) {
571 cf.cphs_cf.b_fax = g_variant_get_boolean(value);
573 if (!g_strcmp0(key, "b_data")) {
574 cf.cphs_cf.b_data = g_variant_get_boolean(value);
578 cf.cf_list.profile_count = g_variant_iter_n_children(iter);
580 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
581 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
582 if (!g_strcmp0(key, "rec_index")) {
583 cf.cf_list.cf[i].rec_index = g_variant_get_int32(value);
585 if (!g_strcmp0(key, "msp_num")) {
586 cf.cf_list.cf[i].msp_num = g_variant_get_byte(value);
588 if (!g_strcmp0(key, "cfu_status")) {
589 cf.cf_list.cf[i].cfu_status = g_variant_get_byte(value);
591 if (!g_strcmp0(key, "cfu_num")) {
592 str_value = g_variant_get_string(value, NULL);
593 snprintf(cf.cf_list.cf[i].cfu_num, strlen((const char*) str_value) + 1, "%s", str_value);
595 if (!g_strcmp0(key, "ton")) {
596 cf.cf_list.cf[i].ton = g_variant_get_int32(value);
598 if (!g_strcmp0(key, "npi")) {
599 cf.cf_list.cf[i].npi = g_variant_get_int32(value);
601 if (!g_strcmp0(key, "cc2_id")) {
602 cf.cf_list.cf[i].cc2_id = g_variant_get_byte(value);
604 if (!g_strcmp0(key, "ext7_id")) {
605 cf.cf_list.cf[i].ext7_id = g_variant_get_byte(value);
609 g_variant_iter_free(iter_row);
611 g_variant_iter_free(iter);
614 if (evt_cb_data->cb_fn) {
615 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cf, evt_cb_data->user_data);
621 static void on_response_set_sim_callforwarding_info(GObject *source_object, GAsyncResult *res,
624 GError *error = NULL;
625 GDBusConnection *conn = NULL;
626 GVariant *dbus_result;
628 struct tapi_resp_data *evt_cb_data = user_data;
629 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
631 dbg("Func Entrance");
632 conn = G_DBUS_CONNECTION (source_object);
633 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
637 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
640 g_variant_get(dbus_result, "(i)", &result);
642 if (evt_cb_data->cb_fn) {
643 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
650 static void on_response_get_sim_messagewaiting_info(GObject *source_object, GAsyncResult *res,
653 GError *error = NULL;
654 GDBusConnection *conn = NULL;
655 GVariant *dbus_result;
656 GVariant *value = NULL;
657 GVariantIter *cphs_iter = NULL;
658 GVariantIter *iter = NULL;
659 GVariantIter *iter_row = NULL;
660 const gchar *key = NULL;
661 struct tapi_resp_data *evt_cb_data = user_data;
662 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
663 TelSimMessageWaitingResp_t mw;
666 dbg("Func Entrance");
667 memset(&mw, 0, sizeof(TelSimMessageWaitingResp_t));
669 conn = G_DBUS_CONNECTION (source_object);
670 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
674 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
677 dbg("dbus_result format(%s)", g_variant_get_type_string(dbus_result));
678 g_variant_get(dbus_result, "(ibaa{sv}a{sv})", &result, &mw.b_cphs, &iter, &cphs_iter);
681 while (g_variant_iter_loop(cphs_iter, "{sv}", &key, &value)) {
682 if (!g_strcmp0(key, "b_voice1")) {
683 mw.cphs_mw.b_voice1 = g_variant_get_boolean(value);
685 if (!g_strcmp0(key, "b_voice2")) {
686 mw.cphs_mw.b_voice2 = g_variant_get_boolean(value);
688 if (!g_strcmp0(key, "b_fax")) {
689 mw.cphs_mw.b_fax = g_variant_get_boolean(value);
691 if (!g_strcmp0(key, "b_data")) {
692 mw.cphs_mw.b_data = g_variant_get_boolean(value);
697 mw.mw_list.profile_count = g_variant_iter_n_children(iter);
699 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
700 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
701 if (!g_strcmp0(key, "rec_index")) {
702 mw.mw_list.mw[i].rec_index = g_variant_get_int32(value);
704 if (!g_strcmp0(key, "indicator_status")) {
705 mw.mw_list.mw[i].indicator_status = g_variant_get_byte(value);
707 if (!g_strcmp0(key, "voice_count")) {
708 mw.mw_list.mw[i].voice_count = g_variant_get_int32(value);
710 if (!g_strcmp0(key, "fax_count")) {
711 mw.mw_list.mw[i].fax_count = g_variant_get_int32(value);
713 if (!g_strcmp0(key, "email_count")) {
714 mw.mw_list.mw[i].email_count = g_variant_get_int32(value);
716 if (!g_strcmp0(key, "other_count")) {
717 mw.mw_list.mw[i].other_count = g_variant_get_int32(value);
719 if (!g_strcmp0(key, "video_count")) {
720 mw.mw_list.mw[i].video_count = g_variant_get_int32(value);
724 g_variant_iter_free(iter_row);
726 g_variant_iter_free(iter);
729 if (evt_cb_data->cb_fn) {
730 evt_cb_data->cb_fn(evt_cb_data->handle, result, &mw, evt_cb_data->user_data);
736 static void on_response_set_sim_messagewaiting_info(GObject *source_object, GAsyncResult *res,
739 GError *error = NULL;
740 GDBusConnection *conn = NULL;
741 GVariant *dbus_result;
743 struct tapi_resp_data *evt_cb_data = user_data;
744 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
746 dbg("Func Entrance");
747 conn = G_DBUS_CONNECTION (source_object);
748 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
752 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
755 g_variant_get(dbus_result, "(i)", &result);
757 if (evt_cb_data->cb_fn) {
758 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
764 static void on_response_get_sim_mailbox_info(GObject *source_object, GAsyncResult *res,
767 GError *error = NULL;
768 GDBusConnection *conn = NULL;
769 GVariant *dbus_result;
770 GVariant *value = NULL;
771 GVariantIter *iter = NULL;
772 GVariantIter *iter_row = NULL;
773 const gchar *key = NULL;
774 const gchar *str_value = NULL;
775 struct tapi_resp_data *evt_cb_data = user_data;
776 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
777 TelSimMailboxList_t list;
781 dbg("Func Entrance");
782 memset(&list, 0, sizeof(TelSimMailboxList_t));
784 conn = G_DBUS_CONNECTION (source_object);
785 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
789 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
792 g_variant_get(dbus_result, "(ibaa{sv})", &result, &b_cphs, &iter);
793 list.count = g_variant_iter_n_children(iter);
794 dbg("list.count=[%d]", list.count);
797 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
798 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
799 list.list[i].b_cphs = b_cphs;
801 if (!g_strcmp0(key, "rec_index")) {
802 list.list[i].rec_index = g_variant_get_int32(value);
804 if (!g_strcmp0(key, "profile_num")) {
805 list.list[i].profile_num = g_variant_get_int32(value);
807 if (!g_strcmp0(key, "mb_type")) {
808 list.list[i].mb_type = g_variant_get_int32(value);
810 if (!g_strcmp0(key, "alpha_id_max_len")) {
811 list.list[i].alpha_id_max_len = g_variant_get_int32(value);
813 if (!g_strcmp0(key, "alpha_id")) {
814 str_value = g_variant_get_string(value, NULL);
815 snprintf(list.list[i].alpha_id, strlen((const char*)str_value) + 1, "%s", str_value);
817 if (!g_strcmp0(key, "ton")) {
818 list.list[i].ton = g_variant_get_int32(value);
820 if (!g_strcmp0(key, "npi")) {
821 list.list[i].npi = g_variant_get_int32(value);
823 if (!g_strcmp0(key, "num")) {
824 str_value = g_variant_get_string(value, NULL);
825 snprintf(list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
827 if (!g_strcmp0(key, "cc_id")) {
828 list.list[i].cc_id = g_variant_get_byte(value);
830 if (!g_strcmp0(key, "ext1_id")) {
831 list.list[i].ext1_id = g_variant_get_byte(value);
835 g_variant_iter_free(iter_row);
837 g_variant_iter_free(iter);
839 if (evt_cb_data->cb_fn) {
840 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
846 static void on_response_set_sim_mailbox_info(GObject *source_object, GAsyncResult *res,
849 GError *error = NULL;
850 GDBusConnection *conn = NULL;
851 GVariant *dbus_result;
853 struct tapi_resp_data *evt_cb_data = user_data;
854 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
856 dbg("Func Entrance");
857 conn = G_DBUS_CONNECTION (source_object);
858 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
862 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
865 g_variant_get(dbus_result, "(i)", &result);
867 if (evt_cb_data->cb_fn) {
868 evt_cb_data->cb_fn(evt_cb_data->handle, result, NULL, evt_cb_data->user_data);
874 static void on_response_get_sim_cphs_info(GObject *source_object, GAsyncResult *res,
877 GError *error = NULL;
878 GDBusConnection *conn = NULL;
879 GVariant *dbus_result;
881 struct tapi_resp_data *evt_cb_data = user_data;
882 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
883 TelSimCphsInfo_t cphs;
885 dbg("Func Entrance");
886 memset(&cphs, 0, sizeof(TelSimCphsInfo_t));
888 conn = G_DBUS_CONNECTION (source_object);
889 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
893 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
896 g_variant_get(dbus_result, "(iibbbbb)", &result, &cphs.CphsPhase,
897 &cphs.CphsServiceTable.bOperatorNameShortForm, &cphs.CphsServiceTable.bMailBoxNumbers,
898 &cphs.CphsServiceTable.bServiceStringTable,
899 &cphs.CphsServiceTable.bCustomerServiceProfile,
900 &cphs.CphsServiceTable.bInformationNumbers);
902 if (evt_cb_data->cb_fn) {
903 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cphs, evt_cb_data->user_data);
909 static void on_response_get_sim_service_table(GObject *source_object, GAsyncResult *res,
912 GError *error = NULL;
913 GDBusConnection *conn = NULL;
914 GVariant *dbus_result = NULL;
916 GVariantIter *iter = NULL;
917 GVariant *param_gv = NULL;
918 GVariant *inner_gv = NULL;
922 struct tapi_resp_data *evt_cb_data = user_data;
923 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
924 TelSimServiceTable_t svct;
926 dbg("Func Entrance");
927 memset(&svct, 0, sizeof(TelSimServiceTable_t));
929 conn = G_DBUS_CONNECTION (source_object);
930 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
934 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
937 g_variant_get(dbus_result, "(ii@v)", &result, &svct.sim_type, ¶m_gv);
938 inner_gv = g_variant_get_variant(param_gv);
940 g_variant_get(inner_gv, "ay", &iter);
941 while (g_variant_iter_loop(iter, "y", &value)) {
942 svct.table.ust.service[i] = value;
945 g_variant_iter_free(iter);
946 g_variant_unref(inner_gv);
947 g_variant_unref(param_gv);
949 if (evt_cb_data->cb_fn) {
950 evt_cb_data->cb_fn(evt_cb_data->handle, result, &svct, evt_cb_data->user_data);
956 static void on_response_get_sim_msisdn(GObject *source_object, GAsyncResult *res,
959 GError *error = NULL;
960 GDBusConnection *conn = NULL;
961 GVariant *dbus_result;
962 GVariant *value = NULL;
963 GVariantIter *iter = NULL;
964 GVariantIter *iter_row = NULL;
965 const gchar *key = NULL;
966 const gchar *str_value = NULL;
967 struct tapi_resp_data *evt_cb_data = user_data;
968 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
969 TelSimMsisdnList_t list;
972 dbg("Func Entrance");
973 memset(&list, 0, sizeof(TelSimMsisdnList_t));
975 conn = G_DBUS_CONNECTION (source_object);
976 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
980 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
983 g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
984 list.count = g_variant_iter_n_children(iter);
986 /*this can be changed regarding concept*/
988 dbg("current list.count[%d] but we fixed maximum with 3", list.count);
991 /*this can be changed regarding concept*/
994 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
995 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
996 if (!g_strcmp0(key, "name")) {
997 str_value = g_variant_get_string(value, NULL);
998 snprintf(list.list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
1000 if (!g_strcmp0(key, "number")) {
1001 str_value = g_variant_get_string(value, NULL);
1002 snprintf(list.list[i].num, strlen((const char*)str_value) + 1, "%s", str_value);
1006 g_variant_iter_free(iter_row);
1007 /*this can be changed regarding concept*/
1010 /*this can be changed regarding concept*/
1012 g_variant_iter_free(iter);
1014 dbg("msisdn count[%d]", list.count);
1015 for(i =0; i < list.count; i++){
1016 dbg("msisdn[%d]-name[%s]number[%s]",i,list.list[i].name, list.list[i].num);
1019 TAPI_SIM_CALL_CBFUNC(evt_cb_data, result, &list);
1020 g_free(evt_cb_data);
1023 static void on_response_get_sim_oplmnwact(GObject *source_object, GAsyncResult *res,
1026 GError *error = NULL;
1027 GDBusConnection *conn = NULL;
1028 GVariant *dbus_result;
1029 GVariant *value = NULL;
1030 GVariantIter *iter = NULL;
1031 GVariantIter *iter_row = NULL;
1032 const gchar *key = NULL;
1033 const gchar *str_value = NULL;
1034 struct tapi_resp_data *evt_cb_data = user_data;
1035 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1036 TelSimOplmnwactList_t list;
1039 dbg("Func Entrance");
1040 memset(&list, 0, sizeof(TelSimOplmnwactList_t));
1042 conn = G_DBUS_CONNECTION (source_object);
1043 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1044 CHECK_DEINIT(error);
1047 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1050 g_variant_get(dbus_result, "(iaa{sv})", &result, &iter);
1051 list.count = g_variant_iter_n_children(iter);
1054 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1055 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
1056 if (!g_strcmp0(key, "plmn")) {
1057 str_value = g_variant_get_string(value, NULL);
1058 snprintf(list.list[i].plmn, strlen((const char*)str_value) + 1, "%s", str_value);
1060 if (!g_strcmp0(key, "b_umst")) {
1061 list.list[i].b_umts = g_variant_get_boolean(value);
1063 if (!g_strcmp0(key, "b_gsm")) {
1064 list.list[i].b_gsm = g_variant_get_boolean(value);
1068 g_variant_iter_free(iter_row);
1070 g_variant_iter_free(iter);
1072 if (evt_cb_data->cb_fn) {
1073 evt_cb_data->cb_fn(evt_cb_data->handle, result, &list, evt_cb_data->user_data);
1076 g_free(evt_cb_data);
1079 static void on_response_get_sim_spn(GObject *source_object, GAsyncResult *res,
1082 GError *error = NULL;
1083 GDBusConnection *conn = NULL;
1084 GVariant *dbus_result;
1086 struct tapi_resp_data *evt_cb_data = user_data;
1087 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1088 TelSimSpn_t spn_info;
1092 memset(&spn_info, 0, sizeof(TelSimSpn_t));
1094 dbg("Func Entrance");
1095 conn = G_DBUS_CONNECTION (source_object);
1096 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1097 CHECK_DEINIT(error);
1100 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1103 g_variant_get(dbus_result, "(iys)", &result, &dc, &spn);
1105 dbg("result[%d]", result);
1106 if ( result == TAPI_SIM_ACCESS_SUCCESS) {
1107 dbg("spn[%s], display condition[0x%x]", spn, dc);
1108 spn_info.display_condition = dc;
1109 snprintf((char *)spn_info.spn, strlen((const char*)spn)+1, "%s", spn);
1112 TAPI_SIM_CALL_CBFUNC(evt_cb_data, result, &spn_info);
1113 g_free(evt_cb_data);
1116 static void on_response_get_sim_cphs_netname(GObject *source_object, GAsyncResult *res,
1119 GError *error = NULL;
1120 GDBusConnection *conn = NULL;
1121 GVariant *dbus_result;
1123 struct tapi_resp_data *evt_cb_data = user_data;
1124 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1125 TelSimCphsNetName_t cphs_net;
1126 gchar *full_name = NULL;
1127 gchar *short_name = NULL;
1129 memset(&cphs_net, 0, sizeof(TelSimCphsNetName_t));
1131 dbg("Func Entrance");
1132 conn = G_DBUS_CONNECTION (source_object);
1133 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1134 CHECK_DEINIT(error);
1137 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1140 g_variant_get(dbus_result, "(iss)", &result, &full_name, &short_name);
1142 dbg("result[%d]", result);
1143 if ( result == TAPI_SIM_ACCESS_SUCCESS) {
1144 dbg("full name[%s], short name[%s]", full_name, short_name);
1145 snprintf((char *)cphs_net.full_name, strlen((const char*)full_name)+1, "%s", full_name);
1146 snprintf((char *)cphs_net.short_name, strlen((const char*)short_name)+1, "%s", short_name);
1149 if (evt_cb_data->cb_fn) {
1150 evt_cb_data->cb_fn(evt_cb_data->handle, result, &cphs_net, evt_cb_data->user_data);
1153 g_free(evt_cb_data);
1156 static void on_response_req_sim_authentication(GObject *source_object, GAsyncResult *res,
1159 GError *error = NULL;
1160 GDBusConnection *conn = NULL;
1161 GVariant *dbus_result;
1163 GVariantIter *iter = NULL;
1164 GVariant *ak_gv = NULL;
1165 GVariant *cp_gv = NULL;
1166 GVariant *it_gv = NULL;
1167 GVariant *resp_gv = NULL;
1168 GVariant *ak = NULL;
1169 GVariant *cp = NULL;
1170 GVariant *it = NULL;
1171 GVariant *resp = NULL;
1175 struct tapi_resp_data *evt_cb_data = user_data;
1176 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1177 TelSimAuthenticationResponse_t auth_resp;
1179 dbg("Func Entrance");
1180 memset(&auth_resp, 0, sizeof(TelSimAuthenticationResponse_t));
1182 conn = G_DBUS_CONNECTION (source_object);
1183 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1184 CHECK_DEINIT(error);
1187 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1190 dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));
1191 g_variant_get(dbus_result, "(iii@v@v@v@v)", &result, &auth_resp.auth_type,
1192 &auth_resp.auth_result, &ak_gv, &cp_gv, &it_gv, &resp_gv);
1194 ak = g_variant_get_variant(ak_gv);
1195 g_variant_get(ak, "ay", &iter);
1196 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1197 auth_resp.authentication_key[i] = rt_i;
1200 auth_resp.authentication_key_length = i;
1201 g_variant_iter_free(iter);
1204 cp = g_variant_get_variant(cp_gv);
1205 g_variant_get(cp, "ay", &iter);
1206 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1207 auth_resp.cipher_data[i] = rt_i;
1210 auth_resp.cipher_length = i;
1211 g_variant_iter_free(iter);
1214 it = g_variant_get_variant(it_gv);
1215 g_variant_get(it, "ay", &iter);
1216 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1217 auth_resp.integrity_data[i] = rt_i;
1220 auth_resp.integrity_length = i;
1221 g_variant_iter_free(iter);
1224 resp = g_variant_get_variant(resp_gv);
1225 g_variant_get(resp, "ay", &iter);
1226 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1227 auth_resp.resp_data[i] = rt_i;
1230 auth_resp.resp_length = i;
1231 g_variant_iter_free(iter);
1234 if (evt_cb_data->cb_fn) {
1235 evt_cb_data->cb_fn(evt_cb_data->handle, result, &auth_resp, evt_cb_data->user_data);
1238 g_free(evt_cb_data);
1241 static void on_response_verify_sim_pins(GObject *source_object, GAsyncResult *res,
1244 GError *error = NULL;
1245 GDBusConnection *conn = NULL;
1246 GVariant *dbus_result;
1248 struct tapi_resp_data *evt_cb_data = user_data;
1249 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1250 TelSimSecResult_t sec_rt;
1252 dbg("Func Entrance");
1253 memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1255 conn = G_DBUS_CONNECTION (source_object);
1256 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1257 CHECK_DEINIT(error);
1260 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1263 g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1265 if (evt_cb_data->cb_fn) {
1266 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1269 g_free(evt_cb_data);
1272 static void on_response_verify_sim_puks(GObject *source_object, GAsyncResult *res,
1275 GError *error = NULL;
1276 GDBusConnection *conn = NULL;
1277 GVariant *dbus_result;
1279 struct tapi_resp_data *evt_cb_data = user_data;
1280 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1281 TelSimSecResult_t sec_rt;
1283 dbg("Func Entrance");
1284 memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1286 conn = G_DBUS_CONNECTION (source_object);
1287 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1288 CHECK_DEINIT(error);
1291 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1294 g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1296 if (evt_cb_data->cb_fn) {
1297 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1300 g_free(evt_cb_data);
1303 static void on_response_change_sim_pins(GObject *source_object, GAsyncResult *res,
1306 GError *error = NULL;
1307 GDBusConnection *conn = NULL;
1308 GVariant *dbus_result;
1310 struct tapi_resp_data *evt_cb_data = user_data;
1311 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1312 TelSimSecResult_t sec_rt;
1314 dbg("Func Entrance");
1315 memset(&sec_rt, 0, sizeof(TelSimSecResult_t));
1317 conn = G_DBUS_CONNECTION (source_object);
1318 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1319 CHECK_DEINIT(error);
1322 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1325 g_variant_get(dbus_result, "(iii)", &result, &sec_rt.type, &sec_rt.retry_count);
1327 if (evt_cb_data->cb_fn) {
1328 evt_cb_data->cb_fn(evt_cb_data->handle, result, &sec_rt, evt_cb_data->user_data);
1331 g_free(evt_cb_data);
1334 static void on_response_disable_sim_facility(GObject *source_object, GAsyncResult *res,
1337 GError *error = NULL;
1338 GDBusConnection *conn = NULL;
1339 GVariant *dbus_result;
1341 struct tapi_resp_data *evt_cb_data = user_data;
1342 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1343 TelSimFacilityResult_t f_rt;
1345 dbg("Func Entrance");
1346 memset(&f_rt, 0, sizeof(TelSimFacilityResult_t));
1348 conn = G_DBUS_CONNECTION (source_object);
1349 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1350 CHECK_DEINIT(error);
1353 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1356 g_variant_get(dbus_result, "(iii)", &result, &f_rt.type, &f_rt.retry_count);
1358 TAPI_SIM_CALL_CBFUNC(evt_cb_data, result, &f_rt);
1359 g_free(evt_cb_data);
1362 static void on_response_enable_sim_facility(GObject *source_object, GAsyncResult *res,
1365 GError *error = NULL;
1366 GDBusConnection *conn = NULL;
1367 GVariant *dbus_result;
1369 struct tapi_resp_data *evt_cb_data = user_data;
1370 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1371 TelSimFacilityResult_t f_rt;
1373 dbg("Func Entrance");
1374 memset(&f_rt, 0, sizeof(TelSimFacilityResult_t));
1376 conn = G_DBUS_CONNECTION (source_object);
1377 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1378 CHECK_DEINIT(error);
1381 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1384 g_variant_get(dbus_result, "(iii)", &result, &f_rt.type, &f_rt.retry_count);
1386 TAPI_SIM_CALL_CBFUNC(evt_cb_data, result, &f_rt);
1387 g_free(evt_cb_data);
1390 static void on_response_get_sim_facility(GObject *source_object, GAsyncResult *res,
1393 GError *error = NULL;
1394 GDBusConnection *conn = NULL;
1395 GVariant *dbus_result;
1397 struct tapi_resp_data *evt_cb_data = user_data;
1398 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1399 TelSimFacilityInfo_t fi;
1401 dbg("Func Entrance");
1402 memset(&fi, 0, sizeof(TelSimFacilityInfo_t));
1404 conn = G_DBUS_CONNECTION (source_object);
1405 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1406 CHECK_DEINIT(error);
1409 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1412 g_variant_get(dbus_result, "(iii)", &result, &fi.type, &fi.f_status);
1414 TAPI_SIM_CALL_CBFUNC(evt_cb_data, result, &fi);
1415 g_free(evt_cb_data);
1418 static void on_response_get_sim_lock_info(GObject *source_object, GAsyncResult *res,
1421 GError *error = NULL;
1422 GDBusConnection *conn = NULL;
1423 GVariant *dbus_result;
1425 struct tapi_resp_data *evt_cb_data = user_data;
1426 TelSimPinOperationResult_t result = TAPI_SIM_PIN_OPERATION_SUCCESS;
1427 TelSimLockInfo_t lock;
1429 dbg("Func Entrance");
1430 memset(&lock, 0, sizeof(TelSimLockInfo_t));
1432 conn = G_DBUS_CONNECTION (source_object);
1433 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1434 CHECK_DEINIT(error);
1437 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1440 g_variant_get(dbus_result, "(iiii)", &result, &lock.lock_type, &lock.lock_status,
1443 if (evt_cb_data->cb_fn) {
1444 evt_cb_data->cb_fn(evt_cb_data->handle, result, &lock, evt_cb_data->user_data);
1447 g_free(evt_cb_data);
1450 static void on_response_req_sim_apdu(GObject *source_object, GAsyncResult *res, gpointer user_data)
1452 GError *error = NULL;
1453 GDBusConnection *conn = NULL;
1454 GVariant *dbus_result;
1456 GVariantIter *iter = NULL;
1457 GVariant *param_gv = NULL;
1458 GVariant *inner_gv = NULL;
1460 unsigned short i = 0;
1462 struct tapi_resp_data *evt_cb_data = user_data;
1463 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1464 TelSimApduResp_t r_apdu;
1466 dbg("Func Entrance");
1467 memset(&r_apdu, 0, sizeof(TelSimApduResp_t));
1469 conn = G_DBUS_CONNECTION (source_object);
1470 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1471 CHECK_DEINIT(error);
1474 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1477 /* dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));*/
1478 g_variant_get(dbus_result, "(i@v)", &result, ¶m_gv);
1479 inner_gv = g_variant_get_variant(param_gv);
1481 g_variant_get(inner_gv, "ay", &iter);
1482 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1483 r_apdu.apdu_resp[i] = rt_i;
1485 if (i >= TAPI_SIM_APDU_MAX_LEN)
1488 r_apdu.apdu_resp_len = i;
1489 dbg("r_apdu.apdu_resp_len=[%d]", r_apdu.apdu_resp_len);
1490 g_variant_iter_free(iter);
1491 g_variant_unref(inner_gv);
1492 g_variant_unref(param_gv);
1494 if (evt_cb_data->cb_fn) {
1495 evt_cb_data->cb_fn(evt_cb_data->handle, result, &r_apdu, evt_cb_data->user_data);
1498 g_free(evt_cb_data);
1501 static void on_response_req_sim_atr(GObject *source_object, GAsyncResult *res, gpointer user_data)
1503 GError *error = NULL;
1504 GDBusConnection *conn = NULL;
1505 GVariant *dbus_result;
1507 GVariantIter *iter = NULL;
1508 GVariant *param_gv = NULL;
1509 GVariant *inner_gv = NULL;
1511 unsigned short i = 0;
1513 struct tapi_resp_data *evt_cb_data = user_data;
1514 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1515 TelSimAtrResp_t r_atr;
1517 dbg("Func Entrance");
1518 memset(&r_atr, 0, sizeof(TelSimAtrResp_t));
1520 conn = G_DBUS_CONNECTION (source_object);
1521 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1522 CHECK_DEINIT(error);
1525 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, evt_cb_data);
1528 dbg("dbus_result type_format(%s)", g_variant_get_type_string(dbus_result));
1529 g_variant_get(dbus_result, "(i@v)", &result, ¶m_gv);
1530 inner_gv = g_variant_get_variant(param_gv);
1532 g_variant_get(inner_gv, "ay", &iter);
1533 while (g_variant_iter_loop(iter, "y", &rt_i)) {
1534 r_atr.atr_resp[i] = rt_i;
1537 r_atr.atr_resp_len = i;
1538 dbg("r_atr.atr_resp_len=[%d]", r_atr.atr_resp_len);
1539 g_variant_iter_free(iter);
1540 g_variant_unref(inner_gv);
1541 g_variant_unref(param_gv);
1543 if (evt_cb_data->cb_fn) {
1544 evt_cb_data->cb_fn(evt_cb_data->handle, result, &r_atr, evt_cb_data->user_data);
1547 g_free(evt_cb_data);
1550 static void on_response_call_sim_async(GObject *source_object, GAsyncResult *res,
1553 GError *error = NULL;
1554 GDBusConnection *conn = NULL;
1555 GVariant *dbus_result;
1557 struct tapi_sim_resp_data *evt_cb_data = user_data;
1558 TelSimAccessResult_t result = TAPI_SIM_ACCESS_SUCCESS;
1559 TelSimResponseData_t resp;
1561 memset(&resp, 0, sizeof(TelSimResponseData_t));
1563 dbg("Func Entrance");
1564 conn = G_DBUS_CONNECTION (source_object);
1565 dbus_result = g_dbus_connection_call_finish(conn, res, &error);
1566 CHECK_DEINIT(error);
1569 TAPI_SIM_CHECK_ERR_MSG_AND_CALL_NULL_CBFUNC(error, (&evt_cb_data->tapi_resp));
1572 result = __get_dbus_resp_data(evt_cb_data->op_type, dbus_result, &resp);
1574 dbg("result[%d]", result);
1576 TAPI_SIM_CALL_CBFUNC((&evt_cb_data->tapi_resp), result, &resp);
1577 g_free(evt_cb_data);
1580 EXPORT_API int tel_get_sim_init_info(TapiHandle *handle, TelSimCardStatus_t *sim_status,
1583 GError *gerr = NULL;
1584 GVariant *sync_gv = NULL;
1585 TelSimCardStatus_t init_status = 0;
1586 int changed = FALSE;
1588 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1589 TAPI_RET_ERR_NUM_IF_FAIL(sim_status, TAPI_API_INVALID_PTR);
1590 TAPI_RET_ERR_NUM_IF_FAIL(card_changed, TAPI_API_INVALID_PTR);
1592 TAPI_SIM_CHECK_TAPI_STATE();
1594 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1595 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetInitStatus", NULL, NULL,
1596 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
1599 g_variant_get(sync_gv, "(ib)", &init_status, &changed);
1600 *sim_status = init_status;
1601 *card_changed = changed;
1602 dbg("init_status[%d] changed[%d]",init_status, changed);
1604 TAPI_SIM_CHECK_ERR_MSG(gerr);
1607 return TAPI_API_SUCCESS;
1610 EXPORT_API int tel_get_sim_type(TapiHandle *handle, TelSimCardType_t *card_type)
1612 GError *gerr = NULL;
1613 GVariant *sync_gv = NULL;
1615 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1616 TAPI_RET_ERR_NUM_IF_FAIL(card_type, TAPI_API_INVALID_PTR);
1618 TAPI_SIM_CHECK_TAPI_STATE();
1620 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1621 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetCardType", NULL, NULL,
1622 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
1625 g_variant_get(sync_gv, "(i)", card_type);
1627 TAPI_SIM_CHECK_ERR_MSG(gerr);
1629 return TAPI_API_SUCCESS;
1632 EXPORT_API int tel_get_sim_imsi(TapiHandle *handle, TelSimImsiInfo_t *imsi)
1634 GError *gerr = NULL;
1635 GVariant *sync_gv = NULL;
1637 dbg("Func Entrance");
1639 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1640 TAPI_RET_ERR_NUM_IF_FAIL(imsi, TAPI_API_INVALID_PTR);
1642 TAPI_SIM_CHECK_TAPI_STATE();
1644 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1645 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetIMSI", NULL, NULL,
1646 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
1649 gchar *gplmn = NULL;
1650 gchar *gmsin = NULL;
1654 g_variant_get(sync_gv, "(ss)", &gplmn, &gmsin);
1656 gplmn_len = strlen((const char*)gplmn);
1657 gmsin_len = strlen((const char*)gmsin);
1659 if (gplmn_len >= 5 && gmsin_len >= 9) {
1660 snprintf(imsi->szMcc, 3 + 1, "%s", gplmn);
1661 snprintf(imsi->szMnc, gplmn_len - 3 + 1, "%s", &gplmn[3]);
1662 snprintf(imsi->szMsin, gmsin_len + 1, "%s", gmsin);
1664 dbg("invalid length.(plmn_len=%d, msin_len=%d)", gplmn_len,gmsin_len);
1665 memset(imsi, 0, sizeof(TelSimImsiInfo_t));
1668 TAPI_SIM_CHECK_ERR_MSG(gerr);
1671 return TAPI_API_SUCCESS;
1674 EXPORT_API int tel_get_sim_ecc(TapiHandle *handle, TelSimEccList_t *ecc)
1676 GError *gerr = NULL;
1678 GVariant *value = NULL;
1679 GVariantIter *iter = NULL;
1680 GVariantIter *iter_row = NULL;
1681 const gchar *key = NULL;
1682 const gchar *str_value = NULL;
1685 dbg("Func Entrance");
1687 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1688 TAPI_RET_ERR_NUM_IF_FAIL(ecc, TAPI_API_INVALID_PTR);
1690 memset(ecc, 0, sizeof(TelSimEccList_t));
1692 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
1693 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, "GetECC", NULL, NULL,
1694 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
1697 /* dbg("ecc type_format(%s)", g_variant_get_type_string(sync_gv));*/
1698 g_variant_get(sync_gv, "(aa{sv})", &iter);
1699 ecc->ecc_count = g_variant_iter_n_children(iter);
1700 dbg("ecc->ecc_count[%d]",ecc->ecc_count);
1702 while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
1703 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
1704 if (!g_strcmp0(key, "name")) {
1705 str_value = g_variant_get_string(value, NULL);
1706 snprintf(ecc->list[i].name, strlen((const char*)str_value) + 1, "%s", str_value);
1708 if (!g_strcmp0(key, "number")) {
1709 str_value = g_variant_get_string(value, NULL);
1710 snprintf(ecc->list[i].number, strlen((const char*)str_value) + 1, "%s", str_value);
1712 if (!g_strcmp0(key, "category")) {
1713 ecc->list[i].category = g_variant_get_int32(value);
1717 g_variant_iter_free(iter_row);
1719 g_variant_iter_free(iter);
1721 TAPI_SIM_CHECK_ERR_MSG(gerr);
1723 return TAPI_API_SUCCESS;
1726 EXPORT_API int tel_get_sim_iccid(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1728 struct tapi_resp_data *evt_cb_data = NULL;
1730 dbg("Func Entrance ");
1732 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1734 TAPI_SIM_CHECK_TAPI_STATE();
1736 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1738 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1739 DBUS_TELEPHONY_SIM_INTERFACE, "GetICCID", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
1740 on_response_get_sim_iccid, evt_cb_data);
1742 return TAPI_API_SUCCESS;
1745 EXPORT_API int tel_get_sim_language(TapiHandle *handle, tapi_response_cb callback, void *user_data)
1747 struct tapi_resp_data *evt_cb_data = NULL;
1749 dbg("Func Entrance ");
1751 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1753 TAPI_SIM_CHECK_TAPI_STATE();
1755 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1757 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1758 DBUS_TELEPHONY_SIM_INTERFACE, "GetLanguage", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
1759 handle->ca, on_response_get_sim_language, evt_cb_data);
1761 return TAPI_API_SUCCESS;
1764 EXPORT_API int tel_set_sim_language(TapiHandle *handle, TelSimLanguagePreferenceCode_t language,
1765 tapi_response_cb callback, void *user_data)
1767 struct tapi_resp_data *evt_cb_data = NULL;
1768 GVariant *param = NULL;
1770 dbg("Func Entrance w/ lang[%d]",language);
1772 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1774 TAPI_SIM_CHECK_TAPI_STATE();
1776 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1778 param = g_variant_new("(i)", language);
1780 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1781 DBUS_TELEPHONY_SIM_INTERFACE, "SetLanguage", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
1782 handle->ca, on_response_set_sim_language, evt_cb_data);
1784 return TAPI_API_SUCCESS;
1787 EXPORT_API int tel_get_sim_callforwarding_info(TapiHandle *handle, tapi_response_cb callback,
1790 struct tapi_resp_data *evt_cb_data = NULL;
1792 dbg("Func Entrance ");
1794 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1796 TAPI_SIM_CHECK_TAPI_STATE();
1798 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1800 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1801 DBUS_TELEPHONY_SIM_INTERFACE, "GetCallForwarding", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
1802 TAPI_DEFAULT_TIMEOUT, handle->ca, on_response_get_sim_callforwarding_info, evt_cb_data);
1804 return TAPI_API_SUCCESS;
1807 EXPORT_API int tel_set_sim_callforwarding_info(TapiHandle *handle, TelSimCallForwardingReq_t *req_cf,
1808 tapi_response_cb callback, void *user_data)
1810 struct tapi_resp_data *evt_cb_data = NULL;
1811 GVariant *param = NULL;
1812 gchar *g_number = NULL;
1814 dbg("Func Entrance ");
1816 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1818 TAPI_SIM_CHECK_TAPI_STATE();
1820 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1822 g_number = calloc(1, strlen((const char*)&req_cf->cf_data_u.cf.cfu_num)+1);
1824 g_free(evt_cb_data);
1825 return TAPI_API_SYSTEM_OUT_OF_MEM;
1828 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));
1830 param = g_variant_new("(biiyiisiibbbb)",
1832 req_cf->cf_data_u.cf.rec_index,
1833 req_cf->cf_data_u.cf.msp_num,
1834 req_cf->cf_data_u.cf.cfu_status,
1835 req_cf->cf_data_u.cf.ton,
1836 req_cf->cf_data_u.cf.npi,
1838 req_cf->cf_data_u.cf.cc2_id,
1839 req_cf->cf_data_u.cf.ext7_id,
1840 req_cf->cf_data_u.cphs_cf.b_line1,
1841 req_cf->cf_data_u.cphs_cf.b_line2,
1842 req_cf->cf_data_u.cphs_cf.b_fax,
1843 req_cf->cf_data_u.cphs_cf.b_data);
1845 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1846 DBUS_TELEPHONY_SIM_INTERFACE, "SetCallForwarding", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
1847 handle->ca, on_response_set_sim_callforwarding_info, evt_cb_data);
1852 return TAPI_API_SUCCESS;
1855 EXPORT_API int tel_get_sim_messagewaiting_info(TapiHandle *handle, tapi_response_cb callback,
1858 struct tapi_resp_data *evt_cb_data = NULL;
1860 dbg("Func Entrance ");
1862 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1864 TAPI_SIM_CHECK_TAPI_STATE();
1866 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1868 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1869 DBUS_TELEPHONY_SIM_INTERFACE, "GetMessageWaiting", NULL, NULL, G_DBUS_CALL_FLAGS_NONE,
1870 TAPI_DEFAULT_TIMEOUT, handle->ca, on_response_get_sim_messagewaiting_info, evt_cb_data);
1872 return TAPI_API_SUCCESS;
1875 EXPORT_API int tel_set_sim_messagewaiting_info(TapiHandle *handle, TelSimMessageWaitingReq_t *req_mw,
1876 tapi_response_cb callback, void *user_data)
1878 struct tapi_resp_data *evt_cb_data = NULL;
1879 GVariant *param = NULL;
1881 dbg("Func Entrance ");
1883 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1885 TAPI_SIM_CHECK_TAPI_STATE();
1887 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1889 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]",
1891 req_mw->mw_data_u.mw.rec_index,
1892 req_mw->mw_data_u.mw.indicator_status,
1893 req_mw->mw_data_u.mw.voice_count,
1894 req_mw->mw_data_u.mw.fax_count,
1895 req_mw->mw_data_u.mw.email_count,
1896 req_mw->mw_data_u.mw.other_count,
1897 req_mw->mw_data_u.mw.video_count,
1898 req_mw->mw_data_u.cphs_mw.b_voice1,
1899 req_mw->mw_data_u.cphs_mw.b_voice2,
1900 req_mw->mw_data_u.cphs_mw.b_fax,
1901 req_mw->mw_data_u.cphs_mw.b_data);
1903 param = g_variant_new("(biyiiiiibbbb)",
1905 req_mw->mw_data_u.mw.rec_index,
1906 req_mw->mw_data_u.mw.indicator_status,
1907 req_mw->mw_data_u.mw.voice_count,
1908 req_mw->mw_data_u.mw.fax_count,
1909 req_mw->mw_data_u.mw.email_count,
1910 req_mw->mw_data_u.mw.other_count,
1911 req_mw->mw_data_u.mw.video_count,
1912 req_mw->mw_data_u.cphs_mw.b_voice1,
1913 req_mw->mw_data_u.cphs_mw.b_voice2,
1914 req_mw->mw_data_u.cphs_mw.b_fax,
1915 req_mw->mw_data_u.cphs_mw.b_data);
1917 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1918 DBUS_TELEPHONY_SIM_INTERFACE, "SetMessageWaiting", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
1919 handle->ca, on_response_set_sim_messagewaiting_info, evt_cb_data);
1921 return TAPI_API_SUCCESS;
1924 EXPORT_API int tel_get_sim_mailbox_info(TapiHandle *handle, tapi_response_cb callback,
1927 struct tapi_resp_data *evt_cb_data = NULL;
1929 dbg("Func Entrance ");
1931 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1933 TAPI_SIM_CHECK_TAPI_STATE();
1935 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1937 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
1938 DBUS_TELEPHONY_SIM_INTERFACE, "GetMailbox", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
1939 handle->ca, on_response_get_sim_mailbox_info, evt_cb_data);
1941 return TAPI_API_SUCCESS;
1944 EXPORT_API int tel_set_sim_mailbox_info(TapiHandle *handle, TelSimMailBoxNumber_t *req_mb,
1945 tapi_response_cb callback, void *user_data)
1947 struct tapi_resp_data *evt_cb_data = NULL;
1948 GVariant *param = NULL;
1949 gchar *g_alpha = NULL;
1950 gchar *g_number = NULL;
1952 dbg("Func Entrance ");
1954 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
1956 TAPI_SIM_CHECK_TAPI_STATE();
1958 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
1960 g_alpha = calloc(1, strlen((const char*)&req_mb->alpha_id)+1);
1962 g_free(evt_cb_data);
1963 return TAPI_API_SYSTEM_OUT_OF_MEM;
1966 memcpy((void*)g_alpha, (const void*)&req_mb->alpha_id, strlen((const char*)&req_mb->alpha_id));
1968 g_number = calloc(1, strlen((const char*)&req_mb->num)+1);
1971 g_free(evt_cb_data);
1972 return TAPI_API_SYSTEM_OUT_OF_MEM;
1975 memcpy((void*)g_number, (const void*)&req_mb->num, strlen((const char*)&req_mb->num));
1977 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]",
1980 req_mb->profile_num,
1982 req_mb->alpha_id_max_len,
1985 dbg("req_mb->ton[%d],req_mb->npi[%d],g_number[%s],req_mb->cc_id[%d],req_mb->ext1_id[%d]",
1992 param = g_variant_new("(biiiisiisii)",
1996 req_mb->profile_num,
1997 req_mb->alpha_id_max_len,
2005 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2006 DBUS_TELEPHONY_SIM_INTERFACE, "SetMailbox", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2007 handle->ca, on_response_set_sim_mailbox_info, evt_cb_data);
2015 return TAPI_API_SUCCESS;
2018 EXPORT_API int tel_get_sim_cphs_info(TapiHandle *handle, tapi_response_cb callback,
2021 struct tapi_resp_data *evt_cb_data = NULL;
2023 dbg("Func Entrance ");
2025 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2027 TAPI_SIM_CHECK_TAPI_STATE();
2029 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2031 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2032 DBUS_TELEPHONY_SIM_INTERFACE, "GetCPHSInfo", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
2033 on_response_get_sim_cphs_info, evt_cb_data);
2035 return TAPI_API_SUCCESS;
2038 EXPORT_API int tel_get_sim_service_table(TapiHandle *handle, tapi_response_cb callback,
2041 struct tapi_resp_data *evt_cb_data = NULL;
2043 dbg("Func Entrance ");
2045 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2047 TAPI_SIM_CHECK_TAPI_STATE();
2049 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2051 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2052 DBUS_TELEPHONY_SIM_INTERFACE, "GetServiceTable", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
2053 on_response_get_sim_service_table, evt_cb_data);
2055 return TAPI_API_SUCCESS;
2058 EXPORT_API int tel_get_sim_msisdn(TapiHandle *handle, tapi_response_cb callback, void *user_data)
2060 struct tapi_resp_data *evt_cb_data = NULL;
2062 dbg("Func Entrance ");
2064 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2066 TAPI_SIM_CHECK_TAPI_STATE();
2068 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2070 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2071 DBUS_TELEPHONY_SIM_INTERFACE, "GetMSISDN", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
2072 on_response_get_sim_msisdn, evt_cb_data);
2074 return TAPI_API_SUCCESS;
2077 EXPORT_API int tel_get_sim_oplmnwact(TapiHandle *handle, tapi_response_cb callback,
2080 struct tapi_resp_data *evt_cb_data = NULL;
2082 dbg("Func Entrance ");
2084 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2086 TAPI_SIM_CHECK_TAPI_STATE();
2088 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2090 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2091 DBUS_TELEPHONY_SIM_INTERFACE, "GetOplmnwact", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2092 handle->ca, on_response_get_sim_oplmnwact, evt_cb_data);
2094 return TAPI_API_SUCCESS;
2097 EXPORT_API int tel_get_sim_spn(TapiHandle *handle, tapi_response_cb callback,
2100 struct tapi_resp_data *evt_cb_data = NULL;
2102 dbg("Func Entrance ");
2104 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2106 TAPI_SIM_CHECK_TAPI_STATE();
2108 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2110 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2111 DBUS_TELEPHONY_SIM_INTERFACE, "GetSpn", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2112 handle->ca, on_response_get_sim_spn, evt_cb_data);
2114 return TAPI_API_SUCCESS;
2117 EXPORT_API int tel_get_sim_cphs_netname(TapiHandle *handle, tapi_response_cb callback,
2120 struct tapi_resp_data *evt_cb_data = NULL;
2122 dbg("Func Entrance ");
2124 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2126 TAPI_SIM_CHECK_TAPI_STATE();
2128 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2130 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2131 DBUS_TELEPHONY_SIM_INTERFACE, "GetCphsNetName", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2132 handle->ca, on_response_get_sim_cphs_netname, evt_cb_data);
2134 return TAPI_API_SUCCESS;
2137 EXPORT_API int tel_req_sim_authentication(TapiHandle *handle,
2138 TelSimAuthenticationData_t *authentication_data, tapi_response_cb callback, void *user_data)
2140 struct tapi_resp_data *evt_cb_data = NULL;
2141 GVariantBuilder *builder = NULL;
2142 GVariant *param = NULL;
2143 GVariant *rand_gv = NULL;
2144 GVariant *autn_gv = NULL;
2147 dbg("Func Entrance ");
2149 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2150 TAPI_RET_ERR_NUM_IF_FAIL(authentication_data, TAPI_API_INVALID_PTR);
2152 TAPI_SIM_CHECK_TAPI_STATE();
2154 if (authentication_data->auth_type > TAPI_SIM_AUTH_TYPE_3G)
2155 return TAPI_API_INVALID_INPUT;
2157 if (authentication_data->rand_length == 0)
2158 return TAPI_API_INVALID_INPUT;
2160 if (authentication_data->auth_type != TAPI_SIM_AUTH_TYPE_GSM
2161 && authentication_data->autn_length == 0)
2162 return TAPI_API_INVALID_INPUT;
2164 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2166 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2167 for (i = 0; i < authentication_data->rand_length; i++) {
2168 dbg("authentication_data->rand_data[%d][0x%02x]", i,authentication_data->rand_data[i]);
2169 g_variant_builder_add(builder, "y", authentication_data->rand_data[i]);
2171 rand_gv = g_variant_builder_end(builder);
2173 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2174 for (i = 0; i < authentication_data->autn_length; i++) {
2175 dbg("authentication_data->autn_data[%d][0x%02x]", i,authentication_data->autn_data[i]);
2176 g_variant_builder_add(builder, "y", authentication_data->autn_data[i]);
2178 autn_gv = g_variant_builder_end(builder);
2180 param = g_variant_new("(ivv)", authentication_data->auth_type, rand_gv, autn_gv);
2181 /*g_variant_builder_unref (builder);*/
2183 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2184 DBUS_TELEPHONY_SIM_INTERFACE, "Authentication", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2185 handle->ca, on_response_req_sim_authentication, evt_cb_data);
2187 return TAPI_API_SUCCESS;
2190 EXPORT_API int tel_verifiy_sim_pins(TapiHandle *handle, const TelSimSecPw_t *pin_data,
2191 tapi_response_cb callback, void *user_data)
2193 struct tapi_resp_data *evt_cb_data = NULL;
2194 GVariant *param = NULL;
2197 dbg("Func Entrance");
2199 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2200 TAPI_RET_ERR_NUM_IF_FAIL(pin_data, TAPI_API_INVALID_PTR);
2201 TAPI_RET_ERR_NUM_IF_FAIL(pin_data->pw, TAPI_API_INVALID_PTR);
2203 TAPI_SIM_CHECK_TAPI_STATE();
2205 dbg("pin type[%d]", pin_data->type);
2206 if (pin_data->type != TAPI_SIM_PTYPE_PIN1 && pin_data->type != TAPI_SIM_PTYPE_PIN2
2207 && pin_data->type != TAPI_SIM_PTYPE_SIM)
2208 return TAPI_API_INVALID_INPUT;
2210 if ((pin_data->pw_len < 4) || (pin_data->pw_len > 8))
2211 return TAPI_API_INVALID_INPUT;
2213 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2215 gpw = calloc(1, pin_data->pw_len+1);
2217 g_free(evt_cb_data);
2218 return TAPI_API_SYSTEM_OUT_OF_MEM;
2221 memcpy((void*)gpw, (const void*)pin_data->pw, pin_data->pw_len);
2223 param = g_variant_new("(is)", pin_data->type, gpw);
2225 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2226 DBUS_TELEPHONY_SIM_INTERFACE, "VerifySec", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2227 handle->ca, on_response_verify_sim_pins, evt_cb_data);
2232 return TAPI_API_SUCCESS;
2235 EXPORT_API int tel_verify_sim_puks(TapiHandle *handle, const TelSimSecPw_t *puk_data,
2236 const TelSimSecPw_t *new_pin_data, tapi_response_cb callback, void *user_data)
2238 struct tapi_resp_data *evt_cb_data = NULL;
2239 GVariant *param = NULL;
2243 dbg("Func Entrance");
2245 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2246 TAPI_RET_ERR_NUM_IF_FAIL((puk_data != NULL && new_pin_data != NULL), TAPI_API_INVALID_PTR);
2247 TAPI_RET_ERR_NUM_IF_FAIL((puk_data->pw != NULL && new_pin_data->pw != NULL), TAPI_API_INVALID_PTR);
2249 TAPI_SIM_CHECK_TAPI_STATE();
2251 dbg("puk type[%d] pin type[%d]", puk_data->type, new_pin_data->type);
2252 if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 && puk_data->type != TAPI_SIM_PTYPE_PUK2)
2253 || (new_pin_data->type != TAPI_SIM_PTYPE_PIN1 && new_pin_data->type != TAPI_SIM_PTYPE_PIN2))
2254 return TAPI_API_INVALID_INPUT;
2256 if ((puk_data->type != TAPI_SIM_PTYPE_PUK1 || new_pin_data->type != TAPI_SIM_PTYPE_PIN1)
2257 && (puk_data->type != TAPI_SIM_PTYPE_PUK2 || new_pin_data->type != TAPI_SIM_PTYPE_PIN2))
2258 return TAPI_API_INVALID_INPUT;
2260 if ((puk_data->pw_len < 4) || (puk_data->pw_len > 8) || (new_pin_data->pw_len < 4)
2261 || (new_pin_data->pw_len > 8))
2262 return TAPI_API_INVALID_INPUT;
2264 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2266 gpin = calloc(1, new_pin_data->pw_len+1);
2268 g_free(evt_cb_data);
2269 return TAPI_API_SYSTEM_OUT_OF_MEM;
2272 gpuk = calloc(1, puk_data->pw_len+1);
2274 g_free(evt_cb_data);
2276 return TAPI_API_SYSTEM_OUT_OF_MEM;
2279 memcpy((void*)gpin, (const void*)new_pin_data->pw, new_pin_data->pw_len);
2280 memcpy((void*)gpuk, (const void*)puk_data->pw, puk_data->pw_len);
2282 param = g_variant_new("(iss)", puk_data->type, gpuk, gpin);
2284 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2285 DBUS_TELEPHONY_SIM_INTERFACE, "VerifyPUK", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2286 handle->ca, on_response_verify_sim_puks, evt_cb_data);
2294 return TAPI_API_SUCCESS;
2297 EXPORT_API int tel_change_sim_pins(TapiHandle *handle, const TelSimSecPw_t *old_pin,
2298 const TelSimSecPw_t *new_pin, tapi_response_cb callback, void *user_data)
2300 struct tapi_resp_data *evt_cb_data = NULL;
2301 GVariant *param = NULL;
2302 gchar *gpin_o = NULL;
2303 gchar *gpin_n = NULL;
2305 dbg("Func Entrance");
2307 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2308 TAPI_RET_ERR_NUM_IF_FAIL((old_pin != NULL && new_pin != NULL), TAPI_API_INVALID_PTR);
2309 TAPI_RET_ERR_NUM_IF_FAIL((old_pin->pw != NULL && new_pin->pw != NULL), TAPI_API_INVALID_PTR);
2311 TAPI_SIM_CHECK_TAPI_STATE();
2313 dbg("old_pin type[%d],new_pin type[%d]", old_pin->type, new_pin->type);
2314 if ((old_pin->type != TAPI_SIM_PTYPE_PIN1) && (old_pin->type != TAPI_SIM_PTYPE_PIN2)
2315 && (new_pin->type != TAPI_SIM_PTYPE_PIN1) && (new_pin->type != TAPI_SIM_PTYPE_PIN2))
2316 return TAPI_API_INVALID_INPUT;
2318 if (old_pin->type != new_pin->type)
2319 return TAPI_API_INVALID_INPUT;
2321 if ((old_pin->pw_len < 4) || (old_pin->pw_len > 8))
2322 return TAPI_API_INVALID_INPUT;
2324 if ((new_pin->pw_len < 4) || (new_pin->pw_len > 8))
2325 return TAPI_API_INVALID_INPUT;
2327 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2329 gpin_o = calloc(1, old_pin->pw_len+1);
2331 g_free(evt_cb_data);
2332 return TAPI_API_SYSTEM_OUT_OF_MEM;
2335 gpin_n = calloc(1, new_pin->pw_len+1);
2338 g_free(evt_cb_data);
2339 return TAPI_API_SYSTEM_OUT_OF_MEM;
2342 memcpy((void*)gpin_o, (const void*)old_pin->pw, old_pin->pw_len);
2343 memcpy((void*)gpin_n, (const void*)new_pin->pw, new_pin->pw_len);
2345 param = g_variant_new("(iss)", old_pin->type, gpin_o, gpin_n);
2346 dbg("old_pin len[%d],new_pin len[%d]", old_pin->pw_len, new_pin->pw_len);
2348 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2349 DBUS_TELEPHONY_SIM_INTERFACE, "ChangePIN", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2350 handle->ca, on_response_change_sim_pins, evt_cb_data);
2358 return TAPI_API_SUCCESS;
2361 EXPORT_API int tel_disable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw,
2362 tapi_response_cb callback, void *user_data)
2364 struct tapi_resp_data *evt_cb_data = NULL;
2365 GVariant *param = NULL;
2368 dbg("Func Entrance");
2370 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2371 TAPI_RET_ERR_NUM_IF_FAIL(pw, TAPI_API_INVALID_PTR);
2372 TAPI_RET_ERR_NUM_IF_FAIL(pw->pw, TAPI_API_INVALID_PTR);
2374 TAPI_SIM_CHECK_TAPI_STATE();
2376 dbg("facility type[%d]", pw->lock_type);
2377 if(pw->lock_type < TAPI_SIM_LOCK_PS || pw->lock_type >TAPI_SIM_LOCK_PC)
2378 return TAPI_API_INVALID_INPUT;
2379 if ((pw->lock_type < TAPI_SIM_LOCK_PN) && ((pw->pw_len < 4) || (pw->pw_len > 8)) )
2380 return TAPI_API_INVALID_INPUT;
2381 if ((pw->lock_type > TAPI_SIM_LOCK_FD) && (pw->pw_len < 6) )
2382 return TAPI_API_INVALID_INPUT;
2384 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2386 gpw = calloc(1, pw->pw_len+1);
2388 g_free(evt_cb_data);
2389 return TAPI_API_SYSTEM_OUT_OF_MEM;
2392 memcpy((void*)gpw, (const void*)pw->pw, pw->pw_len);
2394 param = g_variant_new("(is)", pw->lock_type, gpw);
2396 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2397 DBUS_TELEPHONY_SIM_INTERFACE, "DisableFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE,
2398 TAPI_DEFAULT_TIMEOUT, handle->ca, on_response_disable_sim_facility, evt_cb_data);
2403 return TAPI_API_SUCCESS;
2406 EXPORT_API int tel_enable_sim_facility(TapiHandle *handle, TelSimFacilityPw_t *pw,
2407 tapi_response_cb callback, void *user_data)
2409 struct tapi_resp_data *evt_cb_data = NULL;
2410 GVariant *param = NULL;
2413 dbg("Func Entrance");
2415 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2416 TAPI_RET_ERR_NUM_IF_FAIL(pw, TAPI_API_INVALID_PTR);
2417 TAPI_RET_ERR_NUM_IF_FAIL(pw->pw, TAPI_API_INVALID_PTR);
2419 TAPI_SIM_CHECK_TAPI_STATE();
2421 dbg("facility type[%d]", pw->lock_type);
2422 if(pw->lock_type < TAPI_SIM_LOCK_PS || pw->lock_type >TAPI_SIM_LOCK_PC)
2423 return TAPI_API_INVALID_INPUT;
2424 if ((pw->lock_type < TAPI_SIM_LOCK_PN) && ((pw->pw_len < 4) || (pw->pw_len > 8)) )
2425 return TAPI_API_INVALID_INPUT;
2426 if ((pw->lock_type > TAPI_SIM_LOCK_FD) && (pw->pw_len < 6) )
2427 return TAPI_API_INVALID_INPUT;
2429 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2431 gpw = calloc(1, pw->pw_len+1);
2433 g_free(evt_cb_data);
2434 return TAPI_API_SYSTEM_OUT_OF_MEM;
2437 memcpy((void*)gpw, (const void*)pw->pw, pw->pw_len);
2439 param = g_variant_new("(is)", pw->lock_type, gpw);
2441 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2442 DBUS_TELEPHONY_SIM_INTERFACE, "EnableFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2443 handle->ca, on_response_enable_sim_facility, evt_cb_data);
2448 return TAPI_API_SUCCESS;
2451 EXPORT_API int tel_get_sim_facility(TapiHandle *handle, TelSimLockType_t type,
2452 tapi_response_cb callback, void *user_data)
2454 struct tapi_resp_data *evt_cb_data = NULL;
2455 GVariant *param = NULL;
2457 dbg("Func Entrance");
2459 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2461 TAPI_SIM_CHECK_TAPI_STATE();
2463 dbg("facility type[%d]", type);
2464 if(type < TAPI_SIM_LOCK_PS || type >TAPI_SIM_LOCK_PC)
2465 return TAPI_API_INVALID_INPUT;
2467 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2469 param = g_variant_new("(i)", type);
2471 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2472 DBUS_TELEPHONY_SIM_INTERFACE, "GetFacility", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2473 handle->ca, on_response_get_sim_facility, evt_cb_data);
2475 return TAPI_API_SUCCESS;
2478 EXPORT_API int tel_get_sim_lock_info(TapiHandle *handle, TelSimLockType_t type,
2479 tapi_response_cb callback, void *user_data)
2481 struct tapi_resp_data *evt_cb_data = NULL;
2482 GVariant *param = NULL;
2484 dbg("Func Entrance");
2486 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2488 TAPI_SIM_CHECK_TAPI_STATE();
2490 dbg("lock type[%d]", type);
2491 if(type < TAPI_SIM_LOCK_PS || type >TAPI_SIM_LOCK_PC)
2492 return TAPI_API_INVALID_INPUT;
2494 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2496 param = g_variant_new("(i)", type);
2498 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2499 DBUS_TELEPHONY_SIM_INTERFACE, "GetLockInfo", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2500 handle->ca, on_response_get_sim_lock_info, evt_cb_data);
2502 return TAPI_API_SUCCESS;
2505 EXPORT_API int tel_req_sim_apdu(TapiHandle *handle, TelSimApdu_t* apdu_data,
2506 tapi_response_cb callback, void *user_data)
2508 struct tapi_resp_data *evt_cb_data = NULL;
2509 GVariantBuilder *builder = NULL;
2510 GVariant *param = NULL;
2511 GVariant *inner_gv = NULL;
2514 dbg("Func Entrance");
2516 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2517 TAPI_RET_ERR_NUM_IF_FAIL(apdu_data, TAPI_API_INVALID_PTR);
2519 TAPI_SIM_CHECK_TAPI_STATE();
2521 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2523 builder = g_variant_builder_new(G_VARIANT_TYPE ("ay"));
2524 for (i = 0; i < apdu_data->apdu_len; i++) {
2525 g_variant_builder_add(builder, "y", apdu_data->apdu[i]);
2527 inner_gv = g_variant_builder_end(builder);
2528 param = g_variant_new("(v)", inner_gv);
2529 /*g_variant_builder_unref (builder);*/
2531 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2532 DBUS_TELEPHONY_SIM_INTERFACE, "TransferAPDU", param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT,
2533 handle->ca, on_response_req_sim_apdu, evt_cb_data);
2535 return TAPI_API_SUCCESS;
2538 EXPORT_API int tel_req_sim_atr(TapiHandle *handle, tapi_response_cb callback, void *user_data)
2540 struct tapi_resp_data *evt_cb_data = NULL;
2542 dbg("Func Entrance");
2544 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2546 TAPI_SIM_CHECK_TAPI_STATE();
2548 MAKE_RESP_CB_DATA(evt_cb_data, handle, callback, user_data);
2550 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2551 DBUS_TELEPHONY_SIM_INTERFACE, "GetATR", NULL, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
2552 on_response_req_sim_atr, evt_cb_data);
2554 return TAPI_API_SUCCESS;
2557 EXPORT_API int tel_request_sim_sync(TapiHandle *handle, TelSimTapiOperation_t op_type, TelSimRequestData_t *inparam, TelSimResponseData_t *outparam)
2559 GVariant *sync_gv = NULL;
2560 GVariant *param = NULL;
2561 GError *gerr = NULL;
2562 int ret = TAPI_API_SUCCESS;
2564 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2565 TAPI_RET_ERR_NUM_IF_FAIL(outparam, TAPI_API_INVALID_PTR);
2567 TAPI_SIM_CHECK_TAPI_STATE();
2569 dbg("op_type = [%d]", op_type);
2571 param = __make_dbus_req_data(op_type, inparam);
2573 sync_gv = g_dbus_connection_call_sync(handle->dbus_connection, DBUS_TELEPHONY_SERVICE,
2574 handle->path, DBUS_TELEPHONY_SIM_INTERFACE, __get_dbus_method_name(op_type), param, NULL,
2575 G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca, &gerr);
2578 ret = __get_dbus_resp_data(op_type, sync_gv, outparam);
2580 TAPI_SIM_CHECK_ERR_MSG(gerr);
2586 EXPORT_API int tel_request_sim_async(TapiHandle *handle, TelSimTapiOperation_t op_type, TelSimRequestData_t *inparam, tapi_response_cb callback, void *user_data)
2588 GVariant *param = NULL;
2589 struct tapi_sim_resp_data *evt_cb_data = NULL;
2591 TAPI_RET_ERR_NUM_IF_FAIL(handle, TAPI_API_INVALID_PTR);
2593 TAPI_SIM_CHECK_TAPI_STATE();
2595 evt_cb_data = g_new0(struct tapi_sim_resp_data, 1);
2596 evt_cb_data->tapi_resp.handle = handle;
2597 evt_cb_data->tapi_resp.cb_fn = callback;
2598 evt_cb_data->tapi_resp.user_data = user_data;
2599 evt_cb_data->op_type = op_type;
2601 param = __make_dbus_req_data(op_type, inparam);
2603 g_dbus_connection_call(handle->dbus_connection, DBUS_TELEPHONY_SERVICE, handle->path,
2604 DBUS_TELEPHONY_SIM_INTERFACE, __get_dbus_method_name(op_type), param, NULL, G_DBUS_CALL_FLAGS_NONE, TAPI_DEFAULT_TIMEOUT, handle->ca,
2605 on_response_call_sim_async, evt_cb_data);
2607 return TAPI_API_SUCCESS;