src/s_ss.c

   1 /*\r
   2  * tel-plugin-imc\r
   3  *\r
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.\r
   5  *\r
   6  * Contact: sharanayya mathapati <sharan.m@samsung.com>\r
   7  *\r
   8  * Licensed under the Apache License, Version 2.0 (the "License");\r
   9  * you may not use this file except in compliance with the License.\r
  10  * You may obtain a copy of the License at\r
  11  *\r
  12  * http://www.apache.org/licenses/LICENSE-2.0\r
  13  *\r
  14  * Unless required by applicable law or agreed to in writing, software\r
  15  * distributed under the License is distributed on an "AS IS" BASIS,\r
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  17  * See the License for the specific language governing permissions and\r
  18  * limitations under the License.\r
  19  */\r
  20 \r
  21 \r
  22 #include <stdio.h>\r
  23 #include <stdlib.h>\r
  24 #include <string.h>\r
  25 #include <glib.h>\r
  26 \r
  27 #include <tcore.h>\r
  28 #include <hal.h>\r
  29 #include <core_object.h>\r
  30 #include <plugin.h>\r
  31 #include <queue.h>\r
  32 #include <co_call.h>\r
  33 #include <co_ss.h>\r
  34 #include <user_request.h>\r
  35 #include <util.h>\r
  36 #include <server.h>\r
  37 #include <at.h>\r
  38 \r
  39 #include "s_common.h"\r
  40 #include "s_ss.h"\r
  41 \r
  42 #define NUM_TYPE_INTERNATIONAL          0x01\r
  43 #define NUM_PLAN_ISDN                               0x01\r
  44 \r
  45 //To avoid sending multiple response to application\r
  46 static gboolean UssdResp = FALSE;\r
  47 \r
  48 enum  telephony_ss_opcode\r
  49 {\r
  50         SS_OPCO_REG=0x01,         /* 0x01 : Registration */\r
  51         SS_OPCO_DEREG,            /* 0x02 : De-registration(erase) */\r
  52         SS_OPCO_ACTIVATE,         /* 0x03 : Activation */\r
  53         SS_OPCO_DEACTIVATE,       /* 0x04 : De-activation */\r
  54         SS_OPCO_MAX\r
  55 };\r
  56 \r
  57 struct ss_confirm_info\r
  58 {\r
  59         enum telephony_ss_class class;\r
  60         int  flavor_type;\r
  61         enum tcore_response_command resp;\r
  62         void *data;\r
  63         int  data_len;\r
  64 };\r
  65 \r
  66 static gboolean _ss_request_message(TcorePending *pending,\r
  67                                     CoreObject *o,\r
  68                                     UserRequest *ur,\r
  69                                     void* on_resp,\r
  70                                     void* user_data);\r
  71 \r
  72 static TReturn _ss_barring_get(CoreObject *o,\r
  73                                                                 UserRequest *ur,\r
  74                                                                 enum telephony_ss_class class,\r
  75                                                                 enum telephony_ss_barring_mode type,\r
  76                                                                 enum tcore_response_command resp);\r
  77 \r
  78 static TReturn _ss_forwarding_get(CoreObject *o,\r
  79                                                                         UserRequest *ur,\r
  80                                                                         enum telephony_ss_class class,\r
  81                                                                         enum telephony_ss_forwarding_mode type,\r
  82                                                                         enum tcore_response_command resp);\r
  83 \r
  84 static TReturn _ss_waiting_get(CoreObject *o,\r
  85                                                                 UserRequest *ur,\r
  86                                                                 enum telephony_ss_class class,\r
  87                                                                 enum tcore_response_command resp);\r
  88 \r
  89 static TReturn s_ss_barring_activate(CoreObject *o, UserRequest *ur);\r
  90 static TReturn s_ss_barring_deactivate(CoreObject *o, UserRequest *ur);\r
  91 static TReturn s_ss_barring_change_password(CoreObject *o, UserRequest *ur);\r
  92 static TReturn s_ss_barring_get_status(CoreObject *o, UserRequest *ur);\r
  93 \r
  94 static TReturn s_ss_forwarding_activate(CoreObject *o, UserRequest *ur);\r
  95 static TReturn s_ss_forwarding_deactivate(CoreObject *o, UserRequest *ur);\r
  96 static TReturn s_ss_forwarding_register(CoreObject *o, UserRequest *ur);\r
  97 static TReturn s_ss_forwarding_deregister(CoreObject *o, UserRequest *ur);\r
  98 static TReturn s_ss_forwarding_get_status(CoreObject *o, UserRequest *ur);\r
  99 \r
 100 static TReturn s_ss_waiting_activate(CoreObject *o, UserRequest *ur);\r
 101 static TReturn s_ss_waiting_deactivate(CoreObject *o, UserRequest *ur);\r
 102 static TReturn s_ss_waiting_get_status(CoreObject *o, UserRequest *ur);\r
 103 \r
 104 static TReturn s_ss_cli_activate(CoreObject *o, UserRequest *ur);\r
 105 static TReturn s_ss_cli_deactivate(CoreObject *o, UserRequest *ur);\r
 106 static TReturn s_ss_cli_get_status(CoreObject *o, UserRequest *ur);\r
 107 \r
 108 static TReturn s_ss_send_ussd(CoreObject *o, UserRequest *ur);\r
 109 \r
 110 static TReturn s_ss_set_aoc(CoreObject *o, UserRequest *ur);\r
 111 static TReturn s_ss_get_aoc(CoreObject *o, UserRequest *ur);\r
 112 \r
 113 static TReturn  s_ss_manage_call_0_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data);\r
 114 static TReturn  s_ss_manage_call_1_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data);\r
 115 static TReturn  s_ss_manage_call_1x_send(CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data);\r
 116 static TReturn  s_ss_manage_call_2_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data);\r
 117 static TReturn  s_ss_manage_call_2x_send(CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data);\r
 118 static TReturn  s_ss_manage_call_3_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data);\r
 119 static TReturn  s_ss_manage_call_4_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data);\r
 120 static TReturn  s_ss_manage_call_4dn_send(CoreObject* o, UserRequest* ur, const char* number, ConfirmCallback cb, void* user_data);\r
 121 \r
 122 static void on_confirmation_ss_message_send(TcorePending *p, gboolean result, void *user_data);\r
 123 \r
 124 static void _ss_ussd_response(UserRequest *ur, const char* ussd_str, enum telephony_ss_ussd_type type, enum telephony_ss_ussd_status status);\r
 125 static void _ss_ussd_notification(TcorePlugin *p, const char* ussd_str, enum telephony_ss_ussd_status status);\r
 126 \r
 127 static gboolean on_notification_ss_info(CoreObject *o, const void *data, void *user_data);\r
 128 static gboolean on_notification_ss_ussd(CoreObject *o, const void *data, void *user_data);\r
 129 \r
 130 \r
 131 static gboolean _ss_request_message(TcorePending *pending,\r
 132                                                                                 CoreObject *o,\r
 133                                                                                 UserRequest *ur,\r
 134                                                                                 void* on_resp,\r
 135                                                                                 void* user_data)\r
 136 {\r
 137         TcoreHal *hal = NULL;\r
 138         TReturn ret;\r
 139         dbg("Entry");\r
 140 \r
 141         if (on_resp) {\r
 142                 tcore_pending_set_response_callback(pending, on_resp, user_data);\r
 143         }\r
 144         tcore_pending_set_send_callback(pending, on_confirmation_ss_message_send, NULL);\r
 145         if (ur) {\r
 146                 tcore_pending_link_user_request(pending, ur);\r
 147         }\r
 148         else {\r
 149                 err("User Request is NULL, is this internal request??");\r
 150         }\r
 151         // HAL\r
 152         hal = tcore_object_get_hal(o);\r
 153 \r
 154         // Send request to HAL\r
 155         ret = tcore_hal_send_request(hal, pending);\r
 156         if(TCORE_RETURN_SUCCESS != ret) {\r
 157                 err("Request send failed");\r
 158                 return FALSE;\r
 159         }\r
 160 \r
 161         dbg("Exit");\r
 162         return TRUE;\r
 163 }\r
 164 \r
 165 static void _ss_ussd_response(UserRequest *ur, const char* ussd_str, enum telephony_ss_ussd_type type, enum telephony_ss_ussd_status status)\r
 166 {\r
 167         struct tresp_ss_ussd resp;\r
 168         dbg("Entry");\r
 169 \r
 170         if (ur) {\r
 171                 memset (&resp, 0x0, sizeof(struct tresp_ss_ussd));\r
 172                 resp.type = type;\r
 173                 resp.status = status;\r
 174                 resp.err = FALSE;\r
 175         dbg("ussd_str = %s resp.type - %d resp.status - %d",ussd_str ,resp.type,resp.status);\r
 176 \r
 177                 if (ussd_str) {\r
 178                         int len = strlen(ussd_str);\r
 179                 if (len < MAX_SS_USSD_LEN) {\r
 180                                 memcpy(resp.str, ussd_str, len);\r
 181                                 resp.str[len] = '\0';\r
 182                         }\r
 183                         else {\r
 184                                 memcpy(resp.str, ussd_str, MAX_SS_USSD_LEN);\r
 185                                 resp.str[MAX_SS_USSD_LEN - 1] = '\0';\r
 186                         }\r
 187                         dbg("Response string: %s", resp.str);\r
 188                 }\r
 189                 else {\r
 190                         dbg("USSD string is not present");\r
 191                         memset(resp.str, '\0', MAX_SS_USSD_LEN);\r
 192                 }\r
 193          UssdResp = TRUE;\r
 194                 // Send response to TAPI\r
 195                 tcore_user_request_send_response(ur, TRESP_SS_SEND_USSD, sizeof(struct tresp_ss_ussd), &resp);\r
 196         }\r
 197         else {\r
 198                 err("User request is NULL");\r
 199         }\r
 200 \r
 201         dbg("Exit");\r
 202         return;\r
 203 }\r
 204 \r
 205 static void _ss_ussd_notification(TcorePlugin *p, const char* ussd_str, enum telephony_ss_ussd_status status)\r
 206 {\r
 207         CoreObject *core_obj = 0;\r
 208         struct tnoti_ss_ussd noti;\r
 209 \r
 210         dbg("function enter");\r
 211         if (!p) {\r
 212                 dbg("[ error ] p : (NULL)");\r
 213                 return ;\r
 214         }\r
 215         noti.status = status;\r
 216         if (ussd_str) {\r
 217 \r
 218                 int len = strlen(ussd_str);\r
 219                 if (len < MAX_SS_USSD_LEN) {\r
 220                         memcpy(noti.str, ussd_str, len);\r
 221                         noti.str[ len ] = '\0';\r
 222                 }\r
 223         else {\r
 224                         memcpy(noti.str, ussd_str, MAX_SS_USSD_LEN);\r
 225                         noti.str[ MAX_SS_USSD_LEN - 1 ] = '\0';\r
 226                 }\r
 227 \r
 228         }\r
 229     else {\r
 230                 memset(noti.str, '\0', MAX_SS_USSD_LEN);\r
 231         }\r
 232     dbg("noti.str - %s", noti.str);\r
 233 \r
 234         core_obj = tcore_plugin_ref_core_object(p, "ss");\r
 235         tcore_server_send_notification(tcore_plugin_ref_server(p),\r
 236                         core_obj,\r
 237                         TNOTI_SS_USSD,\r
 238                         sizeof(struct tnoti_ss_ussd),\r
 239                         (void*)&noti);\r
 240 \r
 241 }\r
 242 \r
 243 static gboolean on_notification_ss_ussd(CoreObject *o, const void *data, void *user_data)\r
 244 {\r
 245     enum telephony_ss_ussd_status status;\r
 246         UssdSession *ussd_session = 0;\r
 247         char *ussd_str = 0, *cmd = 0;\r
 248         TcorePlugin *plugin = 0;\r
 249         int m = -1, dcs = 0;\r
 250     char *ussdnoti= NULL, *str = NULL, *dcs_str = NULL;\r
 251     GSList *tokens = NULL;\r
 252     GSList *lines = NULL;\r
 253     char *ussd_string = NULL;\r
 254     unsigned int len;\r
 255 \r
 256         plugin = tcore_object_ref_plugin(o);\r
 257         ussd_session = tcore_ss_ussd_get_session(o);\r
 258 \r
 259     dbg("function enter");\r
 260         lines = (GSList*)data;\r
 261         if (1 != g_slist_length(lines)) {\r
 262                 dbg("unsolicited msg but multiple line");\r
 263                 goto OUT;\r
 264         }\r
 265         cmd = (char*)(lines->data);\r
 266         // parse ussd status\r
 267     tokens = tcore_at_tok_new(cmd);\r
 268 \r
 269     // parse <m>\r
 270     ussdnoti = g_slist_nth_data(tokens, 0);\r
 271     if(!ussdnoti) {\r
 272         dbg("+CUSD<m> is missing from %CUSD Notification");\r
 273 \r
 274     }\r
 275     else {\r
 276 \r
 277         m  = atoi(ussdnoti);\r
 278         dbg("USSD status  %d",m);\r
 279         //parse [ <str>, <dcs>]\r
 280         ussd_string = g_slist_nth_data(tokens, 1);\r
 281         if(ussd_string) {\r
 282 \r
 283             /* Strike off starting & ending quotes. 1 extra character for NULL termination */\r
 284             str = malloc(strlen(ussd_string) - 1);\r
 285             dbg("length of Ussd Stirng - %d", strlen(ussd_string));\r
 286             if(str) {\r
 287                 memset(str, 0x00, strlen(ussd_string) - 1);\r
 288             }\r
 289             else {\r
 290                 dbg("malloc failed")\r
 291                 return FALSE;\r
 292             }\r
 293             len  = strlen(ussd_string)-1;\r
 294             ++ussd_string;\r
 295             strncpy(str, ussd_string, len);\r
 296 \r
 297             dbg("USSD String - %s len = %d",str,strlen(str));\r
 298      }\r
 299      if((dcs_str = g_slist_nth_data(tokens, 2))) {\r
 300             dcs = atoi(dcs_str);\r
 301             dbg("USSD dcs %d",dcs);\r
 302       }\r
 303    }\r
 304 \r
 305         switch(m) {\r
 306 \r
 307                 case 0:\r
 308                         status = SS_USSD_NO_ACTION_REQUIRE;\r
 309                 break;\r
 310 \r
 311                 case 1:\r
 312                         status = SS_USSD_ACTION_REQUIRE;\r
 313                 break;\r
 314 \r
 315                 case 2:\r
 316                         status = SS_USSD_TERMINATED_BY_NET;\r
 317                 break;\r
 318 \r
 319                 case 3:\r
 320                         status = SS_USSD_OTHER_CLIENT;\r
 321                 break;\r
 322 \r
 323                 case 4:\r
 324                         status = SS_USSD_NOT_SUPPORT;\r
 325                 break;\r
 326 \r
 327                 case 5:\r
 328                         status = SS_USSD_TIME_OUT;\r
 329                 break;\r
 330 \r
 331                 default:\r
 332                         dbg("unsupported m : %d", m);\r
 333                         status = SS_USSD_MAX;\r
 334                 break;\r
 335         }\r
 336 \r
 337     switch (tcore_util_get_cbs_coding_scheme(dcs)) {\r
 338 \r
 339         case TCORE_DCS_TYPE_7_BIT:\r
 340         case TCORE_DCS_TYPE_UNSPECIFIED:\r
 341                 //ussd_str = tcore_util_unpack_gsm7bit(str, strlen(str));\r
 342          //break;\r
 343 \r
 344         case TCORE_DCS_TYPE_UCS2:\r
 345         case TCORE_DCS_TYPE_8_BIT:\r
 346             if ( (str != NULL ) && (strlen(str)  > 0))\r
 347             {\r
 348                         ussd_str = g_new0(char, strlen(str)  + 1);\r
 349                         if(ussd_str != NULL){\r
 350                                     memcpy(ussd_str,str, strlen(str));\r
 351                                     ussd_str[ strlen(str) ] = '\0';\r
 352                 }\r
 353                 }\r
 354         break;\r
 355         default:\r
 356           dbg("[ error ] unknown dcs type. ussd_session : %x", ussd_session);\r
 357           if (ussd_session) {\r
 358 \r
 359                 UserRequest *ur = 0;\r
 360                 enum telephony_ss_ussd_type type;\r
 361 \r
 362                 tcore_ss_ussd_get_session_data(ussd_session, (void**)&ur);\r
 363                 if (!ur) {\r
 364 \r
 365                     dbg("[ error ] ur : (0)");\r
 366                     return  FALSE;\r
 367                 }\r
 368 \r
 369                 type = (enum telephony_ss_ussd_type)tcore_ss_ussd_get_session_type(ussd_session);\r
 370                 dbg("ussd type  - %d", type);\r
 371 \r
 372                 _ss_ussd_response(ur, ussd_str, type, status);\r
 373           }\r
 374           return FALSE;\r
 375     }\r
 376 \r
 377     switch (status) {\r
 378 \r
 379         case SS_USSD_NO_ACTION_REQUIRE:\r
 380         case SS_USSD_ACTION_REQUIRE:\r
 381         case SS_USSD_OTHER_CLIENT:\r
 382         case SS_USSD_NOT_SUPPORT:\r
 383         case SS_USSD_TIME_OUT:\r
 384         {\r
 385                 if (ussd_session) {\r
 386 \r
 387                         UserRequest *ur = 0;\r
 388                         enum telephony_ss_ussd_type type;\r
 389 \r
 390                         tcore_ss_ussd_get_session_data(ussd_session, (void**)&ur);\r
 391                         if (!ur) {\r
 392                                 dbg("[ error ] ur : (0)");\r
 393                                 return FALSE;\r
 394                         }\r
 395                         type = (enum telephony_ss_ussd_type)tcore_ss_ussd_get_session_type(ussd_session);\r
 396                 dbg("ussd type  - %d", type);\r
 397                         _ss_ussd_response(ur, (const char*)ussd_str, type, status);\r
 398                 if(ussd_str)\r
 399                             g_free(ussd_str);\r
 400                 }\r
 401             else {\r
 402                         tcore_ss_ussd_create_session(o, TCORE_SS_USSD_TYPE_NETWORK_INITIATED, 0, 0);\r
 403                         _ss_ussd_notification(plugin, (const char*)ussd_str, status);\r
 404 \r
 405                  if(ussd_str)\r
 406                             g_free(ussd_str);\r
 407                     }\r
 408             }\r
 409         break;\r
 410             case SS_USSD_TERMINATED_BY_NET:\r
 411         {\r
 412                 if (ussd_session){\r
 413                         UserRequest *ur = 0;\r
 414                         tcore_ss_ussd_get_session_data(ussd_session, (void**)&ur);\r
 415                         if (ur) {\r
 416                     tcore_user_request_unref(ur);\r
 417                         }\r
 418                         tcore_ss_ussd_destroy_session(ussd_session);\r
 419                 }\r
 420             }\r
 421         break;\r
 422 \r
 423             default:\r
 424             break;\r
 425     }\r
 426 \r
 427 OUT:\r
 428         if(NULL!=tokens)\r
 429                 tcore_at_tok_free(tokens);\r
 430 \r
 431     if(NULL != str)\r
 432         free(str);\r
 433     dbg("Exit");\r
 434         return TRUE;\r
 435 \r
 436 }\r
 437 static gboolean on_notification_ss_info(CoreObject *o, const void *data, void *user_data)\r
 438 {\r
 439         TcorePlugin *plugin  = 0;\r
 440         CoreObject *co = 0;\r
 441         char* cmd = 0, *number = 0, *pos;\r
 442         int code1 = -1, code2 = -1, index = 0, ton = 0;\r
 443     char *str_code1, *str_code2, *str_ton ,*str_index;\r
 444     GSList *tokens = NULL;\r
 445     char *buf;\r
 446     gboolean cssu = FALSE,cssi = FALSE;\r
 447     GSList *lines = NULL;\r
 448         char *resp = NULL;
 449     dbg("function enter");\r
 450 \r
 451         plugin  = tcore_object_ref_plugin(o);\r
 452         co      = tcore_plugin_ref_core_object(plugin, "call");\r
 453         if (!co) {\r
 454 \r
 455                 dbg("[ error ] plugin_ref_core_object : call");\r
 456                 return FALSE;\r
 457         }\r
 458 \r
 459         lines = (GSList*)data;\r
 460         if (1 != g_slist_length(lines)) {\r
 461                 dbg("unsolicited msg but multiple line");\r
 462                 goto OUT;\r
 463         }\r
 464 \r
 465         cmd = (char*)(lines->data);\r
 466     pos = strchr(cmd, ':');\r
 467     if(!pos){\r
 468         dbg("[ error ] not valid SS- notification ");\r
 469                 return TRUE;\r
 470     }\r
 471     buf = calloc(pos - cmd + 2, 1);\r
 472         memcpy(buf, cmd, pos - cmd);\r
 473     dbg("buf is %s", buf);\r
 474 \r
 475     if(!strcmp(buf,"+CSSU")){\r
 476 \r
 477         dbg("SS - +CSSU indication");\r
 478         cssu = TRUE;\r
 479     }\r
 480     else if(!strcmp(buf,"+CSSI")) {\r
 481 \r
 482         dbg("SS - +CSSI indication");\r
 483         cssi = TRUE;\r
 484     }\r
 485     free(buf);\r
 486 \r
 487    //handle %CSSU notification\r
 488     if(cssu){\r
 489 \r
 490         tokens = tcore_at_tok_new(cmd);\r
 491         // parse <code2>\r
 492         str_code2 = g_slist_nth_data(tokens, 0);\r
 493         if(!str_code2) {\r
 494             dbg("Code2 is missing from %CSSU indiaction");\r
 495         }\r
 496         else {\r
 497 \r
 498             code2  = atoi(str_code2);\r
 499             //parse [ <index>, <number> <type>]\r
 500             if ((str_index = g_slist_nth_data(tokens, 1))) {\r
 501                 index = atoi(str_index);\r
 502             }\r
 503
 504             if ((resp = g_slist_nth_data(tokens, 2))) {
 505                                 // Strike off double quotes
 506                                 number = util_removeQuotes(resp);
 507                 str_ton = g_slist_nth_data(tokens, 3);\r
 508 \r
 509                 if(str_ton) {\r
 510                    ton = atoi(str_ton);\r
 511                 }\r
 512              }\r
 513         }\r
 514 \r
 515         dbg("CSSU - code2 = %d index = %d number = %s type = %d", code2, index, number, ton);\r
 516         switch(code2) {\r
 517 \r
 518                 case 0:  //this is a forwarded call (MT call setup)\r
 519                         tcore_call_information_mt_forwarded_call(co, number);\r
 520                 break;\r
 521 \r
 522                 case 2: //call has been put on hold (during a voice call)\r
 523                         tcore_call_information_held(co, number);\r
 524                 break;\r
 525 \r
 526                 case 3: //call has been retrieved (during a voice call)\r
 527                         tcore_call_information_active(co, number);\r
 528                 break;\r
 529 \r
 530                 case 4: //multiparty call entered (during a voice call)\r
 531                         tcore_call_information_joined(co, number);\r
 532                 break;\r
 533 \r
 534                 case 5: //call on hold has been released\r
 535                         tcore_call_information_released_on_hold(co, number);\r
 536                 break;\r
 537 \r
 538                 case 6: //forward check SS message received (can be received whenever)\r
 539                         tcore_call_information_cf_check_ss_message(co, number);\r
 540                 break;\r
 541 \r
 542                 case 7: //call is being connected (alerting) with the remote party in alerting state in explicit call transfer operation (during a voice call)\r
 543                         tcore_call_information_transfer_alert(co, number);\r
 544                 break;\r
 545 \r
 546                 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)\r
 547                         tcore_call_information_transfered(co, number);\r
 548                 break;\r
 549 \r
 550                 case 9: //this is a deflected call (MT call setup):\r
 551                         tcore_call_information_mt_deflected_call(co, number);\r
 552                 break;\r
 553 \r
 554                 default:\r
 555                         dbg("CSSU - unsupported code2 : %d",code2);\r
 556                 break;\r
 557         }\r
 558     }\r
 559     //handle %CSSI notification\r
 560 \r
 561     if(cssi) {\r
 562 \r
 563         tokens = tcore_at_tok_new(cmd);\r
 564         // parse <code1>\r
 565         str_code1 = g_slist_nth_data(tokens, 0);\r
 566         if(!str_code1){\r
 567             dbg("Code1 is missing from %CSSI indiaction");\r
 568         }\r
 569         else {\r
 570             code1  = atoi(str_code1);\r
 571             //parse [ <index> ]\r
 572             if ((str_index = g_slist_nth_data(tokens, 1))) {\r
 573                 index = atoi(str_index);\r
 574             }\r
 575 \r
 576         }\r
 577 \r
 578         dbg("CSSI - code1 - %d index - %d ", code1, index);\r
 579 \r
 580         switch(code1) {\r
 581 \r
 582                 case 0:  //Unconditional CF is active\r
 583                         tcore_call_information_mo_cfu(co);\r
 584                 break;\r
 585 \r
 586             case 1:     //some of the conditional call forwarding are active\r
 587                 tcore_call_information_mo_cfc(co);\r
 588             break;\r
 589 \r
 590                 case 2:    // outgoing call is forwarded\r
 591                             tcore_call_information_mo_forwarded(co);\r
 592                 break;\r
 593 \r
 594                 case 3:     // this call is waiting\r
 595                             tcore_call_information_mo_waiting(co);\r
 596                 break;\r
 597 \r
 598                 case 5:     // outgoing call is barred\r
 599                             tcore_call_information_mo_barred_outgoing(co);\r
 600                 break;\r
 601 \r
 602                 case 6:     // incoming call is barred\r
 603                         tcore_call_information_mo_barred_incoming(co);\r
 604                 break;\r
 605 \r
 606                 case 7:     // CLIR suppression rejected\r
 607                             tcore_call_information_mo_clir_suppression_reject(co);\r
 608                 break;\r
 609 \r
 610                 case 8:     // outgoing call is deflected\r
 611                             tcore_call_information_mo_deflected(co);\r
 612                 break;\r
 613 \r
 614                 default:\r
 615                         dbg("unsupported cmd : %d",code1);\r
 616                 break;\r
 617         }\r
 618     }\r
 619 OUT:\r
 620         if(NULL!=tokens)\r
 621                 tcore_at_tok_free(tokens);\r
 622     if(NULL!=number)
 623         g_free(number);
 624         return TRUE;\r
 625 }\r
 626 \r
 627 static void on_confirmation_ss_message_send(TcorePending *p, gboolean result, void *user_data)\r
 628 {\r
 629         dbg("");\r
 630 \r
 631         if (result == FALSE) {\r
 632                 // Fail\r
 633                 dbg("FAIL");\r
 634         }\r
 635         else {\r
 636                 dbg("SEND OK");\r
 637         }\r
 638 }\r
 639 \r
 640 static void on_response_ss_barring_set(TcorePending *p, int data_len, const void *data, void *user_data)\r
 641 {\r
 642 \r
 643         struct ss_confirm_info *info = 0;\r
 644         enum telephony_ss_class class;\r
 645         CoreObject* o = 0;\r
 646         UserRequest *ur;\r
 647         struct tresp_ss_general resp;\r
 648         UserRequest *ur_dup=0;\r
 649         GSList *tokens=NULL;\r
 650         const char *line;\r
 651     int err;\r
 652     const TcoreATResponse* response;\r
 653 \r
 654     dbg("function enter");\r
 655     response = data;\r
 656         o  = tcore_pending_ref_core_object(p);\r
 657         ur = tcore_pending_ref_user_request(p);\r
 658 \r
 659         info = (struct ss_confirm_info*)user_data;\r
 660         class = info->class;\r
 661 \r
 662     if (response->success > 0){\r
 663         dbg("RESPONSE OK");\r
 664         resp.err = TCORE_RETURN_SUCCESS;\r
 665     }\r
 666     else {\r
 667 \r
 668         dbg("RESPONSE NOT OK");\r
 669         line = (const char*)response->final_response;\r
 670                 tokens = tcore_at_tok_new(line);\r
 671 \r
 672                 if (g_slist_length(tokens) < 1) {\r
 673 \r
 674                         dbg("err cause not specified or string corrupted");\r
 675                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
 676                 }\r
 677                 else {\r
 678                         err = atoi(g_slist_nth_data(tokens, 0));\r
 679                         // TODO: CMEE error mapping is required.\r
 680                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
 681                 }\r
 682         tcore_at_tok_free(tokens);\r
 683         }\r
 684 \r
 685     dbg("on_response_ss_barring_set - rsp.err : %d, ur : %x flavor_type = %d", resp.err, ur , info->flavor_type);\r
 686     dbg("[ check ] class : 0x%x", info->class);\r
 687 \r
 688     if (response->success > 0) {\r
 689 \r
 690                 if (info->class == SS_CLASS_VOICE) {\r
 691 \r
 692                     class = SS_CLASS_ALL_TELE_BEARER;\r
 693                 }\r
 694 \r
 695                 ur_dup = tcore_user_request_ref(ur);\r
 696 \r
 697                 if (info->flavor_type == SS_BARR_MODE_AB || info->flavor_type == SS_BARR_MODE_AOB) {\r
 698                         _ss_barring_get(o, ur_dup, class, SS_BARR_MODE_BAOC, info->resp);\r
 699                 }\r
 700                 else if (info->flavor_type == SS_BARR_MODE_AIB) {\r
 701                         _ss_barring_get(o, ur_dup, class, SS_BARR_MODE_BAIC, info->resp);\r
 702                 }\r
 703                 else {\r
 704                         _ss_barring_get(o, ur_dup, class, info->flavor_type, info->resp);\r
 705                 }\r
 706         }\r
 707         else {\r
 708                 if (ur) {\r
 709                         tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);\r
 710                 }\r
 711                 else  {\r
 712                         dbg("[ error ] ur is 0");\r
 713                 }\r
 714         }\r
 715 }\r
 716 \r
 717 static void on_response_ss_barring_change_pwd(TcorePending *p, int data_len, const void *data, void *user_data)\r
 718 {\r
 719     const TcoreATResponse* response = data;\r
 720     struct ss_confirm_info *info = 0;\r
 721         UserRequest *ur;\r
 722         struct tresp_ss_general resp;\r
 723     int err;\r
 724         GSList *tokens=NULL;\r
 725         const char *line;\r
 726 \r
 727     dbg("function enter");\r
 728         ur = tcore_pending_ref_user_request(p);\r
 729         info = (struct ss_confirm_info*)user_data;\r
 730 \r
 731     if (response->success > 0){\r
 732         dbg("RESPONSE OK");\r
 733         resp.err = TCORE_RETURN_SUCCESS;\r
 734     }\r
 735     else {\r
 736         dbg("RESPONSE NOT OK");\r
 737 \r
 738         line = (const char*)response->final_response;\r
 739                 tokens = tcore_at_tok_new(line);\r
 740 \r
 741                 if (g_slist_length(tokens) < 1) {\r
 742 \r
 743                         dbg("err cause not specified or string corrupted");\r
 744                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
 745                 }\r
 746                 else {\r
 747 \r
 748                     err = atoi(g_slist_nth_data(tokens, 0));\r
 749                         // TODO: CMEE error mapping is required.\r
 750                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
 751                 }\r
 752         tcore_at_tok_free(tokens);\r
 753         }\r
 754 \r
 755         dbg("on_response_ss_barring_change_pwd: rsp.err : %d, usr : %x", resp.err, ur);\r
 756         if (ur) {\r
 757                 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);\r
 758         }\r
 759         else {\r
 760                 dbg("[ error ] ur is 0");\r
 761         }\r
 762 \r
 763         g_free(user_data);\r
 764 }\r
 765 \r
 766 static void on_response_ss_forwarding_set(TcorePending *p, int data_len, const void *data, void *user_data)\r
 767 {\r
 768         CoreObject* o = 0;\r
 769         UserRequest* ur = 0, *dup_ur=0;\r
 770         struct ss_confirm_info *info = 0;\r
 771         struct tresp_ss_general resp;\r
 772         GSList *tokens=NULL;\r
 773         const char *line;\r
 774     int err;\r
 775     const TcoreATResponse* response;\r
 776 \r
 777     dbg("function enter");\r
 778 \r
 779     response  = data;\r
 780         o  = tcore_pending_ref_core_object(p);\r
 781         ur = tcore_pending_ref_user_request(p);\r
 782 \r
 783         info = (struct ss_confirm_info*)user_data;\r
 784 \r
 785     if (response->success > 0) {\r
 786 \r
 787         dbg("RESPONSE OK");\r
 788         resp.err = TCORE_RETURN_SUCCESS;\r
 789     }\r
 790     else {\r
 791 \r
 792         dbg("RESPONSE NOT OK");\r
 793 \r
 794         line = (const char*)response->final_response;\r
 795                 tokens = tcore_at_tok_new(line);\r
 796 \r
 797                 if (g_slist_length(tokens) < 1) {\r
 798                         dbg("err cause not specified or string corrupted");\r
 799                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
 800                 }\r
 801                 else {\r
 802                         err = atoi(g_slist_nth_data(tokens, 0));\r
 803                         /// TODO: CMEE error mapping is required.\r
 804                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
 805                 }\r
 806 \r
 807         tcore_at_tok_free(tokens);\r
 808         }\r
 809 \r
 810         dbg("[ check ] class : 0x%x", info->class);\r
 811         dbg("[ check ] flavor_type : 0x%x", info->flavor_type);\r
 812 \r
 813         dbg("on_response_ss_forwarding_set - rsp.err : %d, ur : %x", resp.err, ur);\r
 814 \r
 815         if (response->success > 0) {\r
 816 \r
 817                 if (info->flavor_type == SS_CF_MODE_CF_ALL ||\r
 818                          info->flavor_type == SS_CF_MODE_CFC)  {\r
 819 \r
 820                         if (ur) {\r
 821 \r
 822                                 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);\r
 823                         }\r
 824                         else {\r
 825 \r
 826                                 dbg("[ error ] ur is 0");\r
 827                         }\r
 828                 }\r
 829         else  {\r
 830                         dup_ur = tcore_user_request_ref(ur);\r
 831                         _ss_forwarding_get(o, dup_ur, info->class, info->flavor_type, info->resp);\r
 832                 }\r
 833         }\r
 834     else {\r
 835 \r
 836                 if(ur) {\r
 837                         tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);\r
 838                 }\r
 839                 else {\r
 840                         dbg("[ error ] ur is 0");\r
 841                 }\r
 842         }\r
 843         g_free(user_data);\r
 844 \r
 845 }\r
 846 \r
 847 static void on_response_ss_waiting_set(TcorePending *p, int data_len, const void *data, void *user_data)\r
 848 {\r
 849         CoreObject*     core_obj = 0;\r
 850         UserRequest* ur = 0;\r
 851         UserRequest* ur_dup = 0;\r
 852         struct ss_confirm_info *info = 0;\r
 853         struct tresp_ss_general resp;\r
 854         GSList *tokens = NULL;\r
 855         const char *line;\r
 856     int err;\r
 857     const TcoreATResponse* response;\r
 858 \r
 859     dbg("function enter");\r
 860     response = data;\r
 861         core_obj  = tcore_pending_ref_core_object(p);\r
 862         ur = tcore_pending_ref_user_request(p);\r
 863 \r
 864         info = (struct ss_confirm_info*)user_data;\r
 865 \r
 866         if(response->success > 0){\r
 867         dbg("RESPONSE OK");\r
 868         resp.err = TCORE_RETURN_SUCCESS;\r
 869     }\r
 870     else {\r
 871 \r
 872         dbg("RESPONSE NOT OK");\r
 873 \r
 874         line = (const char*)response->final_response;\r
 875                 tokens = tcore_at_tok_new(line);\r
 876 \r
 877                 if (g_slist_length(tokens) < 1) {\r
 878 \r
 879                         dbg("err cause not specified or string corrupted");\r
 880                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
 881                 }\r
 882                 else {\r
 883 \r
 884                         err = atoi(g_slist_nth_data(tokens, 0));\r
 885                         /// TODO: CMEE error mapping is required.\r
 886                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
 887                 }\r
 888         tcore_at_tok_free(tokens);\r
 889         }\r
 890 \r
 891         dbg("on_response_ss_waiting_set - rsp.err : %d, ur : %x, class : %d", resp.err, ur, info->class);\r
 892 \r
 893         if(resp.err == TCORE_RETURN_SUCCESS) {\r
 894 \r
 895                  ur_dup = tcore_user_request_ref(ur);\r
 896          dbg("Get waiting call status");\r
 897                 _ss_waiting_get(core_obj, ur_dup, info->class, info->resp);\r
 898         }\r
 899     else {\r
 900 \r
 901                 if (ur) {\r
 902 \r
 903                         tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_general), &resp);\r
 904                 }\r
 905                 else {\r
 906 \r
 907                         dbg("[ error ] ur is 0");\r
 908                  }\r
 909          }\r
 910          g_free(user_data);\r
 911 }\r
 912 \r
 913 \r
 914 static void on_confirmation_ss_ussd(TcorePending *p, int data_len, const void *data, void *user_data)\r
 915 {\r
 916     CoreObject* core_obj = 0;\r
 917         struct ss_confirm_info *info = 0;\r
 918         struct tresp_ss_ussd resp;\r
 919         UserRequest* ur = NULL , *ussd_ur= NULL;\r
 920         GSList *tokens = NULL;\r
 921         const char *line;\r
 922         int err;\r
 923     UssdSession *ussd_s = NULL;\r
 924     enum tcore_ss_ussd_type type = TCORE_SS_USSD_TYPE_MAX;\r
 925     const TcoreATResponse* response;\r
 926 \r
 927     dbg("function enter");\r
 928     response = data;\r
 929         ur = tcore_pending_ref_user_request(p);\r
 930         info = (struct ss_confirm_info*)user_data;\r
 931 \r
 932     memset(resp.str, 0x00, MAX_SS_USSD_LEN);\r
 933 \r
 934         core_obj  = tcore_pending_ref_core_object(p);\r
 935         ussd_s = tcore_ss_ussd_get_session(core_obj);\r
 936 \r
 937         if(ussd_s)\r
 938                 type = tcore_ss_ussd_get_session_type(ussd_s);\r
 939         else\r
 940                 dbg("[ error ] ussd_s : (0)");\r
 941 \r
 942         resp.type = (enum telephony_ss_ussd_type)type;\r
 943     resp.status = SS_USSD_MAX; //hardcoded value.\r
 944 \r
 945         if(response->success > 0) {\r
 946 \r
 947         dbg("RESPONSE OK");\r
 948         resp.err = TCORE_RETURN_SUCCESS;\r
 949     }\r
 950     else {\r
 951 \r
 952         dbg("RESPONSE NOT OK");\r
 953 \r
 954         line = (const char*)response->final_response;\r
 955                 tokens = tcore_at_tok_new(line);\r
 956 \r
 957                 if (g_slist_length(tokens) < 1) {\r
 958 \r
 959                         dbg("err cause not specified or string corrupted");\r
 960                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
 961                 }\r
 962                 else {\r
 963 \r
 964                         err = atoi(g_slist_nth_data(tokens, 0));\r
 965                         // TODO: CMEE error mapping is required.\r
 966                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
 967                 }\r
 968         tcore_at_tok_free(tokens);\r
 969      }\r
 970 \r
 971         dbg("on_confirmation_ss_ussd - rsp.err : %d, ur : %x", resp.err, ur);\r
 972 \r
 973         if(response->success > 0) {\r
 974 \r
 975             if(type == TCORE_SS_USSD_TYPE_USER_INITIATED) {\r
 976             dbg("ussd type %d",resp.type);\r
 977 \r
 978             if(ussd_s) {\r
 979                             tcore_ss_ussd_get_session_data(ussd_s, (void**)&ussd_ur);\r
 980                             if(ussd_ur)\r
 981                     tcore_user_request_free(ussd_ur);\r
 982             }\r
 983                 }\r
 984          }\r
 985 \r
 986     if(ussd_s)\r
 987         tcore_ss_ussd_destroy_session(ussd_s);\r
 988 \r
 989         if(ur) {\r
 990 \r
 991         if(UssdResp == FALSE){  // to avoid sending multiple response to application.\r
 992                     tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_ussd), &resp);\r
 993         }\r
 994         UssdResp =  FALSE;\r
 995         }\r
 996         else\r
 997                 dbg("[ error ] ur : (0)");\r
 998 \r
 999         g_free(user_data);\r
1000 \r
1001 }\r
1002 \r
1003 static void on_response_ss_barring_get(TcorePending *p, int data_len, const void *data, void *user_data)\r
1004 {\r
1005 \r
1006         UserRequest* ur = 0;\r
1007         int status = 0, classx = 0, err = 0;\r
1008     GSList *respdata;\r
1009         struct ss_confirm_info* info = 0;\r
1010         struct tresp_ss_barring resp;\r
1011         int countRecords = 0, countValidRecords = 0;\r
1012         GSList *tokens = NULL;\r
1013         const char *line;\r
1014     char *classx_str;\r
1015     char *stat = NULL;\r
1016     const TcoreATResponse *response;\r
1017 \r
1018     dbg("function enter");\r
1019 \r
1020     response = data;\r
1021         ur = tcore_pending_ref_user_request(p);\r
1022         info = (struct ss_confirm_info*)user_data;\r
1023 \r
1024     if(response->lines) {\r
1025         respdata = (GSList *)response->lines;\r
1026         countRecords = g_slist_length(respdata);\r
1027         dbg("total records : %d",countRecords);\r
1028 \r
1029     }\r
1030     else {\r
1031 \r
1032         countRecords  = 0;\r
1033         dbg("no active status - return to user")\r
1034     }\r
1035     resp.record_num = countRecords;\r
1036 \r
1037     if(resp.record_num > 0) {\r
1038 \r
1039                 resp.record = g_new0(struct barring_info, resp.record_num);\r
1040                 for (countValidRecords = 0; respdata != NULL ; respdata = respdata->next) {\r
1041 \r
1042             line  = (const char*)(respdata->data);\r
1043             tokens = tcore_at_tok_new(line);\r
1044 \r
1045            // parse <status>\r
1046             stat = g_slist_nth_data(tokens, 0);\r
1047             if(!stat) {\r
1048 \r
1049                 dbg("Stat is missing");\r
1050                                 goto error;\r
1051             }\r
1052 \r
1053                     status = atoi(stat);\r
1054                         if(status == 1) {\r
1055 \r
1056                                 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;\r
1057                         }\r
1058                         else {\r
1059 \r
1060                                 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;\r
1061                         }\r
1062             dbg("call barring status - %d",status);\r
1063 \r
1064            //Parse <class>\r
1065             classx_str = g_slist_nth_data(tokens, 1);\r
1066 \r
1067                 if (!classx_str) {\r
1068 \r
1069                                 dbg("class error. classx not exist - set to requested one : %d", info->class);\r
1070                                 switch(info->class) {\r
1071 \r
1072                                 case SS_CLASS_ALL_TELE:\r
1073                                         classx = 7;\r
1074                                 break;\r
1075                                 case SS_CLASS_VOICE:\r
1076                                         classx = 1;\r
1077                                 break;\r
1078                                 case SS_CLASS_ALL_DATA_TELE:\r
1079                                         classx =2;\r
1080                                 break;\r
1081                                 case SS_CLASS_FAX:\r
1082                                         classx = 4;\r
1083                                 break;\r
1084                                 case SS_CLASS_SMS:\r
1085                                         classx = 8;\r
1086                                 break;\r
1087                                 case SS_CLASS_ALL_CS_SYNC:\r
1088                                         classx = 16;\r
1089                                 break;\r
1090 \r
1091                                 default:\r
1092                                         classx =7;\r
1093                                         dbg("unsupported class %d. set to default : 7", info->class);\r
1094                                 break;\r
1095                                 }\r
1096                         }\r
1097             else {\r
1098                 classx = atoi(classx_str);\r
1099                 dbg("call barring classx - %d",classx);\r
1100             }\r
1101 \r
1102                         switch(classx) {\r
1103 \r
1104                                 case 1:\r
1105                                         resp.record[countValidRecords].class = SS_CLASS_VOICE;\r
1106                                 break;\r
1107                                 case 2:\r
1108                                         resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;\r
1109                                 break;\r
1110                                 case 4:\r
1111                                         resp.record[countValidRecords].class = SS_CLASS_FAX;\r
1112                                 break;\r
1113                                 case 7:\r
1114                                         resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;\r
1115                                 break;\r
1116                                 case 8:\r
1117                                         resp.record[countValidRecords].class = SS_CLASS_SMS;\r
1118                                 break;\r
1119                                 case 16:\r
1120                                         resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;\r
1121                                 break;\r
1122                                 case 32:\r
1123                                         resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;\r
1124                                 break;\r
1125                                 default:\r
1126                                         dbg("unspoorted class : [%d]\n", classx);\r
1127                                         goto error;\r
1128                                 break;\r
1129                         }\r
1130                         resp.record[countValidRecords].mode = (enum telephony_ss_barring_mode)(info->flavor_type);\r
1131                         countValidRecords++;\r
1132             tcore_at_tok_free(tokens);\r
1133                         continue;\r
1134 \r
1135         error:\r
1136                         dbg("invalid field found. coutinue");\r
1137             tcore_at_tok_free(tokens);\r
1138                         continue;\r
1139                 }\r
1140 \r
1141                 dbg("valid count :%d",countValidRecords);\r
1142                 resp.record_num = countValidRecords;\r
1143                 resp.err = TCORE_RETURN_SUCCESS;\r
1144         }\r
1145     else {\r
1146 \r
1147                 dbg("no active status - return to user")\r
1148         }\r
1149 \r
1150     if(response->success > 0) {\r
1151 \r
1152         dbg("RESPONSE OK");\r
1153         resp.err = TCORE_RETURN_SUCCESS;\r
1154     }\r
1155     else {\r
1156 \r
1157         dbg("RESPONSE NOT OK");\r
1158         resp.err = TCORE_RETURN_FAILURE;\r
1159 \r
1160         line = (const char*)response->final_response;\r
1161                 tokens = tcore_at_tok_new(line);\r
1162 \r
1163                 if (g_slist_length(tokens) < 1) {\r
1164 \r
1165                         dbg("err cause not specified or string corrupted");\r
1166                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
1167                 }\r
1168                 else {\r
1169 \r
1170                         err = atoi(g_slist_nth_data(tokens, 0));\r
1171                         // TODO: CMEE error mapping is required.\r
1172                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
1173                 }\r
1174         tcore_at_tok_free(tokens);\r
1175     }\r
1176 \r
1177         dbg("on_response_ss_barring_get- rsp.err : %d, ur : %x", resp.err, ur);\r
1178 \r
1179     if (ur)\r
1180                 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_barring), &resp);\r
1181         else\r
1182                 dbg("[ error ] ur is 0");\r
1183 \r
1184         if (resp.record) {\r
1185 \r
1186                 g_free(resp.record);\r
1187         resp.record = NULL;\r
1188         }\r
1189 \r
1190         g_free(user_data);\r
1191 \r
1192 }\r
1193 \r
1194 static void on_response_ss_forwarding_get(TcorePending *p, int data_len, const void *data, void *user_data)\r
1195 {\r
1196         UserRequest* ur = 0;\r
1197     int classx = 0, err = 0, time = 0;\r
1198         char* num;\r
1199         struct ss_confirm_info* info = 0;\r
1200         struct tresp_ss_forwarding resp;\r
1201         int countRecords = 0, countValidRecords = 0;\r
1202 \r
1203     GSList *respdata = NULL ,*tokens = NULL ;\r
1204         const char *line;\r
1205     char *classx_str ,*status, *ton, *time_str;\r
1206     const TcoreATResponse *response;\r
1207 \r
1208     dbg("function enter");\r
1209     response = data;\r
1210 \r
1211         ur = tcore_pending_ref_user_request(p);\r
1212     info = (struct ss_confirm_info*)user_data;\r
1213     if(response->lines) {\r
1214 \r
1215         respdata =  (GSList*)response->lines;\r
1216         countRecords = g_slist_length(respdata);\r
1217         dbg("total records : %d",countRecords);\r
1218 \r
1219     }\r
1220     else {\r
1221         countRecords  = 0;\r
1222         dbg("no active status - return to user")\r
1223     }\r
1224     resp.record_num = countRecords;\r
1225 \r
1226     if (resp.record_num > 0) {\r
1227 \r
1228                 resp.record = g_new0(struct forwarding_info, resp.record_num);\r
1229 \r
1230                 for (countValidRecords = 0; respdata != NULL ; respdata = respdata->next) {\r
1231 \r
1232            line  = (const char*)(respdata->data);\r
1233            tokens = tcore_at_tok_new(line);\r
1234 \r
1235            // parse <status>\r
1236             status = g_slist_nth_data(tokens, 0);\r
1237             if(!status) {\r
1238 \r
1239                 dbg("start line error. skip this line");\r
1240                                 goto error;\r
1241             }\r
1242             else {\r
1243 \r
1244                         if(atoi(status)== 1) {\r
1245                                 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;\r
1246                         }\r
1247                         else {\r
1248                                 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;\r
1249                         }\r
1250              }\r
1251 \r
1252                     //Parse <class>\r
1253             classx_str = g_slist_nth_data(tokens, 1);\r
1254                 if (!classx_str) {\r
1255                                 dbg("class error. skip this line");\r
1256                                 goto error;\r
1257                         }\r
1258             else {\r
1259 \r
1260                 switch(atoi(classx_str)) {\r
1261                                 case 1:\r
1262                                         resp.record[countValidRecords].class = SS_CLASS_VOICE;\r
1263                                 break;\r
1264                                 case 2:\r
1265                                         resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;\r
1266                                 break;\r
1267                                 case 4:\r
1268                                         resp.record[countValidRecords].class = SS_CLASS_FAX;\r
1269                                 break;\r
1270                                 case 7:\r
1271                                         resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;\r
1272                                 break;\r
1273                                 case 8:\r
1274                                         resp.record[countValidRecords].class = SS_CLASS_SMS;\r
1275                                 break;\r
1276                                 case 16:\r
1277                                         resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;\r
1278                                 break;\r
1279                                 case 32:\r
1280                                         resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;\r
1281                                 break;\r
1282                                 default:\r
1283                                         dbg("unspoorted class : [%d]\n", classx);\r
1284                                         goto error;\r
1285                                 break;\r
1286                         }\r
1287              }\r
1288 \r
1289             //parse  <numer> <type>\r
1290             num = g_slist_nth_data(tokens, 2);\r
1291             if (num) {\r
1292 \r
1293                 dbg("number  - %s", num);\r
1294                 memcpy((resp.record[countValidRecords].number), num, strlen(num));\r
1295                                 resp.record[countValidRecords].number_present = TRUE;\r
1296 \r
1297                 ton = g_slist_nth_data(tokens, 3);\r
1298                 if(ton) {\r
1299                    resp.record[countValidRecords].number_type = atoi(ton);\r
1300                    dbg("number  type - %d", resp.record[countValidRecords].number_type);\r
1301                  }\r
1302             }\r
1303 \r
1304             //skip  <subaddr> <satype>\r
1305             //parse  <time>\r
1306             time_str = g_slist_nth_data(tokens, 6);\r
1307             if(time_str) {\r
1308 \r
1309                 time  =  atoi(time_str);\r
1310                 resp.record[countValidRecords].time = (enum telephony_ss_forwarding_no_reply_time)time;\r
1311                 dbg("time  - %d", time);\r
1312             }\r
1313 \r
1314                         resp.record[countValidRecords].mode = (enum telephony_ss_forwarding_mode)(info->flavor_type);\r
1315             dbg("flavor_type  - %d", (enum telephony_ss_forwarding_mode)(info->flavor_type));\r
1316 \r
1317                         countValidRecords++;\r
1318             tcore_at_tok_free(tokens);\r
1319                         continue;\r
1320         error:\r
1321                         dbg("invalid field found. coutinue");\r
1322             tcore_at_tok_free(tokens);\r
1323                         continue;\r
1324                 }\r
1325                 dbg("valid count :%d",countValidRecords);\r
1326                 resp.record_num = countValidRecords;\r
1327                 resp.err = TCORE_RETURN_SUCCESS;\r
1328         }\r
1329     else {\r
1330 \r
1331                 dbg("no active status - return to user")\r
1332         }\r
1333 \r
1334     if(response->success > 0) {\r
1335 \r
1336         dbg("RESPONSE OK");\r
1337         resp.err = TCORE_RETURN_SUCCESS;\r
1338     }\r
1339     else {\r
1340 \r
1341         dbg("RESPONSE NOT OK");\r
1342         line = (const char*)response->final_response;\r
1343                 tokens = tcore_at_tok_new(line);\r
1344 \r
1345                 if (g_slist_length(tokens) < 1) {\r
1346 \r
1347                         dbg("err cause not specified or string corrupted");\r
1348                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
1349                 }\r
1350                 else {\r
1351 \r
1352                         err = atoi(g_slist_nth_data(tokens, 0));\r
1353                         /* TODO: CMEE error mapping is required. */\r
1354                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
1355                 }\r
1356         tcore_at_tok_free(tokens);\r
1357     }\r
1358 \r
1359         dbg("on_response_ss_forwarding_get- rsp.err : %d, ur : %x", resp.err, ur);\r
1360     if (ur)\r
1361                 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_forwarding), &resp);\r
1362         else\r
1363                 dbg("[ error ] ur is 0");\r
1364 \r
1365         if (resp.record) {\r
1366                 g_free(resp.record);\r
1367         resp.record = NULL;\r
1368         }\r
1369         g_free(user_data);\r
1370 \r
1371 }\r
1372 \r
1373 static void on_response_ss_waiting_get(TcorePending *p, int data_len, const void *data, void *user_data)\r
1374 {\r
1375 \r
1376         UserRequest* ur = 0;\r
1377     GSList *respdata, *tokens = NULL;\r
1378         int classx = 0, err = 0;\r
1379         struct ss_confirm_info* info = 0;\r
1380         struct tresp_ss_waiting resp;\r
1381         int countRecords = 0, countValidRecords = 0;\r
1382     const char *line;\r
1383     char *classx_str ,*status;\r
1384     const TcoreATResponse *response;\r
1385 \r
1386     dbg("function enter")\r
1387     response = data;\r
1388         ur = tcore_pending_ref_user_request(p);\r
1389         info = (struct ss_confirm_info*)user_data;\r
1390 \r
1391     if(response->lines) {\r
1392 \r
1393         respdata =  (GSList*)response->lines;\r
1394         countRecords = g_slist_length(respdata);\r
1395         dbg("total records : %d",countRecords);\r
1396 \r
1397     }\r
1398     else {\r
1399         countRecords  = 0;\r
1400         dbg("no active status - return to user")\r
1401     }\r
1402     resp.record_num = countRecords;\r
1403 \r
1404         if (resp.record_num > 0) {\r
1405 \r
1406                 resp.record = g_new0(struct waiting_info, resp.record_num);\r
1407 \r
1408                 for (countValidRecords = 0; respdata != NULL ; respdata = respdata->next) {\r
1409 \r
1410            line  = (const char*)(respdata->data);\r
1411            tokens = tcore_at_tok_new(line);\r
1412 \r
1413            // parse <status>\r
1414             status = g_slist_nth_data(tokens, 0);\r
1415             if(!status) {\r
1416                 dbg("Missing stat  in responce ");\r
1417                                 goto error;\r
1418             }\r
1419             else {\r
1420 \r
1421                         if(atoi(status) == 1) {\r
1422                                 resp.record[countValidRecords].status = SS_STATUS_ACTIVATE;\r
1423                         }\r
1424                         else {\r
1425                                 resp.record[countValidRecords].status = SS_STATUS_DEACTIVATE;\r
1426                         }\r
1427             }\r
1428             dbg("status = %d", resp.record[countValidRecords].status);\r
1429 \r
1430            //Parse <class>\r
1431             classx_str = g_slist_nth_data(tokens, 1);\r
1432                 if (!classx_str) {\r
1433                                 dbg("error - class is missing");\r
1434                                 goto error;\r
1435                         }\r
1436             else\r
1437             {\r
1438                 switch(atoi(classx_str)) {\r
1439                                 case 1:\r
1440                                         resp.record[countValidRecords].class = SS_CLASS_VOICE;\r
1441                                 break;\r
1442                                 case 2:\r
1443                                         resp.record[countValidRecords].class = SS_CLASS_ALL_DATA_TELE;\r
1444                                 break;\r
1445                                 case 4:\r
1446                                         resp.record[countValidRecords].class = SS_CLASS_FAX;\r
1447                                 break;\r
1448                                 case 7:\r
1449                                         resp.record[countValidRecords].class = SS_CLASS_ALL_TELE;\r
1450                                 break;\r
1451                                 case 8:\r
1452                                         resp.record[countValidRecords].class = SS_CLASS_SMS;\r
1453                                 break;\r
1454                                 case 16:\r
1455                                         resp.record[countValidRecords].class = SS_CLASS_ALL_CS_SYNC;\r
1456                                 break;\r
1457                                 case 32:\r
1458                                         resp.record[countValidRecords].class = SS_CLASS_ALL_CS_ASYNC;\r
1459                                 break;\r
1460                                 default:\r
1461                                         dbg("unspoorted class : [%d]\n", classx);\r
1462                                         goto error;\r
1463                                 break;\r
1464                         }\r
1465                 dbg("class info %d",resp.record[countValidRecords].class);\r
1466              }\r
1467 \r
1468                             countValidRecords++;\r
1469                 tcore_at_tok_free(tokens);\r
1470                             continue;\r
1471         error:\r
1472                             dbg("invalid field found. coutinue");\r
1473                 tcore_at_tok_free(tokens);\r
1474                             continue;\r
1475                 }\r
1476 \r
1477                 dbg("valid count :%d",countValidRecords);\r
1478                 resp.record_num = countValidRecords;\r
1479                 resp.err = TCORE_RETURN_SUCCESS;\r
1480         }\r
1481         else {\r
1482                 dbg("no active status - return to user")\r
1483         }\r
1484 \r
1485         if(response->success > 0) {\r
1486         dbg("RESPONSE OK");\r
1487         resp.err = TCORE_RETURN_SUCCESS;\r
1488     }\r
1489     else {\r
1490 \r
1491         dbg("RESPONSE NOT OK");\r
1492         line = (const char*)response->final_response;\r
1493                 tokens = tcore_at_tok_new(line);\r
1494 \r
1495                 if (g_slist_length(tokens) < 1) {\r
1496 \r
1497                         dbg("err cause not specified or string corrupted");\r
1498                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
1499                 }\r
1500                 else {\r
1501 \r
1502                         err = atoi(g_slist_nth_data(tokens, 0));\r
1503                         // TODO: CMEE error mapping is required.\r
1504                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
1505                 }\r
1506         tcore_at_tok_free(tokens);\r
1507     }\r
1508 \r
1509         dbg("on_response_ss_waiting_get - rsp.err : %d, ur : %x", resp.err, ur);\r
1510         if (ur)\r
1511                 tcore_user_request_send_response(ur, info->resp, sizeof(struct tresp_ss_waiting), &resp);\r
1512         else\r
1513                 dbg("[ error ] ur is 0");\r
1514 \r
1515     if (resp.record) {\r
1516                 g_free(resp.record);\r
1517         resp.record = NULL;\r
1518         }\r
1519         g_free(user_data);\r
1520 }\r
1521 \r
1522 \r
1523 static void on_response_ss_cli_get(TcorePending *p, int data_len, const void *data, void *user_data)\r
1524 {\r
1525         UserRequest* ur = 0;\r
1526         struct tresp_ss_cli resp;\r
1527         enum telephony_ss_cli_type *p_type = NULL;\r
1528         char *line = NULL, *status;\r
1529         int err = FALSE;\r
1530     int cli_adj,stat ;\r
1531     GSList *tokens = NULL ;\r
1532     const TcoreATResponse *response;\r
1533 \r
1534     dbg("function enter")\r
1535     response = data;\r
1536         ur = tcore_pending_ref_user_request(p);\r
1537         p_type = (enum telephony_ss_cli_type*)(user_data);\r
1538 \r
1539     if (response->success  > 0) {\r
1540 \r
1541         line  = (char*) (((GSList*)response->lines)->data);\r
1542         tokens = tcore_at_tok_new(line);\r
1543 \r
1544         if(*p_type == SS_CLI_TYPE_CLIR){\r
1545 \r
1546             //+CLIR: <n> <m>\r
1547            dbg("CLI type is CLIR")\r
1548             //parse <n>\r
1549             status = g_slist_nth_data(tokens, 0);\r
1550 \r
1551             if(!status) {\r
1552                 dbg("Call line identification adjustment missing <n>");\r
1553             }\r
1554             else {\r
1555 \r
1556                 cli_adj = atoi(status);\r
1557                 dbg("CLIR response value of <n> - %d",cli_adj);\r
1558 \r
1559                 if(cli_adj == 0) {\r
1560 \r
1561                     //parse <m>\r
1562                     status = g_slist_nth_data(tokens, 1);\r
1563                     if(!status) {\r
1564                         dbg("status is missing<m>");\r
1565                     }\r
1566                     stat  = atoi(status);\r
1567                     dbg("CLIR response value of <m> - %d",stat);\r
1568 \r
1569                     if(stat == 1 || stat == 3) {\r
1570                        resp.status = TRUE;\r
1571                     }\r
1572                     else {\r
1573                         resp.status = FALSE;\r
1574                     }\r
1575                }\r
1576                else if (cli_adj  == 1) {\r
1577                   resp.status = TRUE;\r
1578                }\r
1579                else {\r
1580                    resp.status = FALSE;\r
1581                }\r
1582                dbg("resp.status -  %d",resp.status);\r
1583             }\r
1584             tcore_at_tok_free(tokens);\r
1585         }\r
1586         else  {\r
1587             //parse <n>\r
1588             status = g_slist_nth_data(tokens, 0);\r
1589             if(!status) {\r
1590                 dbg("Stat is missing");\r
1591             }\r
1592             else {\r
1593                 stat  = atoi(status);\r
1594                 if(stat == 1)\r
1595                     resp.status = TRUE;\r
1596                 else\r
1597                     resp.status = FALSE ;\r
1598 \r
1599                 dbg("resp.status -  %d",resp.status);\r
1600             }\r
1601             tcore_at_tok_free(tokens);\r
1602         }\r
1603     }\r
1604 \r
1605     if (response->success > 0) {\r
1606         dbg("RESPONSE OK");\r
1607         resp.err = TCORE_RETURN_SUCCESS;\r
1608     }\r
1609 \r
1610     else {\r
1611         dbg("RESPONSE NOT OK");\r
1612 \r
1613         line = (char*)response->final_response;\r
1614                 tokens = tcore_at_tok_new(line);\r
1615 \r
1616                 if (g_slist_length(tokens) < 1) {\r
1617                         dbg("err cause not specified or string corrupted");\r
1618                     resp.err = TCORE_RETURN_3GPP_ERROR;\r
1619                 }\r
1620                 else {\r
1621                         err = atoi(g_slist_nth_data(tokens, 0));\r
1622                         // TODO: CMEE error mapping is required.\r
1623                 resp.err = TCORE_RETURN_3GPP_ERROR;\r
1624                 }\r
1625         tcore_at_tok_free(tokens);\r
1626         }\r
1627 \r
1628     resp.type = *p_type;\r
1629     dbg("check - resp.type = %d ", resp.type);\r
1630         if (ur)\r
1631                 tcore_user_request_send_response(ur, TRESP_SS_CLI_GET_STATUS, sizeof(struct tresp_ss_cli), &resp);\r
1632         else\r
1633                 dbg("[ error ] ur : (0)");\r
1634 \r
1635         g_free(user_data);\r
1636 }\r
1637 \r
1638 static struct tcore_ss_operations ss_ops = {\r
1639         .barring_activate               = s_ss_barring_activate,\r
1640         .barring_deactivate             = s_ss_barring_deactivate,\r
1641         .barring_change_password= s_ss_barring_change_password,\r
1642         .barring_get_status             = s_ss_barring_get_status,\r
1643         .forwarding_activate    = s_ss_forwarding_activate,\r
1644         .forwarding_deactivate  = s_ss_forwarding_deactivate,\r
1645         .forwarding_register    = s_ss_forwarding_register,\r
1646         .forwarding_deregister  = s_ss_forwarding_deregister,\r
1647         .forwarding_get_status  = s_ss_forwarding_get_status,\r
1648         .waiting_activate               = s_ss_waiting_activate,\r
1649         .waiting_deactivate             = s_ss_waiting_deactivate,\r
1650         .waiting_get_status             = s_ss_waiting_get_status,\r
1651         .cli_activate                   = s_ss_cli_activate,\r
1652         .cli_deactivate                 = s_ss_cli_deactivate,\r
1653         .cli_get_status                 = s_ss_cli_get_status,\r
1654         .send_ussd                              = s_ss_send_ussd,\r
1655         .set_aoc                                = s_ss_set_aoc,\r
1656         .get_aoc                                = s_ss_get_aoc,\r
1657 };\r
1658 \r
1659 \r
1660 static TReturn _ss_barring_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op)\r
1661 {\r
1662         struct treq_ss_barring *barring = 0;\r
1663         struct ss_confirm_info *user_data = 0;\r
1664     char *cmd_str = NULL;\r
1665         TcoreHal* hal;\r
1666         TcorePending *pending = NULL;\r
1667         TcoreATRequest *req;\r
1668         char passwd[MAX_SS_BARRING_PASSWORD_LEN+1];\r
1669         int opco;\r
1670         int classx;\r
1671         char* facility = NULL;\r
1672     gboolean ret = FALSE;\r
1673 \r
1674     dbg("function enter");\r
1675     barring = (struct treq_ss_barring*)tcore_user_request_ref_data(ur, 0);\r
1676 \r
1677     switch(op) {\r
1678                 case SS_OPCO_ACTIVATE:\r
1679                          opco = 1;\r
1680                 break;\r
1681                 case SS_OPCO_DEACTIVATE:\r
1682                          opco = 0;\r
1683                 break;\r
1684                 default:\r
1685                         dbg("unsupported opco : %d", op);\r
1686                 return TCORE_RETURN_FAILURE;\r
1687         }\r
1688     dbg("opco - %d",opco);\r
1689 \r
1690         switch(barring->mode){\r
1691                 case SS_BARR_MODE_BAOC:\r
1692                         facility = "AO";\r
1693                 break;\r
1694                 case SS_BARR_MODE_BOIC:\r
1695                         facility = "OI";\r
1696                 break;\r
1697                 case SS_BARR_MODE_BOIC_NOT_HC:\r
1698                         facility = "OX";\r
1699                 break;\r
1700                 case SS_BARR_MODE_BAIC:\r
1701                         facility = "AI";\r
1702                 break;\r
1703                 case SS_BARR_MODE_BIC_ROAM:\r
1704                         facility = "IR";\r
1705                 break;\r
1706                 case SS_BARR_MODE_AB:\r
1707                         facility = "AB";\r
1708                 break;\r
1709                 case SS_BARR_MODE_AOB:\r
1710                         facility = "AG";\r
1711                 break;\r
1712                 case SS_BARR_MODE_AIB:\r
1713                         facility = "AC";\r
1714                 break;\r
1715                 case SS_BARR_MODE_BIC_NOT_SIM:\r
1716                 //      facility = "NS";\r
1717                 default:\r
1718                         dbg("unspported mode %d", barring->mode);\r
1719                 return TCORE_RETURN_FAILURE;\r
1720         }\r
1721 \r
1722     dbg("facility - %s",facility);\r
1723 \r
1724         switch(barring->class) {\r
1725                 case SS_CLASS_ALL_TELE:\r
1726                         classx =7;\r
1727                 break;\r
1728                 case SS_CLASS_VOICE:\r
1729                         classx =1;\r
1730                 break;\r
1731                 case SS_CLASS_ALL_DATA_TELE:\r
1732                         classx =2;\r
1733                 break;\r
1734                 case SS_CLASS_FAX:\r
1735                         classx =4;\r
1736                 break;\r
1737                 case SS_CLASS_SMS:\r
1738                         classx = 8;\r
1739                 break;\r
1740                 case SS_CLASS_ALL_CS_SYNC:\r
1741                         classx = 16;\r
1742                 break;\r
1743 \r
1744                 default:\r
1745                         classx =7;\r
1746                         dbg("unsupported class %d. set to default : 7", barring->class);\r
1747                 break;\r
1748         }\r
1749 \r
1750     dbg("classx - %d",classx);\r
1751 \r
1752         // null-ended pwd handling added - unexpected  0x11 value observed in req string\r
1753         memcpy(passwd, barring->password, MAX_SS_BARRING_PASSWORD_LEN);\r
1754         passwd[MAX_SS_BARRING_PASSWORD_LEN]='\0';\r
1755     dbg("passwd - %s",passwd);\r
1756 \r
1757         hal = tcore_object_get_hal(o);\r
1758         pending = tcore_pending_new(o, 0);\r
1759 \r
1760     cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,\"%s\",%d", facility, opco, passwd, classx);\r
1761     dbg("request command : %s", cmd_str);\r
1762 \r
1763         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
1764         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1765 \r
1766         tcore_pending_set_request_data(pending, 0, req);\r
1767 \r
1768         user_data = g_new0(struct ss_confirm_info, 1);\r
1769         if (op == SS_OPCO_ACTIVATE) {\r
1770                 user_data->resp = TRESP_SS_BARRING_ACTIVATE;\r
1771 \r
1772         }\r
1773     else if (op == SS_OPCO_DEACTIVATE){\r
1774                 user_data->resp = TRESP_SS_BARRING_DEACTIVATE;\r
1775 \r
1776         }\r
1777     else {\r
1778                 dbg("[ error ] wrong ss opco (0x%x)", op);\r
1779                 return TCORE_RETURN_FAILURE;\r
1780         }\r
1781         user_data->flavor_type = (int)(barring->mode);\r
1782         user_data->class = barring->class;\r
1783 \r
1784         ret = _ss_request_message(pending, o, ur, on_response_ss_barring_set, user_data);\r
1785         g_free(cmd_str);\r
1786 \r
1787         if (!ret) {\r
1788 \r
1789             dbg("AT request sent failed ")\r
1790                 return TCORE_RETURN_FAILURE;\r
1791         }\r
1792         return TCORE_RETURN_SUCCESS;\r
1793 }\r
1794 \r
1795 static TReturn _ss_barring_get(CoreObject *o,\r
1796                                                                 UserRequest *ur,\r
1797                                                                 enum telephony_ss_class class,\r
1798                                                                 enum telephony_ss_barring_mode mode,\r
1799                                                                 enum tcore_response_command resp)\r
1800 \r
1801 {\r
1802         struct ss_confirm_info *user_data = 0;\r
1803         gboolean ret = FALSE;\r
1804         char* cmd_str = NULL;\r
1805         int opco, classx;\r
1806         char* facility = NULL;\r
1807     TcoreHal* hal;\r
1808         TcorePending *pending = NULL;\r
1809         TcoreATRequest *req;\r
1810 \r
1811     dbg("function enter");\r
1812 \r
1813     //query status - opco is fixed to 2\r
1814         opco = 2;\r
1815         //barring mode\r
1816         switch(mode){\r
1817 \r
1818                 case SS_BARR_MODE_BAOC:\r
1819                         facility = "AO";\r
1820                 break;\r
1821                 case SS_BARR_MODE_BOIC:\r
1822                         facility = "OI";\r
1823                 break;\r
1824                 case SS_BARR_MODE_BOIC_NOT_HC:\r
1825                         facility = "OX";\r
1826                 break;\r
1827                 case SS_BARR_MODE_BAIC:\r
1828                         facility = "AI";\r
1829                 break;\r
1830                 case SS_BARR_MODE_BIC_ROAM:\r
1831                         facility = "IR";\r
1832                 break;\r
1833                 case SS_BARR_MODE_AB:\r
1834                         facility = "AB";\r
1835                 break;\r
1836                 case SS_BARR_MODE_AOB:\r
1837                         facility = "AG";\r
1838                 break;\r
1839                 case SS_BARR_MODE_AIB:\r
1840                         facility = "AC";\r
1841                 break;\r
1842                 case SS_BARR_MODE_BIC_NOT_SIM:\r
1843                 default:\r
1844                         dbg("unspported mode %d", mode);\r
1845                 return TCORE_RETURN_FAILURE;\r
1846         }\r
1847 \r
1848     dbg("facility - %s", facility);\r
1849 \r
1850         switch(class) {\r
1851 \r
1852                 case SS_CLASS_ALL_TELE:\r
1853                         classx =7;\r
1854                 break;\r
1855                 case SS_CLASS_VOICE:\r
1856                         classx =1;\r
1857                 break;\r
1858                 case SS_CLASS_ALL_DATA_TELE:\r
1859                         classx =2;\r
1860                 break;\r
1861                 case SS_CLASS_FAX:\r
1862                         classx =4;\r
1863                 break;\r
1864                 case SS_CLASS_SMS:\r
1865                         classx = 8;\r
1866                 break;\r
1867                 case SS_CLASS_ALL_CS_SYNC:\r
1868                         classx = 16;\r
1869                 break;\r
1870 \r
1871                 default:\r
1872                         classx =7;\r
1873                         dbg("unsupported class %d. set to default : 7", class);\r
1874                 break;\r
1875         }\r
1876     dbg("class - %d", classx);\r
1877 \r
1878         if(classx ==7)\r
1879             cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d", facility, opco);\r
1880         else\r
1881                 cmd_str = g_strdup_printf("AT+CLCK=\"%s\",%d,,%d", facility, opco,classx);\r
1882 \r
1883         dbg("request command : %s", cmd_str);\r
1884 \r
1885     hal = tcore_object_get_hal(o);\r
1886         pending = tcore_pending_new(o, 0);\r
1887     req = tcore_at_request_new(cmd_str, "+CLCK", TCORE_AT_MULTILINE);\r
1888         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1889 \r
1890         tcore_pending_set_request_data(pending, 0, req);\r
1891 \r
1892         user_data = g_new0(struct ss_confirm_info, 1);\r
1893         user_data->resp = resp;\r
1894         user_data->flavor_type = (int)(mode);\r
1895         user_data->class = class;\r
1896 \r
1897         ret = _ss_request_message(pending, o, ur, on_response_ss_barring_get, user_data);\r
1898         g_free(cmd_str);\r
1899 \r
1900         if (!ret) {\r
1901             dbg("AT request sent failed ")\r
1902                 return TCORE_RETURN_FAILURE;\r
1903         }\r
1904 \r
1905         return TCORE_RETURN_SUCCESS;\r
1906 }\r
1907 \r
1908 static TReturn s_ss_barring_activate(CoreObject *o, UserRequest *ur)\r
1909 {\r
1910         return _ss_barring_set(o, ur, SS_OPCO_ACTIVATE);\r
1911 }\r
1912 \r
1913 static TReturn s_ss_barring_deactivate(CoreObject *o, UserRequest *ur)\r
1914 {\r
1915         return _ss_barring_set(o, ur, SS_OPCO_DEACTIVATE);\r
1916 }\r
1917 \r
1918 static TReturn s_ss_barring_change_password(CoreObject *o, UserRequest *ur)\r
1919 {\r
1920     TcoreHal* hal;\r
1921         TcorePending *pending = NULL;\r
1922         TcoreATRequest *req;\r
1923         struct treq_ss_barring_change_password *barring = 0;\r
1924         struct ss_confirm_info *user_data = 0;\r
1925     char* cmd_str = NULL;\r
1926         gboolean ret = FALSE;\r
1927 \r
1928     dbg("function enter");\r
1929         barring = (struct treq_ss_barring_change_password*)tcore_user_request_ref_data(ur, 0);\r
1930 \r
1931         cmd_str = g_strdup_printf("AT+CPWD=\"%s\",\"%s\",\"%s\"", "AB", barring->password_old, barring->password_new);\r
1932         dbg("request command : %s", cmd_str);\r
1933 \r
1934     hal = tcore_object_get_hal(o);\r
1935         pending = tcore_pending_new(o, 0);\r
1936         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
1937         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
1938 \r
1939         tcore_pending_set_request_data(pending, 0, req);\r
1940 \r
1941         user_data = g_new0(struct ss_confirm_info, 1);\r
1942         user_data->resp = TRESP_SS_BARRING_CHANGE_PASSWORD;\r
1943 \r
1944         ret = _ss_request_message(pending, o, ur, on_response_ss_barring_change_pwd, user_data);\r
1945         g_free(cmd_str);\r
1946     if (!ret) {\r
1947         dbg("AT request sent failed ")\r
1948                 return TCORE_RETURN_FAILURE;\r
1949         }\r
1950         return TCORE_RETURN_SUCCESS;\r
1951 }\r
1952 \r
1953 static TReturn s_ss_barring_get_status(CoreObject *o, UserRequest *ur)\r
1954 {\r
1955         struct treq_ss_barring *barring = 0;\r
1956         barring = (struct treq_ss_barring*)tcore_user_request_ref_data(ur, 0);\r
1957 \r
1958         return _ss_barring_get(o, ur, barring->class, barring->mode, TRESP_SS_BARRING_GET_STATUS);\r
1959 }\r
1960 \r
1961 static TReturn _ss_forwarding_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode op)\r
1962 {\r
1963         struct treq_ss_forwarding *forwarding = 0;\r
1964         struct ss_confirm_info *user_data = 0;\r
1965         gboolean ret = FALSE;\r
1966         int len = 0;\r
1967         char* cmd_str = NULL;\r
1968         char* tmp_str = NULL;\r
1969         int reason=0, mode = 0, num_type = 0, classx = 0,time = 0;\r
1970         gboolean valid_num = FALSE;\r
1971     TcoreHal* hal;\r
1972         TcorePending *pending = NULL;\r
1973         TcoreATRequest *req;\r
1974 \r
1975         dbg("_ss_forwarding_set with opco %d ", op);\r
1976 \r
1977         forwarding = (struct treq_ss_forwarding*) tcore_user_request_ref_data(ur, 0);\r
1978         switch(forwarding->mode) {\r
1979 \r
1980                 case SS_CF_MODE_CFU:\r
1981                         reason = 0;\r
1982                         break;\r
1983                 case SS_CF_MODE_CFB:\r
1984                         reason = 1;\r
1985                         break;\r
1986                 case SS_CF_MODE_CFNRy:\r
1987                         reason = 2;\r
1988                         break;\r
1989                 case SS_CF_MODE_CFNRc:\r
1990                         reason = 3;\r
1991                         break;\r
1992                 case SS_CF_MODE_CF_ALL:\r
1993                         reason = 4;\r
1994                 break;\r
1995                 case SS_CF_MODE_CFC:\r
1996                         reason = 5;\r
1997                 break;\r
1998 \r
1999                 default:\r
2000                         dbg("unsupported reason : %d");\r
2001             return TCORE_RETURN_FAILURE;\r
2002                         break;\r
2003         }\r
2004 \r
2005     dbg("reason = %d", reason);\r
2006         switch(op){\r
2007                 case SS_OPCO_DEACTIVATE:\r
2008                         mode = 0;\r
2009                 break;\r
2010                 case SS_OPCO_ACTIVATE:\r
2011                         mode = 1;\r
2012                 break;\r
2013                 case SS_OPCO_REG:\r
2014                         mode = 3;\r
2015                 break;\r
2016                 case SS_OPCO_DEREG:\r
2017                         mode = 4;\r
2018                 break;\r
2019 \r
2020                 default:\r
2021                         dbg("unsupported opco : %d", op);\r
2022                         return TCORE_RETURN_FAILURE;\r
2023         }\r
2024 \r
2025     dbg("mode = %d", mode);\r
2026 \r
2027     // class\r
2028         switch(forwarding->class) {\r
2029                 case SS_CLASS_ALL_TELE:\r
2030                         classx =7;\r
2031                 break;\r
2032                 case SS_CLASS_VOICE:\r
2033                         classx =1;\r
2034                 break;\r
2035                 case SS_CLASS_ALL_DATA_TELE:\r
2036                         classx =2;\r
2037                 break;\r
2038                 case SS_CLASS_FAX:\r
2039                         classx =4;\r
2040                 break;\r
2041                 case SS_CLASS_SMS:\r
2042                         classx = 8;\r
2043                 break;\r
2044                 case SS_CLASS_ALL_CS_SYNC:\r
2045                         classx = 16;\r
2046                 break;\r
2047 \r
2048                 default:\r
2049                         classx =7;\r
2050                         dbg("unsupported class %d. set to default : 7", forwarding->class);\r
2051                 break;\r
2052         }\r
2053     dbg("classx = %d", classx);\r
2054 \r
2055     //number\r
2056         len = strlen(forwarding->number);\r
2057         if (len > 0){\r
2058                 valid_num = TRUE;\r
2059                 if (forwarding->number[0] == '+')\r
2060                         num_type = ((NUM_TYPE_INTERNATIONAL << 4)| NUM_PLAN_ISDN);\r
2061                 else\r
2062                         num_type = 0;\r
2063         }\r
2064     dbg("number = %s", forwarding->number);\r
2065 \r
2066         user_data = g_new0(struct ss_confirm_info, 1);\r
2067 \r
2068         switch (op) {\r
2069                 case SS_OPCO_REG:\r
2070                         user_data->resp = TRESP_SS_FORWARDING_REGISTER;\r
2071                         break;\r
2072                 case SS_OPCO_DEREG:\r
2073                         user_data->resp = TRESP_SS_FORWARDING_DEREGISTER;\r
2074                         break;\r
2075                 case SS_OPCO_ACTIVATE:\r
2076                         user_data->resp = TRESP_SS_FORWARDING_ACTIVATE;\r
2077                         break;\r
2078                 case SS_OPCO_DEACTIVATE:\r
2079                         user_data->resp = TRESP_SS_FORWARDING_DEACTIVATE;\r
2080                         break;\r
2081                 default:\r
2082                         dbg("[ error ] unknown op (0x%x)", op);\r
2083                         break;\r
2084         }\r
2085 \r
2086    if(forwarding->number[0] == '+')\r
2087        num_type = 145;\r
2088    else\r
2089       num_type = 129;\r
2090 \r
2091         if(op == SS_OPCO_REG)\r
2092                 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,\"%s\",%d,%d", reason, mode, forwarding->number, num_type, classx);\r
2093         else// other opcode does not need num field\r
2094                 tmp_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode, classx);\r
2095 \r
2096         if(forwarding->mode == SS_CF_MODE_CFNRy) {\r
2097                 //add time info to 'no reply' case\r
2098                 time = (int)(forwarding->time);\r
2099                 cmd_str = g_strdup_printf("%s,,,%d", tmp_str,time);\r
2100         }\r
2101         else {\r
2102                 cmd_str = g_strdup_printf("%s", tmp_str);\r
2103         }\r
2104 \r
2105         dbg("request command : %s", cmd_str);\r
2106     hal = tcore_object_get_hal(o);\r
2107         pending = tcore_pending_new(o, 0);\r
2108         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2109         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2110 \r
2111         tcore_pending_set_request_data(pending, 0, req);\r
2112 \r
2113         user_data->flavor_type = forwarding->mode;\r
2114         user_data->class = forwarding->class;\r
2115 \r
2116         ret = _ss_request_message(pending, o, ur, on_response_ss_forwarding_set, user_data);\r
2117 \r
2118         g_free(tmp_str);\r
2119         g_free(cmd_str);\r
2120 \r
2121         if (!ret) {\r
2122             dbg("AT request sent failed ")\r
2123                 return TCORE_RETURN_FAILURE;\r
2124         }\r
2125 \r
2126         return TCORE_RETURN_SUCCESS;\r
2127 }\r
2128 \r
2129 static TReturn _ss_forwarding_get(CoreObject *o,\r
2130                                                                         UserRequest *ur,\r
2131                                                                         enum telephony_ss_class class,\r
2132                                                                         enum telephony_ss_forwarding_mode type,\r
2133                                                                         enum tcore_response_command resp)\r
2134 {\r
2135 \r
2136         struct ss_confirm_info *user_data = 0;\r
2137         gboolean ret = FALSE;\r
2138         char* cmd_str = NULL;\r
2139         int reason = 0, mode = 0, classx = 0;\r
2140     TcoreHal* hal;\r
2141         TcorePending *pending = NULL;\r
2142         TcoreATRequest *req;\r
2143 \r
2144     dbg("function enter");\r
2145 \r
2146         switch(type) {\r
2147                 case SS_CF_MODE_CFU:\r
2148                         reason = 0;\r
2149                 break;\r
2150                 case SS_CF_MODE_CFB:\r
2151                         reason = 1;\r
2152                 break;\r
2153                 case SS_CF_MODE_CFNRy:\r
2154                         reason = 2;\r
2155                 break;\r
2156                 case SS_CF_MODE_CFNRc:\r
2157                         reason = 3;\r
2158                 break;\r
2159                 case SS_CF_MODE_CF_ALL:\r
2160                         reason = 4;\r
2161                 break;\r
2162                 case SS_CF_MODE_CFC:\r
2163                         reason = 5;\r
2164                 break;\r
2165 \r
2166                 default:\r
2167                         dbg("unsupported reason : %d");\r
2168                 break;\r
2169         }\r
2170     dbg("reason  = %d", reason);\r
2171 \r
2172         switch(class) {\r
2173                 case SS_CLASS_ALL_TELE:\r
2174                         classx =7;\r
2175                 break;\r
2176                 case SS_CLASS_VOICE:\r
2177                         classx =1;\r
2178                 break;\r
2179                 case SS_CLASS_ALL_DATA_TELE:\r
2180                         classx =2;\r
2181                 break;\r
2182                 case SS_CLASS_FAX:\r
2183                         classx =4;\r
2184                 break;\r
2185                 case SS_CLASS_SMS:\r
2186                         classx = 8;\r
2187                 break;\r
2188                 case SS_CLASS_ALL_CS_SYNC:\r
2189                         classx = 16;\r
2190                 break;\r
2191                 default:\r
2192                         classx =7;\r
2193                         dbg("unsupported class %d. set to default : 7", class);\r
2194                 break;\r
2195         }\r
2196 \r
2197     dbg("classx  = %d", classx);\r
2198 \r
2199         //query status - mode set to 2\r
2200         mode = 2;\r
2201         user_data = g_new0(struct ss_confirm_info, 1);\r
2202         user_data->resp = resp;\r
2203         user_data->class = class;\r
2204         user_data->flavor_type = type;\r
2205 \r
2206         if(classx ==7)\r
2207                 cmd_str = g_strdup_printf("AT+CCFC=%d,%d", reason, mode);\r
2208         else\r
2209                 cmd_str = g_strdup_printf("AT+CCFC=%d,%d,,,%d", reason, mode,classx);\r
2210 \r
2211         dbg("request command : %s", cmd_str);\r
2212 \r
2213     hal = tcore_object_get_hal(o);\r
2214         pending = tcore_pending_new(o, 0);\r
2215         req = tcore_at_request_new(cmd_str, "+CCFC", TCORE_AT_MULTILINE);\r
2216         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2217 \r
2218         tcore_pending_set_request_data(pending, 0, req);\r
2219 \r
2220         ret = _ss_request_message(pending, o, ur, on_response_ss_forwarding_get, user_data);\r
2221         g_free(cmd_str);\r
2222 \r
2223         if (!ret) {\r
2224             dbg("AT request sent failed ")\r
2225                 return TCORE_RETURN_FAILURE;\r
2226         }\r
2227 \r
2228         return TCORE_RETURN_SUCCESS;\r
2229 }\r
2230 \r
2231 static TReturn s_ss_forwarding_activate(CoreObject *o, UserRequest *ur)\r
2232 {\r
2233         return _ss_forwarding_set(o, ur, SS_OPCO_ACTIVATE);\r
2234 }\r
2235 \r
2236 static TReturn s_ss_forwarding_deactivate(CoreObject *o, UserRequest *ur)\r
2237 {\r
2238         return _ss_forwarding_set(o, ur, SS_OPCO_DEACTIVATE);\r
2239 }\r
2240 \r
2241 static TReturn s_ss_forwarding_register(CoreObject *o, UserRequest *ur)\r
2242 {\r
2243         return _ss_forwarding_set(o, ur, SS_OPCO_REG);\r
2244 }\r
2245 \r
2246 static TReturn s_ss_forwarding_deregister(CoreObject *o, UserRequest *ur)\r
2247 {\r
2248         return _ss_forwarding_set(o, ur, SS_OPCO_DEREG);\r
2249 }\r
2250 \r
2251 static TReturn s_ss_forwarding_get_status(CoreObject *o, UserRequest *ur)\r
2252 {\r
2253         struct treq_ss_forwarding *forwarding = 0;\r
2254         forwarding = (struct treq_ss_forwarding*)tcore_user_request_ref_data(ur, 0);\r
2255 \r
2256         return _ss_forwarding_get(o, ur, forwarding->class, forwarding->mode, TRESP_SS_FORWARDING_GET_STATUS);\r
2257 }\r
2258 \r
2259 \r
2260 static TReturn _ss_waiting_set(CoreObject *o, UserRequest *ur, enum telephony_ss_opcode opco)\r
2261 {\r
2262         struct treq_ss_waiting *waiting = 0;\r
2263         struct ss_confirm_info *user_data = 0;\r
2264         gboolean ret = FALSE;\r
2265         int mode = 0, classx = 0;\r
2266         char* cmd_str;\r
2267     TcoreHal* hal;\r
2268         TcorePending *pending = NULL;\r
2269         TcoreATRequest *req;\r
2270 \r
2271     dbg("function enter ");\r
2272         waiting = (struct treq_ss_waiting*) tcore_user_request_ref_data(ur, 0);\r
2273         user_data = g_new0(struct ss_confirm_info, 1);\r
2274 \r
2275         if(opco == SS_OPCO_ACTIVATE) {\r
2276                 user_data->resp = TRESP_SS_WAITING_ACTIVATE;\r
2277                 mode = 1;//enable\r
2278         }\r
2279         else if (opco == SS_OPCO_DEACTIVATE) {\r
2280                 user_data->resp = TRESP_SS_WAITING_DEACTIVATE;\r
2281                 mode =0; //disable\r
2282         }\r
2283         else\r
2284                 dbg("[ error ] unknown ss mode (0x%x)", opco);\r
2285 \r
2286     switch(waiting->class) {\r
2287                 case SS_CLASS_ALL_TELE:\r
2288                         classx =7;\r
2289                 break;\r
2290                 case SS_CLASS_VOICE:\r
2291                         classx =1;\r
2292                 break;\r
2293                 case SS_CLASS_ALL_DATA_TELE:\r
2294                         classx =2;\r
2295                 break;\r
2296                 case SS_CLASS_FAX:\r
2297                         classx =4;\r
2298                 break;\r
2299                 case SS_CLASS_SMS:\r
2300                         classx = 8;\r
2301                 break;\r
2302 \r
2303                 default:\r
2304                         classx =1;\r
2305                         dbg("unsupported class %d. set to default : 1", waiting->class);\r
2306                 break;\r
2307         }\r
2308     dbg("mode = %d classxx- %d", mode , classx);\r
2309 \r
2310         user_data->class = waiting->class;\r
2311         user_data->flavor_type = (int)opco;\r
2312 \r
2313         cmd_str = g_strdup_printf("AT+CCWA=1,%d,%d", mode, classx); //always enable +CCWA: unsolicited cmd\r
2314         dbg("request command : %s",cmd_str);\r
2315 \r
2316     hal = tcore_object_get_hal(o);\r
2317         pending = tcore_pending_new(o, 0);\r
2318         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2319         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2320 \r
2321         tcore_pending_set_request_data(pending, 0, req);\r
2322 \r
2323         ret = _ss_request_message(pending, o, ur, on_response_ss_waiting_set, user_data);\r
2324         g_free(cmd_str);\r
2325         if (!ret) {\r
2326             dbg("AT request sent failed ")\r
2327                 return TCORE_RETURN_FAILURE;\r
2328         }\r
2329         return TCORE_RETURN_SUCCESS;\r
2330 }\r
2331 \r
2332 static TReturn _ss_waiting_get(CoreObject *o,\r
2333                                                                 UserRequest *ur,\r
2334                                                                 enum telephony_ss_class class,\r
2335                                                                 enum tcore_response_command resp)\r
2336 \r
2337 {\r
2338 \r
2339     struct ss_confirm_info *user_data = 0;\r
2340         gboolean ret = FALSE;\r
2341         int classx; //mode,\r
2342         char* cmd_str;\r
2343     TcoreHal* hal;\r
2344         TcorePending *pending = NULL;\r
2345         TcoreATRequest *req;\r
2346 \r
2347     dbg("function  enter")\r
2348         switch(class) {\r
2349                 case SS_CLASS_ALL_TELE:\r
2350                         classx = 7;\r
2351                 break;\r
2352                 case SS_CLASS_VOICE:\r
2353                         classx = 1;\r
2354                 break;\r
2355                 case SS_CLASS_ALL_DATA_TELE:\r
2356                         classx = 2;\r
2357                 break;\r
2358                 case SS_CLASS_FAX:\r
2359                         classx = 4;\r
2360                 break;\r
2361                 case SS_CLASS_SMS:\r
2362                         classx = 8;\r
2363                 break;\r
2364 \r
2365                 default:\r
2366                         classx =7;\r
2367                         dbg("unsupported class %d. set to default : 7", class);\r
2368                 break;\r
2369         }\r
2370     dbg("classx - %d", classx);\r
2371 \r
2372         dbg("allocating user data");\r
2373         user_data = g_new0(struct ss_confirm_info, 1);\r
2374         user_data->resp = resp;\r
2375         user_data->class = class;\r
2376 \r
2377         cmd_str = g_strdup_printf("AT+CCWA=1,2,%d", classx); //always enable +CCWA: unsolicited cmd , mode is fixed to 2(query status)\r
2378         dbg("request cmd : %s", cmd_str);\r
2379 \r
2380     hal = tcore_object_get_hal(o);\r
2381         pending = tcore_pending_new(o, 0);\r
2382         req = tcore_at_request_new(cmd_str, "+CCWA", TCORE_AT_MULTILINE);\r
2383         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2384 \r
2385         tcore_pending_set_request_data(pending, 0, req);\r
2386 \r
2387         ret = _ss_request_message(pending, o, ur, on_response_ss_waiting_get, user_data);\r
2388         g_free(cmd_str);\r
2389         if (!ret) {\r
2390             dbg("AT request sent failed ")\r
2391                 return TCORE_RETURN_FAILURE;\r
2392         }\r
2393         return TCORE_RETURN_SUCCESS;\r
2394 }\r
2395 \r
2396 static TReturn s_ss_waiting_activate(CoreObject *o, UserRequest *ur)\r
2397 {\r
2398         return _ss_waiting_set(o, ur, SS_OPCO_ACTIVATE);\r
2399 }\r
2400 \r
2401 static TReturn s_ss_waiting_deactivate(CoreObject *o, UserRequest *ur)\r
2402 {\r
2403         return _ss_waiting_set(o, ur, SS_OPCO_DEACTIVATE);\r
2404 }\r
2405 \r
2406 static TReturn s_ss_waiting_get_status(CoreObject *o, UserRequest *ur)\r
2407 {\r
2408         struct treq_ss_waiting *waiting = 0;\r
2409         waiting = (struct treq_ss_waiting*)tcore_user_request_ref_data(ur, 0);\r
2410 \r
2411         return _ss_waiting_get(o, ur, waiting->class, TRESP_SS_WAITING_GET_STATUS);\r
2412 }\r
2413 \r
2414 static TReturn s_ss_cli_activate(CoreObject *o, UserRequest *ur)\r
2415 {\r
2416         return TCORE_RETURN_SUCCESS;\r
2417 }\r
2418 \r
2419 static TReturn s_ss_cli_deactivate(CoreObject *o, UserRequest *ur)\r
2420 {\r
2421         return TCORE_RETURN_SUCCESS;\r
2422 }\r
2423 \r
2424 static TReturn s_ss_cli_get_status(CoreObject *o, UserRequest *ur)\r
2425 {\r
2426 \r
2427         struct treq_ss_cli *cli = 0;\r
2428         gboolean ret = FALSE;\r
2429         char *cmd_prefix = NULL, *rsp_prefix = NULL, *cmd_str = NULL;\r
2430         enum  telephony_ss_cli_type *user_data = 0;\r
2431     TcoreHal* hal;\r
2432         TcorePending *pending = NULL;\r
2433         TcoreATRequest *req;\r
2434 \r
2435         cli = (struct treq_ss_cli*)tcore_user_request_ref_data(ur, 0);\r
2436         switch(cli->type) {\r
2437                 case SS_CLI_TYPE_CLIP:\r
2438                         cmd_prefix = "+CLIP";\r
2439                         rsp_prefix = "+CLIP";\r
2440                 break;\r
2441 \r
2442                 case SS_CLI_TYPE_CLIR:\r
2443                         cmd_prefix = "+CLIR";\r
2444                         rsp_prefix = "+CLIR";\r
2445                 break;\r
2446 \r
2447                 case SS_CLI_TYPE_COLP:\r
2448                         cmd_prefix = "+COLP";\r
2449                         rsp_prefix = "+COLP";\r
2450                 break;\r
2451 \r
2452         case SS_CLI_TYPE_COLR:\r
2453             cmd_prefix = "+COLR";\r
2454                         rsp_prefix = "+COLR";\r
2455          break;\r
2456 \r
2457              case SS_CLI_TYPE_CNAP:\r
2458              cmd_prefix = "+CNAP";\r
2459                          rsp_prefix = "+CNAP";\r
2460           break;\r
2461 \r
2462                 case SS_CLI_TYPE_CDIP:\r
2463                 default:\r
2464                         dbg("unsupported cli_type : %d", cli->type);\r
2465                         return TCORE_RETURN_FAILURE;\r
2466                 break;\r
2467         }\r
2468         dbg("cmd_prefix : %s",cmd_prefix);\r
2469 \r
2470         cmd_str = g_strdup_printf("AT%s?", cmd_prefix);\r
2471         dbg("request cmd : %s", cmd_str);\r
2472 \r
2473         user_data = g_new0(enum telephony_ss_cli_type, 1);\r
2474     *user_data = cli->type;\r
2475 \r
2476     hal = tcore_object_get_hal(o);\r
2477         pending = tcore_pending_new(o, 0);\r
2478 \r
2479         req = tcore_at_request_new(cmd_str, rsp_prefix, TCORE_AT_SINGLELINE);\r
2480         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2481         tcore_pending_set_request_data(pending, 0, req);\r
2482 \r
2483         ret = _ss_request_message(pending, o, ur, on_response_ss_cli_get, user_data);\r
2484         g_free(cmd_str);\r
2485     if (!ret) {\r
2486             dbg("AT request sent failed ")\r
2487                 return TCORE_RETURN_FAILURE;\r
2488         }\r
2489         return TCORE_RETURN_SUCCESS;\r
2490 }\r
2491 \r
2492 static TReturn s_ss_send_ussd(CoreObject *o, UserRequest *ur)\r
2493 {\r
2494         UssdSession *ussd_s = 0;\r
2495         struct treq_ss_ussd *ussd = 0;\r
2496         struct ss_confirm_info *user_data = 0;\r
2497         gboolean ret = FALSE;\r
2498         char* cmd_str;\r
2499     TcoreHal* hal;\r
2500         TcorePending *pending = NULL;\r
2501         TcoreATRequest *req;\r
2502 \r
2503     dbg("function enter");\r
2504         ussd = (struct treq_ss_ussd*)tcore_user_request_ref_data(ur, 0);\r
2505         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\r
2506         dbg("request command : %s",cmd_str);\r
2507 \r
2508         user_data = g_new0(struct ss_confirm_info, 1);\r
2509         user_data->resp = TRESP_SS_SEND_USSD;\r
2510         ussd_s = tcore_ss_ussd_get_session(o);\r
2511         if(!ussd_s) {\r
2512         dbg("USSD session does not  exist");\r
2513                 tcore_ss_ussd_create_session(o, (enum tcore_ss_ussd_type)ussd->type, (void*)tcore_user_request_ref(ur), 0);\r
2514         }\r
2515     else {\r
2516 \r
2517                 if(ussd->type == SS_USSD_TYPE_USER_INITIATED) {\r
2518 \r
2519                     dbg("[ error ] ussd session is already exist");\r
2520                         g_free(user_data);\r
2521                         return TCORE_RETURN_FAILURE;\r
2522                 }\r
2523 \r
2524                 tcore_ss_ussd_set_session_type(ussd_s, (enum tcore_ss_ussd_type)ussd->type);\r
2525         }\r
2526 \r
2527     hal = tcore_object_get_hal(o);\r
2528         pending = tcore_pending_new(o, 0);\r
2529         req = tcore_at_request_new(cmd_str, NULL, TCORE_AT_NO_RESULT);\r
2530         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2531 \r
2532         tcore_pending_set_request_data(pending, 0, req);\r
2533 \r
2534         ret = _ss_request_message(pending, o, ur, on_confirmation_ss_ussd, user_data);\r
2535         g_free(cmd_str);\r
2536 \r
2537         if (!ret) {\r
2538 \r
2539             dbg("AT request sent failed ")\r
2540                 return TCORE_RETURN_FAILURE;\r
2541         }\r
2542         return TCORE_RETURN_SUCCESS;\r
2543 }\r
2544 \r
2545 static TReturn s_ss_set_aoc(CoreObject *o, UserRequest *ur)\r
2546 {\r
2547         dbg("[ error ] unsupported function");\r
2548         return TCORE_RETURN_SUCCESS;\r
2549 }\r
2550 \r
2551 static TReturn s_ss_get_aoc(CoreObject *o, UserRequest *ur)\r
2552 {\r
2553         dbg("[ error ] unsupported function");\r
2554         return TCORE_RETURN_SUCCESS;\r
2555 }\r
2556 \r
2557 \r
2558 static struct tcore_call_control_operations call_ops = {\r
2559         .answer_hold_and_accept = s_ss_manage_call_2_send,\r
2560         .answer_replace                 = s_ss_manage_call_1_send,\r
2561         .answer_reject                  = s_ss_manage_call_0_send,\r
2562         .end_specific                   = s_ss_manage_call_1x_send,\r
2563         .end_all_active                 = s_ss_manage_call_1_send,\r
2564         .end_all_held                   = s_ss_manage_call_0_send,\r
2565         .active                                 = s_ss_manage_call_2_send,\r
2566         .hold                                   = s_ss_manage_call_2_send,\r
2567         .swap                                   = s_ss_manage_call_2_send,\r
2568         .join                                   = s_ss_manage_call_3_send,\r
2569         .split                                  = s_ss_manage_call_2x_send,\r
2570         .transfer                               = s_ss_manage_call_4_send,\r
2571         .deflect                                = s_ss_manage_call_4dn_send,\r
2572 };\r
2573 \r
2574 static TReturn s_ss_manage_call_send(CoreObject* o, UserRequest* ur, const char* cmd, ConfirmCallback cb, void* user_data)\r
2575 {\r
2576         TcorePending *pending = NULL;\r
2577         TcoreATRequest *req;\r
2578         gboolean ret = FALSE;\r
2579 \r
2580         pending = tcore_pending_new(o, 0);\r
2581         req = tcore_at_request_new(cmd, NULL, TCORE_AT_NO_RESULT);\r
2582         dbg("cmd : %s, prefix(if any) :%s, cmd_len : %d", req->cmd, req->prefix, strlen(req->cmd));\r
2583         tcore_pending_set_request_data(pending, 0, req);\r
2584 \r
2585     ret = _ss_request_message(pending, o, ur, (TcorePendingResponseCallback)cb, user_data);\r
2586     if (!ret) {\r
2587             dbg("AT request sent failed ")\r
2588                 return TCORE_RETURN_FAILURE;\r
2589         }\r
2590     return TCORE_RETURN_SUCCESS;\r
2591 }\r
2592 \r
2593 static TReturn s_ss_manage_call_0_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data)\r
2594 {\r
2595         char* cmd_str = NULL;\r
2596         gboolean ret = FALSE;\r
2597 \r
2598     dbg("function enter");\r
2599         cmd_str = g_strdup_printf("%s", "AT+CHLD=0");\r
2600         dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));\r
2601 \r
2602     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);\r
2603         g_free(cmd_str);\r
2604         return ret;\r
2605 }\r
2606 \r
2607 static TReturn s_ss_manage_call_1_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data)\r
2608 {\r
2609         char* cmd_str = NULL;\r
2610         gboolean ret = FALSE;\r
2611 \r
2612     dbg("function enter");\r
2613         cmd_str = g_strdup_printf("%s", "AT+CHLD=1");\r
2614         dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));\r
2615 \r
2616     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);\r
2617         g_free(cmd_str);\r
2618         return ret;\r
2619 }\r
2620 \r
2621 static TReturn s_ss_manage_call_1x_send(CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data)\r
2622 {\r
2623     char* cmd_str = NULL;\r
2624         gboolean ret = FALSE;\r
2625 \r
2626     dbg("function enter");\r
2627         cmd_str = g_strdup_printf("%s%d", "AT+CHLD=1", id);\r
2628         dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));\r
2629 \r
2630     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);\r
2631         g_free(cmd_str);\r
2632         return ret;\r
2633 }\r
2634 \r
2635 static TReturn s_ss_manage_call_2_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data)\r
2636 {\r
2637     char* cmd_str = NULL;\r
2638         gboolean ret = FALSE;\r
2639 \r
2640     dbg("function enter");\r
2641         cmd_str = g_strdup_printf("%s", "AT+CHLD=2");\r
2642         dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));\r
2643 \r
2644     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb,  user_data);\r
2645         g_free(cmd_str);\r
2646         return ret;\r
2647 \r
2648 }\r
2649 \r
2650 static TReturn s_ss_manage_call_2x_send(CoreObject* o, UserRequest* ur, const int id, ConfirmCallback cb, void* user_data)\r
2651 {\r
2652     char* cmd_str = NULL;\r
2653         gboolean ret = FALSE;\r
2654 \r
2655     dbg("function enter");\r
2656         cmd_str = g_strdup_printf("%s%d", "AT+CHLD=2", id);\r
2657         dbg("cmd : %s, prefix(if any) : %s, cmd_len : %d",cmd_str, "N/A", strlen(cmd_str));\r
2658 \r
2659     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb,  user_data);\r
2660         g_free(cmd_str);\r
2661         return ret;\r
2662 }\r
2663 \r
2664 static TReturn s_ss_manage_call_3_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data)\r
2665 {\r
2666         char* cmd_str = NULL;\r
2667     gboolean ret = FALSE;\r
2668 \r
2669     dbg("function enter");\r
2670         cmd_str = g_strdup_printf("%s", "AT+CHLD=3");\r
2671 \r
2672     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);\r
2673         g_free(cmd_str);\r
2674         return ret;\r
2675 }\r
2676 \r
2677 \r
2678 static TReturn s_ss_manage_call_4_send(CoreObject* o, UserRequest* ur, ConfirmCallback cb, void* user_data)\r
2679 {\r
2680     char* cmd_str = NULL;\r
2681     gboolean ret = FALSE;\r
2682 \r
2683     dbg("function enter");\r
2684         cmd_str = g_strdup_printf("%s", "AT+CHLD=4");\r
2685 \r
2686     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);\r
2687         g_free(cmd_str);\r
2688         return ret;\r
2689 }\r
2690 \r
2691 static TReturn s_ss_manage_call_4dn_send(CoreObject* o, UserRequest* ur, const char* number, ConfirmCallback cb, void* user_data)\r
2692 {\r
2693 \r
2694     char* cmd_str = NULL;\r
2695     gboolean ret = FALSE;\r
2696 \r
2697     dbg("function enter");\r
2698         cmd_str = g_strdup_printf("%s%s", "AT+CHLD=4", number);\r
2699 \r
2700     ret =  s_ss_manage_call_send(o, ur, cmd_str, cb, user_data);\r
2701         g_free(cmd_str);\r
2702 \r
2703         return ret;\r
2704 }\r
2705 \r
2706 gboolean s_ss_init(TcorePlugin *p, TcoreHal *h)\r
2707 {\r
2708         CoreObject *so = 0, *co = 0;\r
2709         struct property_call_info *data = 0;\r
2710 \r
2711         so = tcore_ss_new(p, "ss", &ss_ops, h);\r
2712         if (!so) {\r
2713                 dbg("[ error ] ss_new()");\r
2714                 return FALSE;\r
2715         }\r
2716 \r
2717         co = tcore_plugin_ref_core_object(p, "call");\r
2718         if (!co) {\r
2719                 dbg("[ error ] plugin_ref_core_object");\r
2720                 return FALSE;\r
2721         }\r
2722 \r
2723         tcore_call_control_set_operations(co, &call_ops);\r
2724 \r
2725         tcore_object_add_callback(so, "+CSSU", on_notification_ss_info, 0);\r
2726     tcore_object_add_callback(so, "+CSSI", on_notification_ss_info, 0);\r
2727         tcore_object_add_callback(so, "+CUSD", on_notification_ss_ussd, 0);\r
2728 \r
2729         data = calloc(sizeof(struct property_call_info *), 1);\r
2730         tcore_plugin_link_property(p, "SS", data);\r
2731 \r
2732         return TRUE;\r
2733 }\r
2734 \r
2735 void s_ss_exit(TcorePlugin *p)\r
2736 {\r
2737         CoreObject *o;\r
2738         struct property_network_info *data;\r
2739 \r
2740         o = tcore_plugin_ref_core_object(p, "ss");\r
2741 \r
2742         data = tcore_plugin_ref_property(p, "SS");\r
2743         if (data)\r
2744                 free(data);\r
2745 \r
2746         tcore_ss_free(o);\r
2747 }\r