src/sms.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 <glib-object.h>
  29 #include <gio/gio.h>
  30
  31 #include <tcore.h>
  32 #include <server.h>
  33 #include <plugin.h>
  34 #include <hal.h>
  35 #include <communicator.h>
  36 #include <storage.h>
  37 #include <queue.h>
  38 #include <user_request.h>
  39 #include <co_sms.h>
  40
  41 #include "generated-code.h"
  42 #include "common.h"
  43
  44 TReturn ret = TCORE_RETURN_SUCCESS;
  45
  46 static gboolean
  47 on_sms_send_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
  48         const gchar *sca,
  49         gint tpdu_length,
  50         const gchar *tpdu_data,
  51         gint moreMsg,
  52         gpointer user_data)
  53 {
  54         struct treq_sms_send_umts_msg sendUmtsMsg;
  55         struct custom_data *ctx = user_data;
  56         UserRequest *ur = NULL;
  57
  58         gsize length;
  59         guchar *decoded_sca = NULL;
  60         guchar *decoded_tpdu = NULL;
  61
  62         memset(&sendUmtsMsg, 0 , sizeof(struct treq_sms_send_umts_msg));
  63
  64         decoded_sca = g_base64_decode(sca, &length);
  65         memcpy(&(sendUmtsMsg.msgDataPackage.sca[0]), decoded_sca, SMS_SMSP_ADDRESS_LEN);
  66
  67         sendUmtsMsg.msgDataPackage.msgLength = tpdu_length;
  68         dbg("tpdu_length = 0x%x", tpdu_length);
  69
  70         decoded_tpdu = g_base64_decode(tpdu_data, &length);
  71         memcpy(&(sendUmtsMsg.msgDataPackage.tpduData[0]), decoded_tpdu, SMS_SMDATA_SIZE_MAX + 1);
  72         sendUmtsMsg.more = moreMsg;
  73
  74         ur = MAKE_UR(ctx, sms, invocation);
  75         tcore_user_request_set_data(ur, sizeof(struct treq_sms_send_umts_msg), &sendUmtsMsg);
  76         tcore_user_request_set_command(ur, TREQ_SMS_SEND_UMTS_MSG);
  77
  78         g_free(decoded_sca);
  79         g_free(decoded_tpdu);
  80
  81         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
  82         if (ret != TCORE_RETURN_SUCCESS) {
  83                 telephony_sms_complete_send_msg(sms, invocation, SMS_DEVICE_FAILURE);
  84                 tcore_user_request_unref(ur);
  85         }
  86
  87         return  TRUE;
  88 }
  89
  90 static gboolean
  91 on_sms_read_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
  92         gint arg_index,
  93         gpointer user_data)
  94 {
  95         struct treq_sms_read_msg readMsg = {0,};
  96         struct custom_data *ctx = user_data;
  97         UserRequest *ur = NULL;
  98
  99         readMsg.index = arg_index;
 100
 101         ur = MAKE_UR(ctx, sms, invocation);
 102         tcore_user_request_set_data(ur, sizeof(struct treq_sms_read_msg), &readMsg);
 103         tcore_user_request_set_command(ur, TREQ_SMS_READ_MSG);
 104
 105         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 106         if (ret != TCORE_RETURN_SUCCESS) {
 107                 telephony_sms_complete_read_msg(sms, invocation, SMS_DEVICE_FAILURE, -1, -1, NULL, 0, NULL);
 108                 tcore_user_request_unref(ur);
 109         }
 110
 111         return TRUE;
 112 }
 113
 114 static gboolean
 115 on_sms_save_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
 116         gint arg_msg_status,
 117         const gchar * arg_sca,
 118         gint arg_tpdu_length,
 119         const gchar * arg_tpdu_data,
 120         gpointer user_data)
 121 {
 122         struct treq_sms_save_msg saveMsg = {0,};
 123         struct custom_data *ctx = user_data;
 124         UserRequest *ur = NULL;
 125
 126         gsize length;
 127         guchar *decoded_sca = NULL;
 128         guchar *decoded_tpdu = NULL;
 129
 130         saveMsg.simIndex = 0xffff;
 131         saveMsg.msgStatus = arg_msg_status;
 132
 133         decoded_sca = g_base64_decode(arg_sca, &length);
 134         memcpy(&(saveMsg.msgDataPackage.sca[0]), decoded_sca, SMS_SMSP_ADDRESS_LEN);
 135
 136         saveMsg.msgDataPackage.msgLength = arg_tpdu_length;
 137
 138         decoded_tpdu = g_base64_decode(arg_tpdu_data, &length);
 139         memcpy(&(saveMsg.msgDataPackage.tpduData[0]), decoded_tpdu, SMS_SMDATA_SIZE_MAX + 1);
 140
 141         ur = MAKE_UR(ctx, sms, invocation);
 142         tcore_user_request_set_data(ur, sizeof(struct treq_sms_save_msg), &saveMsg);
 143         tcore_user_request_set_command(ur, TREQ_SMS_SAVE_MSG);
 144
 145         g_free(decoded_sca);
 146         g_free(decoded_tpdu);
 147
 148         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 149         if (ret != TCORE_RETURN_SUCCESS) {
 150                 telephony_sms_complete_save_msg(sms, invocation, SMS_DEVICE_FAILURE, -1);
 151                 tcore_user_request_unref(ur);
 152         }
 153
 154         return TRUE;
 155 }
 156
 157 static gboolean
 158 on_sms_delete_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
 159         gint arg_index,
 160         gpointer user_data)
 161 {
 162         struct treq_sms_delete_msg deleteMsg = {0,};
 163         struct custom_data *ctx = user_data;
 164         UserRequest *ur = NULL;
 165
 166         deleteMsg.index = arg_index;
 167
 168         ur = MAKE_UR(ctx, sms, invocation);
 169         tcore_user_request_set_data(ur, sizeof(struct treq_sms_delete_msg), &deleteMsg);
 170         tcore_user_request_set_command(ur, TREQ_SMS_DELETE_MSG);
 171
 172         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 173         if (ret != TCORE_RETURN_SUCCESS) {
 174                 telephony_sms_complete_delete_msg(sms, invocation, SMS_DEVICE_FAILURE, -1);
 175                 tcore_user_request_unref(ur);
 176         }
 177
 178         return TRUE;
 179 }
 180
 181 static gboolean
 182 on_sms_get_msg_count(TelephonySms *sms, GDBusMethodInvocation *invocation,
 183         gpointer user_data)
 184 {
 185         struct treq_sms_get_msg_count getMsgCnt;
 186         struct custom_data *ctx = user_data;
 187         UserRequest *ur = NULL;
 188
 189         ur = MAKE_UR(ctx, sms, invocation);
 190         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_msg_count), &getMsgCnt);
 191         tcore_user_request_set_command(ur, TREQ_SMS_GET_COUNT);
 192
 193         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 194         if (ret != TCORE_RETURN_SUCCESS) {
 195                 telephony_sms_complete_get_msg_count(sms, invocation, SMS_DEVICE_FAILURE, 0, -1, NULL);
 196                 tcore_user_request_unref(ur);
 197         }
 198
 199         return TRUE;
 200 }
 201
 202 static gboolean
 203 on_sms_get_sca(TelephonySms *sms, GDBusMethodInvocation *invocation,
 204         gint arg_index,
 205         gpointer user_data)
 206 {
 207         struct treq_sms_get_sca getSca = {0,};
 208         struct custom_data *ctx = user_data;
 209         UserRequest *ur = NULL;
 210
 211         getSca.index = arg_index;
 212
 213         ur = MAKE_UR(ctx, sms, invocation);
 214         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_sca), &getSca);
 215         tcore_user_request_set_command(ur, TREQ_SMS_GET_SCA);
 216
 217         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 218         if (ret != TCORE_RETURN_SUCCESS) {
 219                 telephony_sms_complete_get_sca(sms, invocation, SMS_DEVICE_FAILURE, -1, -1, 0, NULL);
 220                 tcore_user_request_unref(ur);
 221         }
 222
 223         return TRUE;
 224 }
 225
 226 static gboolean
 227 on_sms_set_sca(TelephonySms *sms, GDBusMethodInvocation *invocation,
 228         gint arg_index,
 229         gint arg_ton,
 230         gint arg_npi,
 231         gint arg_dialNumberLength,
 232         const gchar *arg_dialNumber,
 233         gpointer user_data)
 234 {
 235         struct treq_sms_set_sca setSca;
 236         struct custom_data *ctx = user_data;
 237         UserRequest *ur = NULL;
 238
 239         memset(&setSca, 0, sizeof(struct treq_sms_set_sca));
 240
 241         setSca.index = arg_index;
 242         setSca.scaInfo.dialNumLen = arg_dialNumberLength;
 243         setSca.scaInfo.typeOfNum = arg_ton;
 244         setSca.scaInfo.numPlanId = arg_npi;
 245
 246         if ((setSca.scaInfo.dialNumLen <= 0)
 247                         || (setSca.scaInfo.dialNumLen > SMS_SMSP_ADDRESS_LEN)) {
 248                 err("[tcore_SMS] TAPI_API_INVALID_INPUT !!!");
 249                 return  FALSE;
 250         }
 251         else if(setSca.index != 0) {
 252                 err("[tcore_SMS] Index except 0 is supported");
 253                 // api_err = TAPI_API_NOT_SUPPORTED;
 254                 return  FALSE;
 255         } else {
 256                 gsize length;
 257                 guchar *decoded_sca = NULL;
 258
 259                 decoded_sca = g_base64_decode(arg_dialNumber, &length);
 260                 memcpy(&(setSca.scaInfo.diallingNum[0]), decoded_sca, SMS_SMSP_ADDRESS_LEN + 1);
 261
 262                 ur = MAKE_UR(ctx, sms, invocation);
 263                 tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_sca), &setSca);
 264                 tcore_user_request_set_command(ur, TREQ_SMS_SET_SCA);
 265
 266                 g_free(decoded_sca);
 267
 268                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 269                 if (ret != TCORE_RETURN_SUCCESS) {
 270                         telephony_sms_complete_set_sca(sms, invocation, SMS_DEVICE_FAILURE);
 271                         tcore_user_request_unref(ur);
 272                 }
 273         }
 274
 275         return TRUE;
 276 }
 277
 278 static gboolean
 279 on_sms_get_cb_config(TelephonySms *sms, GDBusMethodInvocation *invocation,
 280         gpointer user_data)
 281 {
 282         struct treq_sms_get_cb_config getCbConfig;
 283         struct custom_data *ctx = user_data;
 284         UserRequest *ur = NULL;
 285
 286         ur = MAKE_UR(ctx, sms, invocation);
 287         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_cb_config), &getCbConfig);
 288         tcore_user_request_set_command(ur, TREQ_SMS_GET_CB_CONFIG);
 289
 290         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 291         if (ret != TCORE_RETURN_SUCCESS) {
 292                 GVariant *gv = NULL;
 293                 GVariantBuilder b;
 294                 g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 295                 gv = g_variant_builder_end(&b);
 296                 telephony_sms_complete_get_cb_config(sms, invocation, SMS_DEVICE_FAILURE, -1, -1, 0, 0, gv);
 297                 g_variant_unref(gv);
 298                 tcore_user_request_unref(ur);
 299         }
 300
 301         return TRUE;
 302 }
 303
 304 static gboolean
 305 on_sms_set_cb_config(TelephonySms *sms, GDBusMethodInvocation *invocation,
 306         gint arg_net3gppType,
 307         gboolean arg_cbEnable,
 308         gint arg_msgIdMaxCount,
 309         gint arg_msgIdRangeCount,
 310         const gchar *arg_msgId,
 311         gpointer user_data)
 312 {
 313     struct treq_sms_set_cb_config setCbConfig = {0,};
 314         struct custom_data *ctx = user_data;
 315         UserRequest *ur = NULL;
 316
 317         gsize length;
 318         guchar *decoded_msgId = NULL;
 319
 320         setCbConfig.net3gppType = arg_net3gppType;
 321         setCbConfig.cbEnabled = arg_cbEnable;
 322         setCbConfig.msgIdMaxCount = arg_msgIdMaxCount;
 323         setCbConfig.msgIdRangeCount = arg_msgIdRangeCount;
 324
 325         decoded_msgId = g_base64_decode(arg_msgId, &length);
 326         memcpy(&(setCbConfig.msgIDs[0]), decoded_msgId, SMS_GSM_SMS_CBMI_LIST_SIZE_MAX*5);
 327
 328         ur = MAKE_UR(ctx, sms, invocation);
 329         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_cb_config), &setCbConfig);
 330         tcore_user_request_set_command(ur, TREQ_SMS_SET_CB_CONFIG);
 331
 332         g_free(decoded_msgId);
 333
 334         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 335         if (ret != TCORE_RETURN_SUCCESS) {
 336                 telephony_sms_complete_set_cb_config(sms, invocation, SMS_DEVICE_FAILURE);
 337                 tcore_user_request_unref(ur);
 338         }
 339
 340         return TRUE;
 341 }
 342
 343 static gboolean
 344 on_sms_set_mem_status(TelephonySms *sms, GDBusMethodInvocation *invocation,
 345         gint arg_memoryStatus,
 346         gpointer user_data)
 347 {
 348         struct treq_sms_set_mem_status memStatus = {0,};
 349         struct custom_data *ctx = user_data;
 350         UserRequest *ur = NULL;
 351
 352         memStatus.memory_status = arg_memoryStatus;
 353
 354         ur = MAKE_UR(ctx, sms, invocation);
 355         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_mem_status), &memStatus);
 356         tcore_user_request_set_command(ur, TREQ_SMS_SET_MEM_STATUS);
 357
 358         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 359         if (ret != TCORE_RETURN_SUCCESS) {
 360                 telephony_sms_complete_set_mem_status(sms, invocation, SMS_DEVICE_FAILURE);
 361                 tcore_user_request_unref(ur);
 362         }
 363
 364         return TRUE;
 365 }
 366
 367 static gboolean
 368 on_sms_get_pref_bearer(TelephonySms *sms, GDBusMethodInvocation *invocation,
 369         gpointer user_data)
 370 {
 371         struct treq_sms_get_pref_bearer getPrefBearer;
 372         struct custom_data *ctx = user_data;
 373         UserRequest *ur = NULL;
 374
 375         ur = MAKE_UR(ctx, sms, invocation);
 376         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_pref_bearer), &getPrefBearer);
 377         tcore_user_request_set_command(ur, TREQ_SMS_GET_PREF_BEARER);
 378
 379         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 380         if (ret != TCORE_RETURN_SUCCESS) {
 381                 telephony_sms_complete_get_pref_bearer(sms, invocation, SMS_DEVICE_FAILURE);
 382                 tcore_user_request_unref(ur);
 383         }
 384
 385         return TRUE;
 386 }
 387
 388 static gboolean
 389 on_sms_set_pref_bearer(TelephonySms *sms, GDBusMethodInvocation *invocation,
 390         gint arg_bearerType,
 391         gpointer user_data)
 392 {
 393         struct treq_sms_set_pref_bearer setPrefBearer = {0,};
 394         struct custom_data *ctx = user_data;
 395         UserRequest *ur = NULL;
 396
 397         setPrefBearer.svc = arg_bearerType;
 398
 399         ur = MAKE_UR(ctx, sms, invocation);
 400         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_pref_bearer), &setPrefBearer);
 401         tcore_user_request_set_command(ur, TREQ_SMS_SET_PREF_BEARER);
 402
 403         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 404         if (ret != TCORE_RETURN_SUCCESS) {
 405                 telephony_sms_complete_set_pref_bearer(sms, invocation, SMS_DEVICE_FAILURE);
 406                 tcore_user_request_unref(ur);
 407         }
 408
 409         return TRUE;
 410 }
 411
 412 static gboolean
 413 on_sms_set_delivery_report(TelephonySms *sms, GDBusMethodInvocation *invocation,
 414         const gchar *arg_sca,
 415         gint arg_tpdu_length,
 416         const gchar *arg_tpdu_data,
 417         gint arg_rpCause,
 418         gpointer user_data)
 419 {
 420         struct treq_sms_set_delivery_report deliveryReport;
 421         struct custom_data *ctx = user_data;
 422         UserRequest *ur = NULL;
 423
 424         gsize length;
 425         guchar *decoded_sca = NULL;
 426         guchar *decoded_tpdu = NULL;
 427
 428         memset(&deliveryReport, 0, sizeof(struct treq_sms_set_delivery_report));
 429
 430         decoded_sca = g_base64_decode(arg_sca, &length);
 431         memcpy(&(deliveryReport.dataInfo.sca[0]), decoded_sca, SMS_SMSP_ADDRESS_LEN);
 432
 433         deliveryReport.dataInfo.msgLength = arg_tpdu_length;
 434
 435         decoded_tpdu = g_base64_decode(arg_tpdu_data, &length);
 436         memcpy(&(deliveryReport.dataInfo.tpduData[0]), decoded_tpdu, SMS_SMDATA_SIZE_MAX + 1);
 437
 438         deliveryReport.rspType = arg_rpCause;
 439
 440         ur = MAKE_UR(ctx, sms, invocation);
 441         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_delivery_report), &deliveryReport);
 442         tcore_user_request_set_command(ur, TREQ_SMS_SET_DELIVERY_REPORT);
 443
 444         g_free(decoded_sca);
 445         g_free(decoded_tpdu);
 446
 447         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 448         if (ret != TCORE_RETURN_SUCCESS) {
 449                 telephony_sms_complete_set_delivery_report(sms, invocation, SMS_DEVICE_FAILURE);
 450                 tcore_user_request_unref(ur);
 451         }
 452
 453         return TRUE;
 454 }
 455
 456 static gboolean
 457 on_sms_set_msg_status(TelephonySms *sms, GDBusMethodInvocation *invocation,
 458         gint arg_index,
 459         gint arg_msgStatus,
 460         gpointer user_data)
 461 {
 462         struct treq_sms_set_msg_status msgStatus = {0,};
 463         struct custom_data *ctx = user_data;
 464         UserRequest *ur = NULL;
 465
 466         msgStatus.index = arg_index;
 467         msgStatus.msgStatus = arg_msgStatus;
 468
 469         ur = MAKE_UR(ctx, sms, invocation);
 470         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_msg_status), &msgStatus);
 471         tcore_user_request_set_command(ur, TREQ_SMS_SET_MSG_STATUS);
 472
 473         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 474         if (ret != TCORE_RETURN_SUCCESS) {
 475                 telephony_sms_complete_set_msg_status(sms, invocation, SMS_DEVICE_FAILURE);
 476                 tcore_user_request_unref(ur);
 477         }
 478
 479         return TRUE;
 480 }
 481
 482 static gboolean
 483 on_sms_get_sms_params(TelephonySms *sms, GDBusMethodInvocation *invocation,
 484         gint arg_index,
 485         gpointer user_data)
 486 {
 487         struct treq_sms_get_params getParams = {0,};
 488         struct custom_data *ctx = user_data;
 489         UserRequest *ur = NULL;
 490
 491         getParams.index = arg_index;
 492
 493         ur = MAKE_UR(ctx, sms, invocation);
 494         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_params), &getParams);
 495         tcore_user_request_set_command(ur, TREQ_SMS_GET_PARAMS);
 496
 497         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 498         if (ret != TCORE_RETURN_SUCCESS) {
 499                 telephony_sms_complete_get_sms_params(sms, invocation, SMS_DEVICE_FAILURE,
 500                 0, 0, 0, NULL, 0, 0, -1, -1, NULL, 0, -1, -1, NULL, 0, 0, 0);
 501                 tcore_user_request_unref(ur);
 502         }
 503
 504         return TRUE;
 505 }
 506
 507 static gboolean
 508 on_sms_set_sms_params(TelephonySms *sms, GDBusMethodInvocation *invocation,
 509         gint arg_recordIndex,
 510         gint arg_recordLen,
 511         gint arg_alphaIdLen,
 512         const gchar *arg_alphaId,
 513         gint arg_paramIndicator,
 514         gint arg_destAddr_DialNumLen,
 515         gint arg_destAddr_Ton,
 516         gint arg_destAddr_Npi,
 517         const gchar *arg_destAddr_DiallingNum,
 518         gint arg_svcCntrAddr_DialNumLen,
 519         gint arg_SvcCntrAddr_Ton,
 520         gint arg_svcCntrAddr_Npi,
 521         const gchar *arg_svcCntrAddr_DialNum,
 522         gint arg_protocolId,
 523         gint arg_dataCodingScheme,
 524         gint arg_validityPeriod,
 525         gpointer user_data)
 526 {
 527         struct treq_sms_set_params setParams;
 528         struct custom_data *ctx = user_data;
 529         UserRequest *ur = NULL;
 530
 531         gsize length;
 532         guchar *decoded_alphaId = NULL;
 533         guchar *decoded_destDialNum = NULL;
 534         guchar *decoded_scaDialNum = NULL;
 535
 536         memset(&setParams, 0, sizeof(struct treq_sms_set_params));
 537
 538         setParams.params.recordIndex = arg_recordIndex;
 539         setParams.params.recordLen = arg_recordLen;
 540         setParams.params.alphaIdLen = arg_alphaIdLen;
 541         decoded_alphaId = g_base64_decode(arg_alphaId, &length);
 542         memcpy(&(setParams.params.szAlphaId[0]), decoded_alphaId, SMS_SMSP_ALPHA_ID_LEN_MAX + 1);
 543         setParams.params.paramIndicator = arg_paramIndicator;
 544
 545         setParams.params.tpDestAddr.dialNumLen = arg_destAddr_DialNumLen;
 546         setParams.params.tpDestAddr.typeOfNum = arg_destAddr_Ton;
 547         setParams.params.tpDestAddr.numPlanId = arg_destAddr_Npi;
 548         decoded_destDialNum = g_base64_decode(arg_destAddr_DiallingNum, &length);
 549         memcpy(&(setParams.params.tpDestAddr.diallingNum[0]), decoded_destDialNum, SMS_SMSP_ADDRESS_LEN + 1);
 550
 551         setParams.params.tpSvcCntrAddr.dialNumLen = arg_svcCntrAddr_DialNumLen;
 552         setParams.params.tpSvcCntrAddr.typeOfNum = arg_SvcCntrAddr_Ton;
 553         setParams.params.tpSvcCntrAddr.numPlanId = arg_svcCntrAddr_Npi;
 554         decoded_scaDialNum = g_base64_decode(arg_svcCntrAddr_DialNum, &length);
 555         memcpy(&(setParams.params.tpSvcCntrAddr.diallingNum[0]), decoded_scaDialNum, SMS_SMSP_ADDRESS_LEN + 1);
 556
 557         setParams.params.tpProtocolId = arg_protocolId;
 558         setParams.params.tpDataCodingScheme = arg_dataCodingScheme;
 559         setParams.params.tpValidityPeriod = arg_validityPeriod;
 560
 561         ur = MAKE_UR(ctx, sms, invocation);
 562         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_params), &setParams);
 563         tcore_user_request_set_command(ur, TREQ_SMS_SET_PARAMS);
 564
 565         g_free(decoded_alphaId);
 566         g_free(decoded_destDialNum);
 567         g_free(decoded_scaDialNum);
 568
 569         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 570         if (ret != TCORE_RETURN_SUCCESS) {
 571                 telephony_sms_complete_set_sms_params(sms, invocation, SMS_DEVICE_FAILURE);
 572                 tcore_user_request_unref(ur);
 573         }
 574
 575         return TRUE;
 576 }
 577
 578 static gboolean
 579 on_sms_get_sms_param_cnt(TelephonySms *sms, GDBusMethodInvocation *invocation,
 580         gpointer user_data)
 581 {
 582         struct treq_sms_get_paramcnt getParamCnt;
 583         struct custom_data *ctx = user_data;
 584         UserRequest *ur = NULL;
 585
 586         ur = MAKE_UR(ctx, sms, invocation);
 587         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_paramcnt), &getParamCnt);
 588         tcore_user_request_set_command(ur, TREQ_SMS_GET_PARAMCNT);
 589
 590         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 591         if (ret != TCORE_RETURN_SUCCESS) {
 592                 telephony_sms_complete_get_sms_param_cnt(sms, invocation, SMS_DEVICE_FAILURE, -1);
 593                 tcore_user_request_unref(ur);
 594         }
 595
 596         return TRUE;
 597 }
 598
 599 static gboolean
 600 on_sms_get_sms_ready_status(TelephonySms *sms, GDBusMethodInvocation *invocation,
 601         gpointer user_data)
 602 {
 603         struct custom_data *ctx = user_data;
 604         CoreObject *co_sms = NULL;
 605         TcorePlugin *plugin = NULL;
 606         char *cp_name = GET_PLUGIN_NAME(invocation);
 607
 608         dbg("Func Entrance");
 609
 610         plugin = tcore_server_find_plugin(ctx->server, cp_name);
 611         co_sms = tcore_plugin_ref_core_object(plugin, CORE_OBJECT_TYPE_SMS);
 612         if (!co_sms) {
 613                 dbg("error- co_sms is NULL");
 614                 return FALSE;
 615         }
 616
 617         telephony_sms_complete_get_sms_ready_status(sms, invocation, tcore_sms_get_ready_status(co_sms));
 618
 619         return TRUE;
 620 }
 621
 622 gboolean dbus_plugin_setup_sms_interface(TelephonyObjectSkeleton *object, struct custom_data *ctx)
 623 {
 624         TelephonySms *sms;
 625
 626         sms = telephony_sms_skeleton_new();
 627         telephony_object_skeleton_set_sms(object, sms);
 628         g_object_unref(sms);
 629
 630         dbg("sms = %p", sms);
 631
 632         g_signal_connect(sms, "handle-send-msg", G_CALLBACK (on_sms_send_msg), ctx);
 633         g_signal_connect(sms, "handle-read-msg", G_CALLBACK (on_sms_read_msg), ctx);
 634         g_signal_connect(sms, "handle-save-msg", G_CALLBACK (on_sms_save_msg), ctx);
 635         g_signal_connect(sms, "handle-delete-msg", G_CALLBACK (on_sms_delete_msg), ctx);
 636         g_signal_connect(sms, "handle-get-msg-count", G_CALLBACK (on_sms_get_msg_count), ctx);
 637         g_signal_connect(sms, "handle-get-sca", G_CALLBACK (on_sms_get_sca), ctx);
 638         g_signal_connect(sms, "handle-set-sca", G_CALLBACK (on_sms_set_sca), ctx);
 639         g_signal_connect(sms, "handle-get-cb-config", G_CALLBACK (on_sms_get_cb_config), ctx);
 640         g_signal_connect(sms, "handle-set-cb-config", G_CALLBACK (on_sms_set_cb_config), ctx);
 641         g_signal_connect(sms, "handle-set-mem-status", G_CALLBACK (on_sms_set_mem_status), ctx);
 642         g_signal_connect(sms, "handle-get-pref-bearer", G_CALLBACK (on_sms_get_pref_bearer), ctx);
 643         g_signal_connect(sms, "handle-set-pref-bearer", G_CALLBACK (on_sms_set_pref_bearer), ctx);
 644         g_signal_connect(sms, "handle-set-delivery-report", G_CALLBACK (on_sms_set_delivery_report), ctx);
 645         g_signal_connect(sms, "handle-set-msg-status", G_CALLBACK (on_sms_set_msg_status), ctx);
 646         g_signal_connect(sms, "handle-get-sms-params", G_CALLBACK (on_sms_get_sms_params), ctx);
 647         g_signal_connect(sms, "handle-set-sms-params", G_CALLBACK (on_sms_set_sms_params), ctx);
 648         g_signal_connect(sms, "handle-get-sms-param-cnt", G_CALLBACK (on_sms_get_sms_param_cnt), ctx);
 649         g_signal_connect(sms, "handle-get-sms-ready-status", G_CALLBACK (on_sms_get_sms_ready_status), ctx);
 650
 651         return TRUE;
 652 }
 653
 654 gboolean dbus_plugin_sms_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)
 655 {
 656         CoreObject *co_sms;
 657         char *modem_name = NULL;
 658         TcorePlugin *p = NULL;
 659         int i;
 660
 661         modem_name = tcore_user_request_get_modem_name(ur);
 662         if (!modem_name)
 663                 return FALSE;
 664
 665         p = tcore_server_find_plugin(ctx->server, modem_name);
 666         free(modem_name);
 667         if (!p)
 668                 return FALSE;
 669
 670         co_sms = tcore_plugin_ref_core_object(p, CORE_OBJECT_TYPE_SMS);
 671         if (!co_sms)
 672                 return FALSE;
 673
 674         switch (command) {
 675                 case TRESP_SMS_SEND_UMTS_MSG: {
 676                         const struct tresp_sms_send_umts_msg *resp = data;
 677
 678
 679                         dbg("receive TRESP_SMS_SEND_UMTS_MSG");
 680                         dbg("resp->result = 0x%x", resp->result);
 681
 682                         telephony_sms_complete_send_msg(dbus_info->interface_object, dbus_info->invocation, resp->result);
 683
 684                         }
 685                         break;
 686
 687                 case TRESP_SMS_READ_MSG: {
 688                         const struct tresp_sms_read_msg *resp = data;
 689                         gchar *sca = NULL;
 690                         gchar *tpdu = NULL;
 691
 692                         dbg("receive TRESP_SMS_READ_MSG");
 693                         dbg("resp->result = 0x%x", resp->result);
 694
 695                         sca = g_base64_encode((const guchar *)&(resp->dataInfo.smsData.sca[0]), SMS_SMSP_ADDRESS_LEN);
 696                         if (sca == NULL) {
 697                                 dbg("g_base64_encode: Failed to Enocde the SCA.");
 698                                 sca = g_strdup("");
 699                         }
 700
 701                         tpdu = g_base64_encode((const guchar *)&(resp->dataInfo.smsData.tpduData[0]), SMS_SMDATA_SIZE_MAX + 1);
 702                         if (sca == NULL) {
 703                                 dbg("g_base64_encode: Failed to Enocde the SCA.");
 704                                 tpdu = g_strdup("");
 705                         }
 706
 707                         telephony_sms_complete_read_msg(dbus_info->interface_object, dbus_info->invocation,
 708                                 resp->result,
 709                                 resp->dataInfo.simIndex,
 710                                 resp->dataInfo.msgStatus,
 711                                 sca,
 712                                 resp->dataInfo.smsData.msgLength,
 713                                 tpdu);
 714
 715                         if (sca)
 716                                 g_free(sca);
 717
 718                         if (tpdu)
 719                                 g_free(tpdu);
 720
 721                         }
 722                         break;
 723
 724                 case TRESP_SMS_SAVE_MSG: {
 725                         const struct tresp_sms_save_msg *resp = data;
 726
 727                         dbg("receive TRESP_SMS_SAVE_MSG");
 728                         dbg("resp->result = 0x%x", resp->result);
 729
 730                         telephony_sms_complete_save_msg (dbus_info->interface_object, dbus_info->invocation,
 731                                 resp->result,
 732                                 resp->index);
 733                         }
 734                         break;
 735
 736                 case TRESP_SMS_DELETE_MSG: {
 737                         const struct tresp_sms_delete_msg *resp = data;
 738
 739                         dbg("receive TRESP_SMS_DELETE_MSG");
 740                         dbg("resp->result = 0x%x", resp->result);
 741
 742                         telephony_sms_complete_delete_msg(dbus_info->interface_object, dbus_info->invocation,
 743                                 resp->result, resp->index);
 744
 745                         }
 746                         break;
 747
 748                 case TRESP_SMS_GET_STORED_MSG_COUNT: {
 749                         const struct tresp_sms_get_storedMsgCnt *resp = data;
 750                         gchar *msgCnt = NULL;
 751
 752                         dbg("receive TRESP_SMS_GET_STORED_MSG_COUNT");
 753                         dbg("resp->result = 0x%x", resp->result);
 754
 755                         msgCnt = g_base64_encode((const guchar *)&(resp->storedMsgCnt.indexList[0]), SMS_GSM_SMS_MSG_NUM_MAX + 1);
 756                         if (msgCnt == NULL) {
 757                                 dbg("g_base64_encode: Failed to Enocde storedMsgCnt.indexList");
 758                                 msgCnt = g_strdup("");
 759                         }
 760
 761                         telephony_sms_complete_get_msg_count(dbus_info->interface_object, dbus_info->invocation,
 762                                 resp->result,
 763                                 resp->storedMsgCnt.totalCount,
 764                                 resp->storedMsgCnt.usedCount,
 765                                 msgCnt);
 766
 767                         if (msgCnt)
 768                                 g_free(msgCnt);
 769                         }
 770
 771                         break;
 772
 773                 case TRESP_SMS_GET_SCA: {
 774                         const struct tresp_sms_get_sca *resp = data;
 775                         gchar *sca = NULL;
 776
 777                         dbg("receive TRESP_SMS_GET_SCA");
 778                         dbg("resp->result = 0x%x", resp->result);
 779
 780                         sca = g_base64_encode((const guchar *)&(resp->scaAddress.diallingNum[0]), SMS_SMSP_ADDRESS_LEN + 1);
 781                         if (sca == NULL) {
 782                                 dbg("g_base64_encode: Failed to Enocde scaAddress.diallingNum");
 783                                 sca = g_strdup("");
 784                         }
 785
 786                         telephony_sms_complete_get_sca(dbus_info->interface_object, dbus_info->invocation,
 787                                 resp->result,
 788                                 resp->scaAddress.typeOfNum,
 789                                 resp->scaAddress.numPlanId,
 790                                 resp->scaAddress.dialNumLen,
 791                                 sca);
 792
 793                         if (sca)
 794                                 g_free(sca);
 795
 796                         }
 797                         break;
 798
 799                 case TRESP_SMS_SET_SCA: {
 800                         const struct tresp_sms_set_sca *resp = data;
 801
 802                         dbg("receive TRESP_SMS_SET_SCA");
 803                         dbg("resp->result = 0x%x", resp->result);
 804
 805                         telephony_sms_complete_set_sca(dbus_info->interface_object, dbus_info->invocation,
 806                                 resp->result);
 807
 808                         }
 809                         break;
 810
 811                 case TRESP_SMS_GET_CB_CONFIG: {
 812                         const struct tresp_sms_get_cb_config *resp = data;
 813                         GVariant *result = NULL;
 814                         GVariantBuilder b;
 815
 816                         dbg("receive TRESP_SMS_GET_CB_CONFIG");
 817                         dbg("resp->result = 0x%x", resp->result);
 818
 819                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
 820
 821                         for (i = 0; i < resp->cbConfig.msgIdRangeCount; i++) {
 822                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
 823
 824                                 if( resp->cbConfig.net3gppType == SMS_NETTYPE_3GPP ) {
 825                                         g_variant_builder_add(&b, "{sv}", "FromMsgId", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp.fromMsgId));
 826                                         g_variant_builder_add(&b, "{sv}", "ToMsgId", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp.toMsgId));
 827                                 } else if( resp->cbConfig.net3gppType == SMS_NETTYPE_3GPP2) {
 828                                         g_variant_builder_add(&b, "{sv}", "CBCategory", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp2.cbCategory));
 829                                         g_variant_builder_add(&b, "{sv}", "CBLanguage", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp2.cbLanguage));
 830                                 } else {
 831                                         dbg("Unknown 3gpp type");
 832                                         return FALSE;
 833                                 }
 834
 835                                 g_variant_builder_add(&b, "{sv}", "Selected", g_variant_new_byte(resp->cbConfig.msgIDs[i].net3gpp.selected));
 836
 837                                 g_variant_builder_close(&b);
 838                         }
 839
 840                         result = g_variant_builder_end(&b);
 841
 842                         telephony_sms_complete_get_cb_config(dbus_info->interface_object, dbus_info->invocation,
 843                                 resp->result,
 844                                 resp->cbConfig.net3gppType,
 845                                 resp->cbConfig.cbEnabled,
 846                                 resp->cbConfig.msgIdMaxCount,
 847                                 resp->cbConfig.msgIdRangeCount,
 848                                 result);
 849                         }
 850                         break;
 851
 852                 case TRESP_SMS_SET_CB_CONFIG: {
 853                         const struct tresp_sms_set_cb_config *resp = data;
 854
 855                         dbg("receive TRESP_SMS_SET_CB_CONFIG");
 856                         dbg("resp->result = 0x%x", resp->result);
 857
 858                         telephony_sms_complete_set_cb_config(dbus_info->interface_object, dbus_info->invocation,
 859                                 resp->result);
 860
 861                         }
 862                         break;
 863
 864                 case TRESP_SMS_SET_MEM_STATUS: {
 865                         const struct tresp_sms_set_mem_status *resp = data;
 866
 867                         dbg("receive TRESP_SMS_SET_MEM_STATUS");
 868                         dbg("resp->result = 0x%x", resp->result);
 869
 870                         telephony_sms_complete_set_mem_status(dbus_info->interface_object, dbus_info->invocation,
 871                                 resp->result);
 872
 873                         }
 874                         break;
 875                 case TRESP_SMS_GET_PREF_BEARER: {
 876                         const struct tresp_sms_get_pref_bearer *resp = data;
 877
 878                         dbg("receive TRESP_SMS_GET_PREF_BEARER");
 879                         dbg("resp->result = 0x%x", resp->result);
 880
 881                         telephony_sms_complete_get_pref_bearer(dbus_info->interface_object, dbus_info->invocation,
 882                                 resp->result);
 883
 884                         }
 885                         break;
 886
 887                 case TRESP_SMS_SET_PREF_BEARER: {
 888                         const struct tresp_sms_set_pref_bearer *resp = data;
 889
 890                         dbg("receive TRESP_SMS_SET_PREF_BEARER");
 891                         dbg("resp->result = 0x%x", resp->result);
 892
 893                         telephony_sms_complete_set_pref_bearer(dbus_info->interface_object, dbus_info->invocation,
 894                                 resp->result);
 895
 896                         }
 897                         break;
 898
 899                 case TRESP_SMS_SET_DELIVERY_REPORT: {
 900                         const struct tresp_sms_set_delivery_report *resp = data;
 901
 902                         dbg("receive TRESP_SMS_SET_DELIVERY_REPORT");
 903                         dbg("resp->result = 0x%x", resp->result);
 904
 905                         telephony_sms_complete_set_delivery_report(dbus_info->interface_object, dbus_info->invocation,
 906                                 resp->result);
 907
 908                         }
 909                         break;
 910
 911                 case TRESP_SMS_SET_MSG_STATUS: {
 912                         const struct tresp_sms_set_mem_status *resp = data;
 913
 914                         dbg("receive TRESP_SMS_SET_MSG_STATUS");
 915                         dbg("resp->result = 0x%x", resp->result);
 916
 917                         telephony_sms_complete_set_msg_status(dbus_info->interface_object, dbus_info->invocation,
 918                                 resp->result);
 919
 920                         }
 921                         break;
 922
 923                 case TRESP_SMS_GET_PARAMS: {
 924                         const struct tresp_sms_get_params *resp = data;
 925                         gchar *alphaId = NULL;
 926                         gchar *destDialNum = NULL;
 927                         gchar *scaDialNum = NULL;
 928
 929                         dbg("receive TRESP_SMS_GET_PARAMS");
 930                         dbg("resp->result = 0x%x", resp->result);
 931
 932                         alphaId = g_base64_encode((const guchar *)&(resp->paramsInfo.szAlphaId[0]), SMS_SMSP_ALPHA_ID_LEN_MAX + 1);
 933                         if (alphaId == NULL) {
 934                                 dbg("g_base64_encode: Failed to Enocde paramsInfo.szAlphaId");
 935                                 alphaId = g_strdup("");
 936                         }
 937
 938                         destDialNum = g_base64_encode((const guchar *)&(resp->paramsInfo.tpDestAddr.diallingNum[0]), SMS_SMSP_ADDRESS_LEN + 1);
 939                         if (destDialNum == NULL) {
 940                                 dbg("g_base64_encode: Failed to Enocde paramsInfo.tpDestAddr.diallingNum");
 941                                 destDialNum = g_strdup("");
 942                         }
 943
 944                         scaDialNum = g_base64_encode((const guchar *)&(resp->paramsInfo.tpSvcCntrAddr.diallingNum[0]), SMS_SMSP_ADDRESS_LEN + 1);
 945                         if (scaDialNum == NULL) {
 946                                 dbg("g_base64_encode: Failed to Enocde paramsInfo.tpSvcCntrAddr.diallingNum");
 947                                 scaDialNum = g_strdup("");
 948                         }
 949
 950                         telephony_sms_complete_get_sms_params(dbus_info->interface_object, dbus_info->invocation,
 951                                 resp->result,
 952                                 resp->paramsInfo.recordIndex,
 953                                 resp->paramsInfo.recordLen,
 954                                 resp->paramsInfo.alphaIdLen,
 955                                 alphaId,
 956                                 resp->paramsInfo.paramIndicator,
 957                                 resp->paramsInfo.tpDestAddr.dialNumLen,
 958                                 resp->paramsInfo.tpDestAddr.typeOfNum,
 959                                 resp->paramsInfo.tpDestAddr.numPlanId,
 960                                 destDialNum,
 961                                 resp->paramsInfo.tpSvcCntrAddr.dialNumLen,
 962                                 resp->paramsInfo.tpSvcCntrAddr.typeOfNum,
 963                                 resp->paramsInfo.tpSvcCntrAddr.numPlanId,
 964                                 scaDialNum,
 965                                 resp->paramsInfo.tpProtocolId,
 966                                 resp->paramsInfo.tpDataCodingScheme,
 967                                 resp->paramsInfo.tpValidityPeriod);
 968
 969                         if(alphaId)
 970                                 g_free(alphaId);
 971
 972                         if(destDialNum)
 973                                 g_free(destDialNum);
 974
 975                         if(scaDialNum)
 976                                 g_free(scaDialNum);
 977
 978                         }
 979                         break;
 980
 981                 case TRESP_SMS_SET_PARAMS:{
 982                         const struct tresp_sms_set_params *resp = data;
 983
 984                         dbg("receive TRESP_SMS_SET_PARAMS");
 985                         dbg("resp->result = 0x%x", resp->result);
 986
 987                         telephony_sms_complete_set_sms_params(dbus_info->interface_object, dbus_info->invocation,
 988                                 resp->result);
 989
 990                         }
 991                         break;
 992
 993                 case TRESP_SMS_GET_PARAMCNT: {
 994                         const struct tresp_sms_get_paramcnt *resp = data;
 995
 996                         dbg("receive TRESP_SMS_GET_PARAMCNT");
 997                         dbg("resp->result = 0x%x", resp->result);
 998
 999                         telephony_sms_complete_get_sms_param_cnt(dbus_info->interface_object, dbus_info->invocation,
1000                                 resp->result,
1001                                 resp->recordCount);
1002
1003                         }
1004                         break;
1005
1006                 default:
1007                         break;
1008         }
1009
1010         return TRUE;
1011 }
1012
1013 gboolean dbus_plugin_sms_notification(struct custom_data *ctx, const char *plugin_name, TelephonyObjectSkeleton *object, enum tcore_notification_command command, unsigned int data_len, const void *data)
1014 {
1015         TelephonySms *sms;
1016
1017         if (!object)
1018         {
1019                 dbg("object is NULL");
1020                 return FALSE;
1021         }
1022
1023         sms = telephony_object_peek_sms(TELEPHONY_OBJECT(object));
1024         dbg("sms = %p", sms);
1025
1026         dbg("[tcore_SMS]notification !!! (command = 0x%x, data_len = %d)", command, data_len);
1027
1028         switch (command) {
1029                 case TNOTI_SMS_INCOM_MSG: {
1030                         const struct tnoti_sms_umts_msg *noti = data;
1031
1032                         gchar *sca = NULL;
1033                         gchar *tpdu = NULL;
1034
1035                         sca = g_base64_encode((const guchar *)&(noti->msgInfo.sca[0]), SMS_ENCODED_SCA_LEN_MAX);
1036                         if (sca == NULL) {
1037                                 dbg("g_base64_encode: Failed to Enocde msgInfo.sca");
1038                                 sca = g_strdup("");
1039                         }
1040
1041                         tpdu = g_base64_encode((const guchar *)&(noti->msgInfo.tpduData[0]), SMS_SMDATA_SIZE_MAX + 1);
1042                         if (tpdu == NULL) {
1043                                 dbg("g_base64_encode: Failed to Enocde msgInfo.tpduData");
1044                                 tpdu = g_strdup("");
1045                         }
1046
1047                         telephony_sms_emit_incomming_msg(sms,
1048                                 sca,
1049                                 noti->msgInfo.msgLength,
1050                                 tpdu);
1051
1052                         if(sca)
1053                                 g_free(sca);
1054
1055                         if(tpdu)
1056                                 g_free(tpdu);
1057
1058                         }
1059                         break;
1060
1061                 case TNOTI_SMS_CB_INCOM_MSG: {
1062                         const struct tnoti_sms_cellBroadcast_msg *noti = data;
1063                         gchar *msgData = NULL;
1064
1065                         msgData = g_base64_encode((const guchar *)&(noti->cbMsg.msgData[0]), SMS_CB_SIZE_MAX + 1);
1066                         if (msgData == NULL) {
1067                                 dbg("g_base64_encode: Failed to Enocde cbMsg.msgData");
1068                                 msgData = g_strdup("");
1069                         }
1070
1071                         telephony_sms_emit_incomming_cb_msg(sms,
1072                                 noti->cbMsg.cbMsgType,
1073                                 noti->cbMsg.length,
1074                                 msgData);
1075
1076                         if(msgData)
1077                                 g_free(msgData);
1078
1079                         }
1080                         break;
1081
1082                 case TNOTI_SMS_ETWS_INCOM_MSG: {
1083                         const struct tnoti_sms_etws_msg *noti = data;
1084                         gchar *msgData = NULL;
1085
1086                         msgData = g_base64_encode((const guchar *)&(noti->etwsMsg.msgData[0]), SMS_ETWS_SIZE_MAX + 1);
1087                         if (msgData == NULL) {
1088                                 dbg("g_base64_encode: Failed to Enocde etwsMsg.msgData");
1089                                 msgData = g_strdup("");
1090                         }
1091
1092                         telephony_sms_emit_incomming_etws_msg(sms,
1093                                 noti->etwsMsg.etwsMsgType,
1094                                 noti->etwsMsg.length,
1095                                 msgData);
1096
1097                         if(msgData)
1098                                 g_free(msgData);
1099                         }
1100                         break;
1101
1102                 case TNOTI_SMS_INCOM_EX_MSG:
1103                         break;
1104
1105                 case TNOTI_SMS_CB_INCOM_EX_MSG:
1106                         break;
1107
1108                 case TNOTI_SMS_MEMORY_STATUS: {
1109                         const struct tnoti_sms_memory_status *noti = data;
1110
1111                         telephony_sms_emit_memory_status(sms, noti->status);
1112
1113                         }
1114                         break;
1115
1116                 case TNOTI_SMS_DEVICE_READY: {
1117                         const struct tnoti_sms_ready_status *noti = data;
1118
1119                         dbg("SMS Device Ready: [%s]", (noti->status ? "YES" : "NO"));
1120
1121                         telephony_sms_emit_sms_ready(sms, noti->status);
1122
1123                         }
1124                         break;
1125
1126                 default:
1127                         dbg("unknown notification");
1128                         return FALSE;
1129                         break;
1130         }
1131
1132         return TRUE;
1133 }