src/cst-tapi-request.c

   1 /*
   2  * Copyright 2012  Samsung Electronics Co., Ltd
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.tizenopensource.org/license
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <Eina.h>
  18
  19 #include <TelSs.h>
  20 #include <ITapiSs.h>
  21 #include <TapiUtility.h>
  22 #include <tapi_event.h>
  23 #include "cst-tapi-request.h"
  24 #include "cst-common.h"
  25 #include "cst-common-string.h"
  26 #include "cst-tapi-request.h"
  27
  28 static void __cst_remove_ss_request(void *data);
  29 static void __cst_send_ss_req_to_telephony_server(CallSettingSSReq_t *req);
  30 static gboolean __cst_ss_barring_resp_cb(TapiHandle *handle, int result, void *data, void *user_data);
  31 static gboolean __cst_ss_forward_resp_cb(TapiHandle *handle, int result, void *data, void *user_data);
  32 static gboolean __cst_ss_waiting_resp_cb(TapiHandle *handle, int result, void *data, void *user_data);
  33 static int __cst_get_ciss_error_from_tapi_error(TelSsCause_t tapi_err);
  34
  35 static gboolean __cst_ss_barring_resp_cb(TapiHandle *handle, int result, void *data, void *user_data)
  36 {
  37         DBG("Enter");
  38         TelSsCause_t ss_result = result;
  39         TelSsBarringResp_t *cb_data = NULL;
  40         CallSettingSSReq_t *req = NULL;
  41         CstUgData_t *ugd = NULL;
  42
  43         cb_data = (TelSsBarringResp_t *)data;
  44         if (cb_data == NULL) {
  45                 ERR("data is NULL, returning");
  46                 return FALSE;
  47         }
  48
  49         req = (CallSettingSSReq_t *)user_data;
  50         if (req == NULL) {
  51                 ERR("User_data is NULL, returning");
  52                 return FALSE;
  53         }
  54
  55         ugd = (CstUgData_t *)req->ugd;
  56         if (ugd == NULL) {
  57                 ERR("ugd is NULL, returning");
  58                 return FALSE;
  59         }
  60
  61         retv_if(req->is_requesting == EINA_FALSE, 0);
  62         if (req->is_canceled == EINA_TRUE) {
  63                 __cst_remove_ss_request(ugd);
  64                 return FALSE;
  65         }
  66
  67         if (ss_result != TAPI_SS_SUCCESS) {
  68                 DBG("Event Status is %d", ss_result);
  69                 int error;
  70                 error = __cst_get_ciss_error_from_tapi_error(ss_result);
  71                 if (req) {
  72                         req->func(req->call_type, req->flavour, EINA_FALSE, NULL, error, req->action, req->data, req->waiting_time);
  73                 }
  74                 __cst_remove_ss_request(ugd);
  75                 return FALSE;
  76         }
  77
  78         char number[50];
  79         Eina_Bool cb_state = EINA_FALSE;
  80         int cb_flavour = -1;
  81         int call_type = -1;
  82         int i = 0;
  83
  84         for (i = 0; i < cb_data->record_num; ++i) {
  85                 number[0] = '\0';
  86                 DBG("TeleCommService=0x%x", cb_data->record[i].Class);
  87                 DBG("Flavour=0x%x", cb_data->record[i].Flavour);
  88                 DBG("Status=0x%x", cb_data->record[i].Status);
  89                 switch (cb_data->record[i].Class) {
  90                 case TAPI_SS_CLASS_VOICE:
  91                         call_type = CST_CALLTYPE_VOICE;
  92                         break;
  93                 case TAPI_SS_CLASS_ALL_TELE:
  94                 case TAPI_SS_CLASS_ALL_TELE_BEARER:
  95                         call_type = CST_CALLTYPE_ALL;
  96                         break;
  97                 default:
  98                         ERR("Invalid call type");
  99                         return FALSE;
 100                 }
 101
 102                 if (req->call_type != call_type && call_type != CST_CALLTYPE_ALL)
 103                         continue;
 104
 105                 switch (cb_data->record[i].Flavour) {
 106                 case TAPI_SS_CB_TYPE_BAOC:
 107                         cb_flavour = CST_SSTYPE_CB_OC;
 108                         break;
 109                 case TAPI_SS_CB_TYPE_BOIC:
 110                         cb_flavour = CST_SSTYPE_CB_OIC;
 111                         break;
 112                 case TAPI_SS_CB_TYPE_BOIC_NOT_HC:
 113                         cb_flavour = CST_SSTYPE_CB_OICEH;
 114                         break;
 115                 case TAPI_SS_CB_TYPE_BAIC:
 116                         cb_flavour = CST_SSTYPE_CB_IC;
 117                         break;
 118                 case TAPI_SS_CB_TYPE_BIC_ROAM:
 119                         cb_flavour = CST_SSTYPE_CB_ICR;
 120                         break;
 121                 default:
 122                         ERR("Invalid CB Flavour");
 123                         return FALSE;
 124                 }
 125
 126                 switch (cb_data->record[i].Status) {
 127                 case TAPI_SS_STATUS_ACTIVE:
 128                 case TAPI_SS_STATUS_REGISTERED:
 129                         cb_state = EINA_TRUE;
 130                         break;
 131                 case TAPI_SS_STATUS_NOTHING:
 132                 case TAPI_SS_STATUS_PROVISIONED:
 133                 case TAPI_SS_STATUS_QUIESCENT:
 134                         cb_state = EINA_FALSE;
 135                         break;
 136                 default:
 137                         ERR("Invalid CB status");
 138                         return FALSE;
 139                 }
 140         }
 141
 142         req->func(call_type, cb_flavour, cb_state, NULL, CST_ERROR_NONE, req->action, req->data, req->waiting_time);
 143         __cst_remove_ss_request(ugd);
 144         return TRUE;
 145 }
 146
 147 static gboolean __cst_ss_forward_resp_cb(TapiHandle *handle, int result, void *data, void *user_data)
 148 {
 149         DBG("Enter __cst_ss_forward_resp_cb");
 150         TelSsCause_t ss_result = result;
 151         TelSsForwardResp_t *cf_data = NULL;
 152         CallSettingSSReq_t *req = NULL;
 153         CstUgData_t *ugd = NULL;
 154
 155         cf_data = (TelSsForwardResp_t *)data;
 156         if (cf_data == NULL) {
 157                 ERR("data is NULL, returning");
 158                 return FALSE;
 159         }
 160
 161         req = (CallSettingSSReq_t *)user_data;
 162         if (req == NULL) {
 163                 ERR("User_data is NULL, returning");
 164                 return FALSE;
 165         }
 166
 167         ugd = (CstUgData_t *)req->ugd;
 168         if (ugd == NULL) {
 169                 ERR("ugd is NULL, returning");
 170                 return FALSE;
 171         }
 172
 173         retv_if(req->is_requesting == EINA_FALSE, 0);
 174         if (req->is_canceled == EINA_TRUE) {
 175                 DBG("Req(0x%xp,req_id=%d) was canceled. So It will be removed", req, req->req_id);
 176                 __cst_remove_ss_request(ugd);
 177                 return FALSE;
 178         }
 179
 180         if (ss_result != TAPI_SS_SUCCESS) {
 181                 DBG("Event Status is %d", ss_result);
 182                 int error;
 183                 error = __cst_get_ciss_error_from_tapi_error(ss_result);
 184                 DBG("req=0x%p", req);
 185                 if (req) {
 186                         req->func(req->call_type, req->flavour, EINA_FALSE, NULL, error, req->action, req->data, req->waiting_time);
 187                 }
 188                 __cst_remove_ss_request(ugd);
 189                 return FALSE;
 190         }
 191
 192         char number[TAPI_CALL_DIALDIGIT_LEN_MAX];
 193
 194         Eina_Bool cf_state = EINA_FALSE;
 195         int cf_flavour = -1;
 196         int call_type = -1;
 197         int waiting_time = 30;
 198         int i = 0;
 199
 200         for (i = 0; i < cf_data->record_num; ++i) {
 201                 number[0] = '\0';
 202                 DBG("TeleCommService=%d", cf_data->record[i].Class);
 203                 DBG("Flavour=%d", cf_data->record[i].ForwardCondition);
 204                 DBG("Status=%d", cf_data->record[i].Status);
 205                 switch (cf_data->record[i].Class) {
 206                 case TAPI_SS_CLASS_VOICE:
 207                         call_type = CST_CALLTYPE_VOICE;
 208                         break;
 209                 case TAPI_SS_CLASS_ALL_TELE:
 210                 case TAPI_SS_CLASS_ALL_BEARER:
 211                         call_type = CST_CALLTYPE_ALL;
 212                         break;
 213                 default:
 214                         ERR("Invalid CF call type");
 215                         return FALSE;
 216                 }
 217
 218                 DBG("req->call_type == %d call_type=%d", req->call_type, call_type);
 219                 if (req->call_type != call_type && call_type != CST_CALLTYPE_ALL)
 220                         continue;
 221
 222                 switch (cf_data->record[i].ForwardCondition) {
 223                 case TAPI_SS_CF_WHEN_CFU:
 224                         cf_flavour = CST_SSTYPE_CF_UNCONDITIONAL;
 225                         break;
 226                 case TAPI_SS_CF_WHEN_CFB:
 227                         cf_flavour = CST_SSTYPE_CF_BUSY;
 228                         break;
 229                 case TAPI_SS_CF_WHEN_CFNRy:
 230                         cf_flavour = CST_SSTYPE_CF_NO_REPLY;
 231                         waiting_time = (int)cf_data->record[i].NoReplyWaitTime;
 232                         DBG("******** Waiting time =%d **********", waiting_time);
 233                         break;
 234                 case TAPI_SS_CF_WHEN_CFNRc:
 235                         cf_flavour = CST_SSTYPE_CF_NOT_REACHABLE;
 236                         break;
 237                 case TAPI_SS_CF_WHEN_CF_ALL:
 238                         cf_flavour = CST_SSTYPE_CF_ALL;
 239                         break;
 240                 case TAPI_SS_CF_WHEN_CFC:
 241                         cf_flavour = CST_SSTYPE_CF_ALL_CONDITIONAL;
 242                         break;
 243                 default:
 244                         ERR("Invalid CF Flavour");
 245                         return FALSE;
 246                 }
 247
 248                 switch (cf_data->record[i].Status) {
 249                 case TAPI_SS_STATUS_ACTIVE:
 250                 case TAPI_SS_STATUS_REGISTERED:
 251                         cf_state = EINA_TRUE;
 252                         break;
 253                 case TAPI_SS_STATUS_NOTHING:
 254                 case TAPI_SS_STATUS_PROVISIONED:
 255                 case TAPI_SS_STATUS_QUIESCENT:
 256                         cf_state = EINA_FALSE;
 257                         break;
 258                 default:
 259                         ERR("Invalid CF status");
 260                         return FALSE;
 261                 }
 262
 263                 if (cf_data->record[i].bCallForwardingNumberPresent == 1) {
 264                         snprintf(number, TAPI_CALL_DIALDIGIT_LEN_MAX, "%s", cf_data->record[i].szCallForwardingNumber);
 265                 }
 266
 267                 req->func(call_type, cf_flavour, cf_state, number, CST_ERROR_NONE, req->action, req->data, waiting_time);
 268         }
 269
 270         __cst_remove_ss_request(ugd);
 271         return TRUE;
 272 }
 273
 274 static gboolean __cst_ss_waiting_resp_cb(TapiHandle *handle, int result, void *data, void *user_data)
 275 {
 276         DBG("Enter __cst_ss_waiting_resp_cb");
 277         TelSsCause_t ss_result = result;
 278         TelSsWaitingResp_t *cw_data = NULL;
 279         CallSettingSSReq_t *req = NULL;
 280         CstUgData_t *ugd = NULL;
 281
 282         cw_data = (TelSsWaitingResp_t *)data;
 283         if (cw_data == NULL) {
 284                 ERR("data is NULL, returning");
 285                 return FALSE;
 286         }
 287
 288         req = (CallSettingSSReq_t *)user_data;
 289         if (req == NULL) {
 290                 ERR("User_data is NULL, returning");
 291                 return FALSE;
 292         }
 293
 294         ugd = (CstUgData_t *)req->ugd;
 295         if (ugd == NULL) {
 296                 ERR("ugd is NULL, returning");
 297                 return FALSE;
 298         }
 299
 300         retv_if(req->is_requesting == EINA_FALSE, 0);
 301         if (req->is_canceled == EINA_TRUE) {
 302                 __cst_remove_ss_request(ugd);
 303                 return FALSE;
 304         }
 305
 306         if (ss_result != TAPI_SS_SUCCESS) {
 307                 DBG("Event Status is %d", ss_result);
 308                 int error;
 309
 310                 error = __cst_get_ciss_error_from_tapi_error(ss_result);
 311
 312                 if (req) {
 313                         req->func(req->call_type, req->flavour, EINA_TRUE, NULL, error, req->action, req->data, req->waiting_time);
 314                 }
 315                 __cst_remove_ss_request(ugd);
 316                 return FALSE;
 317         }
 318
 319         DBG("CW Status = %d", cw_data->record[0].Status);
 320         retv_if(NULL == req->func, 0);
 321         switch (cw_data->record[0].Status) {
 322         case TAPI_SS_STATUS_ACTIVE:
 323         case TAPI_SS_STATUS_REGISTERED:
 324                 req->func(req->call_type, req->flavour, EINA_TRUE, NULL, CST_ERROR_NONE, req->action, req->data, req->waiting_time);
 325                 break;
 326         case TAPI_SS_STATUS_PROVISIONED:
 327         case TAPI_SS_STATUS_QUIESCENT:
 328                 req->func(req->call_type, req->flavour, EINA_FALSE, NULL, CST_ERROR_NONE, req->action, req->data, req->waiting_time);
 329                 break;
 330         default:
 331                 ERR("Call waiting query error");
 332                 break;
 333         }
 334
 335         __cst_remove_ss_request(ugd);
 336         return TRUE;
 337 }
 338
 339 static void __cst_print_req_queue(Eina_List *queue)
 340 {
 341         Eina_List *l;
 342         CallSettingSSReq_t *req;
 343         EINA_LIST_FOREACH(queue, l, req) {
 344                 ret_if(req == NULL);
 345                 DBG("req=0x%p req_id=0x%x requesting=%d canceled=%d flavour=%d", req, req->req_id, req->is_requesting, req->is_canceled, req->flavour);
 346         }
 347 }
 348
 349 void _cst_cancel_all_ss_request(void *data)
 350 {
 351         ENTER(_cst_cancel_all_ss_request);
 352         CstUgData_t *ugd = (CstUgData_t *)data;
 353
 354         Eina_List *l;
 355         Eina_List *l_next;
 356         CallSettingSSReq_t *req;
 357
 358         EINA_LIST_FOREACH_SAFE(ugd->req_queue, l, l_next, req) {
 359                 ret_if(req == NULL);
 360                 DBG("Cancel req=0x%p", req);
 361                 if (req->is_requesting == EINA_TRUE) {
 362                         req->is_canceled = EINA_TRUE;
 363                 } else {
 364                         free(req);
 365                         ugd->req_queue = eina_list_remove_list(ugd->req_queue, l);
 366                 }
 367         }
 368         __cst_print_req_queue(ugd->req_queue);
 369         LEAVE();
 370 }
 371
 372 void _cst_add_ss_request(Eina_List ** queue, int action_type, int call_type, int flavour, char *number, void *func, void *data, int waiting_time, CstUgData_t *ugd)
 373 {
 374         ENTER(_cst_add_ss_request);
 375         ret_if(NULL == data);
 376         ret_if(NULL == func);
 377
 378         CallSettingSSReq_t *req = (CallSettingSSReq_t *)malloc(sizeof(CallSettingSSReq_t));
 379         ret_if(NULL == req);
 380         req->action = action_type;
 381         req->original_state = EINA_FALSE;
 382         req->call_type = call_type;
 383         req->flavour = flavour;
 384         req->data = data;
 385         req->func = func;
 386         req->waiting_time = waiting_time;
 387         req->ugd = ugd;
 388         snprintf(req->number, CST_MAX_PHONE_NUMBER_LEN, "%s", number);
 389         int cnt;
 390
 391         DBG("Add req=0x%p", req);
 392         req->is_canceled = EINA_FALSE;
 393         req->is_requesting = EINA_FALSE;
 394
 395         *queue = eina_list_append(*queue, req);
 396         cnt = eina_list_count(*queue);
 397         DBG("req count=%d", cnt);
 398         if (cnt == 1) {
 399                 __cst_send_ss_req_to_telephony_server(req);
 400         }
 401         LEAVE();
 402 }
 403
 404 static void __cst_remove_ss_request(void *data)
 405 {
 406         ENTER(__cst_remove_ss_request);
 407         CstUgData_t *ugd = (CstUgData_t *)data;
 408         CallSettingSSReq_t *req;
 409         Eina_List *first;
 410         int cnt;
 411         ret_if(eina_list_count(ugd->req_queue) == 0);
 412
 413         first = eina_list_nth_list(ugd->req_queue, 0);
 414         req = (CallSettingSSReq_t *)first->data;
 415         DBG("Remove req=0x%p", req);
 416         ugd->req_queue = eina_list_remove_list(ugd->req_queue, first);
 417         free(req);
 418
 419         cnt = eina_list_count(ugd->req_queue);
 420         DBG("req count=%d", cnt);
 421
 422         if (cnt > 0) {
 423                 first = eina_list_nth_list(ugd->req_queue, 0);
 424                 req = (CallSettingSSReq_t *)first->data;
 425                 __cst_send_ss_req_to_telephony_server(req);
 426         }
 427         __cst_print_req_queue(ugd->req_queue);
 428
 429         LEAVE();
 430
 431 }
 432
 433 static CallSettingSSReq_t *__cst_get_current_request(void *data)
 434 {
 435         ENTER(__cst_get_current_request);
 436         CstUgData_t *ugd = (CstUgData_t *)data;
 437         CallSettingSSReq_t *req = NULL;
 438         retv_if(ugd->req_queue == NULL, NULL);
 439         DBG("list length=%d", eina_list_count(ugd->req_queue));
 440         if (eina_list_count(ugd->req_queue) > 0) {
 441                 req = (CallSettingSSReq_t *)ugd->req_queue->data;
 442                 DBG("current req=0x%p", req);
 443         }
 444         LEAVE();
 445         return req;
 446 }
 447
 448 static int __cst_get_ciss_error_from_tapi_error(TelSsCause_t tapi_err)
 449 {
 450         ENTER(__cst_get_ciss_error_from_tapi_error);
 451
 452         int error_code = -1;
 453
 454         DBG("Error Code =%d", tapi_err);
 455
 456         switch (tapi_err) {
 457         case TAPI_SS_UNKNOWNSUBSCRIBER:
 458         case TAPI_SS_BEARERSERVICENOTPROVISIONED:
 459         case TAPI_SS_TELESERVICENOTPROVISIONED:
 460         case TAPI_SS_CALLBARRED:
 461         case TAPI_SS_ILLEGALSSOPERATION:
 462         case TAPI_SS_ERRORSTATUS:
 463         case TAPI_SS_FACILITYNOTSUPPORTED:
 464         case TAPI_SS_MAXNOMPTYEXCEEDED:
 465         case TAPI_SS_RESOURCESNOTAVAILABLE:
 466         case TAPI_SS_PWREGISTRATIONFAILURE:
 467         case TAPI_SS_SUBSCRIPTIONVIOLATION:
 468         case TAPI_SS_NOTAVAILABLE:
 469         case TAPI_SS_SYSTEMFAILURE:
 470         case TAPI_SS_REJECTEDBYNETWORK:
 471                 error_code = CST_ERROR_SERVICE_UNAVAILABLE;
 472                 break;
 473         case TAPI_SS_INCOMPATIBILITY:
 474         case TAPI_SS_DATAMISSING:
 475         case TAPI_SS_UNEXPECTEDDATAVALUE:
 476                 error_code = CST_ERROR_INCORRECT_OPERATION;
 477                 break;
 478         case TAPI_SS_NEGATIVEPWCHECK:
 479                 error_code = CST_ERROR_INVALID_PASSWORD;
 480                 break;
 481         case TAPI_SS_NUMBEROFPWATTEMPTSVIOLATION:
 482                 error_code = CST_ERROR_PASSWORD_BLOCKED;
 483                 break;
 484         case TAPI_SS_REJECTEDBYUSER:
 485                 error_code = CST_ERROR_REJECTED_BY_NETWORK;
 486                 break;
 487         default:
 488                 DBG("ciss_get_error_from_tapi_error:undefined =0x%x", tapi_err);
 489                 error_code = CST_ERROR_UNKNOWN;
 490                 break;
 491         }
 492         LEAVE();
 493         return error_code;
 494 }
 495
 496 static int __cst_get_tapi_cf_mode(int ciss_action)
 497 {
 498         int mode;
 499
 500         switch (ciss_action) {
 501         case CST_ACTION_ACTIVATE:
 502                 mode = TAPI_SS_CF_MODE_REGISTRATION_EV;
 503                 break;
 504         case CST_ACTION_DEACTIVATE:
 505                 mode = TAPI_SS_CF_MODE_ERASURE_EV;
 506                 break;
 507         default:
 508                 mode = 0;
 509                 ERR("Invalid CF mode");
 510         }
 511
 512         return mode;
 513 }
 514
 515 static int __cst_get_tapi_cf_flavour(int ciss_cf_flavour)
 516 {
 517
 518         int tel_cf_flavour;
 519         switch (ciss_cf_flavour) {
 520         case CST_SSTYPE_CF_UNCONDITIONAL:
 521                 tel_cf_flavour = TAPI_SS_CF_WHEN_CFU;
 522                 break;
 523         case CST_SSTYPE_CF_BUSY:
 524                 tel_cf_flavour = TAPI_SS_CF_WHEN_CFB;
 525                 break;
 526         case CST_SSTYPE_CF_NO_REPLY:
 527                 tel_cf_flavour = TAPI_SS_CF_WHEN_CFNRy;
 528                 break;
 529         case CST_SSTYPE_CF_NOT_REACHABLE:
 530                 tel_cf_flavour = TAPI_SS_CF_WHEN_CFNRc;
 531                 break;
 532         default:
 533                 tel_cf_flavour = -1;
 534                 ERR("Wrong CF flavour");
 535         }
 536         return tel_cf_flavour;
 537 }
 538
 539 static int __cst_get_tapi_teleservice_type(int ciss_call_type)
 540 {
 541         int teleservice;
 542
 543         switch (ciss_call_type) {
 544         case CST_CALLTYPE_VOICE:
 545                 teleservice = TAPI_SS_CLASS_VOICE;
 546                 break;
 547         case CST_CALLTYPE_ALL:
 548                 teleservice = TAPI_SS_CLASS_ALL_TELE_BEARER;
 549                 break;
 550         default:
 551                 teleservice = 0;
 552                 ERR("Invalid call type");
 553         }
 554         return teleservice;
 555 }
 556
 557 static int __cst_get_tapi_cb_mode(int ciss_action)
 558 {
 559         int mode;
 560
 561         switch (ciss_action) {
 562         case CST_ACTION_ACTIVATE:
 563                 mode = TAPI_SS_CB_MODE_ACTIVATE;
 564                 break;
 565         case CST_ACTION_DEACTIVATE:
 566                 mode = TAPI_SS_CB_MODE_DEACTIVATE;
 567                 break;
 568         default:
 569                 mode = 0;
 570                 ERR("Invalid CB action");
 571         }
 572         return mode;
 573 }
 574
 575 static int __cst_get_tapi_cb_flavour(int ciss_cb_flavour)
 576 {
 577
 578         int tel_cb_flavour;
 579         switch (ciss_cb_flavour) {
 580         case CST_SSTYPE_CB_OC:
 581                 tel_cb_flavour = TAPI_SS_CB_TYPE_BAOC;
 582                 break;
 583         case CST_SSTYPE_CB_OIC:
 584                 tel_cb_flavour = TAPI_SS_CB_TYPE_BOIC;
 585                 break;
 586         case CST_SSTYPE_CB_OICEH:
 587                 tel_cb_flavour = TAPI_SS_CB_TYPE_BOIC_NOT_HC;
 588                 break;
 589         case CST_SSTYPE_CB_IC:
 590                 tel_cb_flavour = TAPI_SS_CB_TYPE_BAIC;
 591                 break;
 592         case CST_SSTYPE_CB_ICR:
 593                 tel_cb_flavour = TAPI_SS_CB_TYPE_BIC_ROAM;
 594                 break;
 595         default:
 596                 tel_cb_flavour = -1;
 597                 ERR("Wrong CB flavour");
 598         }
 599         return tel_cb_flavour;
 600 }
 601
 602 static int __cst_get_tapi_cw_mode(int ciss_action)
 603 {
 604         int mode;
 605
 606         switch (ciss_action) {
 607         case CST_ACTION_ACTIVATE:
 608                 mode = TAPI_SS_CW_MODE_ACTIVATE;
 609                 break;
 610         case CST_ACTION_DEACTIVATE:
 611                 mode = TAPI_SS_CW_MODE_DEACTIVATE;
 612                 break;
 613         default:
 614                 mode = 0;
 615                 ERR("Invalid CW action");
 616         }
 617         return mode;
 618 }
 619
 620 static void __cst_send_ss_req_to_telephony_server(CallSettingSSReq_t *req)
 621 {
 622         ENTER(__cst_send_ss_req_to_telephony_server);
 623         TelSsForwardInfo_t cf_info;
 624         TelSsBarringInfo_t cb_info;
 625         TelSsWaitingInfo_t cw_info;
 626         int api_ret = -1;
 627         int req_id = -1;
 628         CstUgData_t *ugd = req->ugd;
 629
 630         ret_if(req == NULL);
 631         DBG("Send req=0x%p action=%d call_type=%d flavour=%d waiting_time=%d", req, req->action, req->call_type, req->flavour, req->waiting_time);
 632         req->is_requesting = EINA_TRUE;
 633
 634         memset(&cf_info, 0x0, sizeof(TelSsForwardInfo_t));
 635         memset(&cb_info, 0x0, sizeof(TelSsBarringInfo_t));
 636         memset(&cw_info, 0x0, sizeof(TelSsWaitingInfo_t));
 637
 638         switch (req->flavour) {
 639         case CST_SSTYPE_CF_UNCONDITIONAL:
 640         case CST_SSTYPE_CF_BUSY:
 641         case CST_SSTYPE_CF_NO_REPLY:
 642         case CST_SSTYPE_CF_NOT_REACHABLE:
 643         case CST_SSTYPE_CF_ALL:
 644         case CST_SSTYPE_CF_ALL_CONDITIONAL:
 645                 cf_info.Condition = __cst_get_tapi_cf_flavour(req->flavour);
 646                 cf_info.Class = TAPI_SS_CLASS_VOICE;
 647
 648                 if (req->action == CST_ACTION_QUERY) {
 649                         api_ret = tel_get_ss_forward_status(ugd->tapi_handle, cf_info.Class, cf_info.Condition, __cst_ss_forward_resp_cb, (void *)req);
 650                 } else {
 651                         cf_info.Mode = __cst_get_tapi_cf_mode(req->action);
 652                         if ((req->flavour == CST_SSTYPE_CF_NO_REPLY) && (req->waiting_time > 0)) {
 653                                 cf_info.NoReplyConditionTimer = req->waiting_time;
 654                         }
 655                         snprintf(cf_info.szPhoneNumber, TAPI_CALL_DIALDIGIT_LEN_MAX, "%s", req->number);
 656                         api_ret = tel_set_ss_forward(ugd->tapi_handle, &cf_info, __cst_ss_forward_resp_cb, (void *)req);
 657                 }
 658                 break;
 659         case CST_SSTYPE_CB_OC:
 660         case CST_SSTYPE_CB_OIC:
 661         case CST_SSTYPE_CB_OICEH:
 662         case CST_SSTYPE_CB_IC:
 663         case CST_SSTYPE_CB_ICR:
 664                 cb_info.Type = __cst_get_tapi_cb_flavour(req->flavour);
 665                 cb_info.Class = __cst_get_tapi_teleservice_type(req->call_type);
 666
 667                 DBG("%d <= %d <= %d calltype", TAPI_SS_CLASS_VOICE, cb_info.Class, TAPI_SS_CLASS_ALL_TELE);
 668                 DBG("%d <= %d <= %d type", TAPI_SS_CB_TYPE_AB, cb_info.Type, TAPI_SS_CB_TYPE_BIC_NOT_SIM);
 669                 if (req->action == CST_ACTION_QUERY) {
 670                         /*To do - add callback function*/
 671                         api_ret = tel_get_ss_barring_status(ugd->tapi_handle, cb_info.Class, cb_info.Type, __cst_ss_barring_resp_cb, (void *)req);
 672                 } else {
 673                         cb_info.Mode = __cst_get_tapi_cb_mode(req->action);
 674                         DBG("%d <= %d <= %d mode", TAPI_SS_CB_MODE_ACTIVATE, cb_info.Mode, TAPI_SS_CB_MODE_DEACTIVATE);
 675                         DBG("%d == %d pwd length", strnlen(cb_info.szPassword, 4), TAPI_SS_GSM_BARR_PW_LEN_MAX);
 676                         memcpy(cb_info.szPassword, req->number, TAPI_SS_GSM_BARR_PW_LEN_MAX);
 677                         api_ret = tel_set_ss_barring(ugd->tapi_handle, &cb_info, __cst_ss_barring_resp_cb, (void *)req);
 678                 }
 679                 break;
 680         case CST_SSTYPE_CW:
 681                 cw_info.Class = __cst_get_tapi_teleservice_type(req->call_type);
 682                 if (req->action == CST_ACTION_QUERY) {
 683                         api_ret = tel_get_ss_waiting_status(ugd->tapi_handle, cw_info.Class, __cst_ss_waiting_resp_cb, (void *)req);
 684                 } else {
 685                         cw_info.Mode = __cst_get_tapi_cw_mode(req->action);
 686                         api_ret = tel_set_ss_waiting(ugd->tapi_handle, &cw_info, __cst_ss_waiting_resp_cb, (void *)req);
 687                 }
 688                 break;
 689         }
 690
 691         if (req->req_id != -1) {
 692                 req->req_id = req_id;
 693         }
 694
 695         if (api_ret != TAPI_API_SUCCESS) {
 696                 CstGlItemData_t *item_data;
 697                 CstUgData_t *ugd;
 698
 699                 req->func(req->call_type, req->flavour, EINA_FALSE, NULL, CST_ERROR_INCORRECT_OPERATION, req->action, req->data, req->waiting_time);
 700                 item_data = (CstGlItemData_t *)req->data;
 701                 ugd = (CstUgData_t *)item_data->ugd;
 702                 __cst_remove_ss_request(ugd);
 703         }
 704         DBG("api_ret=%d req_id=0x%p", api_ret, req_id);
 705
 706         LEAVE();
 707         return;
 708 }
 709
 710 void _cst_ciss_register_tel_event(void *data)
 711 {
 712         ENTER(_cst_ciss_register_tel_event);
 713         CstUgData_t *ugd = (CstUgData_t *)data;
 714
 715         if (ugd == NULL) {
 716                 ERR("ugd = NULL, so returning");
 717                 return;
 718         }
 719
 720         ugd->tapi_handle = tel_init(NULL);
 721         if (ugd->tapi_handle != NULL)
 722                 ERR("tel_init() Success, handle created.");
 723         else
 724                 ERR("tel_init() failed.");
 725
 726         LEAVE();
 727         return;
 728 }
 729