plugin/src/socket_network.c

   1 /*
   2  * tel-plugin-socket-communicator
   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 <stdlib.h>
  24 #include <errno.h>
  25 #include <glib-object.h>
  26
  27 #include <tcore.h>
  28 #include <server.h>
  29 #include <plugin.h>
  30 #include <hal.h>
  31 #include <communicator.h>
  32 #include <core_object.h>
  33 #include <queue.h>
  34 #include <user_request.h>
  35 #include <util.h>
  36 #include <co_network.h>
  37
  38 #include "sipc.h"
  39 #include "tapi_common.h"
  40 #include "module_req.h"
  41
  42 static void _request_fail(UserRequest *ur, int cmd, int resp_len, void *resp)
  43 {
  44         tcore_user_request_send_response(ur, cmd, resp_len, resp);
  45         tcore_user_request_unref(ur);
  46 }
  47
  48 gboolean scomm_service_request_network(unsigned int ch_id, Communicator *c, TcorePlugin *plugin,
  49                 tapi_service_command_e cmd, gchar *data, void **outparam)
  50 {
  51         int ret = 0;
  52         struct _sipc_marshal_object *out_obj;
  53         struct _sipc_marshal_object *in_obj;
  54         gboolean result = TRUE;
  55         UserRequest *ur = NULL;
  56         struct tcore_user_info ui = { 0, 0, 0, NULL, 0, 0, NULL };
  57
  58         in_obj = sipc_util_marshal_object_deserializer(data);
  59         if (!in_obj) {
  60                 dbg("in_obj is NULL");
  61                 result = FALSE;
  62                 goto RETURN;
  63         }
  64
  65         ur = tcore_user_request_new(c, tcore_plugin_get_description(plugin)->name);
  66         if (!ur) {
  67                 dbg("ur is NULL");
  68                 result = FALSE;
  69                 goto RETURN;
  70         }
  71
  72         ui.channel_id = ch_id;
  73         ui.client_cmd = cmd;
  74         tcore_user_request_set_user_info(ur, &ui);
  75
  76         switch (cmd) {
  77                 case TAPI_SERVICE_NETWORK_SEARCH:
  78                         tcore_user_request_set_data(ur, 0, NULL);
  79                         tcore_user_request_set_command(ur, TREQ_NETWORK_SEARCH);
  80                         break;
  81
  82                 case TAPI_SERVICE_NETWORK_SET_PLMN_SELECTION_MODE: {
  83                         struct treq_network_set_plmn_selection_mode data_plmn_select;
  84                         struct tresp_network_set_plmn_selection_mode resp;
  85                         gchar *mode = NULL;
  86                         gchar *plmn = NULL;
  87
  88                         mode = sipc_util_marshal_object_get_string(in_obj, "mode");
  89                         if (!mode) {
  90                                 resp.result = TCORE_RETURN_EINVAL;
  91                                 _request_fail(ur, TRESP_NETWORK_SET_PLMN_SELECTION_MODE, sizeof(struct tresp_network_set_plmn_selection_mode), &resp);
  92                                 result = FALSE;
  93                                 break;
  94                         }
  95
  96                         plmn = sipc_util_marshal_object_get_string(in_obj, "plmn");
  97
  98                         memset(&data_plmn_select, 0, sizeof(struct treq_network_set_plmn_selection_mode));
  99                         if (!g_strcmp0(mode, "automatic")) {
 100                                 data_plmn_select.mode = NETWORK_SELECT_MODE_GSM_AUTOMATIC;
 101                         }
 102                         else if (!g_strcmp0(mode, "manual")) {
 103                                 data_plmn_select.mode = NETWORK_SELECT_MODE_GSM_MANUAL;
 104                                 snprintf(data_plmn_select.plmn, 6, "%s", plmn);
 105                                 if (strlen(data_plmn_select.plmn) <= 5)
 106                                         data_plmn_select.plmn[5] = '#';
 107                         }
 108                         else {
 109                                 /* fail */
 110                                 g_free(mode);
 111                                 g_free(plmn);
 112
 113                                 resp.result = TCORE_RETURN_EINVAL;
 114                                 _request_fail(ur, TRESP_NETWORK_SET_PLMN_SELECTION_MODE, sizeof(struct tresp_network_set_plmn_selection_mode), &resp);
 115                                 result = FALSE;
 116                                 break;
 117                         }
 118
 119                         g_free(mode);
 120                         g_free(plmn);
 121
 122                         tcore_user_request_set_data(ur, sizeof(struct treq_network_set_plmn_selection_mode), &data_plmn_select);
 123                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_PLMN_SELECTION_MODE);
 124                 }
 125                         break;
 126
 127                 case TAPI_SERVICE_NETWORK_GET_PLMN_SELECTION_MODE:
 128                         tcore_user_request_set_data(ur, 0, NULL);
 129                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_PLMN_SELECTION_MODE);
 130                         break;
 131
 132                 case TAPI_SERVICE_NETWORK_SET_SERVICE_DOMAIN: {
 133                         struct treq_network_set_service_domain data_service_domain;
 134                         struct tresp_network_set_service_domain resp;
 135                         gchar *domain = NULL;
 136
 137                         domain = sipc_util_marshal_object_get_string(in_obj, "domain");
 138                         if (!domain) {
 139                                 resp.result = TCORE_RETURN_EINVAL;
 140                                 _request_fail(ur, TRESP_NETWORK_SET_SERVICE_DOMAIN, sizeof(struct tresp_network_set_service_domain), &resp);
 141                                 result = FALSE;
 142                                 break;
 143                         }
 144
 145                         if (!g_strcmp0(domain, "circuit")) {
 146                                 data_service_domain.domain = NETWORK_SERVICE_DOMAIN_CS;
 147                         }
 148                         else if (!g_strcmp0(domain, "packet")) {
 149                                 data_service_domain.domain = NETWORK_SERVICE_DOMAIN_PS;
 150                         }
 151                         else if (!g_strcmp0(domain, "combined")) {
 152                                 data_service_domain.domain = NETWORK_SERVICE_DOMAIN_COMBINED;
 153                         }
 154                         else {
 155                                 /* fail */
 156                                 g_free(domain);
 157                                 result = FALSE;
 158                                 resp.result = TCORE_RETURN_EINVAL;
 159                                 _request_fail(ur, TRESP_NETWORK_SET_SERVICE_DOMAIN, sizeof(struct tresp_network_set_service_domain), &resp);
 160                                 break;
 161                         }
 162
 163                         g_free(domain);
 164
 165                         tcore_user_request_set_data(ur, sizeof(struct treq_network_set_service_domain), &data_service_domain);
 166                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_SERVICE_DOMAIN);
 167                 }
 168                         break;
 169
 170                 case TAPI_SERVICE_NETWORK_GET_SERVICE_DOMAIN:
 171                         tcore_user_request_set_data(ur, 0, NULL);
 172                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_SERVICE_DOMAIN);
 173                         break;
 174
 175                 case TAPI_SERVICE_NETWORK_SET_BAND :{
 176                         struct treq_network_set_band data_band;
 177                         struct tresp_network_set_band resp;
 178                         gchar *mode = NULL;
 179                         gint band;
 180
 181                         mode = sipc_util_marshal_object_get_string(in_obj, "mode");
 182                         if (!mode) {
 183                                 result = FALSE;
 184                                 resp.result = TCORE_RETURN_EINVAL;
 185                                 _request_fail(ur, TRESP_NETWORK_SET_BAND, sizeof(struct tresp_network_set_band), &resp);
 186                                 break;
 187                         }
 188
 189                         band = sipc_util_marshal_object_get_int(in_obj, "band");
 190
 191                         if (!g_strcmp0(mode, "only")) {
 192                                 data_band.mode = NETWORK_BAND_MODE_ONLY;
 193                         }
 194                         else if (!g_strcmp0(mode, "preferred")) {
 195                                 data_band.mode = NETWORK_BAND_MODE_PREFERRED;
 196                         }
 197                         else {
 198                                 /* fail */
 199                                 g_free(mode);
 200                                 result = FALSE;
 201                                 resp.result = TCORE_RETURN_EINVAL;
 202                                 _request_fail(ur, TRESP_NETWORK_SET_BAND, sizeof(struct tresp_network_set_band), &resp);
 203                                 break;
 204                         }
 205
 206                         data_band.band = band;
 207
 208                         g_free(mode);
 209
 210                         tcore_user_request_set_data(ur, sizeof(struct treq_network_set_band), &data_band);
 211                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_BAND);
 212                 }
 213                         break;
 214
 215                 case TAPI_SERVICE_NETWORK_GET_BAND:
 216                         tcore_user_request_set_data(ur, 0, NULL);
 217                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_BAND);
 218                         break;
 219
 220                 case TAPI_SERVICE_NETWORK_SET_PREFERRED_PLMN :{
 221                         struct treq_network_set_preferred_plmn data_preferred_plmn;
 222                         struct tresp_network_set_preferred_plmn resp;
 223                         gchar *mode = NULL;
 224                         gchar *plmn = NULL;
 225                         gint act;
 226                         gint ef_index;
 227
 228                         mode = sipc_util_marshal_object_get_string(in_obj, "mode");
 229                         if (!mode) {
 230                                 result = FALSE;
 231                                 resp.result = TCORE_RETURN_EINVAL;
 232                                 _request_fail(ur, TRESP_NETWORK_SET_PREFERRED_PLMN, sizeof(struct tresp_network_set_preferred_plmn), &resp);
 233                                 break;
 234                         }
 235
 236                         plmn = sipc_util_marshal_object_get_string(in_obj, "plmn");
 237                         if (!plmn) {
 238                                 g_free(mode);
 239                                 result = FALSE;
 240                                 resp.result = TCORE_RETURN_EINVAL;
 241                                 _request_fail(ur, TRESP_NETWORK_SET_PREFERRED_PLMN, sizeof(struct tresp_network_set_preferred_plmn), &resp);
 242                                 break;
 243                         }
 244
 245                         act = sipc_util_marshal_object_get_int(in_obj, "act");
 246                         ef_index = sipc_util_marshal_object_get_int(in_obj, "ef_index");
 247
 248                         if (!g_strcmp0(mode, "add")) {
 249                                 data_preferred_plmn.operation = NETWORK_PREF_PLMN_ADD;
 250
 251                         }
 252                         else if (!g_strcmp0(mode, "edit")) {
 253                                 data_preferred_plmn.operation = NETWORK_PREF_PLMN_EDIT;
 254
 255                         }
 256                         else if (!g_strcmp0(mode, "delete")) {
 257                                 data_preferred_plmn.operation = NETWORK_PREF_PLMN_DELETE;
 258                         }
 259                         else {
 260                                 /* fail */
 261                                 g_free(mode);
 262                                 g_free(plmn);
 263                                 result = FALSE;
 264                                 resp.result = TCORE_RETURN_EINVAL;
 265                                 _request_fail(ur, TRESP_NETWORK_SET_PREFERRED_PLMN, sizeof(struct tresp_network_set_preferred_plmn), &resp);
 266                                 break;
 267                         }
 268
 269                         snprintf(data_preferred_plmn.plmn, 6, "%s", plmn);
 270                         if (strlen(data_preferred_plmn.plmn) <= 5)
 271                                 data_preferred_plmn.plmn[5] = '#';
 272
 273                         data_preferred_plmn.act = act;
 274                         data_preferred_plmn.ef_index = ef_index;
 275
 276                         g_free(mode);
 277                         g_free(plmn);
 278
 279                         tcore_user_request_set_data(ur, sizeof(struct treq_network_set_preferred_plmn), &data_preferred_plmn);
 280                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_PREFERRED_PLMN);
 281                 }
 282                         break;
 283
 284                 case TAPI_SERVICE_NETWORK_GET_PREFERRED_PLMN:
 285                         tcore_user_request_set_data(ur, 0, NULL);
 286                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_PREFERRED_PLMN);
 287                         break;
 288
 289                 case TAPI_SERVICE_NETWORK_SET_ORDER :{
 290                         struct treq_network_set_order data_order;
 291                         struct tresp_network_set_order resp;
 292                         gchar *order = NULL;
 293
 294                         order = sipc_util_marshal_object_get_string(in_obj, "order");
 295                         if (!order) {
 296                                 result = FALSE;
 297                                 resp.result = TCORE_RETURN_EINVAL;
 298                                 _request_fail(ur, TRESP_NETWORK_SET_ORDER, sizeof(struct tresp_network_set_order), &resp);
 299                                 break;
 300                         }
 301
 302                         if (!g_strcmp0(order, "auto")) {
 303                                 data_order.order = NETWORK_ORDER_AUTO;
 304                         }
 305                         else if (!g_strcmp0(order, "gsm")) {
 306                                 data_order.order = NETWORK_ORDER_GSM_FIRST;
 307                         }
 308                         else if (!g_strcmp0(order, "wcdma")) {
 309                                 data_order.order = NETWORK_ORDER_WCDMA_FIRST;
 310                         }
 311                         else if (!g_strcmp0(order, "no_change")) {
 312                                 data_order.order = NETWORK_ORDER_NO_CHANGE;
 313                         }
 314                         else {
 315                                 g_free(order);
 316                                 result = FALSE;
 317                                 resp.result = TCORE_RETURN_EINVAL;
 318                                 _request_fail(ur, TRESP_NETWORK_SET_ORDER, sizeof(struct tresp_network_set_order), &resp);
 319                                 break;
 320                         }
 321
 322                         g_free(order);
 323
 324                         tcore_user_request_set_data(ur, sizeof(struct treq_network_set_order), &data_order);
 325                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_ORDER);
 326                 }
 327                         break;
 328
 329                 case TAPI_SERVICE_NETWORK_GET_ORDER:
 330                         tcore_user_request_set_data(ur, 0, NULL);
 331                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_ORDER);
 332                         break;
 333
 334                 case TAPI_SERVICE_NETWORK_SET_POWER_ON_ATTACH :{
 335                         struct treq_network_set_power_on_attach data_power_on_attach;
 336                         gboolean enable;
 337
 338                         enable = sipc_util_marshal_object_get_boolean(in_obj, "enable");
 339
 340                         data_power_on_attach.enable = enable;
 341
 342                         tcore_user_request_set_data(ur, sizeof(struct treq_network_set_power_on_attach), &data_power_on_attach);
 343                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_POWER_ON_ATTACH);
 344                 }
 345                         break;
 346
 347                 case TAPI_SERVICE_NETWORK_GET_POWER_ON_ATTACH:
 348                         tcore_user_request_set_data(ur, 0, NULL);
 349                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_POWER_ON_ATTACH);
 350                         break;
 351
 352                 case TAPI_SERVICE_NETWORK_SET_CANCEL_MANUAL_SEARCH:
 353                         tcore_user_request_set_data(ur, 0, NULL);
 354                         tcore_user_request_set_command(ur, TREQ_NETWORK_SET_CANCEL_MANUAL_SEARCH);
 355                         break;
 356
 357                 case TAPI_SERVICE_NETWORK_GET_SERVING_NETWORK:
 358                         tcore_user_request_set_data(ur, 0, NULL);
 359                         tcore_user_request_set_command(ur, TREQ_NETWORK_GET_SERVING_NETWORK);
 360                         break;
 361         }
 362
 363 RETURN:
 364         sipc_util_marshal_object_destory(in_obj);
 365         out_obj = sipc_util_marshal_object_create();
 366         sipc_util_marshal_object_add_data(out_obj, "result", &result, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 367
 368         dbg("result = %d", result);
 369
 370         *outparam = sipc_util_marshal_object_serializer(out_obj);
 371         sipc_util_marshal_object_destory(out_obj);
 372
 373         if (result == FALSE) {
 374                 tcore_user_request_unref(ur);
 375                 return FALSE;
 376         }
 377
 378         ret = tcore_communicator_dispatch_request(c, ur);
 379         if (ret != TCORE_RETURN_SUCCESS) {
 380                 return FALSE;
 381         }
 382
 383         return TRUE;
 384 }
 385
 386 gboolean scomm_service_response_network(Communicator *comm, UserRequest *ur, enum tcore_response_command command,
 387                 unsigned int data_len, const void *data)
 388 {
 389         const struct tresp_network_search *resp_network_search = data;
 390         const struct tresp_network_set_plmn_selection_mode *resp_set_plmn_selection_mode = data;
 391         const struct tresp_network_get_plmn_selection_mode *resp_get_plmn_selection_mode = data;
 392         const struct tresp_network_set_service_domain *resp_set_service_domain = data;
 393         const struct tresp_network_get_service_domain *resp_get_service_domain = data;
 394         const struct tresp_network_set_band *resp_set_band = data;
 395         const struct tresp_network_get_band *resp_get_band = data;
 396         const struct tresp_network_set_preferred_plmn *resp_set_preferred_plmn = data;
 397         const struct tresp_network_get_preferred_plmn *resp_get_preferred_plmn = data;
 398         const struct tresp_network_set_order *resp_set_order = data;
 399         const struct tresp_network_get_order *resp_get_order = data;
 400         const struct tresp_network_set_power_on_attach *resp_set_power_on_attach = data;
 401         const struct tresp_network_get_power_on_attach *resp_get_power_on_attach = data;
 402         const struct tresp_network_set_cancel_manual_search *resp_set_cancel_manual_search = data;
 403         const struct tresp_network_get_serving_network *resp_get_serving_network = data;
 404
 405         int ret = 0;
 406         int i = 0;
 407         gchar *out_d = NULL;
 408         gchar *serial_d = NULL;
 409         gchar entry_key[10] = { 0, };
 410         struct custom_data *ctx = NULL;
 411         const struct tcore_user_info *ui;
 412         struct _tapi_header hdr;
 413         struct _sipc_marshal_object* out_obj = NULL;
 414         struct _sipc_marshal_object* entry_obj = NULL;
 415         struct _sipc_marshal_object* in_obj = NULL;
 416
 417         ctx = tcore_communicator_ref_user_data(comm);
 418         if (!ctx) {
 419                 dbg("ctx is NULL");
 420                 return FALSE;
 421         }
 422
 423         ui = tcore_user_request_ref_user_info(ur);
 424
 425         dbg("response command = [0x%x], data_len = %d", command, data_len);
 426         dbg("channel_id = %d, client_cmd = %d", ui->channel_id, ui->client_cmd);
 427
 428         memset(&hdr, 0, sizeof(struct _tapi_header));
 429         hdr.cmd = (tapi_service_command_e) ui->client_cmd;
 430
 431         out_obj = sipc_util_marshal_object_create();
 432
 433         switch (command) {
 434                 case TRESP_NETWORK_SEARCH:
 435                         sipc_util_marshal_object_add_data(out_obj, "count", &resp_network_search->list_count,
 436                                         SIPC_MARSHAL_DATA_INT_TYPE);
 437
 438                         dbg("count = %d", resp_network_search->list_count);
 439                         for (i = 0; i < resp_network_search->list_count; i++) {
 440                                 entry_obj = sipc_util_marshal_object_create();
 441                                 sipc_util_marshal_object_add_data(entry_obj, "plmn", resp_network_search->list[i].plmn,
 442                                                 SIPC_MARSHAL_DATA_STRING_TYPE);
 443                                 sipc_util_marshal_object_add_data(entry_obj, "status", &resp_network_search->list[i].status,
 444                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 445                                 sipc_util_marshal_object_add_data(entry_obj, "act", &resp_network_search->list[i].act,
 446                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 447
 448                                 snprintf(entry_key, 10, "%d", i);
 449                                 sipc_util_marshal_object_add_data(out_obj, entry_key, entry_obj, SIPC_MARSHAL_DATA_OBJECT_TYPE);
 450
 451                                 dbg(
 452                                                 "entry=%p, key=%s, plmn=%s, status=%d, act=%d",
 453                                                 entry_obj,
 454                                                 entry_key, resp_network_search->list[i].plmn, resp_network_search->list[i].status, resp_network_search->list[i].act);
 455                         }
 456                         break;
 457
 458                 case TRESP_NETWORK_SET_PLMN_SELECTION_MODE:
 459                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_plmn_selection_mode->result,
 460                                         SIPC_MARSHAL_DATA_INT_TYPE);
 461                         break;
 462
 463                 case TRESP_NETWORK_GET_PLMN_SELECTION_MODE:
 464                         switch (resp_get_plmn_selection_mode->mode) {
 465                                 case NETWORK_SELECT_MODE_GSM_MANUAL:
 466                                         sipc_util_marshal_object_add_data(out_obj, "mode", "manual", SIPC_MARSHAL_DATA_STRING_TYPE);
 467                                         break;
 468
 469                                 case NETWORK_SELECT_MODE_CDMA:
 470                                         sipc_util_marshal_object_add_data(out_obj, "mode", "cdma", SIPC_MARSHAL_DATA_STRING_TYPE);
 471                                         break;
 472
 473                                 case NETWORK_SELECT_MODE_GLOBAL_AUTOMATIC:
 474                                 default:
 475                                         sipc_util_marshal_object_add_data(out_obj, "mode", "automatic", SIPC_MARSHAL_DATA_STRING_TYPE);
 476                                         sipc_util_marshal_object_add_data(out_obj, "mode", "automatic", SIPC_MARSHAL_DATA_STRING_TYPE);
 477                                         break;
 478                         }
 479                         break;
 480
 481                 case TRESP_NETWORK_SET_SERVICE_DOMAIN:
 482                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_service_domain->result,
 483                                         SIPC_MARSHAL_DATA_INT_TYPE);
 484                         break;
 485
 486                 case TRESP_NETWORK_GET_SERVICE_DOMAIN:
 487                         switch (resp_get_service_domain->domain) {
 488                                 case NETWORK_SERVICE_DOMAIN_CS:
 489                                         sipc_util_marshal_object_add_data(out_obj, "domain", "circuit", SIPC_MARSHAL_DATA_STRING_TYPE);
 490                                         break;
 491
 492                                 case NETWORK_SERVICE_DOMAIN_PS:
 493                                         sipc_util_marshal_object_add_data(out_obj, "domain", "packet", SIPC_MARSHAL_DATA_STRING_TYPE);
 494                                         break;
 495
 496                                 case NETWORK_SERVICE_DOMAIN_COMBINED:
 497                                 default:
 498                                         sipc_util_marshal_object_add_data(out_obj, "domain", "combined", SIPC_MARSHAL_DATA_STRING_TYPE);
 499                                         break;
 500                         }
 501                         break;
 502
 503                 case TRESP_NETWORK_SET_BAND:
 504                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_band->result, SIPC_MARSHAL_DATA_INT_TYPE);
 505                         break;
 506
 507                 case TRESP_NETWORK_GET_BAND:
 508                         sipc_util_marshal_object_add_data(out_obj, "band", &resp_get_band->band, SIPC_MARSHAL_DATA_INT_TYPE);
 509                         if (resp_get_band->mode == NETWORK_BAND_MODE_ONLY) {
 510                                 sipc_util_marshal_object_add_data(out_obj, "mode", "only", SIPC_MARSHAL_DATA_STRING_TYPE);
 511                         }
 512                         else if (resp_get_band->mode == NETWORK_BAND_MODE_PREFERRED) {
 513                                 sipc_util_marshal_object_add_data(out_obj, "mode", "preferred", SIPC_MARSHAL_DATA_STRING_TYPE);
 514                         }
 515                         break;
 516
 517                 case TRESP_NETWORK_SET_PREFERRED_PLMN:
 518                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_preferred_plmn->result,
 519                                         SIPC_MARSHAL_DATA_INT_TYPE);
 520                         break;
 521
 522                 case TRESP_NETWORK_GET_PREFERRED_PLMN:
 523                         sipc_util_marshal_object_add_data(out_obj, "count", &resp_get_preferred_plmn->list_count,
 524                                         SIPC_MARSHAL_DATA_INT_TYPE);
 525
 526                         for (i = 0; i < resp_network_search->list_count; i++) {
 527                                 entry_obj = sipc_util_marshal_object_create();
 528                                 sipc_util_marshal_object_add_data(entry_obj, "plmn", resp_get_preferred_plmn->list[i].plmn,
 529                                                 SIPC_MARSHAL_DATA_STRING_TYPE);
 530                                 sipc_util_marshal_object_add_data(entry_obj, "ef_index", &resp_get_preferred_plmn->list[i].ef_index,
 531                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 532                                 sipc_util_marshal_object_add_data(entry_obj, "act", &resp_get_preferred_plmn->list[i].act,
 533                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 534                                 snprintf(entry_key, 10, "%d", i);
 535                                 sipc_util_marshal_object_add_data(out_obj, entry_key, entry_obj, SIPC_MARSHAL_DATA_OBJECT_TYPE);
 536                         }
 537                         break;
 538
 539                 case TRESP_NETWORK_SET_ORDER:
 540                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_order->result, SIPC_MARSHAL_DATA_INT_TYPE);
 541                         break;
 542
 543                 case TRESP_NETWORK_GET_ORDER:
 544                         switch (resp_get_order->order) {
 545                                 case NETWORK_ORDER_GSM_FIRST:
 546                                         sipc_util_marshal_object_add_data(out_obj, "order", "gsm", SIPC_MARSHAL_DATA_STRING_TYPE);
 547                                         break;
 548
 549                                 case NETWORK_ORDER_WCDMA_FIRST:
 550                                         sipc_util_marshal_object_add_data(out_obj, "order", "wcdma", SIPC_MARSHAL_DATA_STRING_TYPE);
 551                                         break;
 552
 553                                 case NETWORK_ORDER_NO_CHANGE:
 554                                         sipc_util_marshal_object_add_data(out_obj, "order", "no_change", SIPC_MARSHAL_DATA_STRING_TYPE);
 555                                         break;
 556
 557                                 case NETWORK_ORDER_AUTO:
 558                                 default:
 559                                         sipc_util_marshal_object_add_data(out_obj, "order", "auto", SIPC_MARSHAL_DATA_STRING_TYPE);
 560                                         break;
 561
 562                         }
 563                         break;
 564
 565                 case TRESP_NETWORK_SET_POWER_ON_ATTACH:
 566                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_power_on_attach->result,
 567                                         SIPC_MARSHAL_DATA_INT_TYPE);
 568                         break;
 569
 570                 case TRESP_NETWORK_GET_POWER_ON_ATTACH:
 571                         sipc_util_marshal_object_add_data(out_obj, "enabled", &resp_get_power_on_attach->enabled,
 572                                         SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 573                         break;
 574
 575                 case TRESP_NETWORK_SET_CANCEL_MANUAL_SEARCH:
 576                         sipc_util_marshal_object_add_data(out_obj, "result", &resp_set_cancel_manual_search->result,
 577                                         SIPC_MARSHAL_DATA_INT_TYPE);
 578                         break;
 579
 580                 case TRESP_NETWORK_GET_SERVING_NETWORK:
 581                         sipc_util_marshal_object_add_data(out_obj, "plmn", resp_get_serving_network->plmn, SIPC_MARSHAL_DATA_STRING_TYPE);
 582                         sipc_util_marshal_object_add_data(out_obj, "act", &resp_get_serving_network->act, SIPC_MARSHAL_DATA_INT_TYPE);
 583                         sipc_util_marshal_object_add_data(out_obj, "lac", &resp_get_serving_network->gsm.lac, SIPC_MARSHAL_DATA_INT_TYPE);
 584                         sipc_util_marshal_object_add_data(out_obj, "carrier", &resp_get_serving_network->cdma.carrier, SIPC_MARSHAL_DATA_INT_TYPE);
 585                         sipc_util_marshal_object_add_data(out_obj, "sid", &resp_get_serving_network->cdma.sid, SIPC_MARSHAL_DATA_INT_TYPE);
 586                         sipc_util_marshal_object_add_data(out_obj, "nid", &resp_get_serving_network->cdma.nid, SIPC_MARSHAL_DATA_INT_TYPE);
 587                         sipc_util_marshal_object_add_data(out_obj, "bs_id", &resp_get_serving_network->cdma.bs_id, SIPC_MARSHAL_DATA_INT_TYPE);
 588                         sipc_util_marshal_object_add_data(out_obj, "bs_lat", &resp_get_serving_network->cdma.bs_lat, SIPC_MARSHAL_DATA_INT_TYPE);
 589                         sipc_util_marshal_object_add_data(out_obj, "bs_long", &resp_get_serving_network->cdma.bs_long, SIPC_MARSHAL_DATA_INT_TYPE);
 590                         sipc_util_marshal_object_add_data(out_obj, "reg_zone", &resp_get_serving_network->cdma.reg_zone, SIPC_MARSHAL_DATA_INT_TYPE);
 591                         sipc_util_marshal_object_add_data(out_obj, "pilot_pn", &resp_get_serving_network->cdma.pilot_pn, SIPC_MARSHAL_DATA_INT_TYPE);
 592                         break;
 593         }
 594
 595         if (out_obj) {
 596                 serial_d = sipc_util_marshal_object_serializer(out_obj);
 597                 hdr.data_len = strlen(serial_d);
 598                 dbg("data_len = %d", hdr.data_len);
 599                 sipc_util_marshal_object_destory(out_obj);
 600         }
 601
 602         out_d = g_new0(char, sizeof(struct _tapi_header) + hdr.data_len);
 603         memcpy(out_d, &hdr, sizeof(struct _tapi_header));
 604
 605         if (serial_d) {
 606                 memcpy(out_d + sizeof(struct _tapi_header), serial_d, hdr.data_len);
 607                 dbg("serial_d = [%s]", serial_d);
 608                 g_free(serial_d);
 609         }
 610
 611         ret = sipc_server_send(ctx->sk_server, ui->channel_id, out_d, sizeof(struct _tapi_header) + hdr.data_len,
 612                         SIPC_SEND_DATA_ASYNC);
 613         g_free(out_d);
 614
 615         if (ret < 0) {
 616                 dbg("ret = %d", ret);
 617                 return FALSE;
 618         }
 619
 620         return TRUE;
 621 }
 622
 623 gboolean scomm_service_notification_network(Communicator *comm, CoreObject *source, enum tcore_notification_command command,
 624                 unsigned int data_len, const void *data)
 625 {
 626         const struct tnoti_network_registration_status *noti_registration_status = data;
 627         const struct tnoti_network_location_cellinfo *noti_location_cellinfo = data;
 628         const struct tnoti_network_icon_info *noti_icon_info = data;
 629         const struct tnoti_network_change *noti_change = data;
 630         const struct tnoti_network_timeinfo *noti_timeinfo = data;
 631         const struct tnoti_network_identity *noti_identity = data;
 632
 633         int ret = 0;
 634         struct custom_data *ctx = NULL;
 635         struct _tapi_header hdr;
 636         struct _sipc_marshal_object* out_obj = NULL;
 637         gchar *out_d = NULL, *serial_d = NULL;
 638
 639         memset(&hdr, 0, sizeof(struct _tapi_header));
 640
 641         ctx = tcore_communicator_ref_user_data(comm);
 642         if (!ctx) {
 643                 dbg("user_data is NULL");
 644                 return FALSE;
 645         }
 646
 647         dbg("notification !!! (command = 0x%x, data_len = %d)", command, data_len);
 648
 649         switch (command) {
 650                 case TNOTI_NETWORK_REGISTRATION_STATUS:
 651                         hdr.cmd = TAPI_NOTI_NETWORK_REGISTRATION_STATUS;
 652
 653                         out_obj = sipc_util_marshal_object_create();
 654                         switch (noti_registration_status->cs_domain_status) {
 655                                 case NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY:
 656                                         sipc_util_marshal_object_add_data(out_obj, "circuit", "emergency", SIPC_MARSHAL_DATA_STRING_TYPE);
 657                                         break;
 658                                 case NETWORK_SERVICE_DOMAIN_STATUS_FULL:
 659                                         sipc_util_marshal_object_add_data(out_obj, "circuit", "full", SIPC_MARSHAL_DATA_STRING_TYPE);
 660                                         break;
 661                                 case NETWORK_SERVICE_DOMAIN_STATUS_SEARCH:
 662                                         sipc_util_marshal_object_add_data(out_obj, "circuit", "search", SIPC_MARSHAL_DATA_STRING_TYPE);
 663                                         break;
 664                                 case NETWORK_SERVICE_DOMAIN_STATUS_NO:
 665                                 default:
 666                                         sipc_util_marshal_object_add_data(out_obj, "circuit", "none", SIPC_MARSHAL_DATA_STRING_TYPE);
 667                                         break;
 668                         }
 669
 670                         switch (noti_registration_status->ps_domain_status) {
 671                                 case NETWORK_SERVICE_DOMAIN_STATUS_EMERGENCY:
 672                                         sipc_util_marshal_object_add_data(out_obj, "packet", "emergency", SIPC_MARSHAL_DATA_STRING_TYPE);
 673                                         break;
 674                                 case NETWORK_SERVICE_DOMAIN_STATUS_FULL:
 675                                         sipc_util_marshal_object_add_data(out_obj, "packet", "full", SIPC_MARSHAL_DATA_STRING_TYPE);
 676                                         break;
 677                                 case NETWORK_SERVICE_DOMAIN_STATUS_SEARCH:
 678                                         sipc_util_marshal_object_add_data(out_obj, "packet", "search", SIPC_MARSHAL_DATA_STRING_TYPE);
 679                                         break;
 680                                 case NETWORK_SERVICE_DOMAIN_STATUS_NO:
 681                                 default:
 682                                         sipc_util_marshal_object_add_data(out_obj, "packet", "none", SIPC_MARSHAL_DATA_STRING_TYPE);
 683                                         break;
 684                         }
 685                         sipc_util_marshal_object_add_data(out_obj, "service_type", &noti_registration_status->service_type, SIPC_MARSHAL_DATA_INT_TYPE);
 686                         sipc_util_marshal_object_add_data(out_obj, "roaming_status", &noti_registration_status->roaming_status, SIPC_MARSHAL_DATA_BOOLEAN_TYPE);
 687                         break;
 688
 689                 case TNOTI_NETWORK_LOCATION_CELLINFO:
 690                         hdr.cmd = TAPI_NOTI_NETWORK_LOCATION_CELLINFO;
 691
 692                         out_obj = sipc_util_marshal_object_create();
 693                         sipc_util_marshal_object_add_data(out_obj, "lac", &noti_location_cellinfo->lac, SIPC_MARSHAL_DATA_INT_TYPE);
 694                         sipc_util_marshal_object_add_data(out_obj, "cell_id", &noti_location_cellinfo->cell_id, SIPC_MARSHAL_DATA_INT_TYPE);
 695                         break;
 696
 697                 case TNOTI_NETWORK_ICON_INFO:
 698                         hdr.cmd = TAPI_NOTI_NETWORK_ICON_INFO;
 699
 700                         out_obj = sipc_util_marshal_object_create();
 701                         if (noti_icon_info->type & 0x01) {
 702                                 sipc_util_marshal_object_add_data(out_obj, "rssi", &noti_icon_info->rssi,
 703                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 704                         }
 705                         if (noti_icon_info->type & 0x02) {
 706                                 sipc_util_marshal_object_add_data(out_obj, "battery", &noti_icon_info->battery,
 707                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 708                         }
 709                         if (noti_icon_info->type & 0x04) {
 710                                 sipc_util_marshal_object_add_data(out_obj, "hdr_rssi", &noti_icon_info->hdr_rssi,
 711                                                 SIPC_MARSHAL_DATA_INT_TYPE);
 712                         }
 713                         break;
 714
 715                 case TNOTI_NETWORK_CHANGE:
 716                         hdr.cmd = TAPI_NOTI_NETWORK_CHANGE;
 717
 718                         out_obj = sipc_util_marshal_object_create();
 719                         sipc_util_marshal_object_add_data(out_obj, "plmn", noti_change->plmn, SIPC_MARSHAL_DATA_STRING_TYPE);
 720                         sipc_util_marshal_object_add_data(out_obj, "act", &noti_change->act, SIPC_MARSHAL_DATA_INT_TYPE);
 721                         sipc_util_marshal_object_add_data(out_obj, "lac", &noti_change->gsm.lac, SIPC_MARSHAL_DATA_INT_TYPE);
 722                         sipc_util_marshal_object_add_data(out_obj, "carrier", &noti_change->cdma.carrier, SIPC_MARSHAL_DATA_INT_TYPE);
 723                         sipc_util_marshal_object_add_data(out_obj, "sid", &noti_change->cdma.sid, SIPC_MARSHAL_DATA_INT_TYPE);
 724                         sipc_util_marshal_object_add_data(out_obj, "nid", &noti_change->cdma.nid, SIPC_MARSHAL_DATA_INT_TYPE);
 725                         sipc_util_marshal_object_add_data(out_obj, "bs_id", &noti_change->cdma.bs_id, SIPC_MARSHAL_DATA_INT_TYPE);
 726                         sipc_util_marshal_object_add_data(out_obj, "bs_lat", &noti_change->cdma.bs_lat, SIPC_MARSHAL_DATA_INT_TYPE);
 727                         sipc_util_marshal_object_add_data(out_obj, "bs_long", &noti_change->cdma.bs_long, SIPC_MARSHAL_DATA_INT_TYPE);
 728                         sipc_util_marshal_object_add_data(out_obj, "reg_zone", &noti_change->cdma.reg_zone, SIPC_MARSHAL_DATA_INT_TYPE);
 729                         sipc_util_marshal_object_add_data(out_obj, "pilot_pn", &noti_change->cdma.pilot_pn, SIPC_MARSHAL_DATA_INT_TYPE);
 730                         break;
 731
 732                 case TNOTI_NETWORK_TIMEINFO:
 733                         hdr.cmd = TAPI_NOTI_NETWORK_TIMEINFO;
 734
 735                         out_obj = sipc_util_marshal_object_create();
 736                         sipc_util_marshal_object_add_data(out_obj, "plmn", noti_timeinfo->plmn, SIPC_MARSHAL_DATA_STRING_TYPE);
 737                         sipc_util_marshal_object_add_data(out_obj, "year", &noti_timeinfo->year, SIPC_MARSHAL_DATA_INT_TYPE);
 738                         sipc_util_marshal_object_add_data(out_obj, "month", &noti_timeinfo->month, SIPC_MARSHAL_DATA_INT_TYPE);
 739                         sipc_util_marshal_object_add_data(out_obj, "day", &noti_timeinfo->day, SIPC_MARSHAL_DATA_INT_TYPE);
 740                         sipc_util_marshal_object_add_data(out_obj, "hour", &noti_timeinfo->hour, SIPC_MARSHAL_DATA_INT_TYPE);
 741                         sipc_util_marshal_object_add_data(out_obj, "minute", &noti_timeinfo->minute, SIPC_MARSHAL_DATA_INT_TYPE);
 742                         sipc_util_marshal_object_add_data(out_obj, "second", &noti_timeinfo->second, SIPC_MARSHAL_DATA_INT_TYPE);
 743                         sipc_util_marshal_object_add_data(out_obj, "wday", &noti_timeinfo->wday, SIPC_MARSHAL_DATA_INT_TYPE);
 744                         sipc_util_marshal_object_add_data(out_obj, "gmtoff", &noti_timeinfo->gmtoff, SIPC_MARSHAL_DATA_INT_TYPE);
 745                         sipc_util_marshal_object_add_data(out_obj, "dstoff", &noti_timeinfo->dstoff, SIPC_MARSHAL_DATA_INT_TYPE);
 746                         sipc_util_marshal_object_add_data(out_obj, "isdst", &noti_timeinfo->isdst, SIPC_MARSHAL_DATA_INT_TYPE);
 747                         break;
 748
 749                 case TNOTI_NETWORK_IDENTITY:
 750                         hdr.cmd = TAPI_NOTI_NETWORK_IDENTITY;
 751
 752                         out_obj = sipc_util_marshal_object_create();
 753                         sipc_util_marshal_object_add_data(out_obj, "plmn", noti_identity->plmn, SIPC_MARSHAL_DATA_STRING_TYPE);
 754                         sipc_util_marshal_object_add_data(out_obj, "short_name", noti_identity->short_name, SIPC_MARSHAL_DATA_STRING_TYPE);
 755                         sipc_util_marshal_object_add_data(out_obj, "full_name", noti_identity->full_name, SIPC_MARSHAL_DATA_STRING_TYPE);
 756                         break;
 757
 758                 default:
 759                         dbg("unknown notification");
 760                         return FALSE;
 761                         break;
 762         }
 763
 764         if (out_obj) {
 765                 serial_d = sipc_util_marshal_object_serializer(out_obj);
 766                 hdr.data_len = strlen(serial_d);
 767                 sipc_util_marshal_object_destory(out_obj);
 768         }
 769
 770         out_d = g_new0(char, sizeof(struct _tapi_header)+hdr.data_len);
 771         memcpy(out_d, &hdr, sizeof(struct _tapi_header));
 772         if (serial_d) {
 773                 memcpy(out_d + sizeof(struct _tapi_header), serial_d, hdr.data_len);
 774                 g_free(serial_d);
 775         }
 776
 777         dbg("len = %d, cmd = 0x%x, serialize = [%s]", sizeof(struct _tapi_header) + hdr.data_len, hdr.cmd, out_d);
 778
 779         ret = sipc_server_broadcast(ctx->sk_server, out_d, sizeof(struct _tapi_header) + hdr.data_len);
 780         dbg("ret = %d", ret);
 781         g_free(out_d);
 782
 783         return TRUE;
 784 }