src/ss.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <pthread.h>
   4 #include <unistd.h>
   5 #include <stdlib.h>
   6 #include <time.h>
   7 #include <glib.h>
   8 #include <glib-object.h>
   9 #include <gio/gio.h>
  10
  11 #include <tcore.h>
  12 #include <server.h>
  13 #include <plugin.h>
  14 #include <hal.h>
  15 #include <communicator.h>
  16 #include <storage.h>
  17 #include <queue.h>
  18 #include <user_request.h>
  19 #include <co_ss.h>
  20 #include <co_sim.h>
  21 #include <co_ps.h>
  22
  23 #include "generated-code.h"
  24 #include "common.h"
  25
  26
  27
  28 static gboolean
  29 on_ss_activate_barring (TelephonySs *ss,
  30                 GDBusMethodInvocation *invocation,
  31                 gint ss_class,
  32                 gint barring_mode,
  33                 const gchar *barring_password,
  34                 gpointer user_data)
  35 {
  36         char buf[5];
  37         struct treq_ss_barring req;
  38         struct custom_data *ctx = user_data;
  39         UserRequest *ur = NULL;
  40
  41         memset(&req, 0, sizeof(struct treq_ss_barring));
  42
  43         req.class = ss_class;
  44         req.mode = barring_mode;
  45
  46         memcpy(req.password, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
  47         memcpy(buf, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
  48
  49         buf[4] = 0;
  50         dbg("req.password = [%s]", buf);
  51
  52         dbg("class = %d, mode = %d", req.class, req.mode);
  53
  54         ur = MAKE_UR(ctx, ss, invocation);
  55
  56         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring), &req);
  57         tcore_user_request_set_command(ur, TREQ_SS_BARRING_ACTIVATE);
  58         tcore_communicator_dispatch_request(ctx->comm, ur);
  59
  60         return TRUE;
  61 }
  62
  63 static gboolean
  64 on_ss_deactivate_barring (TelephonySs *ss,
  65                 GDBusMethodInvocation *invocation,
  66                 gint ss_class,
  67                 gint barring_mode,
  68                 const gchar *barring_password,
  69                 gpointer user_data)
  70 {
  71         char buf[5];
  72         struct treq_ss_barring req;
  73         struct custom_data *ctx = user_data;
  74         UserRequest *ur = NULL;
  75
  76         memset(&req, 0, sizeof(struct treq_ss_barring));
  77
  78         req.class = ss_class;
  79         req.mode = barring_mode;
  80
  81         memcpy(req.password, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
  82         memcpy(buf, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
  83
  84         buf[4] = 0;
  85         dbg("req.password = [%s]", buf);
  86         dbg("class = %d, mode = %d", req.class, req.mode);
  87
  88         ur = MAKE_UR(ctx, ss, invocation);
  89
  90         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring), &req);
  91         tcore_user_request_set_command(ur, TREQ_SS_BARRING_DEACTIVATE);
  92         tcore_communicator_dispatch_request(ctx->comm, ur);
  93
  94         return TRUE;
  95 }
  96
  97 static gboolean
  98 on_ss_change_barring_password (TelephonySs *ss,
  99                 GDBusMethodInvocation *invocation,
 100                 const gchar *barring_password,
 101                 const gchar *barring_password_new,
 102                 const gchar *barring_password_confirm,
 103                 gpointer user_data)
 104 {
 105         char buf[5];
 106         struct treq_ss_barring_change_password req;
 107         struct custom_data *ctx = user_data;
 108         UserRequest *ur = NULL;
 109
 110         memset(&req, 0, sizeof(struct treq_ss_barring_change_password));
 111
 112         memcpy(req.password_old, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 113         memcpy(req.password_new, barring_password_new, MAX_SS_BARRING_PASSWORD_LEN);
 114         memcpy(req.password_confirm, barring_password_confirm, MAX_SS_BARRING_PASSWORD_LEN);
 115
 116         memcpy(buf, barring_password, MAX_SS_BARRING_PASSWORD_LEN);
 117         buf[4] = 0;
 118         dbg("req.password_old = [%s]", buf);
 119
 120         memcpy(buf, barring_password_new, MAX_SS_BARRING_PASSWORD_LEN);
 121         dbg("req.password_new = [%s]", buf);
 122
 123
 124         memcpy(buf, barring_password_confirm, MAX_SS_BARRING_PASSWORD_LEN);
 125         dbg("req.password_confirm = [%s]", buf);
 126
 127         ur = MAKE_UR(ctx, ss, invocation);
 128
 129         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring_change_password), &req);
 130         tcore_user_request_set_command(ur, TREQ_SS_BARRING_CHANGE_PASSWORD);
 131         tcore_communicator_dispatch_request(ctx->comm, ur);
 132
 133         return TRUE;
 134 }
 135
 136 static gboolean
 137 on_ss_get_barring_status (TelephonySs *ss,
 138                 GDBusMethodInvocation *invocation,
 139                 gint ss_class,
 140                 gint barring_mode,
 141                 gpointer user_data)
 142 {
 143         struct treq_ss_barring req;
 144         struct custom_data *ctx = user_data;
 145         UserRequest *ur = NULL;
 146
 147         memset(&req, 0, sizeof(struct treq_ss_barring));
 148
 149         req.class = ss_class;
 150         req.mode = barring_mode;
 151
 152         dbg("class = %d, mode = %d", req.class, req.mode);
 153
 154         ur = MAKE_UR(ctx, ss, invocation);
 155
 156         tcore_user_request_set_data(ur, sizeof(struct treq_ss_barring), &req);
 157         tcore_user_request_set_command(ur, TREQ_SS_BARRING_GET_STATUS);
 158         tcore_communicator_dispatch_request(ctx->comm, ur);
 159
 160
 161         return TRUE;
 162 }
 163
 164 static gboolean
 165 on_ss_register_forwarding (TelephonySs *ss,
 166                 GDBusMethodInvocation *invocation,
 167                 gint ss_class,
 168                 gint forward_mode,
 169                 gint forward_no_reply_time,
 170                 const gchar *forward_number,
 171                 gpointer user_data)
 172 {
 173         struct treq_ss_forwarding req;
 174         struct custom_data *ctx = user_data;
 175         UserRequest *ur = NULL;
 176
 177         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 178
 179         req.class = ss_class;
 180         req.mode = forward_mode;
 181         req.time = forward_no_reply_time;
 182         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 183
 184         dbg("class = %d, mode = %d, time = %d, number = %s",
 185                         req.class, req.mode, req.time, req.number);
 186
 187         ur = MAKE_UR(ctx, ss, invocation);
 188
 189         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 190         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_REGISTER);
 191         tcore_communicator_dispatch_request(ctx->comm, ur);
 192
 193         return TRUE;
 194 }
 195
 196 static gboolean
 197 on_ss_deregister_forwarding (TelephonySs *ss,
 198                 GDBusMethodInvocation *invocation,
 199                 gint ss_class,
 200                 gint forward_mode,
 201                 gint forward_no_reply_time,
 202                 const gchar *forward_number,
 203                 gpointer user_data)
 204 {
 205         struct treq_ss_forwarding req;
 206         struct custom_data *ctx = user_data;
 207         UserRequest *ur = NULL;
 208
 209         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 210
 211         req.class = ss_class;
 212         req.mode = forward_mode;
 213         req.time = forward_no_reply_time;
 214         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 215
 216         dbg("class = %d, mode = %d, time = %d, number = %s",
 217                         req.class, req.mode, req.time, req.number);
 218
 219         ur = MAKE_UR(ctx, ss, invocation);
 220
 221         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 222         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_DEREGISTER);
 223         tcore_communicator_dispatch_request(ctx->comm, ur);
 224
 225         return TRUE;
 226 }
 227
 228 static gboolean
 229 on_ss_activate_forwarding (TelephonySs *ss,
 230                 GDBusMethodInvocation *invocation,
 231                 gint ss_class,
 232                 gint forward_mode,
 233                 gint forward_no_reply_time,
 234                 const gchar *forward_number,
 235                 gpointer user_data)
 236 {
 237         struct treq_ss_forwarding req;
 238         struct custom_data *ctx = user_data;
 239         UserRequest *ur = NULL;
 240
 241         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 242
 243         req.class = ss_class;
 244         req.mode = forward_mode;
 245         req.time = forward_no_reply_time;
 246         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 247
 248         dbg("class = %d, mode = %d, time = %d, number = %s",
 249                         req.class, req.mode, req.time, req.number);
 250
 251         ur = MAKE_UR(ctx, ss, invocation);
 252
 253         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 254         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_ACTIVATE);
 255         tcore_communicator_dispatch_request(ctx->comm, ur);
 256
 257         return TRUE;
 258 }
 259
 260 static gboolean
 261 on_ss_deactivate_forwarding (TelephonySs *ss,
 262                 GDBusMethodInvocation *invocation,
 263                 gint ss_class,
 264                 gint forward_mode,
 265                 gint forward_no_reply_time,
 266                 const gchar *forward_number,
 267                 gpointer user_data)
 268 {
 269         struct treq_ss_forwarding req;
 270         struct custom_data *ctx = user_data;
 271         UserRequest *ur = NULL;
 272
 273         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 274
 275         req.class = ss_class;
 276         req.mode = forward_mode;
 277         req.time = forward_no_reply_time;
 278         snprintf(req.number, MAX_SS_FORWARDING_NUMBER_LEN, "%s", forward_number);
 279
 280         dbg("class = %d, mode = %d, time = %d, number = %s",
 281                         req.class, req.mode, req.time, req.number);
 282
 283         ur = MAKE_UR(ctx, ss, invocation);
 284
 285         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 286         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_DEACTIVATE);
 287         tcore_communicator_dispatch_request(ctx->comm, ur);
 288
 289         return TRUE;
 290 }
 291
 292 static gboolean
 293 on_ss_get_forwarding_status (TelephonySs *ss,
 294                 GDBusMethodInvocation *invocation,
 295                 gint ss_class,
 296                 gint forward_mode,
 297                 gpointer user_data)
 298 {
 299         struct treq_ss_forwarding req;
 300         struct custom_data *ctx = user_data;
 301         UserRequest *ur = NULL;
 302
 303         memset(&req, 0, sizeof(struct treq_ss_forwarding));
 304
 305         req.class = ss_class;
 306         req.mode = forward_mode;
 307
 308         dbg("class = %d, mode = %d, time = %d, number = %s",
 309                         req.class, req.mode, req.time, req.number);
 310
 311         ur = MAKE_UR(ctx, ss, invocation);
 312
 313         tcore_user_request_set_data(ur, sizeof(struct treq_ss_forwarding), &req);
 314         tcore_user_request_set_command(ur, TREQ_SS_FORWARDING_GET_STATUS);
 315         tcore_communicator_dispatch_request(ctx->comm, ur);
 316
 317         return TRUE;
 318 }
 319
 320 static gboolean
 321 on_ss_activate_waiting (TelephonySs *ss,
 322                 GDBusMethodInvocation *invocation,
 323                 gint ss_class,
 324                 gpointer user_data)
 325 {
 326         struct treq_ss_waiting req;
 327         struct custom_data *ctx = user_data;
 328         UserRequest *ur = NULL;
 329
 330         memset(&req, 0, sizeof(struct treq_ss_waiting));
 331
 332         req.class = ss_class;
 333
 334         dbg("class = %d", req.class);
 335
 336         ur = MAKE_UR(ctx, ss, invocation);
 337
 338         tcore_user_request_set_data(ur, sizeof(struct treq_ss_waiting), &req);
 339         tcore_user_request_set_command(ur, TREQ_SS_WAITING_ACTIVATE);
 340         tcore_communicator_dispatch_request(ctx->comm, ur);
 341
 342         return TRUE;
 343 }
 344
 345 static gboolean
 346 on_ss_deactivate_waiting (TelephonySs *ss,
 347                 GDBusMethodInvocation *invocation,
 348                 gint ss_class,
 349                 gpointer user_data)
 350 {
 351         struct treq_ss_waiting req;
 352         struct custom_data *ctx = user_data;
 353         UserRequest *ur = NULL;
 354
 355         memset(&req, 0, sizeof(struct treq_ss_waiting));
 356
 357         req.class = ss_class;
 358
 359         dbg("class = %d", req.class);
 360
 361         ur = MAKE_UR(ctx, ss, invocation);
 362
 363         tcore_user_request_set_data(ur, sizeof(struct treq_ss_waiting), &req);
 364         tcore_user_request_set_command(ur, TREQ_SS_WAITING_DEACTIVATE);
 365         tcore_communicator_dispatch_request(ctx->comm, ur);
 366
 367         return TRUE;
 368 }
 369
 370 static gboolean
 371 on_ss_get_waiting_status (TelephonySs *ss,
 372                 GDBusMethodInvocation *invocation,
 373                 gint ss_class,
 374                 gpointer user_data)
 375 {
 376         struct treq_ss_waiting req;
 377         struct custom_data *ctx = user_data;
 378         UserRequest *ur = NULL;
 379
 380         memset(&req, 0, sizeof(struct treq_ss_waiting));
 381
 382         req.class = ss_class;
 383
 384         dbg("class = %d", req.class);
 385
 386         ur = MAKE_UR(ctx, ss, invocation);
 387
 388         tcore_user_request_set_data(ur, sizeof(struct treq_ss_waiting), &req);
 389         tcore_user_request_set_command(ur, TREQ_SS_WAITING_GET_STATUS);
 390         tcore_communicator_dispatch_request(ctx->comm, ur);
 391
 392         return TRUE;
 393 }
 394
 395 static gboolean
 396 on_ss_get_cli_status (TelephonySs *ss,
 397                 GDBusMethodInvocation *invocation,
 398                 gint cli_type,
 399                 gpointer user_data)
 400 {
 401         struct treq_ss_cli req;
 402         struct custom_data *ctx = user_data;
 403         UserRequest *ur = NULL;
 404
 405         memset(&req, 0, sizeof(struct treq_ss_cli));
 406
 407         req.type = cli_type;
 408
 409         dbg("type = %d", req.type);
 410
 411         ur = MAKE_UR(ctx, ss, invocation);
 412
 413         tcore_user_request_set_data(ur, sizeof(struct treq_ss_cli), &req);
 414         tcore_user_request_set_command(ur, TREQ_SS_CLI_GET_STATUS);
 415         tcore_communicator_dispatch_request(ctx->comm, ur);
 416
 417         return TRUE;
 418 }
 419
 420 static gboolean
 421 on_ss_send_ussd (TelephonySs *ss,
 422                 GDBusMethodInvocation *invocation,
 423                 gint ussd_type,
 424                 gint ussd_len,
 425                 const gchar *ussd_string,
 426                 gpointer user_data)
 427 {
 428         struct treq_ss_ussd req;
 429         struct custom_data *ctx = user_data;
 430         UserRequest *ur = NULL;
 431
 432         memset(&req, 0, sizeof(struct treq_ss_ussd));
 433
 434         req.type = SS_USSD_TYPE_USER_INITIATED;
 435         snprintf(req.str, MAX_SS_USSD_LEN, "%s", ussd_string);
 436
 437         dbg("type = %d, string = %s", req.type, req.str);
 438
 439         ur = MAKE_UR(ctx, ss, invocation);
 440
 441         tcore_user_request_set_data(ur, sizeof(struct treq_ss_ussd), &req);
 442         tcore_user_request_set_command(ur, TREQ_SS_SEND_USSD);
 443         tcore_communicator_dispatch_request(ctx->comm, ur);
 444
 445         return TRUE;
 446 }
 447
 448 gboolean dbus_plugin_setup_ss_interface(TelephonyObjectSkeleton *object, struct custom_data *ctx)
 449 {
 450         TelephonySs *ss;
 451
 452         ss = telephony_ss_skeleton_new();
 453         telephony_object_skeleton_set_ss(object, ss);
 454         g_object_unref(ss);
 455
 456         g_signal_connect (ss,
 457                         "handle-activate-barring",
 458                         G_CALLBACK (on_ss_activate_barring),
 459                         ctx);
 460
 461         g_signal_connect (ss,
 462                         "handle-deactivate-barring",
 463                         G_CALLBACK (on_ss_deactivate_barring),
 464                         ctx);
 465
 466         g_signal_connect (ss,
 467                         "handle-change-barring-password",
 468                         G_CALLBACK (on_ss_change_barring_password),
 469                         ctx);
 470
 471         g_signal_connect (ss,
 472                         "handle-get-barring-status",
 473                         G_CALLBACK (on_ss_get_barring_status),
 474                         ctx);
 475
 476         g_signal_connect (ss,
 477                         "handle-register-forwarding",
 478                         G_CALLBACK (on_ss_register_forwarding),
 479                         ctx);
 480
 481         g_signal_connect (ss,
 482                         "handle-deregister-forwarding",
 483                         G_CALLBACK (on_ss_deregister_forwarding),
 484                         ctx);
 485
 486         g_signal_connect (ss,
 487                         "handle-activate-forwarding",
 488                         G_CALLBACK (on_ss_activate_forwarding),
 489                         ctx);
 490
 491         g_signal_connect (ss,
 492                         "handle-deactivate-forwarding",
 493                         G_CALLBACK (on_ss_deactivate_forwarding),
 494                         ctx);
 495
 496         g_signal_connect (ss,
 497                         "handle-get-forwarding-status",
 498                         G_CALLBACK (on_ss_get_forwarding_status),
 499                         ctx);
 500
 501         g_signal_connect (ss,
 502                         "handle-activate-waiting",
 503                         G_CALLBACK (on_ss_activate_waiting),
 504                         ctx);
 505
 506         g_signal_connect (ss,
 507                         "handle-deactivate-waiting",
 508                         G_CALLBACK (on_ss_deactivate_waiting),
 509                         ctx);
 510
 511         g_signal_connect (ss,
 512                         "handle-get-waiting-status",
 513                         G_CALLBACK (on_ss_get_waiting_status),
 514                         ctx);
 515
 516         g_signal_connect (ss,
 517                         "handle-get-clistatus",
 518                         G_CALLBACK (on_ss_get_cli_status),
 519                         ctx);
 520
 521         g_signal_connect (ss,
 522                         "handle-send-ussd",
 523                         G_CALLBACK (on_ss_send_ussd),
 524                         ctx);
 525
 526         return TRUE;
 527 }
 528
 529 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)
 530 {
 531         GVariant *result = 0;
 532         GVariantBuilder b;
 533         int i = 0;
 534
 535         switch (command) {
 536                 case TRESP_SS_BARRING_ACTIVATE: {
 537
 538                         const struct tresp_ss_barring *resp = data;
 539
 540                         dbg("receive TRESP_SS_BARRING_ACTIVATE");
 541                         dbg("resp->err = 0x%x", resp->err);
 542
 543                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 544
 545                         for (i=0; i<resp->record_num; i++) {
 546                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 547                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 548                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 549                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( resp->record[i].mode ));
 550                                 g_variant_builder_close(&b);
 551                         }
 552
 553                         result = g_variant_builder_end(&b);
 554
 555                         telephony_ss_complete_activate_barring(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 556
 557                         g_variant_unref(result);
 558
 559                 } break;
 560
 561                 case TRESP_SS_BARRING_DEACTIVATE: {
 562
 563                         const struct tresp_ss_barring *resp = data;
 564
 565                         dbg("receive TRESP_SS_BARRING_DEACTIVATE");
 566                         dbg("resp->err = 0x%x", resp->err);
 567
 568                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 569
 570                         for (i=0; i<resp->record_num; i++) {
 571                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 572                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 573                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 574                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( resp->record[i].mode ));
 575                                 g_variant_builder_close(&b);
 576                         }
 577
 578                         result = g_variant_builder_end(&b);
 579
 580                         telephony_ss_complete_deactivate_barring(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 581
 582                         g_variant_unref(result);
 583
 584                 } break;
 585
 586                 case TRESP_SS_BARRING_CHANGE_PASSWORD: {
 587
 588                         const struct tresp_ss_general *resp = data;
 589
 590                         dbg("receive TRESP_SS_BARRING_CHANGE_PASSWORD");
 591                         dbg("resp->err = 0x%x", resp->err);
 592
 593                         telephony_ss_complete_change_barring_password(dbus_info->interface_object, dbus_info->invocation, resp->err);
 594
 595                 } break;
 596
 597                 case TRESP_SS_BARRING_GET_STATUS: {
 598
 599                         const struct tresp_ss_barring *resp = data;
 600
 601                         dbg("receive TRESP_SS_BARRING_GET_STATUS");
 602                         dbg("resp->err = 0x%x", resp->err);
 603
 604                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 605
 606                         for (i=0; i<resp->record_num; i++) {
 607                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 608                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 609                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 610                                 g_variant_builder_add(&b, "{sv}", "barring_mode", g_variant_new_int32( resp->record[i].mode ));
 611                                 g_variant_builder_close(&b);
 612                         }
 613
 614                         result = g_variant_builder_end(&b);
 615
 616                         telephony_ss_complete_get_barring_status(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 617
 618                         g_variant_unref(result);
 619
 620                 } break;
 621
 622                 case TRESP_SS_FORWARDING_ACTIVATE: {
 623                         const struct tresp_ss_forwarding *resp = data;
 624
 625                         dbg("receive TRESP_SS_FORWARDING_ACTIVATE");
 626                         dbg("resp->err = 0x%x", resp->err);
 627
 628                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 629
 630                         for (i=0; i<resp->record_num; i++) {
 631                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 632                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 633                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 634                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 635                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 636                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 637                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 638                                 g_variant_builder_close(&b);
 639                         }
 640
 641                         result = g_variant_builder_end(&b);
 642
 643                         telephony_ss_complete_activate_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 644
 645                         g_variant_unref(result);
 646
 647                 } break;
 648
 649                 case TRESP_SS_FORWARDING_DEACTIVATE: {
 650
 651                         const struct tresp_ss_forwarding *resp = data;
 652
 653                         dbg("receive TRESP_SS_FORWARDING_DEACTIVATE");
 654                         dbg("resp->err = 0x%x", resp->err);
 655
 656                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 657
 658                         for (i=0; i<resp->record_num; i++) {
 659                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 660                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 661                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 662                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 663                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 664                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 665                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 666                                 g_variant_builder_close(&b);
 667                         }
 668
 669                         result = g_variant_builder_end(&b);
 670
 671                         telephony_ss_complete_deactivate_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 672
 673                         g_variant_unref(result);
 674
 675                 } break;
 676
 677                 case TRESP_SS_FORWARDING_REGISTER: {
 678
 679                         const struct tresp_ss_forwarding *resp = data;
 680
 681                         dbg("receive TRESP_SS_FORWARDING_REGISTER");
 682                         dbg("resp->err = 0x%x", resp->err);
 683
 684                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 685
 686                         for (i=0; i<resp->record_num; i++) {
 687                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 688                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 689                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 690                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 691                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 692                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 693                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 694                                 g_variant_builder_close(&b);
 695                         }
 696
 697                         result = g_variant_builder_end(&b);
 698
 699                         telephony_ss_complete_register_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 700
 701                         g_variant_unref(result);
 702
 703             } break;
 704
 705                 case TRESP_SS_FORWARDING_DEREGISTER: {
 706
 707                         const struct tresp_ss_forwarding *resp = data;
 708
 709                         dbg("receive TRESP_SS_FORWARDING_DEREGISTER");
 710                         dbg("resp->err = 0x%x", resp->err);
 711
 712                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 713
 714                         for (i=0; i<resp->record_num; i++) {
 715                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 716                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 717                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 718                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 719                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 720                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 721                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 722                                 g_variant_builder_close(&b);
 723                         }
 724
 725                         result = g_variant_builder_end(&b);
 726
 727                         telephony_ss_complete_deregister_forwarding(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 728
 729                         g_variant_unref(result);
 730
 731                 } break;
 732
 733                 case TRESP_SS_FORWARDING_GET_STATUS: {
 734
 735                         const struct tresp_ss_forwarding *resp = data;
 736
 737                         dbg("receive TRESP_SS_FORWARDING_GET_STATUS");
 738                         dbg("resp->err = 0x%x", resp->err);
 739
 740                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 741
 742                         for (i=0; i<resp->record_num; i++) {
 743                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 744                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 745                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 746                                 g_variant_builder_add(&b, "{sv}", "forwarding_mode", g_variant_new_int32( resp->record[i].mode ));
 747                                 g_variant_builder_add(&b, "{sv}", "no_reply_time", g_variant_new_int32( resp->record[i].time ));
 748                                 g_variant_builder_add(&b, "{sv}", "number_present", g_variant_new_int32( resp->record[i].number_present ));
 749                                 g_variant_builder_add(&b, "{sv}", "forwarding_number", g_variant_new_string( resp->record[i].number ));
 750                                 g_variant_builder_close(&b);
 751                         }
 752
 753                         result = g_variant_builder_end(&b);
 754
 755                         telephony_ss_complete_get_forwarding_status(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 756
 757                         g_variant_unref(result);
 758
 759                 } break;
 760
 761                 case TRESP_SS_WAITING_ACTIVATE: {
 762
 763                         const struct tresp_ss_waiting *resp = data;
 764
 765                         dbg("receive TRESP_SS_WAITING_ACTIVATE");
 766                         dbg("resp->err = 0x%x", resp->err);
 767
 768                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 769
 770                         for (i=0; i<resp->record_num; i++) {
 771                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 772                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 773                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 774                                 g_variant_builder_close(&b);
 775                         }
 776
 777                         result = g_variant_builder_end(&b);
 778
 779                         telephony_ss_complete_activate_waiting(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 780
 781                         g_variant_unref(result);
 782
 783                 } break;
 784
 785                 case TRESP_SS_WAITING_DEACTIVATE: {
 786
 787                         const struct tresp_ss_waiting *resp = data;
 788
 789                         dbg("receive TRESP_SS_WAITING_DEACTIVATE");
 790                         dbg("resp->err = 0x%x", resp->err);
 791
 792                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 793
 794                         for (i=0; i<resp->record_num; i++) {
 795                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 796                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 797                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 798                                 g_variant_builder_close(&b);
 799                         }
 800
 801                         result = g_variant_builder_end(&b);
 802
 803                         telephony_ss_complete_deactivate_waiting(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 804
 805                         g_variant_unref(result);
 806
 807                 } break;
 808
 809                 case TRESP_SS_WAITING_GET_STATUS: {
 810
 811                         const struct tresp_ss_waiting *resp = data;
 812
 813                         dbg("receive TRESP_SS_WAITING_GET_STATUS");
 814                         dbg("resp->err = 0x%x", resp->err);
 815
 816                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 817
 818                         for (i=0; i<resp->record_num; i++) {
 819                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 820                                 g_variant_builder_add(&b, "{sv}", "ss_class", g_variant_new_int32( resp->record[i].class ));
 821                                 g_variant_builder_add(&b, "{sv}", "ss_status", g_variant_new_int32( resp->record[i].status ));
 822                                 g_variant_builder_close(&b);
 823                         }
 824
 825                         result = g_variant_builder_end(&b);
 826
 827                         telephony_ss_complete_get_waiting_status(dbus_info->interface_object, dbus_info->invocation, result, resp->err);
 828
 829                         g_variant_unref(result);
 830
 831                 } break;
 832
 833                 case TRESP_SS_CLI_GET_STATUS: {
 834
 835                         const struct tresp_ss_cli *resp = data;
 836
 837                         dbg("receive TRESP_SS_CLI_GET_STATUS");
 838                         dbg("resp->err = 0x%x", resp->err);
 839
 840                         telephony_ss_complete_get_clistatus(dbus_info->interface_object, dbus_info->invocation, resp->err, resp->type, resp->status);
 841
 842                 } break;
 843
 844                 case TRESP_SS_SEND_USSD: {
 845
 846                         const struct tresp_ss_ussd *resp = data;
 847
 848                         dbg("receive TRESP_SS_SEND_USSD");
 849                         dbg("resp->err = 0x%x", resp->err);
 850
 851                         if ( resp->err ) {
 852                                 dbg("USSD Request is failed");
 853                                 telephony_ss_complete_send_ussd(dbus_info->interface_object, dbus_info->invocation, resp->err, resp->type, resp->status, -1, 0);
 854
 855                         } else {
 856                                 int ussd_len = strlen(resp->str);
 857                                 dbg("USSD Request is Success");
 858                                 dbg("USSD : %s (%d)", resp->str, ussd_len);
 859                                 telephony_ss_complete_send_ussd(dbus_info->interface_object, dbus_info->invocation, resp->err, resp->type, resp->status, ussd_len, resp->str);
 860
 861                         }
 862
 863                 } break;
 864
 865                 default:
 866                         dbg("not handled command[%d]", command);
 867                 break;
 868         }
 869
 870         return TRUE;
 871 }
 872
 873 gboolean dbus_plugin_ss_notification(struct custom_data *ctx, const char *plugin_name, TelephonyObjectSkeleton *object, enum tcore_notification_command command, unsigned int data_len, const void *data)
 874 {
 875         TelephonySs *ss;
 876         const struct tnoti_ss_ussd *ussd = data;
 877
 878         if (!object) {
 879                 dbg("object is NULL");
 880                 return FALSE;
 881         }
 882
 883         ss = telephony_object_peek_ss(TELEPHONY_OBJECT(object));
 884         dbg("ss = %p", ss);
 885
 886         switch (command) {
 887                 case TNOTI_SS_USSD:
 888                         telephony_ss_emit_notify_ussd(ss,
 889                                         ussd->status,
 890                                         strlen(ussd->str),
 891                                         ussd->str );
 892                         break;
 893
 894                 default:
 895                         dbg("not handled command[%d]", command);
 896                 break;
 897         }
 898
 899         return TRUE;
 900 }
 901