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>
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 s_ss_barring_activate(CoreObject *o, UserRequest *ur);
73 static TReturn s_ss_barring_deactivate(CoreObject *o, UserRequest *ur);
74 static TReturn s_ss_barring_change_password(CoreObject *o, UserRequest *ur);
75 static TReturn s_ss_barring_get_status(CoreObject *o, UserRequest *ur);
77 static TReturn s_ss_forwarding_activate(CoreObject *o, UserRequest *ur);
78 static TReturn s_ss_forwarding_deactivate(CoreObject *o, UserRequest *ur);
79 static TReturn s_ss_forwarding_register(CoreObject *o, UserRequest *ur);
80 static TReturn s_ss_forwarding_deregister(CoreObject *o, UserRequest *ur);
81 static TReturn s_ss_forwarding_get_status(CoreObject *o, UserRequest *ur);
83 static TReturn s_ss_waiting_activate(CoreObject *o, UserRequest *ur);
84 static TReturn s_ss_waiting_deactivate(CoreObject *o, UserRequest *ur);
85 static TReturn s_ss_waiting_get_status(CoreObject *o, UserRequest *ur);
87 static TReturn s_ss_cli_activate(CoreObject *o, UserRequest *ur);
88 static TReturn s_ss_cli_deactivate(CoreObject *o, UserRequest *ur);
89 static TReturn s_ss_cli_get_status(CoreObject *o, UserRequest *ur);
91 static TReturn s_ss_send_ussd(CoreObject *o, UserRequest *ur);
93 static TReturn s_ss_set_aoc(CoreObject *o, UserRequest *ur);
94 static TReturn s_ss_get_aoc(CoreObject *o, UserRequest *ur);
96 static TReturn s_ss_manage_call_0_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
97 static TReturn s_ss_manage_call_1_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
98 static TReturn s_ss_manage_call_1x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data);
99 static TReturn s_ss_manage_call_2_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
100 static TReturn s_ss_manage_call_2x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data);
101 static TReturn s_ss_manage_call_3_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
102 static TReturn s_ss_manage_call_4_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data);
103 static TReturn s_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_info(CoreObject *o, const void *data, void *user_data);
111 static gboolean on_notification_ss_ussd(CoreObject *o, const void *data, void *user_data);
114 static gboolean _ss_request_message(TcorePending *pending,
120 TcoreHal *hal = NULL;
125 tcore_pending_set_response_callback(pending, on_resp, user_data);
127 tcore_pending_set_send_callback(pending, on_confirmation_ss_message_send, NULL);
129 tcore_pending_link_user_request(pending, ur);
131 err("User Request is NULL, is this internal request??");
134 hal = tcore_object_get_hal(o);
136 // Send request to HAL
137 ret = tcore_hal_send_request(hal, pending);
138 if (TCORE_RETURN_SUCCESS != ret) {
139 err("Request send failed");
147 static void _ss_ussd_response(UserRequest *ur, const char *ussd_str, enum telephony_ss_ussd_type type, enum telephony_ss_ussd_status status)
149 struct tresp_ss_ussd resp;
153 memset(&resp, 0x0, sizeof(struct tresp_ss_ussd));
155 resp.status = status;
156 resp.err = SS_ERROR_NONE;
157 dbg("ussd_str = %s resp.type - %d resp.status - %d", ussd_str, resp.type, resp.status);
160 int len = strlen(ussd_str);
161 if (len < MAX_SS_USSD_LEN) {
162 memcpy(resp.str, ussd_str, len);
163 resp.str[len] = '\0';
165 memcpy(resp.str, ussd_str, MAX_SS_USSD_LEN);
166 resp.str[MAX_SS_USSD_LEN - 1] = '\0';
168 dbg("Response string: %s", resp.str);
170 dbg("USSD string is not present");
171 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");
239 cmd = (char *) (lines->data);
241 tokens = tcore_at_tok_new(cmd);
244 ussdnoti = g_slist_nth_data(tokens, 0);
246 dbg("+CUSD<m> is missing from %CUSD Notification");
249 dbg("USSD status %d", m);
250 // parse [ <str>, <dcs>]
251 ussd_string = g_slist_nth_data(tokens, 1);
253 /* Strike off starting & ending quotes. 1 extra character for NULL termination */
254 str = malloc(strlen(ussd_string) - 1);
255 dbg("length of Ussd Stirng - %d", strlen(ussd_string));
257 memset(str, 0x00, strlen(ussd_string) - 1);
260 if (NULL != tokens) {
261 tcore_at_tok_free(tokens);
265 len = strlen(ussd_string) - 1;
267 strncpy(str, ussd_string, len);
269 dbg("USSD String - %s len = %d", str, strlen(str));
271 if ((dcs_str = g_slist_nth_data(tokens, 2))) {
273 dbg("USSD dcs %d", dcs);
279 status = SS_USSD_NO_ACTION_REQUIRE;
283 status = SS_USSD_ACTION_REQUIRE;
287 status = SS_USSD_TERMINATED_BY_NET;
291 status = SS_USSD_OTHER_CLIENT;
295 status = SS_USSD_NOT_SUPPORT;
299 status = SS_USSD_TIME_OUT;
303 dbg("unsupported m : %d", m);
304 status = SS_USSD_MAX;
308 switch (tcore_util_get_cbs_coding_scheme(dcs)) {
309 case TCORE_DCS_TYPE_7_BIT:
310 case TCORE_DCS_TYPE_UNSPECIFIED:
311 // ussd_str = tcore_util_unpack_gsm7bit(str, strlen(str));
314 case TCORE_DCS_TYPE_UCS2:
315 case TCORE_DCS_TYPE_8_BIT:
316 if ((str != NULL) && (strlen(str) > 0)) {
317 ussd_str = g_new0(char, strlen(str) + 1);
318 if (ussd_str != NULL) {
319 memcpy(ussd_str, str, strlen(str));
320 ussd_str[strlen(str)] = '\0';
326 dbg("[ error ] unknown dcs type. ussd_session : %x", ussd_session);
329 enum telephony_ss_ussd_type type;
331 tcore_ss_ussd_get_session_data(ussd_session, (void **) &ur);
333 dbg("[ error ] ur : (0)");
337 type = (enum telephony_ss_ussd_type) tcore_ss_ussd_get_session_type(ussd_session);
338 dbg("ussd type - %d", type);
340 _ss_ussd_response(ur, ussd_str, type, status);
344 if (NULL != tokens) {
345 tcore_at_tok_free(tokens);
355 case SS_USSD_NO_ACTION_REQUIRE:
356 case SS_USSD_ACTION_REQUIRE:
357 case SS_USSD_OTHER_CLIENT:
358 case SS_USSD_NOT_SUPPORT:
359 case SS_USSD_TIME_OUT:
363 enum telephony_ss_ussd_type type;
365 tcore_ss_ussd_get_session_data(ussd_session, (void **) &ur);
367 dbg("[ error ] ur : (0)");
368 if (NULL != tokens) {
369 tcore_at_tok_free(tokens);
381 type = (enum telephony_ss_ussd_type) tcore_ss_ussd_get_session_type(ussd_session);
382 dbg("ussd type - %d", type);
383 _ss_ussd_response(ur, (const char *) ussd_str, type, status);
387 tcore_ss_ussd_create_session(o, TCORE_SS_USSD_TYPE_NETWORK_INITIATED, 0, 0);
388 _ss_ussd_notification(plugin, (const char *) ussd_str, status);
396 case SS_USSD_TERMINATED_BY_NET:
400 tcore_ss_ussd_get_session_data(ussd_session, (void **) &ur);
402 tcore_user_request_unref(ur);
404 tcore_ss_ussd_destroy_session(ussd_session);
413 if (NULL != tokens) {
414 tcore_at_tok_free(tokens);
425 static gboolean on_notification_ss_info(CoreObject *o, const void *data, void *user_data)
427 TcorePlugin *plugin = 0;
429 char *cmd = 0, *number = 0, *pos;
430 int code1 = -1, code2 = -1, index = 0, ton = 0;
431 char *str_code1, *str_code2, *str_ton, *str_index;
432 GSList *tokens = NULL;
434 gboolean cssu = FALSE, cssi = FALSE;
435 GSList *lines = NULL;
437 dbg("function enter");
439 plugin = tcore_object_ref_plugin(o);
440 co = tcore_plugin_ref_core_object(plugin, CORE_OBJECT_TYPE_CALL);
442 dbg("[ error ] plugin_ref_core_object : call");
446 lines = (GSList *) data;
447 if (1 != g_slist_length(lines)) {
448 dbg("unsolicited msg but multiple line");
452 cmd = (char *) (lines->data);
453 pos = strchr(cmd, ':');
455 dbg("[ error ] not valid SS- notification ");
458 buf = calloc(pos - cmd + 2, 1);
459 memcpy(buf, cmd, pos - cmd);
460 dbg("buf is %s", buf);
462 if (!strcmp(buf, "+CSSU")) {
463 dbg("SS - +CSSU indication");
465 } else if (!strcmp(buf, "+CSSI")) {
466 dbg("SS - +CSSI indication");
471 // handle %CSSU notification
473 tokens = tcore_at_tok_new(cmd);
475 str_code2 = g_slist_nth_data(tokens, 0);
477 dbg("Code2 is missing from %CSSU indiaction");
479 code2 = atoi(str_code2);
480 // parse [ <index>, <number> <type>]
481 if ((str_index = g_slist_nth_data(tokens, 1))) {
482 index = atoi(str_index);
485 if ((resp = g_slist_nth_data(tokens, 2))) {
486 // Strike off double quotes
487 number = util_removeQuotes(resp);
488 str_ton = g_slist_nth_data(tokens, 3);
496 dbg("CSSU - code2 = %d index = %d number = %s type = %d", code2, index, number, ton);
498 case 0: // this is a forwarded call (MT call setup)
499 tcore_call_information_mt_forwarded_call(co, number);
502 case 2: // call has been put on hold (during a voice call)
503 tcore_call_information_held(co, number);
506 case 3: // call has been retrieved (during a voice call)
507 tcore_call_information_active(co, number);
510 case 4: // multiparty call entered (during a voice call)
511 tcore_call_information_joined(co, number);
514 case 5: // call on hold has been released
515 tcore_call_information_released_on_hold(co, number);
518 case 6: // forward check SS message received (can be received whenever)
519 tcore_call_information_cf_check_ss_message(co, number);
522 case 7: // call is being connected (alerting) with the remote party in alerting state in explicit call transfer operation (during a voice call)
523 tcore_call_information_transfer_alert(co, number);
526 case 8: // call has been connected with the other remote party in explicit call transfer operation (also number and subaddress parameters may be present) (during a voice call or MT call setup)
527 tcore_call_information_transfered(co, number);
530 case 9: // this is a deflected call (MT call setup):
531 tcore_call_information_mt_deflected_call(co, number);
535 dbg("CSSU - unsupported code2 : %d", code2);
539 // handle %CSSI notification
542 tokens = tcore_at_tok_new(cmd);
544 str_code1 = g_slist_nth_data(tokens, 0);
546 dbg("Code1 is missing from %CSSI indiaction");
548 code1 = atoi(str_code1);
550 if ((str_index = g_slist_nth_data(tokens, 1))) {
551 index = atoi(str_index);
555 dbg("CSSI - code1 - %d index - %d ", code1, index);
558 case 0: // Unconditional CF is active
559 tcore_call_information_mo_cfu(co);
562 case 1: // some of the conditional call forwarding are active
563 tcore_call_information_mo_cfc(co);
566 case 2: // outgoing call is forwarded
567 tcore_call_information_mo_forwarded(co);
570 case 3: // this call is waiting
571 tcore_call_information_mo_waiting(co);
574 case 5: // outgoing call is barred
575 tcore_call_information_mo_barred_outgoing(co);
578 case 6: // incoming call is barred
579 tcore_call_information_mo_barred_incoming(co);
582 case 7: // CLIR suppression rejected
583 tcore_call_information_mo_clir_suppression_reject(co);
586 case 8: // outgoing call is deflected
587 tcore_call_information_mo_deflected(co);
591 dbg("unsupported cmd : %d", code1);
596 if (NULL != tokens) {
597 tcore_at_tok_free(tokens);
600 if (NULL != number) {
606 static void on_confirmation_ss_message_send(TcorePending *p, gboolean result, void *user_data)
610 if (result == FALSE) {
618 static void on_response_ss_barring_set(TcorePending *p, int data_len, const void *data, void *user_data)
620 struct ss_confirm_info *info = 0;
621 enum telephony_ss_class class;
624 struct tresp_ss_barring resp;
625 UserRequest *ur_dup = 0;
626 GSList *tokens = NULL;
629 const TcoreATResponse *response;
631 dbg("function enter");
633 o = tcore_pending_ref_core_object(p);
634 ur = tcore_pending_ref_user_request(p);
636 info = (struct ss_confirm_info *) user_data;
639 if (response->success > 0) {
641 resp.err = SS_ERROR_NONE;
644 dbg("RESPONSE NOT OK");
646 line = (const char *) response->final_response;
647 tokens = tcore_at_tok_new(line);
649 if (g_slist_length(tokens) < 1) {
650 dbg("err cause not specified or string corrupted");
651 resp.err = SS_ERROR_SYSTEMFAILURE;
653 err = atoi(g_slist_nth_data(tokens, 0));
654 // TODO: CMEE error mapping is required.
655 resp.err = SS_ERROR_SYSTEMFAILURE;
657 tcore_at_tok_free(tokens);
660 dbg("on_response_ss_barring_set - rsp.err : %d, ur : %x flavor_type = %d", resp.err, ur, info->flavor_type);
661 dbg("[ check ] class : 0x%x", info->class);
663 if (response->success > 0) {
664 if (info->class == SS_CLASS_VOICE) {
665 class = SS_CLASS_ALL_TELE_BEARER;
668 ur_dup = tcore_user_request_ref(ur);
670 if (info->flavor_type == SS_BARR_MODE_AB || info->flavor_type == SS_BARR_MODE_AOB) {
671 _ss_barring_get(o, ur_dup, class, SS_BARR_MODE_BAOC, info->resp);
672 } else if (info->flavor_type == SS_BARR_MODE_AIB) {
673 _ss_barring_get(o, ur_dup, class, SS_BARR_MODE_BAIC, info->resp);
675 _ss_barring_get(o, ur_dup, class, info->flavor_type, info->resp);
679 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
681 dbg("[ error ] ur is 0");
687 static void on_response_ss_barring_change_pwd(TcorePending *p, int data_len, const void *data, void *user_data)
689 const TcoreATResponse *response = data;
690 struct ss_confirm_info *info = 0;
692 struct tresp_ss_barring resp;
694 GSList *tokens = NULL;
697 dbg("function enter");
698 ur = tcore_pending_ref_user_request(p);
699 info = (struct ss_confirm_info *) user_data;
701 if (response->success > 0) {
703 resp.err = SS_ERROR_NONE;
705 dbg("RESPONSE NOT OK");
707 line = (const char *) response->final_response;
708 tokens = tcore_at_tok_new(line);
710 if (g_slist_length(tokens) < 1) {
711 dbg("err cause not specified or string corrupted");
712 resp.err = SS_ERROR_SYSTEMFAILURE;
714 err = atoi(g_slist_nth_data(tokens, 0));
715 // TODO: CMEE error mapping is required.
716 resp.err = SS_ERROR_SYSTEMFAILURE;
718 tcore_at_tok_free(tokens);
721 dbg("on_response_ss_barring_change_pwd: rsp.err : %d, usr : %x", resp.err, ur);
723 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
725 dbg("[ error ] ur is 0");
731 static void on_response_ss_forwarding_set(TcorePending *p, int data_len, const void *data, void *user_data)
734 UserRequest *ur = 0, *dup_ur = 0;
735 struct ss_confirm_info *info = 0;
736 struct tresp_ss_forwarding resp;
737 GSList *tokens = NULL;
740 const TcoreATResponse *response;
742 dbg("function enter");
745 o = tcore_pending_ref_core_object(p);
746 ur = tcore_pending_ref_user_request(p);
748 info = (struct ss_confirm_info *) user_data;
750 if (response->success > 0) {
752 resp.err = SS_ERROR_NONE;
755 dbg("RESPONSE NOT OK");
757 line = (const char *) response->final_response;
758 tokens = tcore_at_tok_new(line);
760 if (g_slist_length(tokens) < 1) {
761 dbg("err cause not specified or string corrupted");
762 resp.err = SS_ERROR_SYSTEMFAILURE;
764 err = atoi(g_slist_nth_data(tokens, 0));
765 // / TODO: CMEE error mapping is required.
766 resp.err = SS_ERROR_SYSTEMFAILURE;
769 tcore_at_tok_free(tokens);
772 dbg("[ check ] class : 0x%x", info->class);
773 dbg("[ check ] flavor_type : 0x%x", info->flavor_type);
775 dbg("on_response_ss_forwarding_set - rsp.err : %d, ur : %x", resp.err, ur);
777 if (response->success > 0) {
778 if (info->flavor_type == SS_CF_MODE_CF_ALL ||
779 info->flavor_type == SS_CF_MODE_CFC) {
781 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
783 dbg("[ error ] ur is 0");
786 dup_ur = tcore_user_request_ref(ur);
787 _ss_forwarding_get(o, dup_ur, info->class, info->flavor_type, info->resp);
791 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
793 dbg("[ error ] ur is 0");
799 static void on_response_ss_waiting_set(TcorePending *p, int data_len, const void *data, void *user_data)
801 CoreObject *core_obj = 0;
803 UserRequest *ur_dup = 0;
804 struct ss_confirm_info *info = 0;
805 struct tresp_ss_waiting resp;
806 GSList *tokens = NULL;
809 const TcoreATResponse *response;
811 dbg("function enter");
813 core_obj = tcore_pending_ref_core_object(p);
814 ur = tcore_pending_ref_user_request(p);
816 info = (struct ss_confirm_info *) user_data;
818 if (response->success > 0) {
820 resp.err = SS_ERROR_NONE;
823 dbg("RESPONSE NOT OK");
825 line = (const char *) response->final_response;
826 tokens = tcore_at_tok_new(line);
828 if (g_slist_length(tokens) < 1) {
829 dbg("err cause not specified or string corrupted");
830 resp.err = SS_ERROR_SYSTEMFAILURE;
832 err = atoi(g_slist_nth_data(tokens, 0));
833 // / TODO: CMEE error mapping is required.
834 resp.err = SS_ERROR_SYSTEMFAILURE;
836 tcore_at_tok_free(tokens);
839 dbg("on_response_ss_waiting_set - rsp.err : %d, ur : %x, class : %d", resp.err, ur, info->class);
841 if (resp.err == SS_ERROR_NONE) {
842 ur_dup = tcore_user_request_ref(ur);
843 dbg("Get waiting call status");
844 _ss_waiting_get(core_obj, ur_dup, info->class, info->resp);
847 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_waiting), &resp);
849 dbg("[ error ] ur is 0");
856 static void on_confirmation_ss_ussd(TcorePending *p, int data_len, const void *data, void *user_data)
858 CoreObject *core_obj = 0;
859 struct ss_confirm_info *info = 0;
860 struct tresp_ss_ussd resp;
861 UserRequest *ur = NULL, *ussd_ur = NULL;
862 GSList *tokens = NULL;
865 UssdSession *ussd_s = NULL;
866 enum tcore_ss_ussd_type type = TCORE_SS_USSD_TYPE_MAX;
867 const TcoreATResponse *response;
869 dbg("function enter");
871 ur = tcore_pending_ref_user_request(p);
872 info = (struct ss_confirm_info *) user_data;
874 memset(resp.str, 0x00, MAX_SS_USSD_LEN);
876 core_obj = tcore_pending_ref_core_object(p);
877 ussd_s = tcore_ss_ussd_get_session(core_obj);
880 type = tcore_ss_ussd_get_session_type(ussd_s);
882 dbg("[ error ] ussd_s : (0)");
884 resp.type = (enum telephony_ss_ussd_type) type;
885 resp.status = SS_USSD_MAX; // hardcoded value.
887 if (response->success > 0) {
889 resp.err = SS_ERROR_NONE;
891 dbg("RESPONSE NOT OK");
893 line = (const char *) response->final_response;
894 tokens = tcore_at_tok_new(line);
896 if (g_slist_length(tokens) < 1) {
897 dbg("err cause not specified or string corrupted");
898 resp.err = SS_ERROR_SYSTEMFAILURE;
900 err = atoi(g_slist_nth_data(tokens, 0));
901 // TODO: CMEE error mapping is required.
902 resp.err = SS_ERROR_SYSTEMFAILURE;
904 tcore_at_tok_free(tokens);
907 dbg("on_confirmation_ss_ussd - rsp.err : %d, ur : %x", resp.err, ur);
909 if (response->success > 0) {
910 if (type == TCORE_SS_USSD_TYPE_USER_INITIATED) {
911 dbg("ussd type %d", resp.type);
914 tcore_ss_ussd_get_session_data(ussd_s, (void **) &ussd_ur);
916 tcore_user_request_free(ussd_ur);
922 tcore_ss_ussd_destroy_session(ussd_s);
925 if (UssdResp == FALSE) { // to avoid sending multiple response to application.
926 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_ussd), &resp);
930 dbg("[ error ] ur : (0)");
935 static void on_response_ss_barring_get(TcorePending *p, int data_len, const void *data, void *user_data)
938 int status = 0, classx = 0, err = 0;
940 struct ss_confirm_info *info = 0;
941 struct tresp_ss_barring resp;
942 int countRecords = 0, countValidRecords = 0;
943 GSList *tokens = NULL;
947 const TcoreATResponse *response;
949 dbg("function enter");
952 ur = tcore_pending_ref_user_request(p);
953 info = (struct ss_confirm_info *) user_data;
955 if (response->lines) {
956 respdata = (GSList *) response->lines;
957 countRecords = g_slist_length(respdata);
958 dbg("total records : %d", countRecords);
961 dbg("no active status - return to user")
963 resp.record_num = countRecords;
965 if (resp.record_num > 0) {
966 resp.record = g_new0(struct barring_info, resp.record_num);
967 for (countValidRecords = 0; respdata != NULL; respdata = respdata->next) {
968 line = (const char *) (respdata->data);
969 tokens = tcore_at_tok_new(line);
972 stat = g_slist_nth_data(tokens, 0);
974 dbg("Stat is missing");
980 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
982 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
984 dbg("call barring status - %d", status);
987 classx_str = g_slist_nth_data(tokens, 1);
990 dbg("class error. classx not exist - set to requested one : %d", info->class);
991 switch (info->class) {
992 case SS_CLASS_ALL_TELE:
1000 case SS_CLASS_ALL_DATA_TELE:
1012 case SS_CLASS_ALL_CS_SYNC:
1018 dbg("unsupported class %d. set to default : 7", info->class);
1022 classx = atoi(classx_str);
1023 dbg("call barring classx - %d", classx);
1028 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1032 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1036 resp.record[countValidRecords].class = SS_CLASS_FAX;
1040 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1044 resp.record[countValidRecords].class = SS_CLASS_SMS;
1048 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1052 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1056 dbg("unspoorted class : [%d]\n", classx);
1060 resp.record[countValidRecords].mode = (enum telephony_ss_barring_mode) (info->flavor_type);
1061 countValidRecords++;
1062 tcore_at_tok_free(tokens);
1066 dbg("invalid field found. coutinue");
1067 tcore_at_tok_free(tokens);
1071 dbg("valid count :%d", countValidRecords);
1072 resp.record_num = countValidRecords;
1073 resp.err = SS_ERROR_NONE;
1075 dbg("no active status - return to user")
1078 if (response->success > 0) {
1080 resp.err = SS_ERROR_NONE;
1082 dbg("RESPONSE NOT OK");
1083 resp.err = TCORE_RETURN_FAILURE;
1085 resp.record_num = 0;
1087 line = (const char *) response->final_response;
1088 tokens = tcore_at_tok_new(line);
1090 if (g_slist_length(tokens) < 1) {
1091 dbg("err cause not specified or string corrupted");
1092 resp.err = SS_ERROR_SYSTEMFAILURE;
1094 err = atoi(g_slist_nth_data(tokens, 0));
1095 // TODO: CMEE error mapping is required.
1096 resp.err = SS_ERROR_SYSTEMFAILURE;
1098 tcore_at_tok_free(tokens);
1101 dbg("on_response_ss_barring_get- rsp.err : %d, ur : %x", resp.err, ur);
1104 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);
1106 dbg("[ error ] ur is 0");
1109 g_free(resp.record);
1116 static void on_response_ss_forwarding_get(TcorePending *p, int data_len, const void *data, void *user_data)
1118 UserRequest *ur = 0;
1119 int classx = 0, err = 0, time = 0;
1121 struct ss_confirm_info *info = 0;
1122 struct tresp_ss_forwarding resp;
1123 int countRecords = 0, countValidRecords = 0;
1125 GSList *respdata = NULL, *tokens = NULL;
1127 char *classx_str, *status, *ton, *time_str;
1128 const TcoreATResponse *response;
1130 dbg("function enter");
1133 ur = tcore_pending_ref_user_request(p);
1134 info = (struct ss_confirm_info *) user_data;
1135 if (response->lines) {
1136 respdata = (GSList *) response->lines;
1137 countRecords = g_slist_length(respdata);
1138 dbg("total records : %d", countRecords);
1141 dbg("no active status - return to user")
1143 resp.record_num = countRecords;
1145 if (resp.record_num > 0) {
1146 resp.record = g_new0(struct forwarding_info, resp.record_num);
1148 for (countValidRecords = 0; respdata != NULL; respdata = respdata->next) {
1149 line = (const char *) (respdata->data);
1150 tokens = tcore_at_tok_new(line);
1153 status = g_slist_nth_data(tokens, 0);
1155 dbg("start line error. skip this line");
1158 if (atoi(status) == 1) {
1159 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
1161 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
1166 classx_str = g_slist_nth_data(tokens, 1);
1168 dbg("class error. skip this line");
1171 switch (atoi(classx_str)) {
1173 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1177 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1181 resp.record[countValidRecords].class = SS_CLASS_FAX;
1185 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1189 resp.record[countValidRecords].class = SS_CLASS_SMS;
1193 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1197 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1201 dbg("unspoorted class : [%d]\n", classx);
1207 // parse <numer> <type>
1208 num = g_slist_nth_data(tokens, 2);
1210 dbg("number - %s", num);
1211 memcpy((resp.record[countValidRecords].number), num, strlen(num));
1212 resp.record[countValidRecords].number_present = TRUE;
1214 ton = g_slist_nth_data(tokens, 3);
1216 resp.record[countValidRecords].number_type = atoi(ton);
1217 dbg("number type - %d", resp.record[countValidRecords].number_type);
1221 // skip <subaddr> <satype>
1223 time_str = g_slist_nth_data(tokens, 6);
1225 time = atoi(time_str);
1226 resp.record[countValidRecords].time = (enum telephony_ss_forwarding_no_reply_time) time;
1227 dbg("time - %d", time);
1230 resp.record[countValidRecords].mode = (enum telephony_ss_forwarding_mode) (info->flavor_type);
1231 dbg("flavor_type - %d", (enum telephony_ss_forwarding_mode) (info->flavor_type));
1233 countValidRecords++;
1234 tcore_at_tok_free(tokens);
1237 dbg("invalid field found. coutinue");
1238 tcore_at_tok_free(tokens);
1241 dbg("valid count :%d", countValidRecords);
1242 resp.record_num = countValidRecords;
1243 resp.err = SS_ERROR_NONE;
1245 dbg("no active status - return to user")
1248 if (response->success > 0) {
1250 resp.err = SS_ERROR_NONE;
1252 dbg("RESPONSE NOT OK");
1254 resp.record_num = 0;
1255 line = (const char *) response->final_response;
1256 tokens = tcore_at_tok_new(line);
1258 if (g_slist_length(tokens) < 1) {
1259 dbg("err cause not specified or string corrupted");
1260 resp.err = SS_ERROR_SYSTEMFAILURE;
1262 err = atoi(g_slist_nth_data(tokens, 0));
1263 /* TODO: CMEE error mapping is required. */
1264 resp.err = SS_ERROR_SYSTEMFAILURE;
1266 tcore_at_tok_free(tokens);
1269 dbg("on_response_ss_forwarding_get- rsp.err : %d, ur : %x", resp.err, ur);
1271 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);
1273 dbg("[ error ] ur is 0");
1276 g_free(resp.record);
1282 static void on_response_ss_waiting_get(TcorePending *p, int data_len, const void *data, void *user_data)
1284 UserRequest *ur = 0;
1285 GSList *respdata, *tokens = NULL;
1286 int classx = 0, err = 0;
1287 struct ss_confirm_info *info = 0;
1288 struct tresp_ss_waiting resp;
1289 int countRecords = 0, countValidRecords = 0;
1291 char *classx_str, *status;
1292 const TcoreATResponse *response;
1294 dbg("function enter")
1296 ur = tcore_pending_ref_user_request(p);
1297 info = (struct ss_confirm_info *) user_data;
1299 if (response->lines) {
1300 respdata = (GSList *) response->lines;
1301 countRecords = g_slist_length(respdata);
1302 dbg("total records : %d", countRecords);
1305 dbg("no active status - return to user")
1307 resp.record_num = countRecords;
1310 if (resp.record_num > 0) {
1311 resp.record = g_new0(struct waiting_info, resp.record_num);
1313 for (countValidRecords = 0; respdata != NULL; respdata = respdata->next) {
1314 line = (const char *) (respdata->data);
1315 tokens = tcore_at_tok_new(line);
1318 status = g_slist_nth_data(tokens, 0);
1320 dbg("Missing stat in responce ");
1323 if (atoi(status) == 1) {
1324 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;
1326 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;
1329 dbg("status = %d", resp.record[countValidRecords].status);
1332 classx_str = g_slist_nth_data(tokens, 1);
1334 dbg("error - class is missing");
1337 switch (atoi(classx_str)) {
1339 resp.record[countValidRecords].class = SS_CLASS_VOICE;
1343 resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;
1347 resp.record[countValidRecords].class = SS_CLASS_FAX;
1351 resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;
1355 resp.record[countValidRecords].class = SS_CLASS_SMS;
1359 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;
1363 resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;
1367 dbg("unspoorted class : [%d]\n", classx);
1371 dbg("class info %d", resp.record[countValidRecords].class);
1374 countValidRecords++;
1375 tcore_at_tok_free(tokens);
1378 dbg("invalid field found. coutinue");
1379 tcore_at_tok_free(tokens);
1383 dbg("valid count :%d", countValidRecords);
1384 resp.record_num = countValidRecords;
1385 resp.err = SS_ERROR_NONE;
1387 dbg("no active status - return to user")
1390 if (response->success > 0) {
1392 resp.err = SS_ERROR_NONE;
1394 dbg("RESPONSE NOT OK");
1396 resp.record_num = 0;
1397 line = (const char *) response->final_response;
1398 tokens = tcore_at_tok_new(line);
1400 if (g_slist_length(tokens) < 1) {
1401 dbg("err cause not specified or string corrupted");
1402 resp.err = SS_ERROR_SYSTEMFAILURE;
1404 err = atoi(g_slist_nth_data(tokens, 0));
1405 // TODO: CMEE error mapping is required.
1406 resp.err = SS_ERROR_SYSTEMFAILURE;
1408 tcore_at_tok_free(tokens);
1411 dbg("on_response_ss_waiting_get - rsp.err : %d, ur : %x", resp.err, ur);
1413 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_waiting), &resp);
1415 dbg("[ error ] ur is 0");
1418 g_free(resp.record);
1425 static void on_response_ss_cli_get(TcorePending *p, int data_len, const void *data, void *user_data)
1427 UserRequest *ur = 0;
1428 struct tresp_ss_cli resp;
1429 enum telephony_ss_cli_type *p_type = NULL;
1430 char *line = NULL, *status;
1433 GSList *tokens = NULL;
1434 const TcoreATResponse *response;
1436 dbg("function enter")
1438 ur = tcore_pending_ref_user_request(p);
1439 p_type = (enum telephony_ss_cli_type *) (user_data);
1441 if (response->success > 0) {
1442 line = (char *) (((GSList *) response->lines)->data);
1443 tokens = tcore_at_tok_new(line);
1445 if (*p_type == SS_CLI_TYPE_CLIR) {
1447 dbg("CLI type is CLIR")
1449 status = g_slist_nth_data(tokens, 0);
1452 dbg("Call line identification adjustment missing <n>");
1454 cli_adj = atoi(status);
1455 dbg("CLIR response value of <n> - %d", cli_adj);
1459 status = g_slist_nth_data(tokens, 1);
1461 dbg("status is missing<m>");
1463 stat = atoi(status);
1464 dbg("CLIR response value of <m> - %d", stat);
1466 if (stat == 1 || stat == 3) {
1469 resp.status = FALSE;
1471 } else if (cli_adj == 1) {
1474 resp.status = FALSE;
1476 dbg("resp.status - %d", resp.status);
1478 tcore_at_tok_free(tokens);
1481 status = g_slist_nth_data(tokens, 0);
1483 dbg("Stat is missing");
1485 stat = atoi(status);
1489 resp.status = FALSE;
1491 dbg("resp.status - %d", resp.status);
1493 tcore_at_tok_free(tokens);
1497 if (response->success > 0) {
1499 resp.err = SS_ERROR_NONE;
1501 dbg("RESPONSE NOT OK");
1503 line = (char *) response->final_response;
1504 tokens = tcore_at_tok_new(line);
1506 if (g_slist_length(tokens) < 1) {
1507 dbg("err cause not specified or string corrupted");
1508 resp.err = SS_ERROR_SYSTEMFAILURE;
1510 err = atoi(g_slist_nth_data(tokens, 0));
1511 // TODO: CMEE error mapping is required.
1512 resp.err = SS_ERROR_SYSTEMFAILURE;
1514 tcore_at_tok_free(tokens);
1517 resp.type = *p_type;
1518 dbg("check - resp.type = %d ", resp.type);
1520 tcore_user_request_send_response(ur, TRESP_SS_CLI_GET_STATUS, sizeof(struct tresp_ss_cli), &resp);
1522 dbg("[ error ] ur : (0)");
1527 static struct tcore_ss_operations ss_ops = {
1528 .barring_activate = s_ss_barring_activate,
1529 .barring_deactivate = s_ss_barring_deactivate,
1530 .barring_change_password = s_ss_barring_change_password,
1531 .barring_get_status = s_ss_barring_get_status,
1532 .forwarding_activate = s_ss_forwarding_activate,
1533 .forwarding_deactivate = s_ss_forwarding_deactivate,
1534 .forwarding_register = s_ss_forwarding_register,
1535 .forwarding_deregister = s_ss_forwarding_deregister,
1536 .forwarding_get_status = s_ss_forwarding_get_status,
1537 .waiting_activate = s_ss_waiting_activate,
1538 .waiting_deactivate = s_ss_waiting_deactivate,
1539 .waiting_get_status = s_ss_waiting_get_status,
1540 .cli_activate = s_ss_cli_activate,
1541 .cli_deactivate = s_ss_cli_deactivate,
1542 .cli_get_status = s_ss_cli_get_status,
1543 .send_ussd = s_ss_send_ussd,
1544 .set_aoc = s_ss_set_aoc,
1545 .get_aoc = s_ss_get_aoc,
1549 static TReturn _ss_barring_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op)
1551 struct treq_ss_barring *barring = 0;
1552 struct ss_confirm_info *user_data = 0;
1553 char *cmd_str = NULL;
1555 TcorePending *pending = NULL;
1556 TcoreATRequest *req;
1557 char passwd[MAX_SS_BARRING_PASSWORD_LEN + 1];
1560 char *facility = NULL;
1561 gboolean ret = FALSE;
1563 dbg("function enter");
1564 barring = (struct treq_ss_barring *) tcore_user_request_ref_data(ur, 0);
1567 case SS_OPCO_ACTIVATE:
1571 case SS_OPCO_DEACTIVATE:
1576 dbg("unsupported opco : %d", op);
1577 return TCORE_RETURN_FAILURE;
1579 dbg("opco - %d", opco);
1581 switch (barring->mode) {
1582 case SS_BARR_MODE_BAOC:
1586 case SS_BARR_MODE_BOIC:
1590 case SS_BARR_MODE_BOIC_NOT_HC:
1594 case SS_BARR_MODE_BAIC:
1598 case SS_BARR_MODE_BIC_ROAM:
1602 case SS_BARR_MODE_AB:
1606 case SS_BARR_MODE_AOB:
1610 case SS_BARR_MODE_AIB:
1614 case SS_BARR_MODE_BIC_NOT_SIM:
1617 dbg("unspported mode %d", barring->mode);
1618 return TCORE_RETURN_FAILURE;
1621 dbg("facility - %s", facility);
1623 switch (barring->class) {
1624 case SS_CLASS_ALL_TELE:
1628 case SS_CLASS_VOICE:
1632 case SS_CLASS_ALL_DATA_TELE:
1644 case SS_CLASS_ALL_CS_SYNC:
1650 dbg("unsupported class %d. set to default : 7", barring->class);
1654 dbg("classx - %d", classx);
1656 // null-ended pwd handling added - unexpected 0x11 value observed in req string
1657 memcpy(passwd, barring->password, MAX_SS_BARRING_PASSWORD_LEN);
1658 passwd[MAX_SS_BARRING_PASSWORD_LEN] = '\0';
1659 dbg("passwd - %s", passwd);
1661 hal = tcore_object_get_hal(o);
1662 pending = tcore_pending_new(o, 0);
1664 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,\"%s\",%d", facility, opco, passwd, classx);
1665 dbg("request command : %s", cmd_str);
1667 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
1668 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
1670 tcore_pending_set_request_data(pending, 0, req);
1672 user_data = g_new0(struct ss_confirm_info, 1);
1673 if (op == SS_OPCO_ACTIVATE) {
1674 user_data->resp = TRESP_SS_BARRING_ACTIVATE;
1675 } else if (op == SS_OPCO_DEACTIVATE) {
1676 user_data->resp = TRESP_SS_BARRING_DEACTIVATE;
1678 dbg("[ error ] wrong ss opco (0x%x)", op);
1679 if (user_data != NULL) {
1683 return TCORE_RETURN_FAILURE;
1685 user_data->flavor_type = (int) (barring->mode);
1686 user_data->class = barring->class;
1688 ret = _ss_request_message(pending, o, ur, on_response_ss_barring_set, user_data);
1692 dbg("AT request sent failed ")
1693 if (user_data != NULL) {
1696 return TCORE_RETURN_FAILURE;
1698 return TCORE_RETURN_SUCCESS;
1701 static TReturn _ss_barring_get(CoreObject *o,
1703 enum telephony_ss_class class,
1704 enum telephony_ss_barring_mode mode,
1705 enum tcore_response_command resp)
1707 struct ss_confirm_info *user_data = 0;
1708 gboolean ret = FALSE;
1709 char *cmd_str = NULL;
1711 char *facility = NULL;
1713 TcorePending *pending = NULL;
1714 TcoreATRequest *req;
1716 dbg("function enter");
1718 // query status - opco is fixed to 2
1722 case SS_BARR_MODE_BAOC:
1726 case SS_BARR_MODE_BOIC:
1730 case SS_BARR_MODE_BOIC_NOT_HC:
1734 case SS_BARR_MODE_BAIC:
1738 case SS_BARR_MODE_BIC_ROAM:
1742 case SS_BARR_MODE_AB:
1743 case SS_BARR_MODE_AOB:
1744 case SS_BARR_MODE_AIB:
1745 case SS_BARR_MODE_BIC_NOT_SIM:
1747 dbg("unsupported mode %d", mode);
1748 return TCORE_RETURN_FAILURE;
1751 dbg("facility - %s", facility);
1754 case SS_CLASS_ALL_TELE:
1758 case SS_CLASS_VOICE:
1762 case SS_CLASS_ALL_DATA_TELE:
1774 case SS_CLASS_ALL_CS_SYNC:
1780 dbg("unsupported class %d. set to default : 7", class);
1783 dbg("class - %d", classx);
1786 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d", facility, opco);
1788 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,,%d", facility, opco, classx);
1790 dbg("request command : %s", cmd_str);
1792 hal = tcore_object_get_hal(o);
1793 pending = tcore_pending_new(o, 0);
1794 req = tcore_at_request_new(cmd_str, "+CLCK", TCORE_AT_MULTILINE);
1795 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
1797 tcore_pending_set_request_data(pending, 0, req);
1799 user_data = g_new0(struct ss_confirm_info, 1);
1800 user_data->resp = resp;
1801 user_data->flavor_type = (int) (mode);
1802 user_data->class = class;
1804 ret = _ss_request_message(pending, o, ur, on_response_ss_barring_get, user_data);
1808 dbg("AT request sent failed ")
1809 if (user_data != NULL) {
1812 return TCORE_RETURN_FAILURE;
1815 return TCORE_RETURN_SUCCESS;
1818 static TReturn s_ss_barring_activate(CoreObject *o, UserRequest *ur)
1820 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
1821 dbg("cp not ready/n");
1822 return TCORE_RETURN_ENOSYS;
1824 return _ss_barring_set(o, ur, SS_OPCO_ACTIVATE);
1827 static TReturn s_ss_barring_deactivate(CoreObject *o, UserRequest *ur)
1829 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
1830 dbg("cp not ready/n");
1831 return TCORE_RETURN_ENOSYS;
1833 return _ss_barring_set(o, ur, SS_OPCO_DEACTIVATE);
1836 static TReturn s_ss_barring_change_password(CoreObject *o, UserRequest *ur)
1839 TcorePending *pending = NULL;
1840 TcoreATRequest *req;
1841 struct treq_ss_barring_change_password *barring = 0;
1842 struct ss_confirm_info *user_data = 0;
1843 char *cmd_str = NULL;
1844 gboolean ret = FALSE;
1845 char old_password[MAX_SS_BARRING_PASSWORD_LEN + 1];
1846 char new_password[MAX_SS_BARRING_PASSWORD_LEN + 1];
1848 dbg("function enter");
1850 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
1851 dbg("cp not ready/n");
1852 return TCORE_RETURN_ENOSYS;
1855 barring = (struct treq_ss_barring_change_password *) tcore_user_request_ref_data(ur, 0);
1857 if (barring->password_old == NULL || barring->password_new == NULL) {
1858 dbg("[error]password is null");
1859 return TCORE_RETURN_FAILURE;
1861 memcpy(old_password, barring->password_old, MAX_SS_BARRING_PASSWORD_LEN);
1862 old_password[MAX_SS_BARRING_PASSWORD_LEN] = '\0';
1863 memcpy(new_password, barring->password_new, MAX_SS_BARRING_PASSWORD_LEN);
1864 new_password[MAX_SS_BARRING_PASSWORD_LEN] = '\0';
1866 dbg("old passwd - %s new passwd- %s", old_password, new_password);
1867 cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", "AB", old_password, new_password);
1868 dbg("request command : %s", cmd_str);
1870 hal = tcore_object_get_hal(o);
1871 pending = tcore_pending_new(o, 0);
1872 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
1873 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
1875 tcore_pending_set_request_data(pending, 0, req);
1877 user_data = g_new0(struct ss_confirm_info, 1);
1878 user_data->resp = TRESP_SS_BARRING_CHANGE_PASSWORD;
1880 ret = _ss_request_message(pending, o, ur, on_response_ss_barring_change_pwd, user_data);
1883 dbg("AT request sent failed ")
1884 if (user_data != NULL) {
1887 return TCORE_RETURN_FAILURE;
1889 return TCORE_RETURN_SUCCESS;
1892 static TReturn s_ss_barring_get_status(CoreObject *o, UserRequest *ur)
1894 struct treq_ss_barring *barring = 0;
1896 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
1897 dbg("cp not ready/n");
1898 return TCORE_RETURN_ENOSYS;
1900 barring = (struct treq_ss_barring *) tcore_user_request_ref_data(ur, 0);
1902 return _ss_barring_get(o, ur, barring->class, barring->mode, TRESP_SS_BARRING_GET_STATUS);
1905 static TReturn _ss_forwarding_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op)
1907 struct treq_ss_forwarding *forwarding = 0;
1908 struct ss_confirm_info *user_data = 0;
1909 gboolean ret = FALSE;
1911 char *cmd_str = NULL;
1912 char *tmp_str = NULL;
1913 int reason = 0, mode = 0, num_type = 0, classx = 0, time = 0;
1914 gboolean valid_num = FALSE;
1916 TcorePending *pending = NULL;
1917 TcoreATRequest *req;
1919 dbg("_ss_forwarding_set with opco %d ", op);
1921 forwarding = (struct treq_ss_forwarding *) tcore_user_request_ref_data(ur, 0);
1922 switch (forwarding->mode) {
1923 case SS_CF_MODE_CFU:
1927 case SS_CF_MODE_CFB:
1931 case SS_CF_MODE_CFNRy:
1935 case SS_CF_MODE_CFNRc:
1939 case SS_CF_MODE_CF_ALL:
1943 case SS_CF_MODE_CFC:
1948 dbg("unsupported reason : %d");
1949 return TCORE_RETURN_FAILURE;
1953 dbg("reason = %d", reason);
1955 case SS_OPCO_DEACTIVATE:
1959 case SS_OPCO_ACTIVATE:
1972 dbg("unsupported opco : %d", op);
1973 return TCORE_RETURN_FAILURE;
1976 dbg("mode = %d", mode);
1979 switch (forwarding->class) {
1980 case SS_CLASS_ALL_TELE:
1984 case SS_CLASS_VOICE:
1988 case SS_CLASS_ALL_DATA_TELE:
2000 case SS_CLASS_ALL_CS_SYNC:
2006 dbg("unsupported class %d. set to default : 7", forwarding->class);
2009 dbg("classx = %d", classx);
2012 len = strlen(forwarding->number);
2015 if (forwarding->number[0] == '+')
2016 num_type = ((NUM_TYPE_INTERNATIONAL << 4) | NUM_PLAN_ISDN);
2020 dbg("number = %s", forwarding->number);
2022 user_data = g_new0(struct ss_confirm_info, 1);
2026 user_data->resp = TRESP_SS_FORWARDING_REGISTER;
2030 user_data->resp = TRESP_SS_FORWARDING_DEREGISTER;
2033 case SS_OPCO_ACTIVATE:
2034 user_data->resp = TRESP_SS_FORWARDING_ACTIVATE;
2037 case SS_OPCO_DEACTIVATE:
2038 user_data->resp = TRESP_SS_FORWARDING_DEACTIVATE;
2042 dbg("[ error ] unknown op (0x%x)", op);
2046 if (forwarding->number[0] == '+')
2051 if (op == SS_OPCO_REG)
2052 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,\"%s\",%d,%d", reason, mode, forwarding->number, num_type, classx);
2053 else // other opcode does not need num field
2054 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode, classx);
2056 if (forwarding->mode == SS_CF_MODE_CFNRy) {
2057 // add time info to 'no reply' case
2058 time = (int) (forwarding->time);
2059 cmd_str = g_strdup_printf("%s,,,%d", tmp_str, time);
2061 cmd_str = g_strdup_printf("%s", tmp_str);
2064 dbg("request command : %s", cmd_str);
2065 hal = tcore_object_get_hal(o);
2066 pending = tcore_pending_new(o, 0);
2067 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
2068 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2070 tcore_pending_set_request_data(pending, 0, req);
2072 user_data->flavor_type = forwarding->mode;
2073 user_data->class = forwarding->class;
2075 ret = _ss_request_message(pending, o, ur, on_response_ss_forwarding_set, user_data);
2081 dbg("AT request sent failed ")
2082 if (user_data != NULL) {
2085 return TCORE_RETURN_FAILURE;
2088 return TCORE_RETURN_SUCCESS;
2091 static TReturn _ss_forwarding_get(CoreObject *o,
2093 enum telephony_ss_class class,
2094 enum telephony_ss_forwarding_mode type,
2095 enum tcore_response_command resp)
2097 struct ss_confirm_info *user_data = 0;
2098 gboolean ret = FALSE;
2099 char *cmd_str = NULL;
2100 int reason = 0, mode = 0, classx = 0;
2102 TcorePending *pending = NULL;
2103 TcoreATRequest *req;
2105 dbg("function enter");
2108 case SS_CF_MODE_CFU:
2112 case SS_CF_MODE_CFB:
2116 case SS_CF_MODE_CFNRy:
2120 case SS_CF_MODE_CFNRc:
2124 case SS_CF_MODE_CF_ALL:
2128 case SS_CF_MODE_CFC:
2133 dbg("unsupported reason : %d");
2136 dbg("reason = %d", reason);
2139 case SS_CLASS_ALL_TELE:
2143 case SS_CLASS_VOICE:
2147 case SS_CLASS_ALL_DATA_TELE:
2159 case SS_CLASS_ALL_CS_SYNC:
2165 dbg("unsupported class %d. set to default : 7", class);
2169 dbg("classx = %d", classx);
2171 // query status - mode set to 2
2173 user_data = g_new0(struct ss_confirm_info, 1);
2174 user_data->resp = resp;
2175 user_data->class = class;
2176 user_data->flavor_type = type;
2179 cmd_str = g_strdup_printf("AT+CCFC=%d,%d", reason, mode);
2181 cmd_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode, classx);
2183 dbg("request command : %s", cmd_str);
2185 hal = tcore_object_get_hal(o);
2186 pending = tcore_pending_new(o, 0);
2187 req = tcore_at_request_new(cmd_str, "+CCFC", TCORE_AT_MULTILINE);
2188 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2190 tcore_pending_set_request_data(pending, 0, req);
2192 ret = _ss_request_message(pending, o, ur, on_response_ss_forwarding_get, user_data);
2196 dbg("AT request sent failed ")
2197 if (user_data != NULL) {
2200 return TCORE_RETURN_FAILURE;
2203 return TCORE_RETURN_SUCCESS;
2206 static TReturn s_ss_forwarding_activate(CoreObject *o, UserRequest *ur)
2208 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2209 dbg("cp not ready/n");
2210 return TCORE_RETURN_ENOSYS;
2212 return _ss_forwarding_set(o, ur, SS_OPCO_ACTIVATE);
2215 static TReturn s_ss_forwarding_deactivate(CoreObject *o, UserRequest *ur)
2217 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2218 dbg("cp not ready/n");
2219 return TCORE_RETURN_ENOSYS;
2221 return _ss_forwarding_set(o, ur, SS_OPCO_DEACTIVATE);
2224 static TReturn s_ss_forwarding_register(CoreObject *o, UserRequest *ur)
2226 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2227 dbg("cp not ready/n");
2228 return TCORE_RETURN_ENOSYS;
2230 return _ss_forwarding_set(o, ur, SS_OPCO_REG);
2233 static TReturn s_ss_forwarding_deregister(CoreObject *o, UserRequest *ur)
2235 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2236 dbg("cp not ready/n");
2237 return TCORE_RETURN_ENOSYS;
2239 return _ss_forwarding_set(o, ur, SS_OPCO_DEREG);
2242 static TReturn s_ss_forwarding_get_status(CoreObject *o, UserRequest *ur)
2244 struct treq_ss_forwarding *forwarding = 0;
2246 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2247 dbg("cp not ready/n");
2248 return TCORE_RETURN_ENOSYS;
2251 forwarding = (struct treq_ss_forwarding *) tcore_user_request_ref_data(ur, 0);
2253 return _ss_forwarding_get(o, ur, forwarding->class, forwarding->mode, TRESP_SS_FORWARDING_GET_STATUS);
2257 static TReturn _ss_waiting_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode opco)
2259 struct treq_ss_waiting *waiting = 0;
2260 struct ss_confirm_info *user_data = 0;
2261 gboolean ret = FALSE;
2262 int mode = 0, classx = 0;
2265 TcorePending *pending = NULL;
2266 TcoreATRequest *req;
2268 dbg("function enter ");
2269 waiting = (struct treq_ss_waiting *) tcore_user_request_ref_data(ur, 0);
2270 user_data = g_new0(struct ss_confirm_info, 1);
2272 if (opco == SS_OPCO_ACTIVATE) {
2273 user_data->resp = TRESP_SS_WAITING_ACTIVATE;
2275 } else if (opco == SS_OPCO_DEACTIVATE) {
2276 user_data->resp = TRESP_SS_WAITING_DEACTIVATE;
2277 mode = 0; // disable
2279 dbg("[ error ] unknown ss mode (0x%x)", opco);
2281 switch (waiting->class) {
2282 case SS_CLASS_ALL_TELE:
2286 case SS_CLASS_VOICE:
2290 case SS_CLASS_ALL_DATA_TELE:
2304 dbg("unsupported class %d. set to default : 1", waiting->class);
2307 dbg("mode = %d classxx- %d", mode, classx);
2309 user_data->class = waiting->class;
2310 user_data->flavor_type = (int) opco;
2312 cmd_str = g_strdup_printf("AT+CCWA=1,%d,%d", mode, classx); // always enable +CCWA: unsolicited cmd
2313 dbg("request command : %s", cmd_str);
2315 hal = tcore_object_get_hal(o);
2316 pending = tcore_pending_new(o, 0);
2317 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
2318 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2320 tcore_pending_set_request_data(pending, 0, req);
2322 ret = _ss_request_message(pending, o, ur, on_response_ss_waiting_set, user_data);
2325 dbg("AT request sent failed ")
2326 if (user_data != NULL) {
2329 return TCORE_RETURN_FAILURE;
2331 return TCORE_RETURN_SUCCESS;
2334 static TReturn _ss_waiting_get(CoreObject *o,
2336 enum telephony_ss_class class,
2337 enum tcore_response_command resp)
2339 struct ss_confirm_info *user_data = 0;
2340 gboolean ret = FALSE;
2341 int classx; // mode,
2344 TcorePending *pending = NULL;
2345 TcoreATRequest *req;
2347 dbg("function enter")
2349 case SS_CLASS_ALL_TELE:
2353 case SS_CLASS_VOICE:
2357 case SS_CLASS_ALL_DATA_TELE:
2371 dbg("unsupported class %d. set to default : 7", class);
2374 dbg("classx - %d", classx);
2376 dbg("allocating user data");
2377 user_data = g_new0(struct ss_confirm_info, 1);
2378 user_data->resp = resp;
2379 user_data->class = class;
2381 cmd_str = g_strdup_printf("AT+CCWA=1,2,%d", classx); // always enable +CCWA: unsolicited cmd , mode is fixed to 2(query status)
2382 dbg("request cmd : %s", cmd_str);
2384 hal = tcore_object_get_hal(o);
2385 pending = tcore_pending_new(o, 0);
2386 req = tcore_at_request_new(cmd_str, "+CCWA", TCORE_AT_MULTILINE);
2387 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2389 tcore_pending_set_request_data(pending, 0, req);
2391 ret = _ss_request_message(pending, o, ur, on_response_ss_waiting_get, user_data);
2394 dbg("AT request sent failed ")
2395 if (user_data != NULL) {
2398 return TCORE_RETURN_FAILURE;
2400 return TCORE_RETURN_SUCCESS;
2403 static TReturn s_ss_waiting_activate(CoreObject *o, UserRequest *ur)
2405 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2406 dbg("cp not ready/n");
2407 return TCORE_RETURN_ENOSYS;
2409 return _ss_waiting_set(o, ur, SS_OPCO_ACTIVATE);
2412 static TReturn s_ss_waiting_deactivate(CoreObject *o, UserRequest *ur)
2414 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2415 dbg("cp not ready/n");
2416 return TCORE_RETURN_ENOSYS;
2418 return _ss_waiting_set(o, ur, SS_OPCO_DEACTIVATE);
2421 static TReturn s_ss_waiting_get_status(CoreObject *o, UserRequest *ur)
2423 struct treq_ss_waiting *waiting = 0;
2425 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2426 dbg("cp not ready/n");
2427 return TCORE_RETURN_ENOSYS;
2429 waiting = (struct treq_ss_waiting *) tcore_user_request_ref_data(ur, 0);
2431 return _ss_waiting_get(o, ur, waiting->class, TRESP_SS_WAITING_GET_STATUS);
2434 static TReturn s_ss_cli_activate(CoreObject *o, UserRequest *ur)
2436 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2437 dbg("cp not ready/n");
2438 return TCORE_RETURN_ENOSYS;
2440 return TCORE_RETURN_SUCCESS;
2443 static TReturn s_ss_cli_deactivate(CoreObject *o, UserRequest *ur)
2445 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2446 dbg("cp not ready/n");
2447 return TCORE_RETURN_ENOSYS;
2449 return TCORE_RETURN_SUCCESS;
2452 static TReturn s_ss_cli_get_status(CoreObject *o, UserRequest *ur)
2454 struct treq_ss_cli *cli = 0;
2455 gboolean ret = FALSE;
2456 char *cmd_prefix = NULL, *rsp_prefix = NULL, *cmd_str = NULL;
2457 enum telephony_ss_cli_type *user_data = 0;
2459 TcorePending *pending = NULL;
2460 TcoreATRequest *req;
2462 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2463 dbg("cp not ready/n");
2464 return TCORE_RETURN_ENOSYS;
2467 cli = (struct treq_ss_cli *) tcore_user_request_ref_data(ur, 0);
2468 switch (cli->type) {
2469 case SS_CLI_TYPE_CLIP:
2470 cmd_prefix = "+CLIP";
2471 rsp_prefix = "+CLIP";
2474 case SS_CLI_TYPE_CLIR:
2475 cmd_prefix = "+CLIR";
2476 rsp_prefix = "+CLIR";
2479 case SS_CLI_TYPE_COLP:
2480 cmd_prefix = "+COLP";
2481 rsp_prefix = "+COLP";
2484 case SS_CLI_TYPE_COLR:
2485 cmd_prefix = "+COLR";
2486 rsp_prefix = "+COLR";
2489 case SS_CLI_TYPE_CNAP:
2490 cmd_prefix = "+CNAP";
2491 rsp_prefix = "+CNAP";
2494 case SS_CLI_TYPE_CDIP:
2496 dbg("unsupported cli_type : %d", cli->type);
2497 return TCORE_RETURN_FAILURE;
2500 dbg("cmd_prefix : %s", cmd_prefix);
2502 cmd_str = g_strdup_printf("AT%s?", cmd_prefix);
2503 dbg("request cmd : %s", cmd_str);
2505 user_data = g_new0(enum telephony_ss_cli_type, 1);
2506 *user_data = cli->type;
2508 hal = tcore_object_get_hal(o);
2509 pending = tcore_pending_new(o, 0);
2511 req = tcore_at_request_new(cmd_str, rsp_prefix, TCORE_AT_SINGLELINE);
2512 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2513 tcore_pending_set_request_data(pending, 0, req);
2515 ret = _ss_request_message(pending, o, ur, on_response_ss_cli_get, user_data);
2518 dbg("AT request sent failed ")
2519 if (user_data != NULL) {
2522 return TCORE_RETURN_FAILURE;
2524 return TCORE_RETURN_SUCCESS;
2527 static TReturn s_ss_send_ussd(CoreObject *o, UserRequest *ur)
2529 UssdSession *ussd_s = 0;
2530 struct treq_ss_ussd *ussd = 0;
2531 struct ss_confirm_info *user_data = 0;
2532 gboolean ret = FALSE;
2535 TcorePending *pending = NULL;
2536 TcoreATRequest *req;
2538 dbg("function enter");
2540 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2541 dbg("cp not ready/n");
2542 return TCORE_RETURN_ENOSYS;
2545 ussd = (struct treq_ss_ussd *) tcore_user_request_ref_data(ur, 0);
2546 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
2547 dbg("request command : %s", cmd_str);
2549 user_data = g_new0(struct ss_confirm_info, 1);
2550 user_data->resp = TRESP_SS_SEND_USSD;
2551 ussd_s = tcore_ss_ussd_get_session(o);
2553 dbg("USSD session does not exist");
2554 tcore_ss_ussd_create_session(o, (enum tcore_ss_ussd_type) ussd->type, (void *) tcore_user_request_ref(ur), 0);
2556 if (ussd->type == SS_USSD_TYPE_USER_INITIATED) {
2557 dbg("[ error ] ussd session is already exist");
2559 return TCORE_RETURN_FAILURE;
2562 tcore_ss_ussd_set_session_type(ussd_s, (enum tcore_ss_ussd_type) ussd->type);
2565 hal = tcore_object_get_hal(o);
2566 pending = tcore_pending_new(o, 0);
2567 req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);
2568 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2570 tcore_pending_set_request_data(pending, 0, req);
2572 ret = _ss_request_message(pending, o, ur, on_confirmation_ss_ussd, user_data);
2576 dbg("AT request sent failed ")
2577 if (user_data != NULL) {
2580 return TCORE_RETURN_FAILURE;
2582 return TCORE_RETURN_SUCCESS;
2585 static TReturn s_ss_set_aoc(CoreObject *o, UserRequest *ur)
2587 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2588 dbg("cp not ready/n");
2589 return TCORE_RETURN_ENOSYS;
2592 dbg("[ error ] unsupported function");
2593 return TCORE_RETURN_SUCCESS;
2596 static TReturn s_ss_get_aoc(CoreObject *o, UserRequest *ur)
2598 if(FALSE == tcore_hal_get_power_state(tcore_object_get_hal(o))){
2599 dbg("cp not ready/n");
2600 return TCORE_RETURN_ENOSYS;
2603 dbg("[ error ] unsupported function");
2604 return TCORE_RETURN_SUCCESS;
2608 static struct tcore_call_control_operations call_ops = {
2609 .answer_hold_and_accept = s_ss_manage_call_2_send,
2610 .answer_replace = s_ss_manage_call_1_send,
2611 .answer_reject = s_ss_manage_call_0_send,
2612 .end_specific = s_ss_manage_call_1x_send,
2613 .end_all_active = s_ss_manage_call_1_send,
2614 .end_all_held = s_ss_manage_call_0_send,
2615 .active = s_ss_manage_call_2_send,
2616 .hold = s_ss_manage_call_2_send,
2617 .swap = s_ss_manage_call_2_send,
2618 .join = s_ss_manage_call_3_send,
2619 .split = s_ss_manage_call_2x_send,
2620 .transfer = s_ss_manage_call_4_send,
2621 .deflect = s_ss_manage_call_4dn_send,
2624 static TReturn s_ss_manage_call_send(CoreObject *o, UserRequest *ur, const char *cmd, ConfirmCallback cb, void *user_data)
2626 TcorePending *pending = NULL;
2627 TcoreATRequest *req;
2628 gboolean ret = FALSE;
2630 pending = tcore_pending_new(o, 0);
2631 req = tcore_at_request_new(cmd, NULL, TCORE_AT_NO_RESULT);
2632 dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));
2633 tcore_pending_set_request_data(pending, 0, req);
2635 ret = _ss_request_message(pending, o, ur, (TcorePendingResponseCallback) cb, user_data);
2637 dbg("AT request sent failed ")
2638 return TCORE_RETURN_FAILURE;
2640 return TCORE_RETURN_SUCCESS;
2643 static TReturn s_ss_manage_call_0_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2645 char *cmd_str = NULL;
2646 gboolean ret = FALSE;
2648 dbg("function enter");
2649 cmd_str = g_strdup_printf("%s", "AT+CHLD=0");
2650 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2652 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2657 static TReturn s_ss_manage_call_1_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2659 char *cmd_str = NULL;
2660 gboolean ret = FALSE;
2662 dbg("function enter");
2663 cmd_str = g_strdup_printf("%s", "AT+CHLD=1");
2664 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2666 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2671 static TReturn s_ss_manage_call_1x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data)
2673 char *cmd_str = NULL;
2674 gboolean ret = FALSE;
2676 dbg("function enter");
2677 cmd_str = g_strdup_printf("%s%d", "AT+CHLD=1", id);
2678 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2680 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2685 static TReturn s_ss_manage_call_2_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2687 char *cmd_str = NULL;
2688 gboolean ret = FALSE;
2690 dbg("function enter");
2691 cmd_str = g_strdup_printf("%s", "AT+CHLD=2");
2692 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2694 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2699 static TReturn s_ss_manage_call_2x_send(CoreObject *o, UserRequest *ur, const int id, ConfirmCallback cb, void *user_data)
2701 char *cmd_str = NULL;
2702 gboolean ret = FALSE;
2704 dbg("function enter");
2705 cmd_str = g_strdup_printf("%s%d", "AT+CHLD=2", id);
2706 dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d", cmd_str, "N/A", strlen(cmd_str));
2708 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2713 static TReturn s_ss_manage_call_3_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2715 char *cmd_str = NULL;
2716 gboolean ret = FALSE;
2718 dbg("function enter");
2719 cmd_str = g_strdup_printf("%s", "AT+CHLD=3");
2721 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2727 static TReturn s_ss_manage_call_4_send(CoreObject *o, UserRequest *ur, ConfirmCallback cb, void *user_data)
2729 char *cmd_str = NULL;
2730 gboolean ret = FALSE;
2732 dbg("function enter");
2733 cmd_str = g_strdup_printf("%s", "AT+CHLD=4");
2735 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2740 static TReturn s_ss_manage_call_4dn_send(CoreObject *o, UserRequest *ur, const char *number, ConfirmCallback cb, void *user_data)
2742 char *cmd_str = NULL;
2743 gboolean ret = FALSE;
2745 dbg("function enter");
2746 cmd_str = g_strdup_printf("%s%s", "AT+CHLD=4", number);
2748 ret = s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);
2754 gboolean s_ss_init(TcorePlugin *cp, CoreObject *co_ss)
2756 CoreObject *co_call = NULL;
2758 tcore_ss_override_ops(co_ss, &ss_ops);
2761 co_call = tcore_plugin_ref_core_object(cp,
2762 CORE_OBJECT_TYPE_CALL);
2763 if (co_call == NULL) {
2764 err("Can't find CALL core object");
2768 tcore_call_override_ops(co_call, NULL, &call_ops);
2770 tcore_object_override_callback(co_ss, "+CSSU", on_notification_ss_info, NULL);
2771 tcore_object_override_callback(co_ss, "+CSSI", on_notification_ss_info, NULL);
2772 tcore_object_override_callback(co_ss, "+CUSD", on_notification_ss_ussd, NULL);
2777 void s_ss_exit(TcorePlugin *cp, CoreObject *co_ss)