src/tapi_proxy_ss.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  */
  20
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24
  25 #include "tel_cs_conn.h"
  26 #include "tapi_proxy.h"
  27 #include "TapiUtility.h"
  28 #include "TelDefines.h"
  29 #include "TelSs.h"
  30
  31 #include <vconf.h>
  32
  33 extern tapi_dbus_connection_name conn_name;
  34
  35 /**********************************************************************************************
  36  *
  37  * This function is used to Activate or Deactivate the call barring feature.
  38  *
  39  * @param       barringInfo[IN] of type TelSsCallBarringInfo_t Specifies the Teleservice and barring flavour and CB password.
  40  * @return      enum type TapiResult_t Specifies the API's Return result.
  41  * @remark      Call barring password must be known to activate or to deactivate.
  42  *
  43  ***********************************************************************************************/
  44 EXPORT_API int tel_set_ss_barring(const TelSsCallBarringInfo_t *barringInfo, int *req_id)
  45 {
  46
  47         TS_BOOL ret = FALSE;
  48         int returnStatus = TAPI_API_SUCCESS;
  49
  50         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
  51
  52         if (conn_name.length_of_name == 0) {
  53                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
  54                 return TAPI_API_OPERATION_FAILED;
  55         }
  56
  57         /*      Check the input ptr. If NULL then return FALSE  */
  58         TAPI_RETURN_VAL_IF_FAIL(barringInfo, TAPI_API_INVALID_PTR);
  59         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
  60
  61         /*      Check input range for tele service type and call barring flavour        */
  62         if (((barringInfo->CallType >= TAPI_CALL_TYPE_VOICE_EV) && (barringInfo->CallType <= TAPI_CALL_TYPE_ALL_TELE))
  63                         && ((barringInfo->Type >= TAPI_CALL_BARRING_ALL) && (barringInfo->Type <= TAPI_CALL_BARRING_ALL_INCOMING_CALLS_INSIM))
  64                         && ((barringInfo->Mode >= TAPI_SS_CALL_BAR_ACTIVATE) && (barringInfo->Mode <= TAPI_SS_CALL_BAR_DEACTIVATE))
  65                         && (strnlen(barringInfo->szPassword, 4) == TAPI_SS_GSM_BARR_PW_LEN_MAX)) {
  66                 /*       Check for the RPC link.        */
  67                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
  68                 TAPI_GLIB_INIT_PARAMS();
  69
  70                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
  71                                 out_param1,out_param2,out_param3,out_param4);
  72
  73                 g_array_append_vals(in_param1, barringInfo, sizeof(TelSsCallBarringInfo_t));
  74                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
  75
  76                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func");
  77
  78                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_BARRSETREQ, in_param1, in_param2, in_param3, in_param4,
  79                                 &out_param1, &out_param2, &out_param3, &out_param4);
  80
  81                 if (ret) {
  82                         /*      Get the API error value as out param 1, from the server.        */
  83                         returnStatus = g_array_index(out_param1, int, 0);
  84
  85                         *req_id = g_array_index(out_param2, int ,0);
  86                 }
  87                 else {
  88                         /*      RPC API failed, return err to APP       */
  89                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
  90                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
  91                 }
  92
  93                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
  94                                 out_param1,out_param2,out_param3,out_param4);
  95         }
  96         else {
  97                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input");
  98                 returnStatus = TAPI_API_INVALID_INPUT;
  99         }
 100
 101         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 102
 103         return returnStatus;
 104
 105 }
 106
 107 /**********************************************************************************************
 108  *
 109  * This function is used to Activate or Deactivate the call barring feature.
 110  *
 111  * @param       barType[IN] of type TelSsCallBarType_t Specifies the  barring flavour.
 112  * @param       callType[IN] of type TelSsCallType_t Specifies the teleservice type.
 113  * @return      enum type TapiResult_t Specifies the API's Return result.
 114  * @remark
 115  *
 116  ***********************************************************************************************/
 117 EXPORT_API int tel_get_ss_barring_status(TelSsCallBarType_t barType, TelSsCallType_t callType, int *req_id)
 118 {
 119         TS_BOOL ret = FALSE;
 120         int returnStatus = TAPI_API_SUCCESS;
 121
 122         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 123
 124         if (conn_name.length_of_name == 0) {
 125                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 126                 return TAPI_API_OPERATION_FAILED;
 127         }
 128
 129         /*      Check the input ptr. If NULL then return FALSE  */
 130         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 131
 132         /*      Check input range for tele service type and call barring flavour        */
 133         if (((barType >= TAPI_CALL_BARRING_ALL) && (barType <= TAPI_CALL_BARRING_ALL_INCOMING_CALLS_INSIM))
 134                         && ((callType >= TAPI_CALL_TYPE_VOICE_EV) && (callType <= TAPI_CALL_TYPE_ALL_TELE))) {
 135                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 136                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 137                 TAPI_GLIB_INIT_PARAMS();
 138
 139                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 140                                 out_param1,out_param2,out_param3,out_param4);
 141
 142                 g_array_append_vals(in_param1, &barType, sizeof(TelSsCallBarType_t));
 143                 g_array_append_vals(in_param2, &callType, sizeof(TelSsCallType_t));
 144                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 145
 146                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func");
 147
 148                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_BARRQUERYSTATUSREQ, in_param1, in_param2, in_param3,
 149                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 150
 151                 if (ret) {
 152                         /*      Get the API error value as out param 1, from the server.        */
 153                         returnStatus = g_array_index(out_param1, int, 0);
 154                         *req_id = g_array_index(out_param2, int ,0);
 155                 }
 156                 else {
 157                         /*      RPC API failed, return err to APP       */
 158                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 159                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 160                 }
 161
 162                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 163                                 out_param1,out_param2,out_param3,out_param4);
 164         }
 165         else {
 166                 /*      Invalid input range given by the APP.   */
 167                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input ");
 168                 returnStatus = TAPI_API_INVALID_INPUT;
 169         }
 170
 171         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 172
 173         return returnStatus;
 174 }
 175
 176 /**********************************************************************************************
 177  *
 178  * This function is used to change call barring password.
 179  *
 180  * @param       pOldPassword[IN] of type char* Specifies the Old Call Barring Password.
 181  * @param       pNewPassword[IN] of type char* Specifies the New Call Barring Password.
 182  * @param       pNewPasswordAgain[IN] of type char* Specifies the New Call Barring Password for Confirm.
 183  * @return      enum type TapiResult_t Specifies the API's Return result.
 184  * @remark
 185  *
 186  ***********************************************************************************************/
 187 EXPORT_API int tel_change_ss_barring_password(
 188                 const char *pOldPassword,
 189                 const char *pNewPassword,
 190                 const char *pNewPasswordAgain,
 191                 int *req_id)
 192 {
 193         TS_BOOL ret = FALSE;
 194         int returnStatus = TAPI_API_SUCCESS;
 195
 196         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 197
 198         if (conn_name.length_of_name == 0) {
 199                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 200                 return TAPI_API_OPERATION_FAILED;
 201         }
 202
 203         /*      Check the input ptr. If NULL then return FALSE  */
 204         TAPI_RETURN_VAL_IF_FAIL(pOldPassword, TAPI_API_INVALID_PTR);
 205         TAPI_RETURN_VAL_IF_FAIL(pNewPassword, TAPI_API_INVALID_PTR);
 206         TAPI_RETURN_VAL_IF_FAIL(pNewPasswordAgain, TAPI_API_INVALID_PTR);
 207         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 208
 209         // check should be done at APP
 210         if ((strlen(pOldPassword) == TAPI_SS_GSM_BARR_PW_LEN_MAX) && (strlen(pNewPassword) == TAPI_SS_GSM_BARR_PW_LEN_MAX)) {
 211                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 212                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 213                 TAPI_GLIB_INIT_PARAMS();
 214
 215                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 216                                 out_param1,out_param2,out_param3,out_param4);
 217
 218                 g_array_append_vals(in_param1, pOldPassword, TAPI_SS_GSM_BARR_PW_LEN_MAX);
 219                 g_array_append_vals(in_param2, pNewPassword, TAPI_SS_GSM_BARR_PW_LEN_MAX);
 220                 g_array_append_vals(in_param3, pNewPasswordAgain, TAPI_SS_GSM_BARR_PW_LEN_MAX);
 221                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 222
 223                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func");
 224
 225                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_BARRCHANGEPWDREQ, in_param1, in_param2, in_param3,
 226                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 227
 228                 if (ret) {
 229                         /*      Get the API error value as out param 1, from the server.        */
 230                         returnStatus = g_array_index(out_param1, int, 0);
 231                         *req_id = g_array_index(out_param2, int ,0);
 232
 233                 }
 234                 else {
 235                         /*      RPC API failed, return err to APP       */
 236                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 237                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 238                 }
 239
 240                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 241                                 out_param1,out_param2,out_param3,out_param4);
 242         }
 243         else {
 244                 /*      Invalid input range given by the APP.   */
 245                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input  - Password length error");
 246                 returnStatus = TAPI_API_INVALID_INPUT;
 247         }
 248
 249         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 250
 251         return returnStatus;
 252 }
 253
 254 /**********************************************************************************************
 255  *
 256  * This function is used to Activate or Deactivate the call forwarding feature.
 257  *
 258  * @param       forwardInfo[IN] of type TelSsForwardInfo_t which specifies the Teleservice and CF flavour, Forwarded to number.
 259  * @return      enum type TapiResult_t Specifies the API's Return result.
 260  * @remark
 261  *
 262  ***********************************************************************************************/
 263 EXPORT_API int tel_set_ss_forward(const TelSsForwardInfo_t *forwardInfo, int *req_id)
 264 {
 265         TS_BOOL ret = FALSE;
 266         int returnStatus = TAPI_API_SUCCESS;
 267
 268         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 269
 270         if (conn_name.length_of_name == 0) {
 271                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 272                 return TAPI_API_OPERATION_FAILED;
 273         }
 274
 275         /*      Check the input ptr. If NULL then return FALSE  */
 276         TAPI_RETURN_VAL_IF_FAIL(forwardInfo, TAPI_API_INVALID_PTR);
 277         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 278
 279
 280         TAPI_LIB_DEBUG(LEVEL_DEBUG, "szPhoneNumber is [%s]", forwardInfo->szPhoneNumber);
 281         TAPI_LIB_DEBUG(LEVEL_DEBUG, "szPhoneNumber Length is [%d]", strlen(forwardInfo->szPhoneNumber));
 282
 283         /*      Check input range for tele service type and call forwarding flavour     */
 284         if (((forwardInfo->Condition >= TAPI_SS_FORWARD_WHEN_UNCONDITIONAL_EV) && (forwardInfo->Condition <= TAPI_SS_FORWARD_WHEN_ALL_CONDITIONAL_EV))
 285                         && ((forwardInfo->Mode >= TAPI_CALL_FORWARD_MODE_DISABLE_EV) && (forwardInfo->Mode <= TAPI_CALL_FORWARD_MODE_ERASURE_EV))
 286                         && ((forwardInfo->Type >= TAPI_CS_FORWARD_TYPE_VOICE_EV) && (forwardInfo->Type <= TAPI_CS_FORWARD_TYPE_ALL_TELE))
 287                         && (strnlen(forwardInfo->szPhoneNumber, (TAPI_CALL_DIALDIGIT_LEN_MAX)) < (TAPI_CALL_DIALDIGIT_LEN_MAX))) {
 288                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 289                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 290                 TAPI_GLIB_INIT_PARAMS();
 291
 292                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 293                                 out_param1,out_param2,out_param3,out_param4);
 294
 295                 g_array_append_vals(in_param1, forwardInfo, sizeof(TelSsForwardInfo_t));
 296                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 297
 298                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 299
 300                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_FWDSETREQ, in_param1, in_param2, in_param3, in_param4,
 301                                 &out_param1, &out_param2, &out_param3, &out_param4);
 302                 if (ret) {
 303                         /*      Get the API error value as out param 1, from the server.        */
 304                         returnStatus = g_array_index(out_param1, int, 0);
 305                         *req_id = g_array_index(out_param2, int ,0);
 306                 }
 307                 else {
 308                         /*      RPC API failed, return err to APP       */
 309                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 310                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 311                 }
 312
 313                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 314                                 out_param1,out_param2,out_param3,out_param4);
 315         }
 316         else {
 317                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input ");
 318                 returnStatus = TAPI_API_INVALID_INPUT;
 319         }
 320
 321         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 322
 323         return returnStatus;
 324 }
 325
 326 /**********************************************************************************************
 327  *
 328  * This function is used to interrogate the status of call forwarding feature.
 329  *
 330  * @param       forwardType[IN] of type TelSsForwardType_t which specifies the telecommunication service.
 331  * @param       condition[IN]   is of type TelSsForwardWhen_t specified the CF flavour
 332  * @return      enum type TapiResult_t Specifies the API's Return result.
 333  * @remark
 334  *
 335  ***********************************************************************************************/
 336 EXPORT_API int tel_get_ss_forward_status(TelSsForwardType_t forwardType, TelSsForwardWhen_t condition, int *req_id)
 337 {
 338         TS_BOOL ret = FALSE;
 339         int returnStatus = TAPI_API_SUCCESS;
 340
 341         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 342
 343         if (conn_name.length_of_name == 0) {
 344                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 345                 return TAPI_API_OPERATION_FAILED;
 346         }
 347
 348         /*      Check the input ptr. If NULL then return FALSE  */
 349         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 350
 351         /*      Check input range for tele service type and call forwarding flavour     */
 352         if (((condition >= TAPI_SS_FORWARD_WHEN_UNCONDITIONAL_EV)
 353                         && (condition <= TAPI_SS_FORWARD_WHEN_ALL_CONDITIONAL_EV))
 354                         && ((forwardType >= TAPI_CS_FORWARD_TYPE_VOICE_EV) && (forwardType <= TAPI_CS_FORWARD_TYPE_ALL_TELE))) {
 355                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 356                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 357                 TAPI_GLIB_INIT_PARAMS();
 358
 359                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 360                                 out_param1,out_param2,out_param3,out_param4);
 361
 362                 g_array_append_vals(in_param1, &forwardType, sizeof(TelSsForwardType_t));
 363                 g_array_append_vals(in_param2, &condition, sizeof(TelSsForwardWhen_t));
 364                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 365
 366                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 367
 368                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_FWDQUERYSTATUSREQ, in_param1, in_param2, in_param3,
 369                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 370
 371                 if (ret) {
 372                         /*      Get the API error value as out param 1, from the server.        */
 373                         returnStatus = g_array_index(out_param1, int, 0);
 374                         *req_id = g_array_index(out_param2, int ,0);
 375
 376                 }
 377                 else {
 378                         /*      RPC API failed, return err to APP       */
 379                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 380                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 381                 }
 382
 383                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 384                                 out_param1,out_param2,out_param3,out_param4);
 385
 386         }
 387         else {
 388                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input ");
 389                 returnStatus = TAPI_API_INVALID_INPUT;
 390         }
 391
 392         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 393
 394         return returnStatus;
 395 }
 396
 397 /**********************************************************************************************
 398  *
 399  * This function is used to Activate or dectivate call waiting feature.
 400  *
 401  * @param       waitInfo[IN] of type TelSsWaitingInfo_t which specifies the telecommunication service and mode.
 402  * @return      enum type TapiResult_t Specifies the API's Return result.
 403  * @remark
 404  *
 405  ***********************************************************************************************/
 406 EXPORT_API int tel_set_ss_waiting(const TelSsWaitingInfo_t *waitInfo, int *req_id)
 407 {
 408         TS_BOOL ret = FALSE;
 409         int returnStatus = TAPI_API_SUCCESS;
 410
 411         if (conn_name.length_of_name == 0) {
 412                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 413                 return TAPI_API_OPERATION_FAILED;
 414         }
 415
 416         /*      Check the input ptr. If NULL then return FALSE  */
 417         TAPI_RETURN_VAL_IF_FAIL(waitInfo, TAPI_API_INVALID_PTR);
 418         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 419
 420         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 421
 422         /*      Check input range for tele service type and call forwarding flavour     */
 423         if (((waitInfo->Mode >= TAPI_SS_CW_ACTIVATE)
 424                         && (waitInfo->Mode <= TAPI_SS_CW_DEACTIVATE))
 425                         && ((waitInfo->CallType >= TAPI_CALL_TYPE_VOICE_EV) && (waitInfo->CallType <= TAPI_CALL_TYPE_ALL_TELE))) {
 426
 427                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 428                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 429                 TAPI_GLIB_INIT_PARAMS();
 430
 431                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 432                                 out_param1,out_param2,out_param3,out_param4);
 433
 434                 g_array_append_vals(in_param1, waitInfo, sizeof(TelSsWaitingInfo_t));
 435                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 436
 437                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 438
 439                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_WAITSETREQ, in_param1, in_param2, in_param3, in_param4,
 440                                 &out_param1, &out_param2, &out_param3, &out_param4);
 441
 442                 if (ret) {
 443                         /*      Get the API error value as out param 1, from the server.        */
 444                         returnStatus = g_array_index(out_param1, int, 0);
 445                         *req_id = g_array_index(out_param2, int ,0);
 446                 }
 447                 else {
 448                         /*      RPC API failed, return err to APP       */
 449                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 450                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 451                 }
 452
 453                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 454                                 out_param1,out_param2,out_param3,out_param4);
 455         }
 456         else {
 457                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input ");
 458                 returnStatus = TAPI_API_INVALID_INPUT;
 459         }
 460
 461         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 462
 463         return returnStatus;
 464 }
 465
 466 /**********************************************************************************************
 467  *
 468  * This function is used to interrogate the status of call waiting feature.
 469  *
 470  * @param       CallType[IN] of type TelSsCallType_t which specifies the telecommunication service .
 471  * @return      enum type TapiResult_t Specifies the API's Return result.
 472  * @remark
 473  *
 474  ***********************************************************************************************/
 475
 476 EXPORT_API int tel_get_ss_waiting_status(const TelSsCallType_t CallType, int *req_id)
 477 {
 478         TS_BOOL ret = FALSE;
 479         int returnStatus = TAPI_API_SUCCESS;
 480
 481         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 482
 483         if (conn_name.length_of_name == 0) {
 484                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 485                 return TAPI_API_OPERATION_FAILED;
 486         }
 487
 488         /*      Check the input ptr. If NULL then return FALSE  */
 489         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 490
 491         /*      Check input range for tele service type */
 492         if ((CallType >= TAPI_CALL_TYPE_VOICE_EV) && (CallType <= TAPI_CALL_TYPE_ALL_TELE)) {
 493
 494                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 495                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 496                 TAPI_GLIB_INIT_PARAMS();
 497
 498                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 499                                 out_param1,out_param2,out_param3,out_param4);
 500
 501                 g_array_append_vals(in_param1, &CallType, sizeof(TelSsCallType_t));
 502                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 503
 504                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 505
 506                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_WAITQUERYSTATUSREQ, in_param1, in_param2, in_param3,
 507                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 508
 509                 if (ret) {
 510                         /*      Get the API error value as out param 1, from the server.        */
 511                         returnStatus = g_array_index(out_param1, int, 0);
 512                         *req_id = g_array_index(out_param2, int ,0);
 513                 }
 514                 else {
 515                         /*      RPC API failed, return err to APP       */
 516                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 517                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 518                 }
 519
 520                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 521                                 out_param1,out_param2,out_param3,out_param4);
 522         }
 523         else {
 524                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input ");
 525                 returnStatus = TAPI_API_INVALID_INPUT;
 526         }
 527
 528         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", returnStatus);
 529
 530         return returnStatus;
 531 }
 532
 533 /**********************************************************************************************
 534  *
 535  * This function is used to interrogate the status of CLI services feature.
 536  *
 537  * @param       CliType[IN] of type TelSsCliType_t which specifies the CLI service .
 538  * @return      enum type TapiResult_t Specifies the API's Return result.
 539  * @remark
 540  *
 541  ***********************************************************************************************/
 542 EXPORT_API int tel_get_ss_cli_status(TelSsCliType_t CliType, int *req_id)
 543 {
 544         TS_BOOL ret = FALSE;
 545         int api_err = TAPI_API_SUCCESS;
 546
 547         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 548
 549         if (conn_name.length_of_name == 0) {
 550                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 551                 return TAPI_API_OPERATION_FAILED;
 552         }
 553
 554         /*      Check the input ptr. If NULL then return FALSE  */
 555         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 556
 557         /*      Check input range for CLI service type  */
 558         if ((CliType >= TAPI_SS_CLI_CLIP) && (CliType <= TAPI_SS_CLI_CNAP)) {
 559                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 560                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 561                 TAPI_GLIB_INIT_PARAMS();
 562
 563                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 564                                 out_param1,out_param2,out_param3,out_param4);
 565
 566                 g_array_append_vals(in_param1, &CliType, sizeof(TelSsCliType_t));
 567                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 568
 569                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 570
 571                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_CLIQUERYSTATUSREQ, in_param1, in_param2, in_param3,
 572                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 573
 574                 if (ret) {
 575                         /*      Get the API error value as out param 1, from the server.        */
 576                         api_err = g_array_index(out_param1, int, 0);
 577                         *req_id = g_array_index(out_param2, int ,0);
 578
 579                 }
 580                 else {
 581                         /*      RPC API failed, return err to APP       */
 582                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 583                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 584                 }
 585
 586                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 587                                 out_param1,out_param2,out_param3,out_param4);
 588
 589         }
 590         else {
 591                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input ");
 592                 api_err = TAPI_API_INVALID_INPUT;
 593         }
 594
 595         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 596
 597         return api_err;
 598 }
 599
 600 /**********************************************************************************************
 601  *
 602  * This function is used to send a USSD string and also the User response for a NW intiated USSD.
 603  *
 604  * @param       pAppMsg[IN] of type TelSsUssdMsgInfo_t which specifies the USSD String,length of the string, format of the string.
 605  * @return      enum type TapiResult_t Specifies the API's Return result.
 606  * @remark      TelSsUssdMsgInfo_t ->IndType is not used while calling this function, This is used for sending the response.
 607  *                      Limo standard defines only one structure for Request and response.
 608  *
 609  ***********************************************************************************************/
 610 EXPORT_API int tel_send_ss_ussd_request(const TelSsUssdMsgInfo_t *ussd_info, int *req_id)
 611 {
 612         TS_BOOL ret = FALSE;
 613         int api_err = TAPI_API_SUCCESS;
 614         int emergency_mode = 0;
 615
 616         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 617
 618         if (vconf_get_int("db/telephony/emergency", &emergency_mode) != 0) {
 619                 TAPI_LIB_DEBUG(LEVEL_ERR, "[FAIL]GET db/telephony/emergency");
 620                 return TAPI_API_OPERATION_FAILED;
 621         }
 622         if (emergency_mode) {
 623                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "emergency mode on");
 624                 return TAPI_API_OPERATION_FAILED;
 625         }
 626
 627         if (conn_name.length_of_name == 0) {
 628                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 629                 return TAPI_API_OPERATION_FAILED;
 630         }
 631
 632         /*      Check the input ptr. If NULL then return FALSE  */
 633         TAPI_RETURN_VAL_IF_FAIL(ussd_info, TAPI_API_INVALID_PTR);
 634         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 635
 636         if (((ussd_info->UssdStringLength > 0) && (ussd_info->UssdStringLength < TAPI_SS_USSD_DATA_SIZE_MAX))) {
 637
 638                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"--- USSD STR(%s),length = %d", ussd_info->szUssdString,ussd_info->UssdStringLength);
 639
 640                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 641                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 642                 TAPI_GLIB_INIT_PARAMS();
 643
 644                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 645                                 out_param1,out_param2,out_param3,out_param4);
 646
 647                 g_array_append_vals(in_param1, ussd_info, sizeof(TelSsUssdMsgInfo_t));
 648                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 649
 650                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 651
 652                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_USSDSENDSTRINGREQ, in_param1, in_param2, in_param3,
 653                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 654
 655                 if (ret) {
 656                         /*      Get the API error value as out param 1, from the server.        */
 657                         api_err = g_array_index(out_param1, int, 0);
 658                         *req_id = g_array_index(out_param2, int ,0);
 659                 }
 660                 else {
 661                         /*      RPC API failed, return err to APP       */
 662                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 663                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 664                 }
 665
 666                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 667                                 out_param1,out_param2,out_param3,out_param4);
 668         }
 669         else {
 670                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input -USSD  length Error ");
 671                 api_err = TAPI_API_INVALID_INPUT;
 672         }
 673
 674         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 675
 676         return api_err;
 677 }
 678
 679 /**********************************************************************************************
 680  *
 681  * This function is used to send a USSD Rsp.
 682  *
 683  * @param       ussdRspRecord, req_id
 684  * @return      enum type TapiResult_t Specifies the API's Return result.
 685  * @remark
 686  *
 687  ***********************************************************************************************/
 688 EXPORT_API int tel_send_ss_ussd_response(const TelSsUssdMsgInfo_t *ussd_rsp, int *req_id)
 689 {
 690         TS_BOOL ret = FALSE;
 691         int returnStatus = TAPI_API_SUCCESS;
 692
 693         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 694
 695         if (conn_name.length_of_name == 0) {
 696                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 697                 return TAPI_API_OPERATION_FAILED;
 698         }
 699
 700         /*      Check the input ptr. If NULL then return FALSE  */
 701         TAPI_RETURN_VAL_IF_FAIL(ussd_rsp, TAPI_API_INVALID_PTR);
 702         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 703
 704         if (((ussd_rsp->UssdStringLength > 0) && (ussd_rsp->UssdStringLength < TAPI_SS_USSD_DATA_SIZE_MAX))) {
 705                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 706                 TAPI_RETURN_VAL_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 707                 TAPI_GLIB_INIT_PARAMS();
 708
 709                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 710                                 out_param1,out_param2,out_param3,out_param4);
 711
 712                 g_array_append_vals(in_param1, ussd_rsp, sizeof(TelSsUssdMsgInfo_t));
 713                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 714
 715                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "SS Service Request:(Send USSD string req)");
 716
 717                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_USSDRSP, in_param1, in_param2, in_param3, in_param4,
 718                                 &out_param1, &out_param2, &out_param3, &out_param4);
 719
 720                 if (ret) {
 721                         returnStatus = g_array_index(out_param1, int, 0);
 722                         *req_id = g_array_index(out_param2, int ,0);
 723                 }
 724                 else {
 725                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 726                 }
 727
 728                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 729                                 out_param1,out_param2,out_param3,out_param4);
 730         }
 731         else {
 732                 returnStatus = TAPI_API_INVALID_INPUT;
 733                 TAPI_LIB_DEBUG(LEVEL_ERR,"INVALID INPUT TYPE  \n");
 734                 TAPI_LIB_DEBUG(LEVEL_ERR, "##### Invalid Response Type ......");
 735         }
 736
 737         return returnStatus;
 738 }
 739
 740 /**********************************************************************************************
 741  *
 742  * This function is used to send a USSD cancel to release ussd session.
 743  *
 744  * @param       req_id
 745  * @return      enum type TapiResult_t Specifies the API's Return result.
 746  * @remark
 747  *
 748  ***********************************************************************************************/
 749 EXPORT_API int tel_send_ss_ussd_cancel(int *req_id)
 750 {
 751         TS_BOOL ret = FALSE;
 752         int returnStatus = TAPI_API_SUCCESS;
 753
 754         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 755
 756         if (conn_name.length_of_name == 0) {
 757                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 758                 return TAPI_API_OPERATION_FAILED;
 759         }
 760
 761         /* Check the input ptr. If NULL then return FALSE */
 762         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 763
 764         /* Check if D-Bus service is available. If Failed then return FALSE */
 765         TAPI_RETURN_VAL_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 766         TAPI_GLIB_INIT_PARAMS();
 767
 768         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 769                         out_param1,out_param2,out_param3,out_param4);
 770
 771         TAPI_LIB_DEBUG(LEVEL_DEBUG, "SS Service Request:(Send USSD cancel)");
 772         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 773
 774         ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_USSDCANCEL, in_param1, in_param2, in_param3, in_param4,
 775                         &out_param1, &out_param2, &out_param3, &out_param4);
 776
 777         if (ret) {
 778                 returnStatus = g_array_index(out_param1, int, 0);
 779                 *req_id = g_array_index(out_param2, int ,0);
 780         }
 781         else {
 782                 returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 783         }
 784
 785         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 786                         out_param1,out_param2,out_param3,out_param4);
 787
 788         return returnStatus;
 789 }
 790
 791 /**********************************************************************************************
 792  *
 793  * This function is used to Sets AOC information.
 794  *
 795  * @param       AocType[IN] of type TelSsAocType_t which specifies the which AOC type to read.
 796  * @return      enum type TapiResult_t Specifies the API's Return result.
 797  * @remark
 798  *
 799  ***********************************************************************************************/
 800 EXPORT_API int tel_get_ss_aoc_info(TelSsAocType_t AocType, int *req_id)
 801 {
 802         TS_BOOL ret = FALSE;
 803         int api_err = TAPI_API_SUCCESS;
 804
 805         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 806
 807         if (conn_name.length_of_name == 0) {
 808                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 809                 return TAPI_API_OPERATION_FAILED;
 810         }
 811
 812         /*      Check the input ptr. If NULL then return FALSE  */
 813         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 814
 815         /*      Check input range for Aoc type  */
 816         if ((AocType == TAPI_SS_AOC_TYPE_ACM)
 817                         || (AocType == TAPI_SS_AOC_TYPE_PUC)
 818                         || (AocType == TAPI_SS_AOC_TYPE_MAXACM)
 819                         || (AocType == TAPI_SS_AOC_TYPE_CCM)) {
 820                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 821                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 822                 TAPI_GLIB_INIT_PARAMS();
 823
 824                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 825                                 out_param1,out_param2,out_param3,out_param4);
 826
 827                 g_array_append_vals(in_param1, &AocType, sizeof(TelSsAocType_t));
 828                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 829
 830                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 831
 832                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_GETCALLCOSTREQ, in_param1, in_param2, in_param3,
 833                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 834
 835                 if (ret) {
 836                         /*      Get the API error value as out param 1, from the server.        */
 837                         api_err = g_array_index(out_param1, int, 0);
 838                         *req_id = g_array_index(out_param2, int ,0);
 839                 }
 840                 else {
 841                         /*      RPC API failed, return err to APP       */
 842                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 843                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 844                 }
 845
 846                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 847                                 out_param1,out_param2,out_param3,out_param4);
 848         }
 849         else {
 850                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input - Invalid AOC type");
 851                 api_err = TAPI_API_INVALID_INPUT;
 852         }
 853
 854         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 855
 856         return api_err;
 857 }
 858
 859 /**********************************************************************************************
 860  *
 861  * This function is used to Sets AOC information.
 862  *
 863  * @param       AocSetInfo[IN] of type TelCallAocInfo_t which specifies the AOC info parameters .
 864  * @return      enum type TapiResult_t Specifies the API's Return result.
 865  * @remark
 866  *
 867  ***********************************************************************************************/
 868 EXPORT_API int tel_set_ss_aoc_info(TelCallAocInfo_t *AocSetInfo, int *RequestId)
 869 {
 870         TS_BOOL ret = FALSE;
 871         int api_err = TAPI_API_SUCCESS;
 872
 873         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 874
 875         if (conn_name.length_of_name == 0) {
 876                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 877                 return TAPI_API_OPERATION_FAILED;
 878         }
 879
 880         /*      Check the input ptr. If NULL then return FALSE  */
 881         TAPI_RETURN_VAL_IF_FAIL(AocSetInfo, TAPI_API_INVALID_PTR);
 882         TAPI_RETURN_VAL_IF_FAIL(RequestId , TAPI_API_INVALID_PTR);
 883
 884         if ((AocSetInfo->PPM) < ((float) (TAPI_MAX_ULONG / 1000))) {
 885                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Valid ... Input PPM smaller than MAX");
 886         }
 887         else {
 888                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"INVALID.... INPUT greater than MAX");
 889         }
 890
 891         /*      Check input range for Aoc type  */
 892         if ((AocSetInfo->PPM < (float) (TAPI_MAX_ULONG / 1000))
 893                         && ((AocSetInfo->AocType == TAPI_SS_AOC_TYPE_RESET)
 894                                 || (AocSetInfo->AocType == TAPI_SS_AOC_TYPE_PUC)
 895                                 || (AocSetInfo->AocType == TAPI_SS_AOC_TYPE_MAXACM) )) {
 896                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 897                 TAPI_GLIB_INIT_PARAMS();
 898
 899                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 900                                 out_param1,out_param2,out_param3,out_param4);
 901
 902                 g_array_append_vals(in_param1, AocSetInfo, sizeof(TelCallAocInfo_t));
 903                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 904
 905                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 906
 907                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_SETCALLCOSTREQ, in_param1, in_param2, in_param3,
 908                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 909
 910                 if (TRUE == ret) {
 911                         /*      Get the API error value as out param 1, from the server.        */
 912                         api_err = g_array_index(out_param1, int, 0);
 913
 914                         /*      Get the Request ID as out param 2, from the server.    */
 915                         *RequestId = g_array_index(out_param2, int, 0);
 916                 }
 917                 else {
 918                         /*      RPC API failed, return err to APP       */
 919                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 920                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 921                 }
 922
 923                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 924                                 out_param1,out_param2,out_param3,out_param4);
 925         }
 926         else {
 927                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input -Invalid AOC type ");
 928                 api_err = TAPI_API_INVALID_INPUT;
 929         }
 930
 931         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 932
 933         return api_err;
 934 }
 935
 936 /*      EOF  */