src/ss.c

   1 /*
   2  * tel-plugin-dbus-tapi
   3  *
   4  * Copyright (c) 2012 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 #include <stdio.h>
  22 #include <string.h>
  23 #include <pthread.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <time.h>
  27 #include <glib.h>
  28 #include <gio/gio.h>
  29
  30 #include <appsvc.h>
  31 #include <bundle.h>
  32
  33 #include <tcore.h>
  34 #include <server.h>
  35 #include <plugin.h>
  36 #include <hal.h>
  37 #include <communicator.h>
  38 #include <storage.h>
  39 #include <queue.h>
  40 #include <user_request.h>
  41 #include <co_ss.h>
  42 #include <co_sim.h>
  43 #include <co_ps.h>
  44
  45 #include "generated-code.h"
  46 #include "common.h"
  47
  48 struct ciss_data_type {
  49         int status;
  50         int dcs;
  51         int length;
  52         char data[MAX_SS_USSD_LEN];
  53 };
  54
  55 struct ciss_information {
  56         int err;
  57         int ss_type;
  58 };
  59
  60 static void _launch_ciss_information(const struct tnoti_ss_information *info)
  61 {
  62         gchar *encoded_data;
  63         struct ciss_information ciss_inform;
  64
  65         bundle *kb = NULL;
  66
  67         memset(&ciss_inform, 0, sizeof(struct ciss_information));
  68         ciss_inform.err = info->err;
  69         ciss_inform.ss_type = info->ss_type;
  70
  71         dbg("Explicit launch ciss application by appsvc");
  72
  73         kb = bundle_create();
  74         if (!kb) {
  75                 warn("bundle_create() failed");
  76                 return;
  77         }
  78
  79         appsvc_set_pkgname(kb, "org.tizen.ciss");
  80
  81         encoded_data = g_base64_encode((guchar *)&ciss_inform, sizeof(struct ciss_information));
  82
  83         appsvc_add_data(kb, "CISS_LAUNCHING_MODE", "RESP");
  84         appsvc_add_data(kb, "KEY_EVENT_TYPE", "200");
  85         appsvc_add_data(kb, "KEY_ENCODED_DATA", encoded_data);
  86
  87         dbg("ciss appsvc run");
  88         appsvc_run_service(kb, 0, NULL, NULL);
  89
  90         bundle_free(kb);
  91         g_free(encoded_data);
  92
  93         return;
  94 }
  95
  96
  97 static void _launch_ciss(const struct tnoti_ss_ussd *ussd, enum dbus_tapi_sim_slot_id slot_id)
  98 {
  99         gchar *encoded_data;
 100         struct ciss_data_type ciss_data;
 101         char slot_info[2] = {0,};
 102
 103         bundle *kb = NULL;
 104
 105         memset(&ciss_data, 0, sizeof(struct ciss_data_type));
 106         ciss_data.status = ussd->dcs;
 107         ciss_data.status = ussd->status;
 108         ciss_data.length = ussd->len;
 109         memcpy(ciss_data.data, ussd->str, ciss_data.length);
 110
 111         snprintf(slot_info, 2, "%d", slot_id);
 112         dbg("slot_id : [%s]", slot_info);
 113
 114         dbg("Explicit launch ciss application by appsvc");
 115
 116         kb = bundle_create();
 117         if (!kb) {
 118                 warn("bundle_create() failed");
 119                 return;
 120         }
 121
 122
 123         appsvc_set_pkgname(kb, "org.tizen.ciss");
 124
 125         encoded_data = g_base64_encode((guchar *)&ciss_data, sizeof(struct ciss_data_type));
 126
 127         appsvc_add_data(kb, "CISS_LAUNCHING_MODE", "RESP");
 128         appsvc_add_data(kb, "KEY_EVENT_TYPE", "100");
 129         appsvc_add_data(kb, "KEY_ENCODED_DATA", encoded_data);
 130         appsvc_add_data(kb, "KEY_SLOT_ID", slot_info);
 131
 132         dbg("ciss appsvc run");
 133         appsvc_run_service(kb, 0, NULL, NULL);
 134
 135         bundle_free(kb);
 136         g_free(encoded_data);
 137
 138         return;
 139 }
 140
 141 static gboolean
 142 on_ss_activate_barring (TelephonySs *ss,
 143                 GDBusMethodInvocation *invocation,
 144                 gint ss_class,
 145                 gint barring_mode,
 146                 const gchar *barring_password,
 147                 gpointer user_data)
 148 {
 149         char buf[5];
 150         struct treq_ss_barring req;
 151         struct custom_data *ctx = user_data;
 152         UserRequest *ur = NULL;
 153         int ret = 0;
 154
 155         memset(&req, 0, sizeof(struct treq_ss_barring));
 156
 157         req.class = ss_class;
 158         req.mode = barring_mode;
 159
 160         memcpy(req.password, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 161         memcpy(buf, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 162
 163         buf[4] = 0;
 164         dbg("req.password = [%s]", buf);
 165
 166         dbg("class = %d, mode = %d", req.class, req.mode);
 167
 168         ur = MAKE_UR(ctx, ss, invocation);
 169
 170         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring), &req);
 171         tcore_user_request_set_command(ur, TREQ_SS_BARRING_ACTIVATE);
 172         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 173         if (ret != TCORE_RETURN_SUCCESS ) {
 174                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 175                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 176                 tcore_user_request_unref(ur);
 177         }
 178
 179         return TRUE;
 180 }
 181
 182 static gboolean
 183 on_ss_deactivate_barring (TelephonySs *ss,
 184                 GDBusMethodInvocation *invocation,
 185                 gint ss_class,
 186                 gint barring_mode,
 187                 const gchar *barring_password,
 188                 gpointer user_data)
 189 {
 190         char buf[5];
 191         struct treq_ss_barring req;
 192         struct custom_data *ctx = user_data;
 193         UserRequest *ur = NULL;
 194         int ret = 0;
 195
 196         memset(&req, 0, sizeof(struct treq_ss_barring));
 197
 198         req.class = ss_class;
 199         req.mode = barring_mode;
 200
 201         memcpy(req.password, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 202         memcpy(buf, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 203
 204         buf[4] = 0;
 205         dbg("req.password = [%s]", buf);
 206         dbg("class = %d, mode = %d", req.class, req.mode);
 207
 208         ur = MAKE_UR(ctx, ss, invocation);
 209
 210         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring), &req);
 211         tcore_user_request_set_command(ur, TREQ_SS_BARRING_DEACTIVATE);
 212         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 213         if (ret != TCORE_RETURN_SUCCESS ) {
 214                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 215                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 216                 tcore_user_request_unref(ur);
 217         }
 218
 219         return TRUE;
 220 }
 221
 222 static gboolean
 223 on_ss_change_barring_password (TelephonySs *ss,
 224                 GDBusMethodInvocation *invocation,
 225                 const gchar *barring_password,
 226                 const gchar *barring_password_new,
 227                 const gchar *barring_password_confirm,
 228                 gpointer user_data)
 229 {
 230         char buf[5];
 231         struct treq_ss_barring_change_password req;
 232         struct custom_data *ctx = user_data;
 233         UserRequest *ur = NULL;
 234         int ret = 0;
 235
 236         memset(&req, 0, sizeof(struct treq_ss_barring_change_password));
 237
 238         memcpy(req.password_old, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 239         memcpy(req.password_new, barring_password_new, MAX_SS_BARRING_PASSWORD_LEN);
 240         memcpy(req.password_confirm, barring_password_confirm, MAX_SS_BARRING_PASSWORD_LEN);
 241
 242         memcpy(buf, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 243         buf[4] = 0;
 244
 245         memcpy(buf, barring_password_new, MAX_SS_BARRING_PASSWORD_LEN);
 246
 247         memcpy(buf, barring_password_confirm, MAX_SS_BARRING_PASSWORD_LEN);
 248
 249         ur = MAKE_UR(ctx, ss, invocation);
 250
 251         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring_change_password), &req);
 252         tcore_user_request_set_command(ur, TREQ_SS_BARRING_CHANGE_PASSWORD);
 253         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 254         if (ret != TCORE_RETURN_SUCCESS ) {
 255                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 256                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 257                 tcore_user_request_unref(ur);
 258         }
 259
 260         return TRUE;
 261 }
 262
 263 static gboolean
 264 on_ss_get_barring_status (TelephonySs *ss,
 265                 GDBusMethodInvocation *invocation,
 266                 gint ss_class,
 267                 gint barring_mode,
 268                 gpointer user_data)
 269 {
 270         struct treq_ss_barring req;
 271         struct custom_data *ctx = user_data;
 272         UserRequest *ur = NULL;
 273         int ret = 0;
 274
 275         memset(&req, 0, sizeof(struct treq_ss_barring));
 276
 277         req.class = ss_class;
 278         req.mode = barring_mode;
 279
 280         dbg("class = %d, mode = %d", req.class, req.mode);
 281
 282         ur = MAKE_UR(ctx, ss, invocation);
 283
 284         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring), &req);
 285         tcore_user_request_set_command(ur, TREQ_SS_BARRING_GET_STATUS);
 286         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 287         if (ret != TCORE_RETURN_SUCCESS ) {
 288                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 289                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 290                 tcore_user_request_unref(ur);
 291         }
 292
 293         return TRUE;
 294 }
 295
 296 static gboolean
 297 on_ss_register_forwarding (TelephonySs *ss,
 298                 GDBusMethodInvocation *invocation,
 299                 gint ss_class,
 300                 gint forward_mode,
 301                 gint forward_no_reply_time,
 302                 gint forward_ton,
 303                 gint forward_npi,
 304                 const gchar *forward_number,
 305                 gpointer user_data)
 306 {
 307         struct treq_ss_forwarding req;
 308         struct custom_data *ctx = user_data;
 309         UserRequest *ur = NULL;
 310         int ret = 0;
 311
 312         if (!check_access_control (invocation, AC_SS, "w")) {
 313                 GVariant *result = 0;
 314                 GVariantBuilder b;
 315
 316                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 317                 result = g_variant_builder_end(&b);
 318
 319                 telephony_ss_complete_register_forwarding(ss, invocation, result, ret);
 320
 321                 return TRUE;
 322         }
 323
 324         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 325
 326         req.class = ss_class;
 327         req.mode = forward_mode;
 328         req.time = forward_no_reply_time;
 329         req.ton  = forward_ton;
 330         req.npi  = forward_npi;
 331         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 332
 333         dbg("class = %d, mode = %d, time = %d, number = %s",
 334                         req.class, req.mode, req.time, req.number);
 335
 336         ur = MAKE_UR(ctx, ss, invocation);
 337
 338         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 339         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_REGISTER);
 340         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 341         if (ret != TCORE_RETURN_SUCCESS ) {
 342                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 343                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 344                 tcore_user_request_unref(ur);
 345         }
 346
 347         return TRUE;
 348 }
 349
 350 static gboolean
 351 on_ss_deregister_forwarding (TelephonySs *ss,
 352                 GDBusMethodInvocation *invocation,
 353                 gint ss_class,
 354                 gint forward_mode,
 355                 gint forward_no_reply_time,
 356                 gint forward_ton,
 357                 gint forward_npi,
 358                 const gchar *forward_number,
 359                 gpointer user_data)
 360 {
 361         struct treq_ss_forwarding req;
 362         struct custom_data *ctx = user_data;
 363         UserRequest *ur = NULL;
 364         int ret = 0;
 365
 366         if (!check_access_control (invocation, AC_SS, "w")) {
 367                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 368                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 369                 tcore_user_request_unref(ur);
 370         }
 371
 372         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 373
 374         req.class = ss_class;
 375         req.mode = forward_mode;
 376         req.time = forward_no_reply_time;
 377         req.ton = forward_ton;
 378         req.npi = forward_npi;
 379         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 380
 381         dbg("class = %d, mode = %d, time = %d, number = %s",
 382                         req.class, req.mode, req.time, req.number);
 383
 384         ur = MAKE_UR(ctx, ss, invocation);
 385
 386         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 387         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_DEREGISTER);
 388         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 389         if (ret != TCORE_RETURN_SUCCESS ) {
 390                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 391                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 392                 tcore_user_request_unref(ur);
 393         }
 394
 395         return TRUE;
 396 }
 397
 398 static gboolean
 399 on_ss_activate_forwarding (TelephonySs *ss,
 400                 GDBusMethodInvocation *invocation,
 401                 gint ss_class,
 402                 gint forward_mode,
 403                 gint forward_no_reply_time,
 404                 gint forward_ton,
 405                 gint forward_npi,
 406                 const gchar *forward_number,
 407                 gpointer user_data)
 408 {
 409         struct treq_ss_forwarding req;
 410         struct custom_data *ctx = user_data;
 411         UserRequest *ur = NULL;
 412         int ret = 0;
 413
 414         if (!check_access_control (invocation, AC_SS, "w")) {
 415                 GVariant *result = 0;
 416                 GVariantBuilder b;
 417
 418                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 419                 result = g_variant_builder_end(&b);
 420
 421                 telephony_ss_complete_activate_forwarding(ss, invocation, result, ret);
 422
 423                 return TRUE;
 424         }
 425
 426         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 427
 428         req.class = ss_class;
 429         req.mode = forward_mode;
 430         req.time = forward_no_reply_time;
 431         req.ton = forward_ton;
 432         req.npi = forward_npi;
 433         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 434
 435         dbg("class = %d, mode = %d, time = %d, number = %s",
 436                         req.class, req.mode, req.time, req.number);
 437
 438         ur = MAKE_UR(ctx, ss, invocation);
 439
 440         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 441         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_ACTIVATE);
 442         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 443         if (ret != TCORE_RETURN_SUCCESS ) {
 444                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 445                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 446                 tcore_user_request_unref(ur);
 447         }
 448
 449         return TRUE;
 450 }
 451
 452 static gboolean
 453 on_ss_deactivate_forwarding (TelephonySs *ss,
 454                 GDBusMethodInvocation *invocation,
 455                 gint ss_class,
 456                 gint forward_mode,
 457                 gint forward_no_reply_time,
 458                 gint forward_ton,
 459                 gint forward_npi,
 460                 const gchar *forward_number,
 461                 gpointer user_data)
 462 {
 463         struct treq_ss_forwarding req;
 464         struct custom_data *ctx = user_data;
 465         UserRequest *ur = NULL;
 466         int ret = 0;
 467
 468         if (!check_access_control (invocation, AC_SS, "w")) {
 469                 GVariant *result = 0;
 470                 GVariantBuilder b;
 471
 472                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 473                 result = g_variant_builder_end(&b);
 474
 475                 telephony_ss_complete_deactivate_forwarding(ss, invocation, result, ret);
 476
 477                 return TRUE;
 478         }
 479
 480         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 481
 482         req.class = ss_class;
 483         req.mode = forward_mode;
 484         req.time = forward_no_reply_time;
 485         req.ton = forward_ton;
 486         req.npi = forward_npi;
 487         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 488
 489         dbg("class = %d, mode = %d, time = %d, number = %s",
 490                         req.class, req.mode, req.time, req.number);
 491
 492         ur = MAKE_UR(ctx, ss, invocation);
 493
 494         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 495         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_DEACTIVATE);
 496         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 497         if (ret != TCORE_RETURN_SUCCESS ) {
 498                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 499                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 500                 tcore_user_request_unref(ur);
 501         }
 502
 503         return TRUE;
 504 }
 505
 506 static gboolean
 507 on_ss_get_forwarding_status (TelephonySs *ss,
 508                 GDBusMethodInvocation *invocation,
 509                 gint ss_class,
 510                 gint forward_mode,
 511                 gpointer user_data)
 512 {
 513         struct treq_ss_forwarding req;
 514         struct custom_data *ctx = user_data;
 515         UserRequest *ur = NULL;
 516         int ret = 0;
 517
 518         if (!check_access_control (invocation, AC_SS, "r")) {
 519                 GVariant *result = 0;
 520                 GVariantBuilder b;
 521
 522                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 523                 result = g_variant_builder_end(&b);
 524
 525                 telephony_ss_complete_get_forwarding_status(ss, invocation, result, ret);
 526
 527                 return TRUE;
 528         }
 529
 530         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 531
 532         req.class = ss_class;
 533         req.mode = forward_mode;
 534
 535         dbg("class = %d, mode = %d, time = %d, number = %s",
 536                         req.class, req.mode, req.time, req.number);
 537
 538         ur = MAKE_UR(ctx, ss, invocation);
 539
 540         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 541         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_GET_STATUS);
 542         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 543         if (ret != TCORE_RETURN_SUCCESS ) {
 544                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 545                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 546                 tcore_user_request_unref(ur);
 547         }
 548
 549         return TRUE;
 550 }
 551
 552 static gboolean
 553 on_ss_activate_waiting (TelephonySs *ss,
 554                 GDBusMethodInvocation *invocation,
 555                 gint ss_class,
 556                 gpointer user_data)
 557 {
 558         struct treq_ss_waiting req;
 559         struct custom_data *ctx = user_data;
 560         UserRequest *ur = NULL;
 561         int ret = 0;
 562
 563         memset(&req, 0, sizeof(struct treq_ss_waiting));
 564
 565         req.class = ss_class;
 566
 567         dbg("class = %d", req.class);
 568
 569         ur = MAKE_UR(ctx, ss, invocation);
 570
 571         tcore_user_request_set_data(ur, sizeof(struct treq_ss_waiting), &req);
 572         tcore_user_request_set_command(ur, TREQ_SS_WAITING_ACTIVATE);
 573         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 574         if (ret != TCORE_RETURN_SUCCESS ) {
 575                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 576                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 577                 tcore_user_request_unref(ur);
 578         }
 579
 580         return TRUE;
 581 }
 582
 583 static gboolean
 584 on_ss_deactivate_waiting (TelephonySs *ss,
 585                 GDBusMethodInvocation *invocation,
 586                 gint ss_class,
 587                 gpointer user_data)
 588 {
 589         struct treq_ss_waiting req;
 590         struct custom_data *ctx = user_data;
 591         UserRequest *ur = NULL;
 592         int ret = 0;
 593
 594         memset(&req, 0, sizeof(struct treq_ss_waiting));
 595
 596         req.class = ss_class;
 597
 598         dbg("class = %d", req.class);
 599
 600         ur = MAKE_UR(ctx, ss, invocation);
 601
 602         tcore_user_request_set_data(ur, sizeof(struct treq_ss_waiting), &req);
 603         tcore_user_request_set_command(ur, TREQ_SS_WAITING_DEACTIVATE);
 604         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 605         if (ret != TCORE_RETURN_SUCCESS ) {
 606                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 607                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 608                 tcore_user_request_unref(ur);
 609         }
 610
 611         return TRUE;
 612 }
 613
 614 static gboolean
 615 on_ss_get_waiting_status (TelephonySs *ss,
 616                 GDBusMethodInvocation *invocation,
 617                 gint ss_class,
 618                 gpointer user_data)
 619 {
 620         struct treq_ss_waiting req;
 621         struct custom_data *ctx = user_data;
 622         UserRequest *ur = NULL;
 623         int ret = 0;
 624
 625         memset(&req, 0, sizeof(struct treq_ss_waiting));
 626
 627         req.class = ss_class;
 628
 629         dbg("class = %d", req.class);
 630
 631         ur = MAKE_UR(ctx, ss, invocation);
 632
 633         tcore_user_request_set_data(ur, sizeof(struct treq_ss_waiting), &req);
 634         tcore_user_request_set_command(ur, TREQ_SS_WAITING_GET_STATUS);
 635         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 636         if (ret != TCORE_RETURN_SUCCESS ) {
 637                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 638                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 639                 tcore_user_request_unref(ur);
 640         }
 641
 642         return TRUE;
 643 }
 644
 645 static gboolean
 646 on_ss_set_cli_status (TelephonySs *ss,
 647                 GDBusMethodInvocation *invocation,
 648                 gint cli_type,
 649                 gint cli_status,
 650                 gpointer user_data)
 651 {
 652         struct treq_ss_set_cli req;
 653         struct custom_data *ctx = user_data;
 654         UserRequest *ur = NULL;
 655         int ret = 0;
 656
 657         memset(&req, 0, sizeof(struct treq_ss_set_cli));
 658
 659         req.type = cli_type;
 660         req.status = cli_status;
 661
 662         dbg("type = %d, status = %d", req.type, req.status);
 663
 664         ur = MAKE_UR(ctx, ss, invocation);
 665
 666         tcore_user_request_set_data(ur, sizeof(struct treq_ss_set_cli), &req);
 667         tcore_user_request_set_command(ur, TREQ_SS_CLI_SET_STATUS);
 668         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 669         if (ret != TCORE_RETURN_SUCCESS ) {
 670                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 671                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 672                 tcore_user_request_unref(ur);
 673         }
 674
 675         return TRUE;
 676 }
 677
 678
 679 static gboolean
 680 on_ss_get_cli_status (TelephonySs *ss,
 681                 GDBusMethodInvocation *invocation,
 682                 gint cli_type,
 683                 gpointer user_data)
 684 {
 685         struct treq_ss_cli req;
 686         struct custom_data *ctx = user_data;
 687         UserRequest *ur = NULL;
 688         int ret = 0;
 689
 690         memset(&req, 0, sizeof(struct treq_ss_cli));
 691
 692         req.type = cli_type;
 693
 694         dbg("type = %d", req.type);
 695
 696         ur = MAKE_UR(ctx, ss, invocation);
 697
 698         tcore_user_request_set_data(ur, sizeof(struct treq_ss_cli), &req);
 699         tcore_user_request_set_command(ur, TREQ_SS_CLI_GET_STATUS);
 700         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 701         if (ret != TCORE_RETURN_SUCCESS ) {
 702                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 703                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 704                 tcore_user_request_unref(ur);
 705         }
 706
 707         return TRUE;
 708 }
 709
 710 static gboolean
 711 on_ss_send_ussd (TelephonySs *ss,
 712                 GDBusMethodInvocation *invocation,
 713                 gint ussd_type,
 714                 gint ussd_dcs,
 715                 gint ussd_len,
 716                 const gchar *ussd_string,
 717                 gpointer user_data)
 718 {
 719         struct treq_ss_ussd req;
 720         struct custom_data *ctx = user_data;
 721         UserRequest *ur = NULL;
 722         int ret = 0;
 723
 724         memset(&req, 0, sizeof(struct treq_ss_ussd));
 725
 726         req.type = ussd_type;
 727         req.dcs = (unsigned char)ussd_dcs;
 728         req.len = (unsigned short)ussd_len;
 729
 730         snprintf((char*)req.str, MAX_SS_USSD_LEN, "%s", ussd_string);
 731
 732         dbg("[ check ] type = %d, dcs = %d, len = %d, string = %s", req.type, req.dcs, req.len, req.str);
 733
 734         ur = MAKE_UR(ctx, ss, invocation);
 735
 736         tcore_user_request_set_data(ur, sizeof(struct treq_ss_ussd), &req);
 737         tcore_user_request_set_command(ur, TREQ_SS_SEND_USSD);
 738         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 739         if (ret != TCORE_RETURN_SUCCESS ) {
 740                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 741                 dbg("[ error ] tcore_communicator_dispatch_request() : (0x%x)", ret);
 742                 tcore_user_request_unref(ur);
 743         }
 744
 745         return TRUE;
 746 }
 747
 748 gboolean dbus_plugin_setup_ss_interface(TelephonyObjectSkeleton *object, struct custom_data *ctx)
 749 {
 750         TelephonySs *ss;
 751
 752         ss = telephony_ss_skeleton_new();
 753         telephony_object_skeleton_set_ss(object, ss);
 754         g_object_unref(ss);
 755
 756         g_signal_connect (ss,
 757                         "handle-activate-barring",
 758                         G_CALLBACK (on_ss_activate_barring),
 759                         ctx);
 760
 761         g_signal_connect (ss,
 762                         "handle-deactivate-barring",
 763                         G_CALLBACK (on_ss_deactivate_barring),
 764                         ctx);
 765
 766         g_signal_connect (ss,
 767                         "handle-change-barring-password",
 768                         G_CALLBACK (on_ss_change_barring_password),
 769                         ctx);
 770
 771         g_signal_connect (ss,
 772                         "handle-get-barring-status",
 773                         G_CALLBACK (on_ss_get_barring_status),
 774                         ctx);
 775
 776         g_signal_connect (ss,
 777                         "handle-register-forwarding",
 778                         G_CALLBACK (on_ss_register_forwarding),
 779                         ctx);
 780
 781         g_signal_connect (ss,
 782                         "handle-deregister-forwarding",
 783                         G_CALLBACK (on_ss_deregister_forwarding),
 784                         ctx);
 785
 786         g_signal_connect (ss,
 787                         "handle-activate-forwarding",
 788                         G_CALLBACK (on_ss_activate_forwarding),
 789                         ctx);
 790
 791         g_signal_connect (ss,
 792                         "handle-deactivate-forwarding",
 793                         G_CALLBACK (on_ss_deactivate_forwarding),
 794                         ctx);
 795
 796         g_signal_connect (ss,
 797                         "handle-get-forwarding-status",
 798                         G_CALLBACK (on_ss_get_forwarding_status),
 799                         ctx);
 800
 801         g_signal_connect (ss,
 802                         "handle-activate-waiting",
 803                         G_CALLBACK (on_ss_activate_waiting),
 804                         ctx);
 805
 806         g_signal_connect (ss,
 807                         "handle-deactivate-waiting",
 808                         G_CALLBACK (on_ss_deactivate_waiting),
 809                         ctx);
 810
 811         g_signal_connect (ss,
 812                         "handle-get-waiting-status",
 813                         G_CALLBACK (on_ss_get_waiting_status),
 814                         ctx);
 815
 816         g_signal_connect (ss,
 817                         "handle-set-clistatus",
 818                         G_CALLBACK (on_ss_set_cli_status),
 819                         ctx);
 820
 821         g_signal_connect (ss,
 822                         "handle-get-clistatus",
 823                         G_CALLBACK (on_ss_get_cli_status),
 824                         ctx);
 825
 826         g_signal_connect (ss,
 827                         "handle-send-ussd",
 828                         G_CALLBACK (on_ss_send_ussd),
 829                         ctx);
 830
 831         return TRUE;
 832 }
 833
 834 gboolean dbus_plugin_ss_response(struct custom_data *ctx, UserRequest *ur, struct dbus_request_info *dbus_info, enum tcore_response_command command, unsigned int data_len, const void *data)
 835 {
 836         GVariant *result = 0;
 837         GVariantBuilder b;
 838         int i = 0;
 839
 840         if ( !data ) {
 841                 err("response data : 0");
 842                 return FALSE;
 843         }
 844
 845         switch (command) {
 846                 case TRESP_SS_BARRING_ACTIVATE: {
 847
 848                         const struct tresp_ss_barring *resp = data;
 849
 850                         dbg("receive TRESP_SS_BARRING_ACTIVATE (err[%d])", resp->err);
 851
 852                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 853
 854                         for (i=0; i<resp->record_num; i++) {
 855                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 856                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 857                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 858                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( resp->record[i].mode ));
 859                                 g_variant_builder_close(&b);
 860                         }
 861
 862                         result = g_variant_builder_end(&b);
 863
 864                         telephony_ss_complete_activate_barring(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 865
 866                 } break;
 867
 868                 case TRESP_SS_BARRING_DEACTIVATE: {
 869
 870                         const struct tresp_ss_barring *resp = data;
 871
 872                         dbg("receive TRESP_SS_BARRING_DEACTIVATE (err[%d])", resp->err);
 873
 874                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 875
 876                         for (i=0; i<resp->record_num; i++) {
 877                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 878                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 879                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 880                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( resp->record[i].mode ));
 881                                 g_variant_builder_close(&b);
 882                         }
 883
 884                         result = g_variant_builder_end(&b);
 885
 886                         telephony_ss_complete_deactivate_barring(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 887
 888                 } break;
 889
 890                 case TRESP_SS_BARRING_CHANGE_PASSWORD: {
 891
 892                         const struct tresp_ss_general *resp = data;
 893
 894                         dbg("receive TRESP_SS_BARRING_CHANGE_PASSWORD (err[%d])", resp->err);
 895
 896                         telephony_ss_complete_change_barring_password(dbus_info->interface_object, dbus_info->invocation, resp->err);
 897
 898                 } break;
 899
 900                 case TRESP_SS_BARRING_GET_STATUS: {
 901
 902                         const struct tresp_ss_barring *resp = data;
 903
 904                         dbg("receive TRESP_SS_BARRING_GET_STATUS (err[%d])", resp->err);
 905
 906                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 907
 908                         for (i=0; i<resp->record_num; i++) {
 909                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 910                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 911                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 912                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( resp->record[i].mode ));
 913                                 g_variant_builder_close(&b);
 914                         }
 915
 916                         result = g_variant_builder_end(&b);
 917
 918                         telephony_ss_complete_get_barring_status(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 919
 920                 } break;
 921
 922                 case TRESP_SS_FORWARDING_ACTIVATE: {
 923                         const struct tresp_ss_forwarding *resp = data;
 924
 925                         dbg("receive TRESP_SS_FORWARDING_ACTIVATE (err[%d])", resp->err);
 926
 927                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 928
 929                         for (i=0; i<resp->record_num; i++) {
 930                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 931                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 932                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 933                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 934                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 935                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 936                                 g_variant_builder_add(&b, "{sv}", "type_of_number", g_variant_new_int32( resp->record[i].ton ));
 937                                 g_variant_builder_add(&b, "{sv}", "numbering_plan_identity", g_variant_new_int32( resp->record[i].npi ));
 938                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 939                                 g_variant_builder_close(&b);
 940                         }
 941
 942                         result = g_variant_builder_end(&b);
 943
 944                         telephony_ss_complete_activate_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 945
 946                 } break;
 947
 948                 case TRESP_SS_FORWARDING_DEACTIVATE: {
 949
 950                         const struct tresp_ss_forwarding *resp = data;
 951
 952                         dbg("receive TRESP_SS_FORWARDING_DEACTIVATE (err[%d])", resp->err);
 953
 954                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 955
 956                         for (i=0; i<resp->record_num; i++) {
 957                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 958                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 959                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 960                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 961                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 962                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 963                                 g_variant_builder_add(&b, "{sv}", "type_of_number", g_variant_new_int32( resp->record[i].ton ));
 964                                 g_variant_builder_add(&b, "{sv}", "numbering_plan_identity", g_variant_new_int32( resp->record[i].npi ));
 965                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 966                                 g_variant_builder_close(&b);
 967                         }
 968
 969                         result = g_variant_builder_end(&b);
 970
 971                         telephony_ss_complete_deactivate_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 972
 973                 } break;
 974
 975                 case TRESP_SS_FORWARDING_REGISTER: {
 976
 977                         const struct tresp_ss_forwarding *resp = data;
 978
 979                         dbg("receive TRESP_SS_FORWARDING_REGISTER (err[%d])", resp->err);
 980
 981                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 982
 983                         for (i=0; i<resp->record_num; i++) {
 984                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 985                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 986                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 987                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 988                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 989                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 990                                 g_variant_builder_add(&b, "{sv}", "type_of_number", g_variant_new_int32( resp->record[i].ton ));
 991                                 g_variant_builder_add(&b, "{sv}", "numbering_plan_identity", g_variant_new_int32( resp->record[i].npi ));
 992                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 993                                 g_variant_builder_close(&b);
 994                         }
 995
 996                         result = g_variant_builder_end(&b);
 997
 998                         telephony_ss_complete_register_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 999
1000             } break;
1001
1002                 case TRESP_SS_FORWARDING_DEREGISTER: {
1003
1004                         const struct tresp_ss_forwarding *resp = data;
1005
1006                         dbg("receive TRESP_SS_FORWARDING_DEREGISTER (err[%d])", resp->err);
1007
1008                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1009
1010                         for (i=0; i<resp->record_num; i++) {
1011                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1012                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
1013                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
1014                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
1015                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
1016                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
1017                                 g_variant_builder_add(&b, "{sv}", "type_of_number", g_variant_new_int32( resp->record[i].ton ));
1018                                 g_variant_builder_add(&b, "{sv}", "numbering_plan_identity", g_variant_new_int32( resp->record[i].npi ));
1019                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
1020                                 g_variant_builder_close(&b);
1021                         }
1022
1023                         result = g_variant_builder_end(&b);
1024
1025                         telephony_ss_complete_deregister_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
1026
1027                 } break;
1028
1029                 case TRESP_SS_FORWARDING_GET_STATUS: {
1030
1031                         const struct tresp_ss_forwarding *resp = data;
1032
1033                         dbg("receive TRESP_SS_FORWARDING_GET_STATUS (err[%d])", resp->err);
1034
1035                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1036
1037                         for (i=0; i<resp->record_num; i++) {
1038                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1039                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
1040                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
1041                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
1042                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
1043                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
1044                                 g_variant_builder_add(&b, "{sv}", "type_of_number", g_variant_new_int32( resp->record[i].ton ));
1045                                 g_variant_builder_add(&b, "{sv}", "numbering_plan_identity", g_variant_new_int32( resp->record[i].npi ));
1046                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
1047                                 g_variant_builder_close(&b);
1048                         }
1049
1050                         result = g_variant_builder_end(&b);
1051
1052                         telephony_ss_complete_get_forwarding_status(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
1053
1054                 } break;
1055
1056                 case TRESP_SS_WAITING_ACTIVATE: {
1057
1058                         const struct tresp_ss_waiting *resp = data;
1059
1060                         dbg("receive TRESP_SS_WAITING_ACTIVATE (err[%d])", resp->err);
1061
1062                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1063
1064                         for (i=0; i<resp->record_num; i++) {
1065                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1066                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
1067                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
1068                                 g_variant_builder_close(&b);
1069                         }
1070
1071                         result = g_variant_builder_end(&b);
1072
1073                         telephony_ss_complete_activate_waiting(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
1074
1075                 } break;
1076
1077                 case TRESP_SS_WAITING_DEACTIVATE: {
1078
1079                         const struct tresp_ss_waiting *resp = data;
1080
1081                         dbg("receive TRESP_SS_WAITING_DEACTIVATE (err[%d])", resp->err);
1082
1083                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1084
1085                         for (i=0; i<resp->record_num; i++) {
1086                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1087                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
1088                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
1089                                 g_variant_builder_close(&b);
1090                         }
1091
1092                         result = g_variant_builder_end(&b);
1093
1094                         telephony_ss_complete_deactivate_waiting(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
1095
1096                 } break;
1097
1098                 case TRESP_SS_WAITING_GET_STATUS: {
1099
1100                         const struct tresp_ss_waiting *resp = data;
1101
1102                         dbg("receive TRESP_SS_WAITING_GET_STATUS (err[%d])", resp->err);
1103
1104                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1105
1106                         for (i=0; i<resp->record_num; i++) {
1107                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1108                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
1109                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
1110                                 g_variant_builder_close(&b);
1111                         }
1112
1113                         result = g_variant_builder_end(&b);
1114
1115                         telephony_ss_complete_get_waiting_status(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
1116
1117                 } break;
1118
1119                 case TRESP_SS_CLI_SET_STATUS: {
1120
1121                         const struct tresp_ss_set_cli *resp = data;
1122
1123                         dbg("receive TRESP_SS_CLI_SET_STATUS (err[%d])", resp->err);
1124
1125                         telephony_ss_complete_set_clistatus(dbus_info->interface_object, dbus_info->invocation, resp->err);
1126
1127                 } break;
1128
1129                 case TRESP_SS_CLI_GET_STATUS: {
1130
1131                         const struct tresp_ss_cli *resp = data;
1132
1133                         dbg("receive TRESP_SS_CLI_GET_STATUS (err[%d])", resp->err);
1134
1135                         telephony_ss_complete_get_clistatus(dbus_info->interface_object, dbus_info->invocation, resp->err, resp->type, resp->status);
1136
1137                 } break;
1138
1139                 case TRESP_SS_SEND_USSD: {
1140
1141                         const struct tresp_ss_ussd *resp = data;
1142
1143                         dbg("receive TRESP_SS_SEND_USSD (err[%d])", resp->err);
1144                         dbg("USSD : %s (len : %d, type : 0x%x, status : 0x%x, dcs : 0x%x)", resp->str, resp->len, resp->type, resp->status, resp->dcs);
1145                         telephony_ss_complete_send_ussd(dbus_info->interface_object, dbus_info->invocation, resp->err, resp->type, resp->status, resp->dcs, resp->len, (char*)resp->str);
1146
1147                 } break;
1148
1149                 default:
1150                         dbg("not handled command[%d]", command);
1151                 break;
1152         }
1153
1154         return TRUE;
1155 }
1156
1157 gboolean dbus_plugin_ss_notification(struct custom_data *ctx, CoreObject *source, TelephonyObjectSkeleton *object, enum tcore_notification_command command, unsigned int data_len, const void *data)
1158 {
1159         TelephonySs *ss = 0;
1160         GVariant *result = 0;
1161         GVariantBuilder b;
1162         int i = 0;
1163         char *cp_name= NULL;
1164
1165         if (!object) {
1166                 dbg("object is NULL");
1167                 return FALSE;
1168         }
1169         cp_name =  (char*)tcore_server_get_cp_name_by_plugin(tcore_object_ref_plugin(source));
1170
1171         ss = telephony_object_peek_ss(TELEPHONY_OBJECT(object));
1172
1173         switch (command) {
1174                 case TNOTI_SS_USSD: {
1175                         const struct tnoti_ss_ussd *ussd = data;
1176                         enum dbus_tapi_sim_slot_id slot_id;
1177
1178                         slot_id = get_sim_slot_id_by_cp_name(cp_name);
1179                         dbg("slot_id: [%d]", slot_id);
1180
1181                         telephony_ss_emit_notify_ussd(ss,
1182                                         ussd->status,
1183                                         ussd->dcs,
1184                                         ussd->len,
1185                                         (char*)ussd->str);
1186                         _launch_ciss(ussd, slot_id);
1187                 } break;
1188
1189                 case TNOTI_SS_FORWARDING_STATUS: {
1190                         const struct tnoti_ss_forwarding_status *fwrd = data;
1191
1192                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1193
1194                         for (i=0; i<fwrd->record_num; i++) {
1195                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1196                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( fwrd->record[i].class ));
1197                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( fwrd->record[i].status ));
1198                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( fwrd->record[i].mode ));
1199                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( fwrd->record[i].number_present ));
1200                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( fwrd->record[i].time ));
1201                                 g_variant_builder_add(&b, "{sv}", "type_of_number", g_variant_new_int32( fwrd->record[i].ton ));
1202                                 g_variant_builder_add(&b, "{sv}", "numbering_plan_identity", g_variant_new_int32( fwrd->record[i].npi ));
1203                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( fwrd->record[i].number ));
1204                                 g_variant_builder_close(&b);
1205                         }
1206
1207                         result = g_variant_builder_end(&b);
1208                         telephony_ss_emit_notify_forwarding(ss, result);
1209
1210                 } break;
1211
1212                 case TNOTI_SS_BARRING_STATUS: {
1213
1214                         const struct tnoti_ss_barring_status *barr = data;
1215
1216                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1217
1218                         for (i=0; i<barr->record_num; i++) {
1219                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1220                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( barr->record[i].class ));
1221                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( barr->record[i].status ));
1222                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( barr->record[i].mode ));
1223                                 g_variant_builder_close(&b);
1224                         }
1225
1226                         result = g_variant_builder_end(&b);
1227                         telephony_ss_emit_notify_barring(ss, result);
1228
1229                 } break;
1230
1231                 case TNOTI_SS_WAITING_STATUS: {
1232                         const struct tnoti_ss_waiting_status *wait = data;
1233
1234                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1235
1236                         for (i=0; i<wait->record_num; i++) {
1237                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1238                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( wait->record[i].class ));
1239                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( wait->record[i].status ));
1240                                 g_variant_builder_close(&b);
1241                         }
1242
1243                         result = g_variant_builder_end(&b);
1244                         telephony_ss_emit_notify_waiting(ss, result);
1245
1246                 } break;
1247
1248                 case TNOTI_SS_RELEASE_COMPLETE: {
1249                         int i = 0;
1250                         GVariantBuilder builder;
1251                         GVariant *msg_data = 0, *packet = NULL;
1252                         const struct tnoti_ss_release_complete *msg = data;
1253                         if (msg) {
1254                                 g_variant_builder_init(&builder, G_VARIANT_TYPE ("ay"));
1255                                 for (i = 0; i < msg->data_len; i++) {
1256                                         g_variant_builder_add(&builder, "y", msg->data[i]);
1257                                 }
1258                                 msg_data = g_variant_builder_end(&builder);
1259                                 packet = g_variant_new("v", msg_data);
1260
1261                                 dbg("type_format(%s)", g_variant_get_type_string(packet));
1262                                 telephony_ss_emit_release_complete(ss, msg->data_len, packet );
1263                         } else {
1264                                 dbg("No data is passed in USSD release notification");
1265                                 g_variant_builder_init(&builder, G_VARIANT_TYPE ("ay"));
1266                                 g_variant_builder_add(&builder, "y", '\0');
1267                                 msg_data = g_variant_builder_end(&builder);
1268                                 packet = g_variant_new("v", msg_data);
1269                                 dbg("type_format(%s)", g_variant_get_type_string(packet));
1270                                 telephony_ss_emit_release_complete(ss, 1, packet);
1271                         }
1272                 } break;
1273                 case TNOTI_SS_INFO: {
1274                         const struct tnoti_ss_information *ss_info = data;
1275                         telephony_ss_emit_notify_ss_info(ss,
1276                                         ss_info->err,
1277                                         ss_info->ss_type);
1278                         _launch_ciss_information(ss_info);
1279                         /* Launch CISS application
1280                         _launch_ciss(ss_info);
1281                         */
1282                 } break;
1283                 default:
1284                         dbg("not handled command[%d]", command);
1285                 break;
1286         }
1287
1288         return TRUE;
1289 }
1290