src/tapi_proxy_ss.c

   1 /*
   2  * libslp-tapi
   3  *
   4  * Copyright (c) 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Kyeongchul Kim <kyeongchul.kim@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 EXPORT_API int tel_send_ss_ussd_request(const TelSsUssdMsgInfo_t *ussd_info, int *req_id)
 601 {
 602         TS_BOOL ret = FALSE;
 603         int api_err = TAPI_API_SUCCESS;
 604         int emergency_mode = 0;
 605
 606         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 607
 608         if (vconf_get_int("db/telephony/emergency", &emergency_mode) != 0) {
 609                 TAPI_LIB_DEBUG(LEVEL_ERR, "[FAIL]GET db/telephony/emergency");
 610                 return TAPI_API_OPERATION_FAILED;
 611         }
 612         if (emergency_mode) {
 613                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "emergency mode on");
 614                 return TAPI_API_OPERATION_FAILED;
 615         }
 616
 617         if (conn_name.length_of_name == 0) {
 618                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 619                 return TAPI_API_OPERATION_FAILED;
 620         }
 621
 622         /*      Check the input ptr. If NULL then return FALSE  */
 623         TAPI_RETURN_VAL_IF_FAIL(ussd_info, TAPI_API_INVALID_PTR);
 624         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 625
 626         if (((ussd_info->UssdStringLength > 0) && (ussd_info->UssdStringLength < TAPI_SS_USSD_DATA_SIZE_MAX))) {
 627
 628                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"--- USSD STR(%s),length = %d", ussd_info->szUssdString,ussd_info->UssdStringLength);
 629
 630                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 631                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 632                 TAPI_GLIB_INIT_PARAMS();
 633
 634                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 635                                 out_param1,out_param2,out_param3,out_param4);
 636
 637                 g_array_append_vals(in_param1, ussd_info, sizeof(TelSsUssdMsgInfo_t));
 638                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 639
 640                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 641
 642                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_USSDSENDSTRINGREQ, in_param1, in_param2, in_param3,
 643                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 644
 645                 if (ret) {
 646                         /*      Get the API error value as out param 1, from the server.        */
 647                         api_err = g_array_index(out_param1, int, 0);
 648                         *req_id = g_array_index(out_param2, int ,0);
 649                 }
 650                 else {
 651                         /*      RPC API failed, return err to APP       */
 652                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 653                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 654                 }
 655
 656                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 657                                 out_param1,out_param2,out_param3,out_param4);
 658         }
 659         else {
 660                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input -USSD  length Error ");
 661                 api_err = TAPI_API_INVALID_INPUT;
 662         }
 663
 664         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 665
 666         return api_err;
 667 }
 668
 669 /**********************************************************************************************
 670  *
 671  * This function is used to send a USSD Rsp.
 672  *
 673  * @param       ussdRspRecord, req_id
 674  * @return      enum type TapiResult_t Specifies the API's Return result.
 675  * @remark
 676  *
 677  ***********************************************************************************************/
 678 EXPORT_API int tel_send_ss_ussd_response(const TelSsUssdMsgInfo_t *ussd_rsp, int *req_id)
 679 {
 680         TS_BOOL ret = FALSE;
 681         int returnStatus = TAPI_API_SUCCESS;
 682
 683         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 684
 685         if (conn_name.length_of_name == 0) {
 686                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 687                 return TAPI_API_OPERATION_FAILED;
 688         }
 689
 690         /*      Check the input ptr. If NULL then return FALSE  */
 691         TAPI_RETURN_VAL_IF_FAIL(ussd_rsp, TAPI_API_INVALID_PTR);
 692         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 693
 694         if (((ussd_rsp->UssdStringLength > 0) && (ussd_rsp->UssdStringLength < TAPI_SS_USSD_DATA_SIZE_MAX))) {
 695                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 696                 TAPI_RETURN_VAL_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 697                 TAPI_GLIB_INIT_PARAMS();
 698
 699                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 700                                 out_param1,out_param2,out_param3,out_param4);
 701
 702                 g_array_append_vals(in_param1, ussd_rsp, sizeof(TelSsUssdMsgInfo_t));
 703                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 704
 705                 TAPI_LIB_DEBUG(LEVEL_DEBUG, "SS Service Request:(Send USSD string req)");
 706
 707                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_USSDRSP, in_param1, in_param2, in_param3, in_param4,
 708                                 &out_param1, &out_param2, &out_param3, &out_param4);
 709
 710                 if (ret) {
 711                         returnStatus = g_array_index(out_param1, int, 0);
 712                         *req_id = g_array_index(out_param2, int ,0);
 713                 }
 714                 else {
 715                         returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 716                 }
 717
 718                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 719                                 out_param1,out_param2,out_param3,out_param4);
 720         }
 721         else {
 722                 returnStatus = TAPI_API_INVALID_INPUT;
 723                 TAPI_LIB_DEBUG(LEVEL_ERR,"INVALID INPUT TYPE  \n");
 724                 TAPI_LIB_DEBUG(LEVEL_ERR, "##### Invalid Response Type ......");
 725         }
 726
 727         return returnStatus;
 728 }
 729
 730 /**********************************************************************************************
 731  *
 732  * This function is used to send a USSD cancel to release ussd session.
 733  *
 734  * @param       req_id
 735  * @return      enum type TapiResult_t Specifies the API's Return result.
 736  * @remark
 737  *
 738  ***********************************************************************************************/
 739 EXPORT_API int tel_send_ss_ussd_cancel(int *req_id)
 740 {
 741         TS_BOOL ret = FALSE;
 742         int returnStatus = TAPI_API_SUCCESS;
 743
 744         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 745
 746         if (conn_name.length_of_name == 0) {
 747                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 748                 return TAPI_API_OPERATION_FAILED;
 749         }
 750
 751         /* Check the input ptr. If NULL then return FALSE */
 752         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 753
 754         /* Check if D-Bus service is available. If Failed then return FALSE */
 755         TAPI_RETURN_VAL_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 756         TAPI_GLIB_INIT_PARAMS();
 757
 758         TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 759                         out_param1,out_param2,out_param3,out_param4);
 760
 761         TAPI_LIB_DEBUG(LEVEL_DEBUG, "SS Service Request:(Send USSD cancel)");
 762         g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 763
 764         ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_USSDCANCEL, in_param1, in_param2, in_param3, in_param4,
 765                         &out_param1, &out_param2, &out_param3, &out_param4);
 766
 767         if (ret) {
 768                 returnStatus = g_array_index(out_param1, int, 0);
 769                 *req_id = g_array_index(out_param2, int ,0);
 770         }
 771         else {
 772                 returnStatus = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 773         }
 774
 775         TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 776                         out_param1,out_param2,out_param3,out_param4);
 777
 778         return returnStatus;
 779 }
 780
 781 /**********************************************************************************************
 782  *
 783  * This function is used to Sets AOC information.
 784  *
 785  * @param       AocType[IN] of type TelSsAocType_t which specifies the which AOC type to read.
 786  * @return      enum type TapiResult_t Specifies the API's Return result.
 787  * @remark
 788  *
 789  ***********************************************************************************************/
 790 EXPORT_API int tel_get_ss_aoc_info(TelSsAocType_t AocType, int *req_id)
 791 {
 792         TS_BOOL ret = FALSE;
 793         int api_err = TAPI_API_SUCCESS;
 794
 795         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 796
 797         if (conn_name.length_of_name == 0) {
 798                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 799                 return TAPI_API_OPERATION_FAILED;
 800         }
 801
 802         /*      Check the input ptr. If NULL then return FALSE  */
 803         TAPI_RETURN_VAL_IF_FAIL(req_id, TAPI_API_INVALID_PTR);
 804
 805         /*      Check input range for Aoc type  */
 806         if ((AocType == TAPI_SS_AOC_TYPE_ACM)
 807                         || (AocType == TAPI_SS_AOC_TYPE_PUC)
 808                         || (AocType == TAPI_SS_AOC_TYPE_MAXACM)
 809                         || (AocType == TAPI_SS_AOC_TYPE_CCM)) {
 810                 /*      Check if D-Bus service is available. If Failed then return FALSE        */
 811                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 812                 TAPI_GLIB_INIT_PARAMS();
 813
 814                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 815                                 out_param1,out_param2,out_param3,out_param4);
 816
 817                 g_array_append_vals(in_param1, &AocType, sizeof(TelSsAocType_t));
 818                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 819
 820                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 821
 822                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_GETCALLCOSTREQ, in_param1, in_param2, in_param3,
 823                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 824
 825                 if (ret) {
 826                         /*      Get the API error value as out param 1, from the server.        */
 827                         api_err = g_array_index(out_param1, int, 0);
 828                         *req_id = g_array_index(out_param2, int ,0);
 829                 }
 830                 else {
 831                         /*      RPC API failed, return err to APP       */
 832                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 833                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 834                 }
 835
 836                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 837                                 out_param1,out_param2,out_param3,out_param4);
 838         }
 839         else {
 840                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input - Invalid AOC type");
 841                 api_err = TAPI_API_INVALID_INPUT;
 842         }
 843
 844         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 845
 846         return api_err;
 847 }
 848
 849 /**********************************************************************************************
 850  *
 851  * This function is used to Sets AOC information.
 852  *
 853  * @param       AocSetInfo[IN] of type TelCallAocInfo_t which specifies the AOC info parameters .
 854  * @return      enum type TapiResult_t Specifies the API's Return result.
 855  * @remark
 856  *
 857  ***********************************************************************************************/
 858 EXPORT_API int tel_set_ss_aoc_info(TelCallAocInfo_t *AocSetInfo, int *RequestId)
 859 {
 860         TS_BOOL ret = FALSE;
 861         int api_err = TAPI_API_SUCCESS;
 862
 863         TAPI_LIB_DEBUG(LEVEL_DEBUG,"Func Entrance");
 864
 865         if (conn_name.length_of_name == 0) {
 866                 TAPI_LIB_DEBUG(LEVEL_ERR, "No dbus connection name");
 867                 return TAPI_API_OPERATION_FAILED;
 868         }
 869
 870         /*      Check the input ptr. If NULL then return FALSE  */
 871         TAPI_RETURN_VAL_IF_FAIL(AocSetInfo, TAPI_API_INVALID_PTR);
 872         TAPI_RETURN_VAL_IF_FAIL(RequestId , TAPI_API_INVALID_PTR);
 873
 874         if ((AocSetInfo->PPM) < ((float) (TAPI_MAX_ULONG / 1000))) {
 875                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Valid ... Input PPM smaller than MAX");
 876         }
 877         else {
 878                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"INVALID.... INPUT greater than MAX");
 879         }
 880
 881         /*      Check input range for Aoc type  */
 882         if ((AocSetInfo->PPM < (float) (TAPI_MAX_ULONG / 1000))
 883                         && ((AocSetInfo->AocType == TAPI_SS_AOC_TYPE_RESET)
 884                                 || (AocSetInfo->AocType == TAPI_SS_AOC_TYPE_PUC)
 885                                 || (AocSetInfo->AocType == TAPI_SS_AOC_TYPE_MAXACM) )) {
 886                 TAPI_RET_ERR_NUM_IF_FAIL(tapi_check_dbus_status(), TAPI_API_SYSTEM_RPC_LINK_DOWN);
 887                 TAPI_GLIB_INIT_PARAMS();
 888
 889                 TAPI_GLIB_ALLOC_PARAMS(in_param1,in_param2,in_param3,in_param4,
 890                                 out_param1,out_param2,out_param3,out_param4);
 891
 892                 g_array_append_vals(in_param1, AocSetInfo, sizeof(TelCallAocInfo_t));
 893                 g_array_append_vals(in_param4, &conn_name, sizeof(tapi_dbus_connection_name));
 894
 895                 TAPI_LIB_DEBUG(LEVEL_DEBUG,"Calling Call Back func ");
 896
 897                 ret = tapi_send_request(TAPI_CS_SERVICE_SS, TAPI_CS_SS_SETCALLCOSTREQ, in_param1, in_param2, in_param3,
 898                                 in_param4, &out_param1, &out_param2, &out_param3, &out_param4);
 899
 900                 if (TRUE == ret) {
 901                         /*      Get the API error value as out param 1, from the server.        */
 902                         api_err = g_array_index(out_param1, int, 0);
 903
 904                         /*      Get the Request ID as out param 2, from the server.    */
 905                         *RequestId = g_array_index(out_param2, int, 0);
 906                 }
 907                 else {
 908                         /*      RPC API failed, return err to APP       */
 909                         TAPI_LIB_DEBUG(LEVEL_ALERT, "RPC Link is down");
 910                         api_err = TAPI_API_SYSTEM_RPC_LINK_DOWN;
 911                 }
 912
 913                 TAPI_GLIB_FREE_PARAMS(in_param1,in_param2,in_param3,in_param4,
 914                                 out_param1,out_param2,out_param3,out_param4);
 915         }
 916         else {
 917                 TAPI_LIB_DEBUG(LEVEL_ERR,"Received Invalid Input -Invalid AOC type ");
 918                 api_err = TAPI_API_INVALID_INPUT;
 919         }
 920
 921         TAPI_LIB_DEBUG(LEVEL_INFO, "Returning TapiResult_t [%+d]", api_err);
 922
 923         return api_err;
 924 }
 925
 926 /*      EOF  */