4 * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
6 * Contact: sharanayya mathapati <sharan.m@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.
29 #include <core_object.h>
34 #include <user_request.h>
39 #include "imc_common.h"
42 #define NUM_TYPE_INTERNATIONAL 0x01
43 #define NUM_PLAN_ISDN 0x01
45 /* To avoid sending multiple response to application */
46 static gboolean UssdResp = FALSE;
48 enum telephony_ss_opcode {
49 SS_OPCO_REG = 0x01, /* 0x01 : Registration */
50 SS_OPCO_DEREG, /* 0x02 : De-registration(erase) */
51 SS_OPCO_ACTIVATE, /* 0x03 : Activation */
52 SS_OPCO_DEACTIVATE, /* 0x04 : De-activation */
56 struct ss_confirm_info {
57 enum telephony_ss_class class;
59 enum tcore_response_command resp;
64 static gboolean _ss_request_message(TcorePending *pending, CoreObject *o, UserRequest *ur, void *on_resp, void *user_data);
66 static TReturn _ss_barring_get(CoreObject *o, UserRequest *ur, enum telephony_ss_class class, enum telephony_ss_barring_mode type, enum tcore_response_command resp);
68 static TReturn _ss_forwarding_get(CoreObject *o, UserRequest *ur, enum telephony_ss_class class, enum telephony_ss_forwarding_mode type, enum tcore_response_command resp);
70 static TReturn _ss_waiting_get(CoreObject *o, UserRequest *ur, enum telephony_ss_class class, enum tcore_response_command resp);
72 static TReturn imc_ss_barring_activate(CoreObject *o, UserRequest *ur);
73 static TReturn imc_ss_barring_deactivate(CoreObject *o, UserRequest *ur);
74 static TReturn imc_ss_barring_change_password(CoreObject *o, UserRequest *ur);
75 static TReturn imc_ss_barring_get_status(CoreObject *o, UserRequest *ur);
77 static TReturn imc_ss_forwarding_activate(CoreObject *o, UserRequest *ur);
78 static TReturn imc_ss_forwarding_deactivate(CoreObject *o, UserRequest *ur);
79 static TReturn imc_ss_forwarding_register(CoreObject *o, UserRequest *ur);
80 static TReturn imc_ss_forwarding_deregister(CoreObject *o, UserRequest *ur);
81 static TReturn imc_ss_forwarding_get_status(CoreObject *o, UserRequest *ur);
83 static TReturn imc_ss_waiting_activate(CoreObject *o, UserRequest *ur);
84 static TReturn imc_ss_waiting_deactivate(CoreObject *o, UserRequest *ur);
85 static TReturn imc_ss_waiting_get_status(CoreObject *o, UserRequest *ur);
87 static TReturn imc_ss_cli_activate(CoreObject *o, UserRequest *ur);
88 static TReturn imc_ss_cli_deactivate(CoreObject *o, UserRequest *ur);
89 static TReturn imc_ss_cli_get_status(CoreObject *o, UserRequest *ur);
91 static TReturn imc_ss_send_ussd(CoreObject *o, UserRequest *ur);
93 static TReturn imc_ss_set_aoc(CoreObject *o, UserRequest *ur);
94 static TReturn imc_ss_get_aoc(CoreObject *o, UserRequest *ur);
96 static TReturn imc_ss_manage_call_0_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
97 static TReturn imc_ss_manage_call_1_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
98 static TReturn imc_ss_manage_call_1x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data);
99 static TReturn imc_ss_manage_call_2_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
100 static TReturn imc_ss_manage_call_2x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data);
101 static TReturn imc_ss_manage_call_3_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
102 static TReturn imc_ss_manage_call_4_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
103 static TReturn imc_ss_manage_call_4dn_send(CoreObject *o, UserRequest *ur, const char *number, ConfirmCallback cb, void *user_data);
105 static void on_confirmation_ss_message_send(TcorePending *p, gboolean result, void *user_data);
107 static void _ss_ussd_response(UserRequest *ur, const char *ussd_str, enum telephony_ss_ussd_type type, enum telephony_ss_ussd_status status);
108 static void _ss_ussd_notification(TcorePlugin *p, const char *ussd_str, enum telephony_ss_ussd_status status);
110 static gboolean on_notification_ss_ussd(CoreObject *o, const void *data, void *user_data);
113 static gboolean _ss_request_message(TcorePending *pending,
114 CoreObject *o, UserRequest *ur,
115 void *on_resp, void *user_data)
117 TcoreHal *hal = NULL;
122 tcore_pending_set_response_callback(pending, on_resp, user_data);
124 tcore_pending_set_send_callback(pending, on_confirmation_ss_message_send, NULL);
127 tcore_pending_link_user_request(pending, ur);
129 err("User Request is NULL, is this internal request??");
131 hal = tcore_object_get_hal(o);
133 /* Send request to HAL */
134 ret = tcore_hal_send_request(hal, pending);
135 if (TCORE_RETURN_SUCCESS != ret) {
136 err("Request send failed");
144 static void _ss_ussd_response(UserRequest *ur,
145 const char *ussd_str, enum telephony_ss_ussd_type type,
146 enum telephony_ss_ussd_status status)
148 struct tresp_ss_ussd resp;
152 memset(&resp, 0x0, sizeof(struct tresp_ss_ussd));
154 resp.status = status;
155 resp.err = SS_ERROR_NONE;
156 dbg("ussd_str = %s resp.type - %d resp.status - %d", ussd_str, resp.type, resp.status);
159 int len = strlen(ussd_str);
160 if (len < MAX_SS_USSD_LEN) {
161 memcpy(resp.str, ussd_str, len);
162 resp.str[len] = '\0';
164 memcpy(resp.str, ussd_str, MAX_SS_USSD_LEN);
165 resp.str[MAX_SS_USSD_LEN - 1] = '\0';
167 dbg("Response string: %s", resp.str);
169 dbg("USSD string is not present");
170 memset(resp.str, '\0', MAX_SS_USSD_LEN);
174 /* Send response to TAPI */
175 tcore_user_request_send_response(ur, TRESP_SS_SEND_USSD, sizeof(struct tresp_ss_ussd), &resp);
177 err("User request is NULL");
184 static void _ss_ussd_notification(TcorePlugin *p, const char *ussd_str, enum telephony_ss_ussd_status status)
186 CoreObject *core_obj = 0;
187 struct tnoti_ss_ussd noti;
189 dbg("function enter");
191 dbg("[ error ] p : (NULL)");
194 noti.status = status;
196 int len = strlen(ussd_str);
197 if (len < MAX_SS_USSD_LEN) {
198 memcpy(noti.str, ussd_str, len);
199 noti.str[len] = '\0';
201 memcpy(noti.str, ussd_str, MAX_SS_USSD_LEN);
202 noti.str[MAX_SS_USSD_LEN - 1] = '\0';
205 memset(noti.str, '\0', MAX_SS_USSD_LEN);
207 dbg("noti.str - %s", noti.str);
209 core_obj = tcore_plugin_ref_core_object(p, CORE_OBJECT_TYPE_SS);
210 tcore_server_send_notification(tcore_plugin_ref_server(p),
213 sizeof(struct tnoti_ss_ussd),
217 static gboolean on_notification_ss_ussd(CoreObject *o, const void *data, void *user_data)
219 enum telephony_ss_ussd_status status;
220 UssdSession *ussd_session = 0;
221 char *ussd_str = 0, *cmd = 0;
222 TcorePlugin *plugin = 0;
224 char *ussdnoti = NULL, *str = NULL, *dcs_str = NULL;
225 GSList *tokens = NULL;
226 GSList *lines = NULL;
227 char *ussd_string = NULL;
230 plugin = tcore_object_ref_plugin(o);
231 ussd_session = tcore_ss_ussd_get_session(o);
233 dbg("function enter");
234 lines = (GSList *) data;
235 if (1 != g_slist_length(lines)) {
236 dbg("unsolicited msg but multiple line");
240 cmd = (char *)(lines->data);
242 /* parse ussd status */
243 tokens = tcore_at_tok_new(cmd);
246 ussdnoti = g_slist_nth_data(tokens, 0);
248 dbg("+CUSD<m> is missing from %CUSD Notification");
251 dbg("USSD status %d", m);
253 /* parse [ <str>, <dcs>] */
254 ussd_string = g_slist_nth_data(tokens, 1);
256 /* Strike off starting & ending quotes. 1 extra character for NULL termination */
257 str = malloc(strlen(ussd_string) - 1);
258 dbg("length of Ussd Stirng - %d", strlen(ussd_string));
260 memset(str, 0x00, strlen(ussd_string) - 1);
262 dbg("malloc failed");
264 tcore_at_tok_free(tokens);
269 len = strlen(ussd_string) - 1;
271 strncpy(str, ussd_string, len);
273 dbg("USSD String - %s len = %d", str, strlen(str));
276 if ((dcs_str = g_slist_nth_data(tokens, 2))) {
278 dbg("USSD dcs %d", dcs);
284 status = SS_USSD_NO_ACTION_REQUIRE;
288 status = SS_USSD_ACTION_REQUIRE;
292 status = SS_USSD_TERMINATED_BY_NET;
296 status = SS_USSD_OTHER_CLIENT;
300 status = SS_USSD_NOT_SUPPORT;
304 status = SS_USSD_TIME_OUT;
308 dbg("unsupported m : %d", m);
309 status = SS_USSD_MAX;
313 switch (tcore_util_get_cbs_coding_scheme(dcs)) {
314 case TCORE_DCS_TYPE_7_BIT:
315 case TCORE_DCS_TYPE_UNSPECIFIED:
316 /* ussd_str = tcore_util_unpack_gsm7bit(str, strlen(str)); */
319 case TCORE_DCS_TYPE_UCS2:
320 case TCORE_DCS_TYPE_8_BIT:
321 if ((str != NULL) && (strlen(str) > 0)) {
322 ussd_str = g_new0(char, strlen(str) + 1);
323 if (ussd_str != NULL) {
324 memcpy(ussd_str, str, strlen(str));
325 ussd_str[strlen(str)] = '\0';
331 dbg("[ error ] unknown dcs type. ussd_session : %x", ussd_session);
334 enum telephony_ss_ussd_type type;
336 tcore_ss_ussd_get_session_data(ussd_session, (void **) &ur);
338 dbg("[ error ] ur : (0)");
342 type = (enum telephony_ss_ussd_type)tcore_ss_ussd_get_session_type(ussd_session);
343 dbg("ussd type - %d", type);
345 _ss_ussd_response(ur, ussd_str, type, status);
350 tcore_at_tok_free(tokens);
359 case SS_USSD_NO_ACTION_REQUIRE:
360 case SS_USSD_ACTION_REQUIRE:
361 case SS_USSD_OTHER_CLIENT:
362 case SS_USSD_NOT_SUPPORT:
363 case SS_USSD_TIME_OUT:
366 enum telephony_ss_ussd_type type;
368 tcore_ss_ussd_get_session_data(ussd_session, (void **)&ur);
370 dbg("[ error ] ur : (0)");
372 tcore_at_tok_free(tokens);
382 type = (enum telephony_ss_ussd_type)tcore_ss_ussd_get_session_type(ussd_session);
383 dbg("ussd type - %d", type);
385 _ss_ussd_response(ur, (const char *)ussd_str, type, status);
390 tcore_ss_ussd_create_session(o, TCORE_SS_USSD_TYPE_NETWORK_INITIATED, 0, 0);
391 _ss_ussd_notification(plugin, (const char *)ussd_str, status);
398 case SS_USSD_TERMINATED_BY_NET:
401 tcore_ss_ussd_get_session_data(ussd_session, (void **)&ur);
403 tcore_user_request_unref(ur);
405 tcore_ss_ussd_destroy_session(ussd_session);
414 tcore_at_tok_free(tokens);
423 static gboolean on_notification_ss_cssu_info(CoreObject *co,
424 const void *event_data, void *user_data)
426 TcorePlugin *p = NULL;
427 CoreObject *o = NULL;
428 GSList *tokens = NULL;
429 enum tcore_notification_command command = TNOTI_UNKNOWN;
435 int id = 1; /* TODO: Need to check how to fetch Call id */
439 p = tcore_object_ref_plugin(co);
440 o = tcore_plugin_ref_core_object(p, CORE_OBJECT_TYPE_CALL);
442 err(" Call CoreObject not found ");
446 if (1 != g_slist_length((GSList *) event_data)) {
447 err("unsolicited msg but multiple line");
450 cmd = (char *) ((GSList *) event_data)->data;
451 info("ss notification message[%s]", cmd);
453 tokens = tcore_at_tok_new(cmd);
456 resp = g_slist_nth_data(tokens, 0);
458 err("Code2 is missing from +CSSU indication");
459 tcore_at_tok_free(tokens);
464 /* parse [ <index>, <number> <type>] */
465 if ((resp = g_slist_nth_data(tokens, 1)))
468 if ((resp = g_slist_nth_data(tokens, 2))) {
469 /* Strike off double quotes */
470 number = tcore_at_tok_extract(resp);
473 info("+CSSU: <code2> = %d <index> = %d ", code2, index);
475 /* <code2> - other values will be ignored */
478 command = TNOTI_CALL_INFO_FORWARDED_CALL;
482 command = TNOTI_CALL_INFO_HELD;
486 command = TNOTI_CALL_INFO_ACTIVE;
490 command = TNOTI_CALL_INFO_JOINED;
494 command = TNOTI_CALL_INFO_RELEASED_ON_HOLD;
498 command = TNOTI_CALL_INFO_CF_CHECK_MESSAGE;
502 command = TNOTI_CALL_INFO_TRANSFER_ALERT;
506 command = TNOTI_CALL_INFO_TRANSFERED_CALL;
510 command = TNOTI_CALL_INFO_DEFLECTED_CALL;
514 err("Unsupported +CSSU notification : %d", code2);
518 /* Send notification */
519 if (command != TNOTI_UNKNOWN) {
520 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)),
521 o, command, sizeof(unsigned int), (void *)&id);
523 tcore_at_tok_free(tokens);
529 static gboolean on_notification_ss_cssi_info(CoreObject *co,
530 const void *event_data, void *user_data)
532 TcorePlugin *p = NULL;
533 CoreObject *o = NULL;
534 GSList *tokens = NULL;
535 enum tcore_notification_command command = TNOTI_UNKNOWN;
540 int id = 1; /* TODO: Need to check how to fetch Call id */
544 p = tcore_object_ref_plugin(co);
545 o = tcore_plugin_ref_core_object(p, CORE_OBJECT_TYPE_CALL);
547 err(" Call CoreObject not found ");
551 if (1 != g_slist_length((GSList *) event_data)) {
552 err("unsolicited msg but multiple line");
555 cmd = (char *) ((GSList *) event_data)->data;
556 info("ss notification message[%s]", cmd);
558 tokens = tcore_at_tok_new(cmd);
561 resp = g_slist_nth_data(tokens, 0);
563 err("<code1> is missing from %CSSI indication");
564 tcore_at_tok_free(tokens);
569 /* parse [ <index>] */
570 if ((resp = g_slist_nth_data(tokens, 1)))
573 info("+CSSI: <code1> = %d <index> = %d ", code1, index);
575 /* <code1> - other values will be ignored */
578 command = TNOTI_CALL_INFO_FORWARD_UNCONDITIONAL;
582 command = TNOTI_CALL_INFO_FORWARD_CONDITIONAL;
586 command = TNOTI_CALL_INFO_FORWARDED;
590 command = TNOTI_CALL_INFO_WAITING;
594 command = TNOTI_CALL_INFO_BARRED_OUTGOING;
598 command = TNOTI_CALL_INFO_BARRED_INCOMING;
602 command = TNOTI_CALL_INFO_CLIR_SUPPRESSION_REJECT;
606 command = TNOTI_CALL_INFO_DEFLECTED;
610 dbg("Unsupported +CSSI notification : %d", code1);
614 /* Send notification */
615 if (command != TNOTI_UNKNOWN) {
616 tcore_server_send_notification(tcore_plugin_ref_server(tcore_object_ref_plugin(o)),
617 o, command, sizeof(unsigned int), (void *)&id);
619 tcore_at_tok_free(tokens);
624 static void on_confirmation_ss_message_send(TcorePending *p, gboolean result, void *user_data)
628 if (result == FALSE) {
636 static void on_response_ss_barring_set(TcorePending *p, int data_len, const void *data, void *user_data)
638 struct ss_confirm_info *info = 0;
639 enum telephony_ss_class class;
642 struct tresp_ss_barring resp = {0, };
643 UserRequest *ur_dup = 0;
644 GSList *tokens = NULL;
647 const TcoreATResponse *response;
649 dbg("function enter");
651 o = tcore_pending_ref_core_object(p);
652 ur = tcore_pending_ref_user_request(p);
654 info = (struct ss_confirm_info *)user_data;
657 if (response->success > 0) {
659 resp.err = SS_ERROR_NONE;
661 dbg("RESPONSE NOT OK");
662 line = (const char *)response->final_response;
663 tokens = tcore_at_tok_new(line);
665 if (g_slist_length(tokens) < 1) {
666 dbg("err cause not specified or string corrupted");
667 resp.err = SS_ERROR_SYSTEMFAILURE;
669 error = atoi(g_slist_nth_data(tokens, 0));
670 err("Error: [%d]", error);
671 /* TODO: CMEE error mapping is required. */
672 resp.err = SS_ERROR_SYSTEMFAILURE;
674 tcore_at_tok_free(tokens);
677 dbg("on_response_ss_barring_set - rsp.err : %d, ur : %x flavor_type = %d", resp.err, ur, info->flavor_type);
678 dbg("[ check ] class : 0x%x", info->class);
680 if (response->success > 0) {
681 if (info->class == SS_CLASS_VOICE)
682 class = SS_CLASS_ALL_TELE_BEARER;
684 ur_dup = tcore_user_request_ref(ur);
686 if (info->flavor_type == SS_BARR_MODE_AB || info->flavor_type == SS_BARR_MODE_AOB)
687 _ss_barring_get(o, ur_dup, class, SS_BARR_MODE_BAOC, info->resp);
688 else if (info->flavor_type == SS_BARR_MODE_AIB)
689 _ss_barring_get(o, ur_dup, class, SS_BARR_MODE_BAIC, info->resp);
691 _ss_barring_get(o, ur_dup, class, info->flavor_type, info->resp);
694 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
696 dbg("[ error ] ur is 0");
701 static void on_response_ss_barring_change_pwd(TcorePending *p, int data_len, const void *data, void *user_data)
703 const TcoreATResponse *response = data;
704 struct ss_confirm_info *info = 0;
706 struct tresp_ss_general resp;
708 GSList *tokens = NULL;
711 dbg("function enter");
712 ur = tcore_pending_ref_user_request(p);
713 info = (struct ss_confirm_info *) user_data;
715 if (response->success > 0) {
717 resp.err = SS_ERROR_NONE;
719 dbg("RESPONSE NOT OK");
721 line = (const char *) response->final_response;
722 tokens = tcore_at_tok_new(line);
724 if (g_slist_length(tokens) < 1) {
725 dbg("err cause not specified or string corrupted");
726 resp.err = SS_ERROR_SYSTEMFAILURE;
728 error = atoi(g_slist_nth_data(tokens, 0));
729 err("Error: [%d]", error);
730 /* TODO: CMEE error mapping is required. */
731 resp.err = SS_ERROR_SYSTEMFAILURE;
733 tcore_at_tok_free(tokens);
736 dbg("on_response_ss_barring_change_pwd: rsp.err : %d, usr : %x", resp.err, ur);
738 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);
740 dbg("[ error ] ur is 0");
745 static void on_response_ss_forwarding_set(TcorePending *p, int data_len, const void *data, void *user_data)
748 UserRequest *ur = 0, *dup_ur = 0;
749 struct ss_confirm_info *info = 0;
750 struct tresp_ss_forwarding resp = {0,};
751 GSList *tokens = NULL;
754 const TcoreATResponse *response;
756 dbg("function enter");
759 o = tcore_pending_ref_core_object(p);
760 ur = tcore_pending_ref_user_request(p);
762 info = (struct ss_confirm_info *) user_data;
764 if (response->success > 0) {
766 resp.err = SS_ERROR_NONE;
768 dbg("RESPONSE NOT OK");
771 line = (const char *) response->final_response;
772 tokens = tcore_at_tok_new(line);
774 if (g_slist_length(tokens) < 1) {
775 dbg("Error cause not specified or string corrupted");
776 resp.err = SS_ERROR_SYSTEMFAILURE;
778 error = atoi(g_slist_nth_data(tokens, 0));
779 err("Error: [%d]", error);
780 /* / TODO: CMEE error mapping is required. */
781 resp.err = SS_ERROR_SYSTEMFAILURE;
784 tcore_at_tok_free(tokens);
787 dbg("[ check ] class : 0x%x", info->class);
788 dbg("[ check ] flavor_type : 0x%x", info->flavor_type);
790 dbg("on_response_ss_forwarding_set - rsp.err : %d, ur : %x", resp.err, ur);
792 if (response->success > 0) {
793 if (info->flavor_type == SS_CF_MODE_CF_ALL ||
794 info->flavor_type == SS_CF_MODE_CFC) {
796 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
798 dbg("[ error ] ur is 0");
800 dup_ur = tcore_user_request_ref(ur);
801 _ss_forwarding_get(o, dup_ur, info->class, info->flavor_type, info->resp);
805 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
807 dbg("[ error ] ur is 0");
812 static void on_response_ss_waiting_set(TcorePending *p, int data_len, const void *data, void *user_data)
814 CoreObject *core_obj = 0;
816 UserRequest *ur_dup = 0;
817 struct ss_confirm_info *info = 0;
818 struct tresp_ss_waiting resp = {0,};
819 GSList *tokens = NULL;
822 const TcoreATResponse *response;
824 dbg("function enter");
826 core_obj = tcore_pending_ref_core_object(p);
827 ur = tcore_pending_ref_user_request(p);
829 info = (struct ss_confirm_info *)user_data;
831 if (response->success > 0) {
833 resp.err = SS_ERROR_NONE;
835 dbg("RESPONSE NOT OK");
838 line = (const char *) response->final_response;
839 tokens = tcore_at_tok_new(line);
841 if (g_slist_length(tokens) < 1) {
842 dbg("Error cause not specified or string corrupted");
843 resp.err = SS_ERROR_SYSTEMFAILURE;
845 error = atoi(g_slist_nth_data(tokens, 0));
846 err("Error: [%d]", error);
847 /* TODO: CMEE error mapping is required. */
848 resp.err = SS_ERROR_SYSTEMFAILURE;
852 tcore_at_tok_free(tokens);
855 dbg("Call Waiting - Error: [%d], UR: [0x%x] class: [0x%2x]", resp.err, ur, info->class);
856 if (resp.err == SS_ERROR_NONE) {
857 ur_dup = tcore_user_request_ref(ur);
859 dbg("Get Call Waiting status");
860 _ss_waiting_get(core_obj, ur_dup, info->class, info->resp);
863 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_waiting), &resp);
865 err("User request is NULL");
871 static void on_confirmation_ss_ussd(TcorePending *p, int data_len, const void *data, void *user_data)
873 CoreObject *core_obj = 0;
874 struct ss_confirm_info *info = 0;
875 struct tresp_ss_ussd resp;
876 UserRequest *ur = NULL, *ussd_ur = NULL;
877 GSList *tokens = NULL;
880 UssdSession *ussd_s = NULL;
881 enum tcore_ss_ussd_type type = TCORE_SS_USSD_TYPE_MAX;
882 const TcoreATResponse *response;
884 dbg("function enter");
886 ur = tcore_pending_ref_user_request(p);
887 info = (struct ss_confirm_info *) user_data;
889 memset(resp.str, 0x00, MAX_SS_USSD_LEN);
891 core_obj = tcore_pending_ref_core_object(p);
892 ussd_s = tcore_ss_ussd_get_session(core_obj);
895 type = tcore_ss_ussd_get_session_type(ussd_s);
897 dbg("[ error ] ussd_s : (0)");
899 resp.type = (enum telephony_ss_ussd_type) type;
900 resp.status = SS_USSD_MAX; /* hardcoded value. */
902 if (response->success > 0) {
904 resp.err = SS_ERROR_NONE;
906 dbg("RESPONSE NOT OK");
908 line = (const char *) response->final_response;
909 tokens = tcore_at_tok_new(line);
911 if (g_slist_length(tokens) < 1) {
912 dbg("err cause not specified or string corrupted");
913 resp.err = SS_ERROR_SYSTEMFAILURE;
915 error = atoi(g_slist_nth_data(tokens, 0));
916 err("Error: [%d]", error);
917 /* TODO: CMEE error mapping is required. */
918 resp.err = SS_ERROR_SYSTEMFAILURE;
920 tcore_at_tok_free(tokens);
923 dbg("on_confirmation_ss_ussd - rsp.err : %d, ur : %x", resp.err, ur);
925 if (response->success > 0) {
926 if (type == TCORE_SS_USSD_TYPE_USER_INITIATED) {
927 dbg("ussd type %d", resp.type);
930 tcore_ss_ussd_get_session_data(ussd_s, (void **) &ussd_ur);
932 tcore_user_request_free(ussd_ur);
938 tcore_ss_ussd_destroy_session(ussd_s);
941 if (UssdResp == FALSE) { /* to avoid sending multiple response to application. */
942 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_ussd), &resp);
946 dbg("[ error ] ur : (0)");
951 static void on_response_ss_barring_get(TcorePending *p, int data_len, const void *data, void *user_data)
954 int status = 0, classx = 0, ss_err = 0;
956 struct ss_confirm_info *info = 0;
957 struct tresp_ss_barring resp;
958 int countRecords = 0, countValidRecords = 0;
959 GSList *tokens = NULL;
963 const TcoreATResponse *response;
965 dbg("function enter");
968 ur = tcore_pending_ref_user_request(p);
969 info = (struct ss_confirm_info *) user_data;
971 if (response->lines) {
972 respdata = (GSList *) response->lines;
973 countRecords = g_slist_length(respdata);
974 dbg("total records : %d", countRecords);
977 dbg("no active status - return to user");
979 resp.record_num = countRecords;
981 if (resp.record_num > 0) {
982 resp.record = g_new0(struct barring_info, resp.record_num);
983 for (countValidRecords = 0; respdata != NULL; respdata = respdata->next) {
984 line = (const char *) (respdata->data);
985 tokens = tcore_at_tok_new(line);
988 stat = g_slist_nth_data(tokens, 0);
990 dbg("Stat is missing");
996 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
998 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
1000 dbg("call barring status - %d", status);
1003 classx_str = g_slist_nth_data(tokens, 1);
1006 dbg("class error. classx not exist - set to requested one : %d", info->class);
1007 switch (info->class) {
1008 case SS_CLASS_ALL_TELE:
1012 case SS_CLASS_VOICE:
1016 case SS_CLASS_ALL_DATA_TELE:
1028 case SS_CLASS_ALL_CS_SYNC:
1034 dbg("unsupported class %d. set to default : 7", info->class);
1038 classx = atoi(classx_str);
1039 dbg("call barring classx - %d", classx);
1044 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1048 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1052 resp.record[countValidRecords].class = SS_CLASS_FAX;
1056 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1060 resp.record[countValidRecords].class = SS_CLASS_SMS;
1064 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1068 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1072 dbg("unspoorted class : [%d]\n", classx);
1075 resp.record[countValidRecords].mode = (enum telephony_ss_barring_mode) (info->flavor_type);
1076 countValidRecords++;
1077 tcore_at_tok_free(tokens);
1081 dbg("invalid field found. coutinue");
1082 tcore_at_tok_free(tokens);
1086 dbg("valid count :%d", countValidRecords);
1087 resp.record_num = countValidRecords;
1088 resp.err = SS_ERROR_NONE;
1090 dbg("no active status - return to user");
1093 if (response->success > 0) {
1095 resp.err = SS_ERROR_NONE;
1097 dbg("RESPONSE NOT OK");
1098 resp.err = TCORE_RETURN_FAILURE;
1100 resp.record_num = 0;
1102 line = (const char *) response->final_response;
1103 tokens = tcore_at_tok_new(line);
1105 if (g_slist_length(tokens) < 1) {
1106 dbg("err cause not specified or string corrupted");
1107 resp.err = SS_ERROR_SYSTEMFAILURE;
1109 ss_err = atoi(g_slist_nth_data(tokens, 0));
1110 err("Error: [%d]", ss_err);
1111 /* TODO: CMEE error mapping is required. */
1112 resp.err = SS_ERROR_SYSTEMFAILURE;
1114 tcore_at_tok_free(tokens);
1117 dbg("on_response_ss_barring_get- rsp.err : %d, ur : %x", resp.err, ur);
1120 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
1122 dbg("[ error ] ur is 0");
1125 g_free(resp.record);
1132 static void on_response_ss_forwarding_get(TcorePending *p, int data_len, const void *data, void *user_data)
1134 UserRequest *ur = 0;
1135 int classx = 0, ss_err = 0, time = 0;
1137 struct ss_confirm_info *info = 0;
1138 struct tresp_ss_forwarding resp;
1139 int countRecords = 0, countValidRecords = 0;
1141 GSList *respdata = NULL, *tokens = NULL;
1143 char *classx_str, *status, *ton, *time_str;
1144 const TcoreATResponse *response;
1146 dbg("function enter");
1149 ur = tcore_pending_ref_user_request(p);
1150 info = (struct ss_confirm_info *) user_data;
1151 if (response->lines) {
1152 respdata = (GSList *) response->lines;
1153 countRecords = g_slist_length(respdata);
1154 dbg("total records : %d", countRecords);
1157 dbg("no active status - return to user");
1159 resp.record_num = countRecords;
1161 if (resp.record_num > 0) {
1162 resp.record = g_new0(struct forwarding_info, resp.record_num);
1164 for (countValidRecords = 0; respdata != NULL; respdata = respdata->next) {
1165 line = (const char *) (respdata->data);
1166 tokens = tcore_at_tok_new(line);
1168 /* parse <status> */
1169 status = g_slist_nth_data(tokens, 0);
1171 dbg("start line error. skip this line");
1174 if (atoi(status) == 1)
1175 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
1177 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
1181 classx_str = g_slist_nth_data(tokens, 1);
1183 dbg("class error. skip this line");
1186 switch (atoi(classx_str)) {
1188 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1192 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1196 resp.record[countValidRecords].class = SS_CLASS_FAX;
1200 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1204 resp.record[countValidRecords].class = SS_CLASS_SMS;
1208 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1212 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1216 dbg("unspoorted class : [%d]\n", classx);
1221 /* parse <numer> <type> */
1222 num = g_slist_nth_data(tokens, 2);
1224 dbg("number - %s", num);
1225 memcpy((resp.record[countValidRecords].number), num, strlen(num));
1226 resp.record[countValidRecords].number_present = TRUE;
1228 ton = g_slist_nth_data(tokens, 3);
1230 resp.record[countValidRecords].ton = atoi(ton);
1231 dbg("number type - %d", resp.record[countValidRecords].ton);
1235 /* skip <subaddr> <satype> */
1237 time_str = g_slist_nth_data(tokens, 6);
1239 time = atoi(time_str);
1240 resp.record[countValidRecords].time = (enum telephony_ss_forwarding_no_reply_time) time;
1241 dbg("time - %d", time);
1244 resp.record[countValidRecords].mode = (enum telephony_ss_forwarding_mode) (info->flavor_type);
1245 dbg("flavor_type - %d", (enum telephony_ss_forwarding_mode) (info->flavor_type));
1247 countValidRecords++;
1248 tcore_at_tok_free(tokens);
1251 dbg("invalid field found. coutinue");
1252 tcore_at_tok_free(tokens);
1255 dbg("valid count :%d", countValidRecords);
1256 resp.record_num = countValidRecords;
1257 resp.err = SS_ERROR_NONE;
1259 dbg("no active status - return to user");
1262 if (response->success > 0) {
1264 resp.err = SS_ERROR_NONE;
1266 dbg("RESPONSE NOT OK");
1268 resp.record_num = 0;
1269 line = (const char *) response->final_response;
1270 tokens = tcore_at_tok_new(line);
1272 if (g_slist_length(tokens) < 1) {
1273 dbg("err cause not specified or string corrupted");
1274 resp.err = SS_ERROR_SYSTEMFAILURE;
1276 ss_err = atoi(g_slist_nth_data(tokens, 0));
1277 err("Error: [%d]", ss_err);
1278 /* TODO: CMEE error mapping is required. */
1279 resp.err = SS_ERROR_SYSTEMFAILURE;
1281 tcore_at_tok_free(tokens);
1284 dbg("on_response_ss_forwarding_get- rsp.err : %d, ur : %x", resp.err, ur);
1286 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
1288 dbg("[ error ] ur is 0");
1291 g_free(resp.record);
1297 static void on_response_ss_waiting_get(TcorePending *p, int data_len, const void *data, void *user_data)
1299 UserRequest *ur = 0;
1300 GSList *respdata, *tokens = NULL;
1301 int classx = 0, ss_err = 0;
1302 struct ss_confirm_info *info = 0;
1303 struct tresp_ss_waiting resp;
1304 int countRecords = 0, countValidRecords = 0;
1306 char *classx_str, *status;
1307 const TcoreATResponse *response;
1309 dbg("function enter");
1311 ur = tcore_pending_ref_user_request(p);
1312 info = (struct ss_confirm_info *) user_data;
1314 if (response->lines) {
1315 respdata = (GSList *) response->lines;
1316 countRecords = g_slist_length(respdata);
1317 dbg("total records : %d", countRecords);
1320 dbg("no active status - return to user");
1322 resp.record_num = countRecords;
1325 if (resp.record_num > 0) {
1326 resp.record = g_new0(struct waiting_info, resp.record_num);
1328 for (countValidRecords = 0; respdata != NULL; respdata = respdata->next) {
1329 line = (const char *) (respdata->data);
1330 tokens = tcore_at_tok_new(line);
1332 /* parse <status> */
1333 status = g_slist_nth_data(tokens, 0);
1335 dbg("Missing stat in responce ");
1338 if (atoi(status) == 1)
1339 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
1341 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
1343 dbg("status = %d", resp.record[countValidRecords].status);
1346 classx_str = g_slist_nth_data(tokens, 1);
1348 dbg("error - class is missing");
1351 switch (atoi(classx_str)) {
1353 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1357 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1361 resp.record[countValidRecords].class = SS_CLASS_FAX;
1365 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1369 resp.record[countValidRecords].class = SS_CLASS_SMS;
1373 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1377 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1381 dbg("unspoorted class : [%d]\n", classx);
1384 dbg("class info %d", resp.record[countValidRecords].class);
1387 countValidRecords++;
1388 tcore_at_tok_free(tokens);
1391 dbg("invalid field found. coutinue");
1392 tcore_at_tok_free(tokens);
1396 dbg("valid count :%d", countValidRecords);
1397 resp.record_num = countValidRecords;
1398 resp.err = SS_ERROR_NONE;
1400 dbg("no active status - return to user");
1403 if (response->success > 0) {
1405 resp.err = SS_ERROR_NONE;
1407 dbg("RESPONSE NOT OK");
1409 resp.record_num = 0;
1410 line = (const char *) response->final_response;
1411 tokens = tcore_at_tok_new(line);
1413 if (g_slist_length(tokens) < 1) {
1414 dbg("err cause not specified or string corrupted");
1415 resp.err = SS_ERROR_SYSTEMFAILURE;
1417 ss_err = atoi(g_slist_nth_data(tokens, 0));
1418 err("Error: [%d]", ss_err);
1419 /* TODO: CMEE error mapping is required. */
1420 resp.err = SS_ERROR_SYSTEMFAILURE;
1422 tcore_at_tok_free(tokens);
1425 dbg("on_response_ss_waiting_get - rsp.err : %d, ur : %x", resp.err, ur);
1427 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_waiting), &resp);
1429 dbg("[ error ] ur is 0");
1432 g_free(resp.record);
1439 static void on_response_ss_cli_get(TcorePending *p, int data_len, const void *data, void *user_data)
1441 UserRequest *ur = 0;
1442 struct tresp_ss_cli resp;
1443 enum telephony_ss_cli_type *p_type = NULL;
1444 char *line = NULL, *status;
1446 int cli_adj, stat = 0;
1447 GSList *tokens = NULL;
1448 const TcoreATResponse *response;
1450 dbg("function enter");
1452 ur = tcore_pending_ref_user_request(p);
1453 p_type = (enum telephony_ss_cli_type *) (user_data);
1455 if (response->success > 0) {
1456 line = (char *) (((GSList *) response->lines)->data);
1457 tokens = tcore_at_tok_new(line);
1459 if (*p_type == SS_CLI_TYPE_CLIR) {
1460 /* +CLIR: <n> <m> */
1461 dbg("CLI type is CLIR");
1463 status = g_slist_nth_data(tokens, 0);
1466 dbg("Call line identification adjustment missing <n>");
1468 cli_adj = atoi(status);
1469 dbg("CLIR response value of <n> - %d", cli_adj);
1473 status = g_slist_nth_data(tokens, 1);
1475 dbg("status is missing<m>");
1477 stat = atoi(status);
1478 dbg("CLIR response value of <m> - %d", stat);
1480 if (stat == 1 || stat == 3)
1483 resp.status = FALSE;
1484 } else if (cli_adj == 1) {
1487 resp.status = FALSE;
1489 dbg("resp.status - %d", resp.status);
1491 tcore_at_tok_free(tokens);
1494 status = g_slist_nth_data(tokens, 0);
1496 dbg("Stat is missing");
1498 stat = atoi(status);
1502 resp.status = FALSE;
1504 dbg("resp.status - %d", resp.status);
1506 tcore_at_tok_free(tokens);
1510 if (response->success > 0) {
1512 resp.err = SS_ERROR_NONE;
1514 dbg("RESPONSE NOT OK");
1516 line = (char *) response->final_response;
1517 tokens = tcore_at_tok_new(line);
1519 if (g_slist_length(tokens) < 1) {
1520 dbg("err cause not specified or string corrupted");
1521 resp.err = SS_ERROR_SYSTEMFAILURE;
1523 error = atoi(g_slist_nth_data(tokens, 0));
1524 err("Error: [%d]", error);
1525 /* TODO: CMEE error mapping is required. */
1526 resp.err = SS_ERROR_SYSTEMFAILURE;
1528 tcore_at_tok_free(tokens);
1531 resp.type = *p_type;
1532 dbg("check - resp.type = %d ", resp.type);
1534 tcore_user_request_send_response(ur, TRESP_SS_CLI_GET_STATUS, sizeof(struct tresp_ss_cli), &resp);
1536 dbg("[ error ] ur : (0)");
1541 static struct tcore_ss_operations ss_ops = {
1542 .barring_activate = imc_ss_barring_activate,
1543 .barring_deactivate = imc_ss_barring_deactivate,
1544 .barring_change_password = imc_ss_barring_change_password,
1545 .barring_get_status = imc_ss_barring_get_status,
1546 .forwarding_activate = imc_ss_forwarding_activate,
1547 .forwarding_deactivate = imc_ss_forwarding_deactivate,
1548 .forwarding_register = imc_ss_forwarding_register,
1549 .forwarding_deregister = imc_ss_forwarding_deregister,
1550 .forwarding_get_status = imc_ss_forwarding_get_status,
1551 .waiting_activate = imc_ss_waiting_activate,
1552 .waiting_deactivate = imc_ss_waiting_deactivate,
1553 .waiting_get_status = imc_ss_waiting_get_status,
1554 .cli_activate = imc_ss_cli_activate,
1555 .cli_deactivate = imc_ss_cli_deactivate,
1556 .cli_get_status = imc_ss_cli_get_status,
1557 .send_ussd = imc_ss_send_ussd,
1558 .set_aoc = imc_ss_set_aoc,
1559 .get_aoc = imc_ss_get_aoc,
1563 static TReturn _ss_barring_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op)
1565 struct treq_ss_barring *barring = 0;
1566 struct ss_confirm_info *user_data = 0;
1567 char *cmd_str = NULL;
1568 TcorePending *pending = NULL;
1569 TcoreATRequest *req;
1570 char passwd[MAX_SS_BARRING_PASSWORD_LEN + 1];
1573 char *facility = NULL;
1574 gboolean ret = FALSE;
1576 dbg("function enter");
1577 barring = (struct treq_ss_barring *) tcore_user_request_ref_data(ur, 0);
1580 case SS_OPCO_ACTIVATE:
1584 case SS_OPCO_DEACTIVATE:
1589 dbg("unsupported opco : %d", op);
1590 return TCORE_RETURN_FAILURE;
1592 dbg("opco - %d", opco);
1594 switch (barring->mode) {
1595 case SS_BARR_MODE_BAOC:
1599 case SS_BARR_MODE_BOIC:
1603 case SS_BARR_MODE_BOIC_NOT_HC:
1607 case SS_BARR_MODE_BAIC:
1611 case SS_BARR_MODE_BIC_ROAM:
1615 case SS_BARR_MODE_AB:
1619 case SS_BARR_MODE_AOB:
1623 case SS_BARR_MODE_AIB:
1627 case SS_BARR_MODE_BIC_NOT_SIM:
1628 /* facility = "NS"; */
1630 dbg("unspported mode %d", barring->mode);
1631 return TCORE_RETURN_FAILURE;
1634 dbg("facility - %s", facility);
1636 switch (barring->class) {
1637 case SS_CLASS_ALL_TELE:
1641 case SS_CLASS_VOICE:
1645 case SS_CLASS_ALL_DATA_TELE:
1657 case SS_CLASS_ALL_CS_SYNC:
1663 dbg("unsupported class %d. set to default : 7", barring->class);
1667 dbg("classx - %d", classx);
1669 user_data = g_new0(struct ss_confirm_info, 1);
1671 dbg("[ error ] failed to allocate memory");
1672 return TCORE_RETURN_ENOMEM;
1675 /* null-ended pwd handling added - unexpected 0x11 value observed in req string */
1676 memcpy(passwd, barring->password, MAX_SS_BARRING_PASSWORD_LEN);
1677 passwd[MAX_SS_BARRING_PASSWORD_LEN] = '\0';
1678 dbg("passwd - %s", passwd);
1680 pending = tcore_pending_new(o, 0);
1682 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,\"%s\",%d", facility, opco, passwd, classx);
1683 dbg("request command : %s", cmd_str);
1685 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
1687 tcore_pending_free(pending);
1689 return TCORE_RETURN_FAILURE;
1691 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
1693 tcore_pending_set_request_data(pending, 0, req);
1695 if (op == SS_OPCO_ACTIVATE) {
1696 user_data->resp = TRESP_SS_BARRING_ACTIVATE;
1697 } else if (op == SS_OPCO_DEACTIVATE) {
1698 user_data->resp = TRESP_SS_BARRING_DEACTIVATE;
1700 dbg("[ error ] wrong ss opco (0x%x)", op);
1701 if (user_data != NULL)
1705 tcore_pending_free(pending);
1706 tcore_at_request_free(req);
1707 return TCORE_RETURN_FAILURE;
1709 user_data->flavor_type = (int) (barring->mode);
1710 user_data->class = barring->class;
1712 ret = _ss_request_message(pending, o, ur, on_response_ss_barring_set, user_data);
1716 dbg("AT request sent failed ");
1717 if (user_data != NULL) {
1719 tcore_pending_free(pending);
1720 tcore_at_request_free(req);
1722 return TCORE_RETURN_FAILURE;
1724 return TCORE_RETURN_SUCCESS;
1727 static TReturn _ss_barring_get(CoreObject *o,
1729 enum telephony_ss_class class,
1730 enum telephony_ss_barring_mode mode,
1731 enum tcore_response_command resp)
1733 struct ss_confirm_info *user_data = 0;
1734 gboolean ret = FALSE;
1735 char *cmd_str = NULL;
1737 char *facility = NULL;
1738 TcorePending *pending = NULL;
1739 TcoreATRequest *req;
1741 dbg("function enter");
1743 /* query status - opco is fixed to 2 */
1747 case SS_BARR_MODE_BAOC:
1751 case SS_BARR_MODE_BOIC:
1755 case SS_BARR_MODE_BOIC_NOT_HC:
1759 case SS_BARR_MODE_BAIC:
1763 case SS_BARR_MODE_BIC_ROAM:
1767 case SS_BARR_MODE_AB:
1768 case SS_BARR_MODE_AOB:
1769 case SS_BARR_MODE_AIB:
1770 case SS_BARR_MODE_BIC_NOT_SIM:
1772 dbg("unsupported mode %d", mode);
1773 return TCORE_RETURN_FAILURE;
1776 dbg("facility - %s", facility);
1779 case SS_CLASS_ALL_TELE:
1783 case SS_CLASS_VOICE:
1787 case SS_CLASS_ALL_DATA_TELE:
1799 case SS_CLASS_ALL_CS_SYNC:
1805 dbg("unsupported class %d. set to default : 7", class);
1809 user_data = g_new0(struct ss_confirm_info, 1);
1811 dbg("[ error ] failed to allocate memory");
1812 return TCORE_RETURN_ENOMEM;
1815 dbg("class - %d", classx);
1817 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d", facility, opco);
1819 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,,%d", facility, opco, classx);
1821 dbg("request command : %s", cmd_str);
1823 pending = tcore_pending_new(o, 0);
1824 req = tcore_at_request_new(cmd_str, "+CLCK", TCORE_AT_MULTILINE);
1826 tcore_pending_free(pending);
1828 return TCORE_RETURN_FAILURE;
1830 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
1832 tcore_pending_set_request_data(pending, 0, req);
1834 user_data->resp = resp;
1835 user_data->flavor_type = (int) (mode);
1836 user_data->class = class;
1838 ret = _ss_request_message(pending, o, ur, on_response_ss_barring_get, user_data);
1842 dbg("AT request sent failed ");
1843 if (user_data != NULL) {
1845 tcore_pending_free(pending);
1846 tcore_at_request_free(req);
1848 return TCORE_RETURN_FAILURE;
1851 return TCORE_RETURN_SUCCESS;
1854 static TReturn imc_ss_barring_activate(CoreObject *o, UserRequest *ur)
1856 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
1857 dbg("cp not ready/n");
1858 return TCORE_RETURN_ENOSYS;
1860 return _ss_barring_set(o, ur, SS_OPCO_ACTIVATE);
1863 static TReturn imc_ss_barring_deactivate(CoreObject *o, UserRequest *ur)
1865 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
1866 dbg("cp not ready/n");
1867 return TCORE_RETURN_ENOSYS;
1869 return _ss_barring_set(o, ur, SS_OPCO_DEACTIVATE);
1872 static TReturn imc_ss_barring_change_password(CoreObject *o, UserRequest *ur)
1874 TcorePending *pending = NULL;
1875 TcoreATRequest *req;
1876 struct treq_ss_barring_change_password *barring = 0;
1877 struct ss_confirm_info *user_data = 0;
1878 char *cmd_str = NULL;
1879 gboolean ret = FALSE;
1880 char old_password[MAX_SS_BARRING_PASSWORD_LEN + 1];
1881 char new_password[MAX_SS_BARRING_PASSWORD_LEN + 1];
1883 dbg("function enter");
1885 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
1886 dbg("cp not ready/n");
1887 return TCORE_RETURN_ENOSYS;
1890 barring = (struct treq_ss_barring_change_password *) tcore_user_request_ref_data(ur, 0);
1892 memcpy(old_password, barring->password_old, MAX_SS_BARRING_PASSWORD_LEN);
1893 old_password[MAX_SS_BARRING_PASSWORD_LEN] = '\0';
1894 memcpy(new_password, barring->password_new, MAX_SS_BARRING_PASSWORD_LEN);
1895 new_password[MAX_SS_BARRING_PASSWORD_LEN] = '\0';
1897 user_data = g_new0(struct ss_confirm_info, 1);
1899 dbg("[ error ] failed to allocate memory");
1900 return TCORE_RETURN_ENOMEM;
1902 user_data->resp = TRESP_SS_BARRING_CHANGE_PASSWORD;
1904 dbg("old passwd - %s new passwd- %s", old_password, new_password);
1905 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", "AB", old_password, new_password);
1906 dbg("request command : %s", cmd_str);
1908 pending = tcore_pending_new(o, 0);
1909 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
1911 tcore_pending_free(pending);
1913 return TCORE_RETURN_FAILURE;
1915 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
1917 tcore_pending_set_request_data(pending, 0, req);
1919 ret = _ss_request_message(pending, o, ur, on_response_ss_barring_change_pwd, user_data);
1922 dbg("AT request sent failed ");
1923 if (user_data != NULL)
1926 tcore_pending_free(pending);
1927 tcore_at_request_free(req);
1928 return TCORE_RETURN_FAILURE;
1930 return TCORE_RETURN_SUCCESS;
1933 static TReturn imc_ss_barring_get_status(CoreObject *o, UserRequest *ur)
1935 struct treq_ss_barring *barring = 0;
1937 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
1938 dbg("cp not ready/n");
1939 return TCORE_RETURN_ENOSYS;
1941 barring = (struct treq_ss_barring *) tcore_user_request_ref_data(ur, 0);
1943 return _ss_barring_get(o, ur, barring->class, barring->mode, TRESP_SS_BARRING_GET_STATUS);
1946 static TReturn _ss_forwarding_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op)
1948 struct treq_ss_forwarding *forwarding = 0;
1949 struct ss_confirm_info *user_data = 0;
1950 gboolean ret = FALSE;
1952 char *cmd_str = NULL;
1953 char *tmp_str = NULL;
1954 int reason = 0, mode = 0, num_type = 0, classx = 0, time = 0;
1955 TcorePending *pending = NULL;
1956 TcoreATRequest *req;
1958 dbg("_ss_forwarding_set with opco %d ", op);
1960 forwarding = (struct treq_ss_forwarding *) tcore_user_request_ref_data(ur, 0);
1961 switch (forwarding->mode) {
1962 case SS_CF_MODE_CFU:
1966 case SS_CF_MODE_CFB:
1970 case SS_CF_MODE_CFNRy:
1974 case SS_CF_MODE_CFNRc:
1978 case SS_CF_MODE_CF_ALL:
1982 case SS_CF_MODE_CFC:
1987 dbg("unsupported reason : %d");
1988 return TCORE_RETURN_FAILURE;
1992 dbg("reason = %d", reason);
1994 case SS_OPCO_DEACTIVATE:
1998 case SS_OPCO_ACTIVATE:
2011 dbg("unsupported opco : %d", op);
2012 return TCORE_RETURN_FAILURE;
2015 dbg("mode = %d", mode);
2018 switch (forwarding->class) {
2019 case SS_CLASS_ALL_TELE:
2023 case SS_CLASS_VOICE:
2027 case SS_CLASS_ALL_DATA_TELE:
2039 case SS_CLASS_ALL_CS_SYNC:
2045 dbg("unsupported class %d. set to default : 7", forwarding->class);
2048 dbg("classx = %d", classx);
2051 len = strlen(forwarding->number);
2053 if (forwarding->number[0] == '+')
2054 num_type = ((NUM_TYPE_INTERNATIONAL << 4) | NUM_PLAN_ISDN);
2058 dbg("number = %s", forwarding->number);
2060 user_data = g_new0(struct ss_confirm_info, 1);
2062 dbg("[ error ] failed to allocate memory");
2063 return TCORE_RETURN_ENOMEM;
2068 user_data->resp = TRESP_SS_FORWARDING_REGISTER;
2072 user_data->resp = TRESP_SS_FORWARDING_DEREGISTER;
2075 case SS_OPCO_ACTIVATE:
2076 user_data->resp = TRESP_SS_FORWARDING_ACTIVATE;
2079 case SS_OPCO_DEACTIVATE:
2080 user_data->resp = TRESP_SS_FORWARDING_DEACTIVATE;
2084 dbg("[ error ] unknown op (0x%x)", op);
2088 if (forwarding->number[0] == '+')
2093 if (op == SS_OPCO_REG)
2094 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,\"%s\",%d,%d", reason, mode, forwarding->number, num_type, classx);
2095 else /* other opcode does not need num field */
2096 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode, classx);
2098 if (forwarding->mode == SS_CF_MODE_CFNRy) {
2099 /* add time info to 'no reply' case */
2100 time = (int) (forwarding->time);
2101 cmd_str = g_strdup_printf("%s,,,%d", tmp_str, time);
2103 cmd_str = g_strdup_printf("%s", tmp_str);
2106 dbg("request command : %s", cmd_str);
2107 pending = tcore_pending_new(o, 0);
2108 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
2110 tcore_pending_free(pending);
2113 return TCORE_RETURN_FAILURE;
2115 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2117 tcore_pending_set_request_data(pending, 0, req);
2119 user_data->flavor_type = forwarding->mode;
2120 user_data->class = forwarding->class;
2122 ret = _ss_request_message(pending, o, ur, on_response_ss_forwarding_set, user_data);
2128 dbg("AT request sent failed ");
2129 if (user_data != NULL)
2132 return TCORE_RETURN_FAILURE;
2135 return TCORE_RETURN_SUCCESS;
2138 static TReturn _ss_forwarding_get(CoreObject *o,
2140 enum telephony_ss_class class,
2141 enum telephony_ss_forwarding_mode type,
2142 enum tcore_response_command resp)
2144 struct ss_confirm_info *user_data = 0;
2145 gboolean ret = FALSE;
2146 char *cmd_str = NULL;
2147 int reason = 0, mode = 0, classx = 0;
2148 TcorePending *pending = NULL;
2149 TcoreATRequest *req;
2151 dbg("function enter");
2154 case SS_CF_MODE_CFU:
2158 case SS_CF_MODE_CFB:
2162 case SS_CF_MODE_CFNRy:
2166 case SS_CF_MODE_CFNRc:
2170 case SS_CF_MODE_CF_ALL:
2174 case SS_CF_MODE_CFC:
2179 dbg("unsupported reason : %d");
2182 dbg("reason = %d", reason);
2185 case SS_CLASS_ALL_TELE:
2189 case SS_CLASS_VOICE:
2193 case SS_CLASS_ALL_DATA_TELE:
2205 case SS_CLASS_ALL_CS_SYNC:
2211 dbg("unsupported class %d. set to default : 7", class);
2215 dbg("classx = %d", classx);
2217 /* query status - mode set to 2 */
2219 user_data = g_new0(struct ss_confirm_info, 1);
2221 dbg("[ error ] failed to allocate memory");
2222 return TCORE_RETURN_ENOMEM;
2224 user_data->resp = resp;
2225 user_data->class = class;
2226 user_data->flavor_type = type;
2229 cmd_str = g_strdup_printf("AT+CCFC=%d,%d", reason, mode);
2231 cmd_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode, classx);
2233 dbg("request command : %s", cmd_str);
2235 pending = tcore_pending_new(o, 0);
2236 req = tcore_at_request_new(cmd_str, "+CCFC", TCORE_AT_MULTILINE);
2238 tcore_pending_free(pending);
2240 return TCORE_RETURN_FAILURE;
2242 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2244 tcore_pending_set_request_data(pending, 0, req);
2246 ret = _ss_request_message(pending, o, ur, on_response_ss_forwarding_get, user_data);
2250 dbg("AT request sent failed ");
2251 if (user_data != NULL) {
2253 tcore_pending_free(pending);
2254 tcore_at_request_free(req);
2256 return TCORE_RETURN_FAILURE;
2259 return TCORE_RETURN_SUCCESS;
2262 static TReturn imc_ss_forwarding_activate(CoreObject *o, UserRequest *ur)
2264 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2265 dbg("cp not ready/n");
2266 return TCORE_RETURN_ENOSYS;
2268 return _ss_forwarding_set(o, ur, SS_OPCO_ACTIVATE);
2271 static TReturn imc_ss_forwarding_deactivate(CoreObject *o, UserRequest *ur)
2273 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2274 dbg("cp not ready/n");
2275 return TCORE_RETURN_ENOSYS;
2277 return _ss_forwarding_set(o, ur, SS_OPCO_DEACTIVATE);
2280 static TReturn imc_ss_forwarding_register(CoreObject *o, UserRequest *ur)
2282 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2283 dbg("cp not ready/n");
2284 return TCORE_RETURN_ENOSYS;
2286 return _ss_forwarding_set(o, ur, SS_OPCO_REG);
2289 static TReturn imc_ss_forwarding_deregister(CoreObject *o, UserRequest *ur)
2291 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2292 dbg("cp not ready/n");
2293 return TCORE_RETURN_ENOSYS;
2295 return _ss_forwarding_set(o, ur, SS_OPCO_DEREG);
2298 static TReturn imc_ss_forwarding_get_status(CoreObject *o, UserRequest *ur)
2300 struct treq_ss_forwarding *forwarding = 0;
2302 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2303 dbg("cp not ready/n");
2304 return TCORE_RETURN_ENOSYS;
2307 forwarding = (struct treq_ss_forwarding *) tcore_user_request_ref_data(ur, 0);
2309 return _ss_forwarding_get(o, ur, forwarding->class, forwarding->mode, TRESP_SS_FORWARDING_GET_STATUS);
2313 static TReturn _ss_waiting_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode opco)
2315 struct treq_ss_waiting *waiting = 0;
2316 struct ss_confirm_info *user_data = 0;
2317 gboolean ret = FALSE;
2318 int mode = 0, classx = 0;
2320 TcorePending *pending = NULL;
2321 TcoreATRequest *req;
2323 dbg("function enter ");
2324 waiting = (struct treq_ss_waiting *) tcore_user_request_ref_data(ur, 0);
2325 user_data = g_new0(struct ss_confirm_info, 1);
2327 dbg("[ error ] failed to allocate memory");
2328 return TCORE_RETURN_ENOMEM;
2331 if (opco == SS_OPCO_ACTIVATE) {
2332 user_data->resp = TRESP_SS_WAITING_ACTIVATE;
2333 mode = 1; /* enable */
2334 } else if (opco == SS_OPCO_DEACTIVATE) {
2335 user_data->resp = TRESP_SS_WAITING_DEACTIVATE;
2336 mode = 0; /* disable */
2338 dbg("[ error ] unknown ss mode (0x%x)", opco);
2340 switch (waiting->class) {
2341 case SS_CLASS_ALL_TELE:
2345 case SS_CLASS_VOICE:
2349 case SS_CLASS_ALL_DATA_TELE:
2363 dbg("unsupported class %d. set to default : 1", waiting->class);
2366 dbg("mode = %d classxx- %d", mode, classx);
2368 user_data->class = waiting->class;
2369 user_data->flavor_type = (int) opco;
2371 cmd_str = g_strdup_printf("AT+CCWA=1,%d,%d", mode, classx); /* always enable +CCWA: unsolicited cmd */
2372 dbg("request command : %s", cmd_str);
2374 pending = tcore_pending_new(o, 0);
2375 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
2377 tcore_pending_free(pending);
2379 return TCORE_RETURN_FAILURE;
2381 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2383 tcore_pending_set_request_data(pending, 0, req);
2385 ret = _ss_request_message(pending, o, ur, on_response_ss_waiting_set, user_data);
2388 dbg("AT request sent failed ");
2389 if (user_data != NULL) {
2391 tcore_pending_free(pending);
2392 tcore_at_request_free(req);
2394 return TCORE_RETURN_FAILURE;
2396 return TCORE_RETURN_SUCCESS;
2399 static TReturn _ss_waiting_get(CoreObject *o,
2401 enum telephony_ss_class class,
2402 enum tcore_response_command resp)
2404 struct ss_confirm_info *user_data = 0;
2405 gboolean ret = FALSE;
2406 int classx; /* mode, */
2408 TcorePending *pending = NULL;
2409 TcoreATRequest *req;
2411 dbg("function enter");
2413 case SS_CLASS_ALL_TELE:
2417 case SS_CLASS_VOICE:
2421 case SS_CLASS_ALL_DATA_TELE:
2435 dbg("unsupported class %d. set to default : 7", class);
2438 dbg("classx - %d", classx);
2440 dbg("allocating user data");
2441 user_data = g_new0(struct ss_confirm_info, 1);
2443 dbg("[ error ] failed to allocate memory");
2444 return TCORE_RETURN_ENOMEM;
2446 user_data->resp = resp;
2447 user_data->class = class;
2449 cmd_str = g_strdup_printf("AT+CCWA=1,2,%d", classx); /* always enable +CCWA: unsolicited cmd , mode is fixed to 2(query status) */
2450 dbg("request cmd : %s", cmd_str);
2452 pending = tcore_pending_new(o, 0);
2453 req = tcore_at_request_new(cmd_str, "+CCWA", TCORE_AT_MULTILINE);
2455 err("Request is NULL");
2457 tcore_pending_free(pending);
2458 return TCORE_RETURN_EINVAL;
2460 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2462 tcore_pending_set_request_data(pending, 0, req);
2464 ret = _ss_request_message(pending, o, ur, on_response_ss_waiting_get, user_data);
2467 dbg("AT request sent failed ");
2468 if (user_data != NULL) {
2470 tcore_pending_free(pending);
2471 tcore_at_request_free(req);
2473 return TCORE_RETURN_FAILURE;
2475 return TCORE_RETURN_SUCCESS;
2478 static TReturn imc_ss_waiting_activate(CoreObject *o, UserRequest *ur)
2480 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2481 dbg("cp not ready/n");
2482 return TCORE_RETURN_ENOSYS;
2484 return _ss_waiting_set(o, ur, SS_OPCO_ACTIVATE);
2487 static TReturn imc_ss_waiting_deactivate(CoreObject *o, UserRequest *ur)
2489 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2490 dbg("cp not ready/n");
2491 return TCORE_RETURN_ENOSYS;
2493 return _ss_waiting_set(o, ur, SS_OPCO_DEACTIVATE);
2496 static TReturn imc_ss_waiting_get_status(CoreObject *o, UserRequest *ur)
2498 struct treq_ss_waiting *waiting = 0;
2500 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2501 dbg("cp not ready/n");
2502 return TCORE_RETURN_ENOSYS;
2504 waiting = (struct treq_ss_waiting *) tcore_user_request_ref_data(ur, 0);
2506 return _ss_waiting_get(o, ur, waiting->class, TRESP_SS_WAITING_GET_STATUS);
2509 static TReturn imc_ss_cli_activate(CoreObject *o, UserRequest *ur)
2511 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2512 dbg("cp not ready/n");
2513 return TCORE_RETURN_ENOSYS;
2515 return TCORE_RETURN_SUCCESS;
2518 static TReturn imc_ss_cli_deactivate(CoreObject *o, UserRequest *ur)
2520 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2521 dbg("cp not ready/n");
2522 return TCORE_RETURN_ENOSYS;
2524 return TCORE_RETURN_SUCCESS;
2527 static TReturn imc_ss_cli_get_status(CoreObject *o, UserRequest *ur)
2529 struct treq_ss_cli *cli = 0;
2530 gboolean ret = FALSE;
2531 char *cmd_prefix = NULL, *rsp_prefix = NULL, *cmd_str = NULL;
2532 enum telephony_ss_cli_type *user_data = 0;
2533 TcorePending *pending = NULL;
2534 TcoreATRequest *req;
2536 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2537 dbg("cp not ready/n");
2538 return TCORE_RETURN_ENOSYS;
2541 cli = (struct treq_ss_cli *) tcore_user_request_ref_data(ur, 0);
2542 switch (cli->type) {
2543 case SS_CLI_TYPE_CLIP:
2544 cmd_prefix = "+CLIP";
2545 rsp_prefix = "+CLIP";
2548 case SS_CLI_TYPE_CLIR:
2549 cmd_prefix = "+CLIR";
2550 rsp_prefix = "+CLIR";
2553 case SS_CLI_TYPE_COLP:
2554 cmd_prefix = "+COLP";
2555 rsp_prefix = "+COLP";
2558 case SS_CLI_TYPE_COLR:
2559 cmd_prefix = "+COLR";
2560 rsp_prefix = "+COLR";
2563 case SS_CLI_TYPE_CNAP:
2564 cmd_prefix = "+CNAP";
2565 rsp_prefix = "+CNAP";
2568 case SS_CLI_TYPE_CDIP:
2570 dbg("unsupported cli_type : %d", cli->type);
2571 return TCORE_RETURN_FAILURE;
2573 dbg("cmd_prefix : %s", cmd_prefix);
2575 cmd_str = g_strdup_printf("AT%s?", cmd_prefix);
2576 dbg("request cmd : %s", cmd_str);
2578 user_data = g_new0(enum telephony_ss_cli_type, 1);
2580 dbg("[ error ] failed to allocate memory");
2582 return TCORE_RETURN_ENOMEM;
2584 *user_data = cli->type;
2586 pending = tcore_pending_new(o, 0);
2588 req = tcore_at_request_new(cmd_str, rsp_prefix, TCORE_AT_SINGLELINE);
2590 tcore_pending_free(pending);
2592 return TCORE_RETURN_FAILURE;
2594 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2595 tcore_pending_set_request_data(pending, 0, req);
2597 ret = _ss_request_message(pending, o, ur, on_response_ss_cli_get, user_data);
2600 dbg("AT request sent failed ");
2601 if (user_data != NULL) {
2603 tcore_pending_free(pending);
2604 tcore_at_request_free(req);
2606 return TCORE_RETURN_FAILURE;
2608 return TCORE_RETURN_SUCCESS;
2611 static TReturn imc_ss_send_ussd(CoreObject *o, UserRequest *ur)
2613 UssdSession *ussd_s = 0;
2614 struct treq_ss_ussd *ussd = 0;
2615 struct ss_confirm_info *user_data = 0;
2616 gboolean ret = FALSE;
2618 TcorePending *pending = NULL;
2619 TcoreATRequest *req;
2621 dbg("function enter");
2623 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2624 dbg("cp not ready/n");
2625 return TCORE_RETURN_ENOSYS;
2628 ussd = (struct treq_ss_ussd *) tcore_user_request_ref_data(ur, 0);
2630 user_data = g_new0(struct ss_confirm_info, 1);
2632 dbg("[ error ] failed to allocate memory");
2633 return TCORE_RETURN_ENOMEM;
2635 user_data->resp = TRESP_SS_SEND_USSD;
2636 ussd_s = tcore_ss_ussd_get_session(o);
2638 dbg("USSD session does not exist");
2639 tcore_ss_ussd_create_session(o, (enum tcore_ss_ussd_type) ussd->type, (void *) tcore_user_request_ref(ur), 0);
2641 if (ussd->type == SS_USSD_TYPE_USER_INITIATED) {
2642 dbg("[ error ] ussd session is already exist");
2644 return TCORE_RETURN_FAILURE;
2647 tcore_ss_ussd_set_session_type(ussd_s, (enum tcore_ss_ussd_type) ussd->type);
2650 cmd_str = g_strdup_printf("AT+CUSD=1,\"%s\",%d", ussd->str, 0x0f); /* always enable +CUSD: unsolicited cmd. set to dcs to 0x0f. only supports HEX type */
2651 dbg("request command : %s", cmd_str);
2653 pending = tcore_pending_new(o, 0);
2654 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
2656 tcore_pending_free(pending);
2658 return TCORE_RETURN_FAILURE;
2660 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2662 tcore_pending_set_request_data(pending, 0, req);
2664 ret = _ss_request_message(pending, o, ur, on_confirmation_ss_ussd, user_data);
2668 dbg("AT request sent failed ");
2669 if (user_data != NULL) {
2671 tcore_pending_free(pending);
2672 tcore_at_request_free(req);
2674 return TCORE_RETURN_FAILURE;
2676 return TCORE_RETURN_SUCCESS;
2679 static TReturn imc_ss_set_aoc(CoreObject *o, UserRequest *ur)
2681 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2682 dbg("cp not ready/n");
2683 return TCORE_RETURN_ENOSYS;
2686 dbg("[ error ] unsupported function");
2687 return TCORE_RETURN_SUCCESS;
2690 static TReturn imc_ss_get_aoc(CoreObject *o, UserRequest *ur)
2692 if (FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))) {
2693 dbg("cp not ready/n");
2694 return TCORE_RETURN_ENOSYS;
2697 dbg("[ error ] unsupported function");
2698 return TCORE_RETURN_SUCCESS;
2702 static struct tcore_call_control_operations call_ops = {
2703 .answer_hold_and_accept = imc_ss_manage_call_2_send,
2704 .answer_replace = imc_ss_manage_call_1_send,
2705 .answer_reject = imc_ss_manage_call_0_send,
2706 .end_specific = imc_ss_manage_call_1x_send,
2707 .end_all_active = imc_ss_manage_call_1_send,
2708 .end_all_held = imc_ss_manage_call_0_send,
2709 .active = imc_ss_manage_call_2_send,
2710 .hold = imc_ss_manage_call_2_send,
2711 .swap = imc_ss_manage_call_2_send,
2712 .join = imc_ss_manage_call_3_send,
2713 .split = imc_ss_manage_call_2x_send,
2714 .transfer = imc_ss_manage_call_4_send,
2715 .deflect = imc_ss_manage_call_4dn_send,
2718 static TReturn imc_ss_manage_call_send(CoreObject *o, UserRequest *ur, const char *cmd, ConfirmCallback cb, void *user_data)
2720 TcorePending *pending = NULL;
2721 TcoreATRequest *req;
2722 gboolean ret = FALSE;
2724 pending = tcore_pending_new(o, 0);
2725 req = tcore_at_request_new(cmd, NULL, TCORE_AT_NO_RESULT);
2727 tcore_pending_free(pending);
2728 return TCORE_RETURN_FAILURE;
2730 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2731 tcore_pending_set_request_data(pending, 0, req);
2733 ret = _ss_request_message(pending, o, ur, (TcorePendingResponseCallback) cb, user_data);
2735 dbg("AT request sent failed ");
2736 return TCORE_RETURN_FAILURE;
2738 return TCORE_RETURN_SUCCESS;
2741 static TReturn imc_ss_manage_call_0_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2743 char *cmd_str = NULL;
2744 gboolean ret = FALSE;
2746 dbg("function enter");
2747 cmd_str = g_strdup_printf("%s", "AT+CHLD=0");
2748 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2750 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2755 static TReturn imc_ss_manage_call_1_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2757 char *cmd_str = NULL;
2758 gboolean ret = FALSE;
2760 dbg("function enter");
2761 cmd_str = g_strdup_printf("%s", "AT+CHLD=1");
2762 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2764 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2769 static TReturn imc_ss_manage_call_1x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data)
2771 char *cmd_str = NULL;
2772 gboolean ret = FALSE;
2774 dbg("function enter");
2775 cmd_str = g_strdup_printf("%s%d", "AT+CHLD=1", id);
2776 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2778 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2783 static TReturn imc_ss_manage_call_2_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2785 char *cmd_str = NULL;
2786 gboolean ret = FALSE;
2788 dbg("function enter");
2789 cmd_str = g_strdup_printf("%s", "AT+CHLD=2");
2790 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2792 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2797 static TReturn imc_ss_manage_call_2x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data)
2799 char *cmd_str = NULL;
2800 gboolean ret = FALSE;
2802 dbg("function enter");
2803 cmd_str = g_strdup_printf("%s%d", "AT+CHLD=2", id);
2804 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2806 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2811 static TReturn imc_ss_manage_call_3_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2813 char *cmd_str = NULL;
2814 gboolean ret = FALSE;
2816 dbg("function enter");
2817 cmd_str = g_strdup_printf("%s", "AT+CHLD=3");
2819 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2825 static TReturn imc_ss_manage_call_4_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2827 char *cmd_str = NULL;
2828 gboolean ret = FALSE;
2830 dbg("function enter");
2831 cmd_str = g_strdup_printf("%s", "AT+CHLD=4");
2833 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2838 static TReturn imc_ss_manage_call_4dn_send(CoreObject *o, UserRequest *ur, const char *number, ConfirmCallback cb, void *user_data)
2840 char *cmd_str = NULL;
2841 gboolean ret = FALSE;
2843 dbg("function enter");
2844 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=4", number);
2846 ret = imc_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2852 gboolean imc_ss_init(TcorePlugin *cp, CoreObject *co_ss)
2854 CoreObject *co_call = NULL;
2856 /* Set operations */
2857 tcore_ss_set_ops(co_ss, &ss_ops, TCORE_OPS_TYPE_CP);
2859 co_call = tcore_plugin_ref_core_object(cp,
2860 CORE_OBJECT_TYPE_CALL);
2861 if (co_call == NULL) {
2862 err("Can't find CALL core object");
2866 /* Set operations */
2867 tcore_call_control_set_operations(co_call, &call_ops);
2869 tcore_object_add_callback(co_ss, "+CSSU", on_notification_ss_cssu_info, NULL);
2870 tcore_object_add_callback(co_ss, "+CSSI", on_notification_ss_cssi_info, NULL);
2871 tcore_object_add_callback(co_ss, "+CUSD", on_notification_ss_ussd, NULL);
2876 void imc_ss_exit(TcorePlugin *cp, CoreObject *co_ss)
2880 tcore_object_del_callback(co_ss, "+CSSU", on_notification_ss_cssu_info);
2881 tcore_object_del_callback(co_ss, "+CSSI", on_notification_ss_cssi_info);
2882 tcore_object_del_callback(co_ss, "+CUSD", on_notification_ss_ussd);