src/sms.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 <pthread.h>
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <time.h>
  27 #include <glib.h>
  28 #include <gio/gio.h>
  29
  30 #include <tcore.h>
  31 #include <server.h>
  32 #include <plugin.h>
  33 #include <hal.h>
  34 #include <communicator.h>
  35 #include <storage.h>
  36 #include <queue.h>
  37 #include <user_request.h>
  38 #include <co_sms.h>
  39
  40 #include "generated-code.h"
  41 #include "common.h"
  42
  43 TReturn ret = TCORE_RETURN_SUCCESS;
  44
  45 static gboolean
  46 on_sms_send_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
  47         GVariant *sca,
  48         gint tpdu_length,
  49         GVariant *tpdu_data,
  50         gint moreMsg,
  51         gpointer user_data)
  52 {
  53         struct treq_sms_send_umts_msg sendUmtsMsg;
  54         struct custom_data *ctx = user_data;
  55         UserRequest *ur = NULL;
  56
  57         int i = 0;
  58         GVariantIter *iter = 0;
  59         GVariant *inner_gv = 0;
  60
  61         if (!check_access_control (invocation, AC_SMS, "x"))
  62                 return TRUE;
  63
  64         memset(&sendUmtsMsg, 0 , sizeof(struct treq_sms_send_umts_msg));
  65
  66         inner_gv = g_variant_get_variant( sca );
  67         g_variant_get(inner_gv, "ay", &iter);
  68         while( g_variant_iter_loop(iter, "y", &sendUmtsMsg.msgDataPackage.sca[i] ) ) {
  69                 i++;
  70                 if( i >= SMS_SMSP_ADDRESS_LEN )
  71                         break;
  72         }
  73
  74         sendUmtsMsg.msgDataPackage.msgLength = tpdu_length;
  75
  76         i = 0;
  77         inner_gv = g_variant_get_variant( tpdu_data );
  78         g_variant_get(inner_gv, "ay", &iter);
  79         while( g_variant_iter_loop(iter, "y", &sendUmtsMsg.msgDataPackage.tpduData[i] ) ) {
  80                 i++;
  81                 if( i >= SMS_SMDATA_SIZE_MAX + 1 )
  82                         break;
  83         }
  84         g_variant_iter_free(iter);
  85         g_variant_unref(inner_gv);
  86
  87         sendUmtsMsg.more = moreMsg;
  88
  89         ur = MAKE_UR(ctx, sms, invocation);
  90         tcore_user_request_set_data(ur, sizeof(struct treq_sms_send_umts_msg), &sendUmtsMsg);
  91         tcore_user_request_set_command(ur, TREQ_SMS_SEND_UMTS_MSG);
  92
  93         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
  94         if (ret != TCORE_RETURN_SUCCESS) {
  95                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
  96                 tcore_user_request_unref(ur);
  97         }
  98
  99         return  TRUE;
 100 }
 101 /*
 102
 103 static gboolean
 104 on_sms_send_cdma_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
 105         const gchar *sca,
 106         gint tpdu_length,
 107         const gchar *tpdu_data,
 108         gint moreMsg,
 109         gpointer user_data)
 110 {
 111 #if 0
 112         cdmaMsg.more = sipc_util_marshal_object_get_int(in_obj, "More");
 113         cdmaMsg.cdmaMsgInfo.ParamMask = sipc_util_marshal_object_get_int(in_obj, "ParamMask");
 114         cdmaMsg.cdmaMsgInfo.MsgType = sipc_util_marshal_object_get_int(in_obj, "MsgType");
 115
 116         switch(cdmaMsg.cdmaMsgInfo.MsgType)
 117         {
 118                 case SMS_MESSAGETYPE_SUBMIT: {
 119                         gchar *dstAddr_szAddress;
 120                         gchar *dstSubAddr_szAddress;
 121                         gchar *szData;
 122                         gchar *callBackNumer_szAddress;
 123
 124                          Origination address
 125                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstAddr.Digit = sipc_util_marshal_object_get_int(in_obj, "DstAddr.Digit");
 126                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstAddr.NumberMode = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberMode");
 127                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstAddr.NumberType = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberType");
 128                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstAddr.NumberPlan = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberPlan");
 129                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstAddr.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "DstAddr.szAddrLength");
 130                         dstAddr_szAddress = sipc_util_marshal_object_get_string(in_obj, "DstAddr.szAddress");
 131                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstAddr.szAddress[0]), dstAddr_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 132
 133                          Origination subaddress
 134                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstSubAddr.SubType = sipc_util_marshal_object_get_int(in_obj, "DstSubAddr.SubType");
 135                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstSubAddr.Odd = sipc_util_marshal_object_get_char(in_obj, "DstSubAddr.Odd");
 136                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstSubAddr.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "DstSubAddr.szAddrLength");
 137                         dstSubAddr_szAddress = sipc_util_marshal_object_get_string(in_obj, "DstSubAddr.szAddress");
 138                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DstSubAddr.szAddress[0]), dstSubAddr_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 139
 140                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.TeleService = sipc_util_marshal_object_get_int(in_obj, "TeleService");
 141                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.bBearerReplySeqRequest = sipc_util_marshal_object_get_int(in_obj, "bBearerReplySeqRequest");
 142                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ReplySeqNumber = sipc_util_marshal_object_get_char(in_obj, "ReplySeqNumber");
 143                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.MsgId = sipc_util_marshal_object_get_int(in_obj, "MsgId");
 144                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.MsgEncoding = sipc_util_marshal_object_get_int(in_obj, "MsgEncoding");
 145                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.MsgLength = sipc_util_marshal_object_get_int(in_obj, "MsgLength");
 146                         szData = sipc_util_marshal_object_get_string(in_obj, "szData");
 147                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.szData[0]), szData, SMS_MAXLENGTH_SMS_MO_USER_DATA);
 148
 149                          Validity period - Absolute
 150                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodAbs.year = sipc_util_marshal_object_get_int(in_obj, "ValidityPeriodAbs.year");
 151                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodAbs.month = sipc_util_marshal_object_get_int(in_obj, "ValidityPeriodAbs.month");
 152                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodAbs.day = sipc_util_marshal_object_get_int(in_obj, "ValidityPeriodAbs.day");
 153                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodAbs.hours = sipc_util_marshal_object_get_int(in_obj, "ValidityPeriodAbs.hours");
 154                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodAbs.minutes = sipc_util_marshal_object_get_int(in_obj, "ValidityPeriodAbs.minutes");
 155                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodAbs.seconds = sipc_util_marshal_object_get_int(in_obj, "ValidityPeriodAbs.seconds");
 156
 157                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.ValidityPeriodRel = sipc_util_marshal_object_get_char(in_obj, "ValidityPeriodRel");
 158
 159                          Deferred delivery time - Absolute (not supported)
 160                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeAbs.year = sipc_util_marshal_object_get_int(in_obj, "DeferredDelTimeAbs.year");
 161                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeAbs.month = sipc_util_marshal_object_get_int(in_obj, "DeferredDelTimeAbs.month");
 162                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeAbs.day = sipc_util_marshal_object_get_int(in_obj, "DeferredDelTimeAbs.day");
 163                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeAbs.hours = sipc_util_marshal_object_get_int(in_obj, "DeferredDelTimeAbs.hours");
 164                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeAbs.minutes = sipc_util_marshal_object_get_int(in_obj, "DeferredDelTimeAbs.minutes");
 165                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeAbs.seconds = sipc_util_marshal_object_get_int(in_obj, "DeferredDelTimeAbs.seconds");
 166
 167                          Deferred delivery time - Relative (not supported)
 168                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.DeferredDelTimeRel = sipc_util_marshal_object_get_char(in_obj, "DeferredDelTimeRel");
 169
 170                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.Priority = sipc_util_marshal_object_get_int(in_obj, "Priority");
 171                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.Privacy = sipc_util_marshal_object_get_int(in_obj, "Privacy");
 172                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.bUserAckRequest = sipc_util_marshal_object_get_int(in_obj, "bUserAckRequest");
 173                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.bDeliveryAckRequest = sipc_util_marshal_object_get_int(in_obj, "bDeliveryAckRequest");
 174                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.AlertPriority= sipc_util_marshal_object_get_int(in_obj, "AlertPriority");
 175                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.MsgLang= sipc_util_marshal_object_get_int(in_obj, "MsgLang");
 176
 177                          Callback number address
 178                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.CallBackNumber.Digit = sipc_util_marshal_object_get_int(in_obj, "CallBackNumer.Digit");
 179                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.CallBackNumber.NumberMode = sipc_util_marshal_object_get_int(in_obj, "CallBackNumer.NumberMode");
 180                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.CallBackNumber.NumberType = sipc_util_marshal_object_get_int(in_obj, "CallBackNumer.NumberType");
 181                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.CallBackNumber.NumberPlan = sipc_util_marshal_object_get_int(in_obj, "CallBackNumer.NumberPlan");
 182                         cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.CallBackNumber.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "CallBackNumer.szAddrLength");
 183                         callBackNumer_szAddress = sipc_util_marshal_object_get_string(in_obj, "CallBackNumer.szAddress");
 184                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outSubmit.CallBackNumber.szAddress[0]), callBackNumer_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 185
 186                         }
 187                         break;
 188
 189                 case SMS_MESSAGETYPE_CANCEL: {
 190                         gchar *dstAddr_szAddress;
 191                         gchar *dstSubAddr_szAddress;
 192
 193                          Origination address
 194                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstAddr.Digit = sipc_util_marshal_object_get_int(in_obj, "DstAddr.Digit");
 195                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstAddr.NumberMode = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberMode");
 196                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstAddr.NumberType = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberType");
 197                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstAddr.NumberPlan = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberPlan");
 198                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstAddr.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "DstAddr.szAddrLength");
 199                         dstAddr_szAddress = sipc_util_marshal_object_get_string(in_obj, "DstAddr.szAddress");
 200                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstAddr.szAddress[0]), dstAddr_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 201
 202                          Origination subaddress
 203                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstSubAddr.SubType = sipc_util_marshal_object_get_int(in_obj, "DstSubAddr.SubType");
 204                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstSubAddr.Odd = sipc_util_marshal_object_get_char(in_obj, "DstSubAddr.Odd");
 205                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstSubAddr.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "DstSubAddr.szAddrLength");
 206                         dstSubAddr_szAddress = sipc_util_marshal_object_get_string(in_obj, "DstSubAddr.szAddress");
 207                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outCancel.DstSubAddr.szAddress[0]), dstSubAddr_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 208
 209                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.TeleService = sipc_util_marshal_object_get_int(in_obj, "TeleService");
 210                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.bBearerReplySeqRequest = sipc_util_marshal_object_get_int(in_obj, "bBearerReplySeqRequest");
 211                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.ReplySeqNumber = sipc_util_marshal_object_get_char(in_obj, "ReplySeqNumber");
 212                         cdmaMsg.cdmaMsgInfo.MsgData.outCancel.MsgId = sipc_util_marshal_object_get_int(in_obj, "MsgId");
 213
 214                         }
 215                         break;
 216
 217                 case SMS_MESSAGETYPE_USER_ACK: {
 218                         gchar *dstAddr_szAddress;
 219                         gchar *dstSubAddr_szAddress;
 220                         gchar *szData;
 221
 222                          Origination address
 223                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstAddr.Digit = sipc_util_marshal_object_get_int(in_obj, "DstAddr.Digit");
 224                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstAddr.NumberMode = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberMode");
 225                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstAddr.NumberType = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberType");
 226                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstAddr.NumberPlan = sipc_util_marshal_object_get_int(in_obj, "DstAddr.NumberPlan");
 227                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstAddr.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "DstAddr.szAddrLength");
 228                         dstAddr_szAddress = sipc_util_marshal_object_get_string(in_obj, "DstAddr.szAddress");
 229                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstAddr.szAddress[0]), dstAddr_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 230
 231                          Origination subaddress
 232                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstSubAddr.SubType = sipc_util_marshal_object_get_int(in_obj, "DstSubAddr.SubType");
 233                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstSubAddr.Odd = sipc_util_marshal_object_get_char(in_obj, "DstSubAddr.Odd");
 234                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstSubAddr.szAddrLength = sipc_util_marshal_object_get_char(in_obj, "DstSubAddr.szAddrLength");
 235                         dstSubAddr_szAddress = sipc_util_marshal_object_get_string(in_obj, "DstSubAddr.szAddress");
 236                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outAck.DstSubAddr.szAddress[0]), dstSubAddr_szAddress, SMS_MAXLENGTH_SMS_ADDRESS);
 237
 238                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.TeleService = sipc_util_marshal_object_get_int(in_obj, "TeleService");
 239                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.bBearerReplySeqRequest = sipc_util_marshal_object_get_int(in_obj, "bBearerReplySeqRequest");
 240                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.ReplySeqNumber = sipc_util_marshal_object_get_char(in_obj, "ReplySeqNumber");
 241                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.MsgId = sipc_util_marshal_object_get_int(in_obj, "MsgId");
 242                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.MsgEncoding = sipc_util_marshal_object_get_int(in_obj, "MsgEncoding");
 243                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.MsgLength = sipc_util_marshal_object_get_int(in_obj, "MsgLength");
 244                         szData = sipc_util_marshal_object_get_string(in_obj, "szData");
 245                         memcpy(&(cdmaMsg.cdmaMsgInfo.MsgData.outAck.szData[0]), szData, SMS_MAXLENGTH_SMS_MO_USER_DATA);
 246                         cdmaMsg.cdmaMsgInfo.MsgData.outAck.UserResponseCode = sipc_util_marshal_object_get_char(in_obj, "UserResponseCode");
 247
 248                         }
 249                         break;
 250                 default:
 251                         break;
 252         }
 253
 254         tcore_user_request_set_data(ur, sizeof(struct treq_sms_send_cdma_msg), &cdmaMsg);
 255         tcore_user_request_set_command(ur, TREQ_SMS_SEND_CDMA_MSG);
 256
 257         ret = tcore_communicator_dispatch_request(comm, ur);
 258         if (ret != TCORE_RETURN_SUCCESS) {
 259                 // api_err = TAPI_API_OPERATION_FAILED;
 260                 err("[tcore_SMS] communicator_dispatch_request is fail [0x%x] !!!", ret);
 261                 return  FALSE;
 262         }
 263 #endif
 264         return TRUE;
 265 }
 266
 267 */
 268
 269 static gboolean
 270 on_sms_read_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
 271         gint arg_index,
 272         gpointer user_data)
 273 {
 274         struct treq_sms_read_msg readMsg = {0,};
 275         struct custom_data *ctx = user_data;
 276         UserRequest *ur = NULL;
 277
 278         if (!check_access_control (invocation, AC_SMS, "r"))
 279                 return TRUE;
 280
 281         readMsg.index = arg_index;
 282
 283         ur = MAKE_UR(ctx, sms, invocation);
 284         tcore_user_request_set_data(ur, sizeof(struct treq_sms_read_msg), &readMsg);
 285         tcore_user_request_set_command(ur, TREQ_SMS_READ_MSG);
 286
 287         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 288         if (ret != TCORE_RETURN_SUCCESS) {
 289                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 290                 tcore_user_request_unref(ur);
 291         }
 292
 293         return TRUE;
 294 }
 295
 296 static gboolean
 297 on_sms_save_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
 298         gint arg_msg_status,
 299         GVariant * arg_sca,
 300         gint arg_tpdu_length,
 301         GVariant * arg_tpdu_data,
 302         gpointer user_data)
 303 {
 304         struct treq_sms_save_msg saveMsg = {0,};
 305         struct custom_data *ctx = user_data;
 306         UserRequest *ur = NULL;
 307
 308         int i = 0;
 309         GVariantIter *iter = 0;
 310         GVariant *inner_gv = 0;
 311
 312         if (!check_access_control (invocation, AC_SMS, "w"))
 313                 return TRUE;
 314
 315         saveMsg.simIndex = 0xffff;
 316         saveMsg.msgStatus = arg_msg_status;
 317
 318         inner_gv = g_variant_get_variant( arg_sca );
 319         g_variant_get(inner_gv, "ay", &iter);
 320         while( g_variant_iter_loop(iter, "y", &saveMsg.msgDataPackage.sca[i] ) ) {
 321                 i++;
 322                 if( i >= SMS_SMSP_ADDRESS_LEN )
 323                         break;
 324         }
 325
 326         i = 0;
 327         inner_gv = g_variant_get_variant( arg_tpdu_data );
 328         g_variant_get(inner_gv, "ay", &iter);
 329         while( g_variant_iter_loop(iter, "y", &saveMsg.msgDataPackage.tpduData[i] ) ) {
 330                 i++;
 331                 if( i >= SMS_SMDATA_SIZE_MAX + 1 )
 332                         break;
 333         }
 334         g_variant_iter_free(iter);
 335         g_variant_unref(inner_gv);
 336
 337         saveMsg.msgDataPackage.msgLength = arg_tpdu_length;
 338
 339         ur = MAKE_UR(ctx, sms, invocation);
 340         tcore_user_request_set_data(ur, sizeof(struct treq_sms_save_msg), &saveMsg);
 341         tcore_user_request_set_command(ur, TREQ_SMS_SAVE_MSG);
 342
 343         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 344         if (ret != TCORE_RETURN_SUCCESS) {
 345                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 346                 tcore_user_request_unref(ur);
 347         }
 348
 349         return TRUE;
 350 }
 351
 352 static gboolean
 353 on_sms_delete_msg(TelephonySms *sms, GDBusMethodInvocation *invocation,
 354         gint arg_index,
 355         gpointer user_data)
 356 {
 357         struct treq_sms_delete_msg deleteMsg = {0,};
 358         struct custom_data *ctx = user_data;
 359         UserRequest *ur = NULL;
 360
 361         if (!check_access_control (invocation, AC_SMS, "x"))
 362                 return TRUE;
 363
 364         deleteMsg.index = arg_index;
 365
 366         ur = MAKE_UR(ctx, sms, invocation);
 367         tcore_user_request_set_data(ur, sizeof(struct treq_sms_delete_msg), &deleteMsg);
 368         tcore_user_request_set_command(ur, TREQ_SMS_DELETE_MSG);
 369
 370         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 371         if (ret != TCORE_RETURN_SUCCESS) {
 372                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 373                 tcore_user_request_unref(ur);
 374         }
 375
 376         return TRUE;
 377 }
 378
 379 static gboolean
 380 on_sms_get_msg_count(TelephonySms *sms, GDBusMethodInvocation *invocation,
 381         gpointer user_data)
 382 {
 383         struct custom_data *ctx = user_data;
 384         UserRequest *ur = NULL;
 385
 386         if (!check_access_control (invocation, AC_SMS, "r"))
 387                 return TRUE;
 388
 389         ur = MAKE_UR(ctx, sms, invocation);
 390         tcore_user_request_set_data(ur, 0, NULL);
 391         tcore_user_request_set_command(ur, TREQ_SMS_GET_COUNT);
 392
 393         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 394         if (ret != TCORE_RETURN_SUCCESS) {
 395                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 396                 tcore_user_request_unref(ur);
 397         }
 398
 399         return TRUE;
 400 }
 401
 402 static gboolean
 403 on_sms_get_sca(TelephonySms *sms, GDBusMethodInvocation *invocation,
 404         gint arg_index,
 405         gpointer user_data)
 406 {
 407         struct treq_sms_get_sca getSca = {0,};
 408         struct custom_data *ctx = user_data;
 409         UserRequest *ur = NULL;
 410
 411         if (!check_access_control (invocation, AC_SMS, "r"))
 412                 return TRUE;
 413
 414         getSca.index = arg_index;
 415
 416         ur = MAKE_UR(ctx, sms, invocation);
 417         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_sca), &getSca);
 418         tcore_user_request_set_command(ur, TREQ_SMS_GET_SCA);
 419
 420         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 421         if (ret != TCORE_RETURN_SUCCESS) {
 422                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 423                 tcore_user_request_unref(ur);
 424         }
 425
 426         return TRUE;
 427 }
 428
 429 static gboolean
 430 on_sms_set_sca(TelephonySms *sms, GDBusMethodInvocation *invocation,
 431         gint arg_index,
 432         gint arg_ton,
 433         gint arg_npi,
 434         gint arg_dialNumberLength,
 435         GVariant *arg_dialNumber,
 436         gpointer user_data)
 437 {
 438         struct treq_sms_set_sca setSca;
 439         struct custom_data *ctx = user_data;
 440         UserRequest *ur = NULL;
 441
 442         int i = 0;
 443         GVariantIter *iter = 0;
 444         GVariant *inner_gv = 0;
 445
 446         if (!check_access_control (invocation, AC_SMS, "w"))
 447                 return TRUE;
 448
 449         memset(&setSca, 0, sizeof(struct treq_sms_set_sca));
 450
 451         setSca.index = arg_index;
 452         setSca.scaInfo.dialNumLen = arg_dialNumberLength;
 453         setSca.scaInfo.typeOfNum = arg_ton;
 454         setSca.scaInfo.numPlanId = arg_npi;
 455
 456         if ((setSca.scaInfo.dialNumLen <= 0) || (setSca.scaInfo.dialNumLen > (SMS_MAX_SMS_SERVICE_CENTER_ADDR + 1)))
 457         {
 458                 err("[tcore_SMS] TAPI_API_INVALID_INPUT !!!");
 459                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 460                 return  TRUE;
 461         }
 462         else if(setSca.index != 0)
 463         {
 464                 err("[tcore_SMS] Index except 0 is supported");
 465                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 466                 return  TRUE;
 467         }
 468         else
 469         {
 470                 inner_gv = g_variant_get_variant( arg_dialNumber );
 471                 g_variant_get(inner_gv, "ay", &iter);
 472                 while( g_variant_iter_loop(iter, "y", &setSca.scaInfo.diallingNum[i] ) ) {
 473                         i++;
 474                         if( i >= SMS_SMSP_ADDRESS_LEN + 1 )
 475                                 break;
 476                 }
 477
 478                 ur = MAKE_UR(ctx, sms, invocation);
 479                 tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_sca), &setSca);
 480                 tcore_user_request_set_command(ur, TREQ_SMS_SET_SCA);
 481
 482                 g_variant_iter_free(iter);
 483                 g_variant_unref(inner_gv);
 484
 485                 ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 486                 if (ret != TCORE_RETURN_SUCCESS) {
 487                         FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 488                         tcore_user_request_unref(ur);
 489                 }
 490         }
 491
 492         return TRUE;
 493 }
 494
 495 static gboolean
 496 on_sms_get_cb_config(TelephonySms *sms, GDBusMethodInvocation *invocation,
 497         gpointer user_data)
 498 {
 499         struct custom_data *ctx = user_data;
 500         UserRequest *ur = NULL;
 501
 502         if (!check_access_control (invocation, AC_SMS, "r"))
 503                 return TRUE;
 504
 505         ur = MAKE_UR(ctx, sms, invocation);
 506         tcore_user_request_set_data(ur, 0, NULL);
 507         tcore_user_request_set_command(ur, TREQ_SMS_GET_CB_CONFIG);
 508
 509         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 510         if (ret != TCORE_RETURN_SUCCESS) {
 511                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 512                 tcore_user_request_unref(ur);
 513         }
 514
 515         return TRUE;
 516 }
 517
 518 static gboolean
 519 on_sms_set_cb_config(TelephonySms *sms, GDBusMethodInvocation *invocation,
 520         gint arg_net3gppType,
 521         gboolean arg_cbEnable,
 522         gint arg_msgIdMaxCount,
 523         gint arg_msgIdRangeCount,
 524         GVariant *arg_mdgId,
 525         gpointer user_data)
 526 {
 527     struct treq_sms_set_cb_config setCbConfig = {0,};
 528         struct custom_data *ctx = user_data;
 529         UserRequest *ur = NULL;
 530
 531         GVariant *value = NULL;
 532         GVariant *inner_gv = 0;
 533         GVariantIter *iter = NULL;
 534         GVariantIter *iter_row = NULL;
 535         const gchar *key = NULL;
 536         int i = 0;
 537
 538         if (!check_access_control (invocation, AC_SMS, "w"))
 539                 return TRUE;
 540
 541         setCbConfig.net3gppType = arg_net3gppType;
 542         setCbConfig.cbEnabled = arg_cbEnable;
 543         setCbConfig.msgIdMaxCount = arg_msgIdMaxCount;
 544         setCbConfig.msgIdRangeCount = arg_msgIdRangeCount;
 545
 546         inner_gv = g_variant_get_variant( arg_mdgId );
 547         g_variant_get(inner_gv, "aa{sv}", &iter);
 548
 549         while (g_variant_iter_next(iter, "a{sv}", &iter_row)) {
 550                 while (g_variant_iter_loop(iter_row, "{sv}", &key, &value)) {
 551                         if (!g_strcmp0(key, "FromMsgId")) {
 552                                 setCbConfig.msgIDs[i].net3gpp.fromMsgId = g_variant_get_uint16(value);
 553                         }
 554                         if (!g_strcmp0(key, "ToMsgId")) {
 555                                 setCbConfig.msgIDs[i].net3gpp.toMsgId = g_variant_get_uint16(value);
 556                         }
 557                         if (!g_strcmp0(key, "CBCategory")) {
 558                                 setCbConfig.msgIDs[i].net3gpp2.cbCategory = g_variant_get_uint16(value);
 559                         }
 560                         if (!g_strcmp0(key, "CBLanguage")) {
 561                                 setCbConfig.msgIDs[i].net3gpp2.cbLanguage = g_variant_get_uint16(value);
 562                         }
 563                         if (!g_strcmp0(key, "Selected")) {
 564                                 setCbConfig.msgIDs[i].net3gpp2.selected = g_variant_get_byte(value);
 565                         }
 566                 }
 567                 i++;
 568                 g_variant_iter_free(iter_row);
 569                 if ( i >= SMS_GSM_SMS_CBMI_LIST_SIZE_MAX )
 570                         break;
 571         }
 572         g_variant_iter_free(iter);
 573
 574         ur = MAKE_UR(ctx, sms, invocation);
 575         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_cb_config), &setCbConfig);
 576         tcore_user_request_set_command(ur, TREQ_SMS_SET_CB_CONFIG);
 577
 578         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 579         if (ret != TCORE_RETURN_SUCCESS) {
 580                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 581                 tcore_user_request_unref(ur);
 582         }
 583
 584         return TRUE;
 585 }
 586
 587 static gboolean
 588 on_sms_set_mem_status(TelephonySms *sms, GDBusMethodInvocation *invocation,
 589         gint arg_memoryStatus,
 590         gpointer user_data)
 591 {
 592         struct treq_sms_set_mem_status memStatus = {0,};
 593         struct custom_data *ctx = user_data;
 594         UserRequest *ur = NULL;
 595
 596         if (!check_access_control (invocation, AC_SMS, "w"))
 597                 return TRUE;
 598
 599         memStatus.memory_status = arg_memoryStatus;
 600
 601         ur = MAKE_UR(ctx, sms, invocation);
 602         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_mem_status), &memStatus);
 603         tcore_user_request_set_command(ur, TREQ_SMS_SET_MEM_STATUS);
 604
 605         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 606         if (ret != TCORE_RETURN_SUCCESS) {
 607                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 608                 tcore_user_request_unref(ur);
 609         }
 610
 611         return TRUE;
 612 }
 613
 614 static gboolean
 615 on_sms_get_pref_bearer(TelephonySms *sms, GDBusMethodInvocation *invocation,
 616         gpointer user_data)
 617 {
 618         struct treq_sms_get_pref_bearer getPrefBearer;
 619         struct custom_data *ctx = user_data;
 620         UserRequest *ur = NULL;
 621
 622         if (!check_access_control (invocation, AC_SMS, "r"))
 623                 return TRUE;
 624
 625         ur = MAKE_UR(ctx, sms, invocation);
 626         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_pref_bearer), &getPrefBearer);
 627         tcore_user_request_set_command(ur, TREQ_SMS_GET_PREF_BEARER);
 628
 629         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 630         if (ret != TCORE_RETURN_SUCCESS) {
 631                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 632                 tcore_user_request_unref(ur);
 633         }
 634
 635         return TRUE;
 636 }
 637
 638 static gboolean
 639 on_sms_set_pref_bearer(TelephonySms *sms, GDBusMethodInvocation *invocation,
 640         gint arg_bearerType,
 641         gpointer user_data)
 642 {
 643         struct treq_sms_set_pref_bearer setPrefBearer = {0,};
 644         struct custom_data *ctx = user_data;
 645         UserRequest *ur = NULL;
 646
 647         if (!check_access_control (invocation, AC_SMS, "w"))
 648                 return TRUE;
 649
 650         setPrefBearer.svc = arg_bearerType;
 651
 652         ur = MAKE_UR(ctx, sms, invocation);
 653         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_pref_bearer), &setPrefBearer);
 654         tcore_user_request_set_command(ur, TREQ_SMS_SET_PREF_BEARER);
 655
 656         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 657         if (ret != TCORE_RETURN_SUCCESS) {
 658                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 659                 tcore_user_request_unref(ur);
 660         }
 661
 662         return TRUE;
 663 }
 664
 665 static gboolean
 666 on_sms_set_delivery_report(TelephonySms *sms, GDBusMethodInvocation *invocation,
 667         GVariant *arg_sca,
 668         gint arg_tpdu_length,
 669         GVariant *arg_tpdu_data,
 670         gint arg_rpCause,
 671         gpointer user_data)
 672 {
 673         struct treq_sms_set_delivery_report deliveryReport;
 674         struct custom_data *ctx = user_data;
 675         UserRequest *ur = NULL;
 676
 677         int i = 0;
 678         GVariantIter *iter = 0;
 679         GVariant *inner_gv = 0;
 680
 681         if (!check_access_control (invocation, AC_SMS, "w"))
 682                 return TRUE;
 683
 684         memset(&deliveryReport, 0, sizeof(struct treq_sms_set_delivery_report));
 685
 686         inner_gv = g_variant_get_variant( arg_sca );
 687         g_variant_get(inner_gv, "ay", &iter);
 688         while( g_variant_iter_loop(iter, "y", &deliveryReport.dataInfo.sca[i] ) ) {
 689                 i++;
 690                 if( i >= SMS_SMSP_ADDRESS_LEN )
 691                         break;
 692         }
 693
 694         i = 0;
 695         inner_gv = g_variant_get_variant( arg_tpdu_data );
 696         g_variant_get(inner_gv, "ay", &iter);
 697         while( g_variant_iter_loop(iter, "y", &deliveryReport.dataInfo.tpduData[i] ) ) {
 698                 i++;
 699                 if( i >= SMS_SMDATA_SIZE_MAX + 1 )
 700                         break;
 701         }
 702
 703         deliveryReport.dataInfo.msgLength = arg_tpdu_length;
 704
 705         deliveryReport.rspType = arg_rpCause;
 706
 707         ur = MAKE_UR(ctx, sms, invocation);
 708         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_delivery_report), &deliveryReport);
 709         tcore_user_request_set_command(ur, TREQ_SMS_SET_DELIVERY_REPORT);
 710
 711         g_variant_iter_free(iter);
 712         g_variant_unref(inner_gv);
 713
 714         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 715         if (ret != TCORE_RETURN_SUCCESS) {
 716                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 717                 tcore_user_request_unref(ur);
 718         }
 719
 720         return TRUE;
 721 }
 722
 723 static gboolean
 724 on_sms_set_msg_status(TelephonySms *sms, GDBusMethodInvocation *invocation,
 725         gint arg_index,
 726         gint arg_msgStatus,
 727         gpointer user_data)
 728 {
 729         struct treq_sms_set_msg_status msgStatus = {0,};
 730         struct custom_data *ctx = user_data;
 731         UserRequest *ur = NULL;
 732
 733         if (!check_access_control (invocation, AC_SMS, "w"))
 734                 return TRUE;
 735
 736         msgStatus.index = arg_index;
 737         msgStatus.msgStatus = arg_msgStatus;
 738
 739         ur = MAKE_UR(ctx, sms, invocation);
 740         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_msg_status), &msgStatus);
 741         tcore_user_request_set_command(ur, TREQ_SMS_SET_MSG_STATUS);
 742
 743         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 744         if (ret != TCORE_RETURN_SUCCESS) {
 745                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 746                 tcore_user_request_unref(ur);
 747         }
 748
 749         return TRUE;
 750 }
 751
 752 static gboolean
 753 on_sms_get_sms_params(TelephonySms *sms, GDBusMethodInvocation *invocation,
 754         gint arg_index,
 755         gpointer user_data)
 756 {
 757         struct treq_sms_get_params getParams = {0,};
 758         struct custom_data *ctx = user_data;
 759         UserRequest *ur = NULL;
 760
 761         if (!check_access_control (invocation, AC_SMS, "r"))
 762                 return TRUE;
 763
 764         getParams.index = arg_index;
 765
 766         ur = MAKE_UR(ctx, sms, invocation);
 767         tcore_user_request_set_data(ur, sizeof(struct treq_sms_get_params), &getParams);
 768         tcore_user_request_set_command(ur, TREQ_SMS_GET_PARAMS);
 769
 770         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 771         if (ret != TCORE_RETURN_SUCCESS) {
 772                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 773                 tcore_user_request_unref(ur);
 774         }
 775
 776         return TRUE;
 777 }
 778
 779 static gboolean
 780 on_sms_set_sms_params(TelephonySms *sms, GDBusMethodInvocation *invocation,
 781         gint arg_recordIndex,
 782         gint arg_recordLen,
 783         gint arg_alphaIdLen,
 784         GVariant *arg_alphaId,
 785         gint arg_paramIndicator,
 786         gint arg_destAddr_DialNumLen,
 787         gint arg_destAddr_Ton,
 788         gint arg_destAddr_Npi,
 789         GVariant *arg_destAddr_DiallingNum,
 790         gint arg_svcCntrAddr_DialNumLen,
 791         gint arg_SvcCntrAddr_Ton,
 792         gint arg_svcCntrAddr_Npi,
 793         GVariant *arg_svcCntrAddr_DialNum,
 794         gint arg_protocolId,
 795         gint arg_dataCodingScheme,
 796         gint arg_validityPeriod,
 797         gpointer user_data)
 798 {
 799         struct treq_sms_set_params setParams;
 800         struct custom_data *ctx = user_data;
 801         UserRequest *ur = NULL;
 802
 803         int i = 0;
 804         GVariantIter *iter = 0;
 805         GVariant *inner_gv = 0;
 806
 807         if (!check_access_control (invocation, AC_SMS, "w"))
 808                 return TRUE;
 809
 810         memset(&setParams, 0, sizeof(struct treq_sms_set_params));
 811
 812         setParams.params.recordIndex = arg_recordIndex;
 813         setParams.params.recordLen = arg_recordLen;
 814         setParams.params.alphaIdLen = arg_alphaIdLen;
 815
 816         inner_gv = g_variant_get_variant( arg_alphaId );
 817         g_variant_get(inner_gv, "ay", &iter);
 818         while( g_variant_iter_loop(iter, "y", &setParams.params.szAlphaId[i] ) ) {
 819                 i++;
 820                 if( i >= SMS_SMSP_ALPHA_ID_LEN_MAX + 1 )
 821                         break;
 822         }
 823
 824         setParams.params.paramIndicator = arg_paramIndicator;
 825
 826         setParams.params.tpDestAddr.dialNumLen = arg_destAddr_DialNumLen;
 827         setParams.params.tpDestAddr.typeOfNum = arg_destAddr_Ton;
 828         setParams.params.tpDestAddr.numPlanId = arg_destAddr_Npi;
 829
 830         i = 0;
 831         inner_gv = g_variant_get_variant( arg_destAddr_DiallingNum );
 832         g_variant_get(inner_gv, "ay", &iter);
 833         while( g_variant_iter_loop(iter, "y", &setParams.params.tpDestAddr.diallingNum[i] ) ) {
 834                 i++;
 835                 if( i >= SMS_SMSP_ADDRESS_LEN + 1 )
 836                         break;
 837         }
 838
 839         setParams.params.tpSvcCntrAddr.dialNumLen = arg_svcCntrAddr_DialNumLen;
 840         setParams.params.tpSvcCntrAddr.typeOfNum = arg_SvcCntrAddr_Ton;
 841         setParams.params.tpSvcCntrAddr.numPlanId = arg_svcCntrAddr_Npi;
 842
 843         i = 0;
 844         inner_gv = g_variant_get_variant( arg_svcCntrAddr_DialNum );
 845         g_variant_get(inner_gv, "ay", &iter);
 846         while( g_variant_iter_loop(iter, "y", &setParams.params.tpSvcCntrAddr.diallingNum[i] ) ) {
 847                 i++;
 848                 if( i >= SMS_SMSP_ADDRESS_LEN + 1 )
 849                         break;
 850         }
 851
 852         setParams.params.tpProtocolId = arg_protocolId;
 853         setParams.params.tpDataCodingScheme = arg_dataCodingScheme;
 854         setParams.params.tpValidityPeriod = arg_validityPeriod;
 855
 856         ur = MAKE_UR(ctx, sms, invocation);
 857         tcore_user_request_set_data(ur, sizeof(struct treq_sms_set_params), &setParams);
 858         tcore_user_request_set_command(ur, TREQ_SMS_SET_PARAMS);
 859
 860         g_variant_iter_free(iter);
 861         g_variant_unref(inner_gv);
 862
 863         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 864         if (ret != TCORE_RETURN_SUCCESS) {
 865                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 866                 tcore_user_request_unref(ur);
 867         }
 868
 869         return TRUE;
 870 }
 871
 872 static gboolean
 873 on_sms_get_sms_param_cnt(TelephonySms *sms, GDBusMethodInvocation *invocation,
 874         gpointer user_data)
 875 {
 876         struct custom_data *ctx = user_data;
 877         UserRequest *ur = NULL;
 878
 879         if (!check_access_control (invocation, AC_SMS, "r"))
 880                 return TRUE;
 881
 882         ur = MAKE_UR(ctx, sms, invocation);
 883         tcore_user_request_set_data(ur, 0, NULL);
 884         tcore_user_request_set_command(ur, TREQ_SMS_GET_PARAMCNT);
 885
 886         ret = tcore_communicator_dispatch_request(ctx->comm, ur);
 887         if (ret != TCORE_RETURN_SUCCESS) {
 888                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 889                 tcore_user_request_unref(ur);
 890         }
 891
 892         return TRUE;
 893 }
 894
 895 static gboolean
 896 on_sms_get_sms_ready_status(TelephonySms *sms, GDBusMethodInvocation *invocation,
 897         gpointer user_data)
 898 {
 899         struct custom_data *ctx = user_data;
 900         GSList *co_list = NULL;
 901         CoreObject *co_sms = NULL;
 902         TcorePlugin *plugin = NULL;
 903         gboolean ready_status = FALSE;
 904
 905         plugin = tcore_server_find_plugin(ctx->server, GET_CP_NAME(invocation));
 906         co_list = tcore_plugin_get_core_objects_bytype(plugin, CORE_OBJECT_TYPE_SMS);
 907         if (!co_list) {
 908                 dbg("error- co_list is NULL");
 909                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 910                 return TRUE;
 911         }
 912
 913         co_sms = (CoreObject *)co_list->data;
 914         g_slist_free(co_list);
 915
 916         if (!co_sms) {
 917                 dbg("error- co_sms is NULL");
 918                 FAIL_RESPONSE (invocation, DEFAULT_MSG_REQ_FAILED);
 919                 return TRUE;
 920         }
 921
 922         ready_status = tcore_sms_get_ready_status(co_sms);
 923         dbg("ready_status = %d", ready_status);
 924         telephony_sms_complete_get_sms_ready_status(sms, invocation, ready_status);
 925
 926         return TRUE;
 927 }
 928
 929 gboolean dbus_plugin_setup_sms_interface(TelephonyObjectSkeleton *object, struct custom_data *ctx)
 930 {
 931         TelephonySms *sms;
 932
 933         sms = telephony_sms_skeleton_new();
 934         telephony_object_skeleton_set_sms(object, sms);
 935         g_object_unref(sms);
 936
 937         g_signal_connect(sms,
 938                         "handle-send-msg",
 939                         G_CALLBACK (on_sms_send_msg),
 940                         ctx);
 941
 942         g_signal_connect(sms,
 943                         "handle-read-msg",
 944                         G_CALLBACK (on_sms_read_msg),
 945                         ctx);
 946
 947         g_signal_connect(sms,
 948                         "handle-save-msg",
 949                         G_CALLBACK (on_sms_save_msg),
 950                         ctx);
 951
 952         g_signal_connect(sms,
 953                         "handle-delete-msg",
 954                         G_CALLBACK (on_sms_delete_msg),
 955                         ctx);
 956
 957         g_signal_connect(sms,
 958                         "handle-get-msg-count",
 959                         G_CALLBACK (on_sms_get_msg_count),
 960                         ctx);
 961
 962         g_signal_connect(sms,
 963                         "handle-get-sca",
 964                         G_CALLBACK (on_sms_get_sca),
 965                         ctx);
 966
 967         g_signal_connect(sms,
 968                         "handle-set-sca",
 969                         G_CALLBACK (on_sms_set_sca),
 970                         ctx);
 971
 972         g_signal_connect(sms,
 973                         "handle-get-cb-config",
 974                         G_CALLBACK (on_sms_get_cb_config),
 975                         ctx);
 976
 977         g_signal_connect(sms,
 978                         "handle-set-cb-config",
 979                         G_CALLBACK (on_sms_set_cb_config),
 980                         ctx);
 981
 982         g_signal_connect(sms,
 983                         "handle-set-mem-status",
 984                         G_CALLBACK (on_sms_set_mem_status),
 985                         ctx);
 986
 987         g_signal_connect(sms,
 988                 "handle-get-pref-bearer",
 989                 G_CALLBACK (on_sms_get_pref_bearer),
 990                 ctx);
 991
 992         g_signal_connect(sms,
 993                         "handle-set-pref-bearer",
 994                         G_CALLBACK (on_sms_set_pref_bearer),
 995                         ctx);
 996
 997         g_signal_connect(sms,
 998                         "handle-set-delivery-report",
 999                         G_CALLBACK (on_sms_set_delivery_report),
1000                         ctx);
1001
1002         g_signal_connect(sms,
1003                         "handle-set-msg-status",
1004                         G_CALLBACK (on_sms_set_msg_status),
1005                         ctx);
1006
1007         g_signal_connect(sms,
1008                         "handle-get-sms-params",
1009                         G_CALLBACK (on_sms_get_sms_params),
1010                         ctx);
1011
1012         g_signal_connect(sms,
1013                         "handle-set-sms-params",
1014                         G_CALLBACK (on_sms_set_sms_params),
1015                         ctx);
1016
1017         g_signal_connect(sms,
1018                         "handle-get-sms-param-cnt",
1019                         G_CALLBACK (on_sms_get_sms_param_cnt),
1020                         ctx);
1021
1022         g_signal_connect(sms,
1023                         "handle-get-sms-ready-status",
1024                         G_CALLBACK (on_sms_get_sms_ready_status),
1025                         ctx);
1026
1027         return TRUE;
1028 }
1029
1030 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)
1031 {
1032         GSList *co_list;
1033         CoreObject *co_sms;
1034         char *modem_name = NULL;
1035         TcorePlugin *p = NULL;
1036         int i;
1037
1038         modem_name = tcore_user_request_get_modem_name(ur);
1039         if (!modem_name)
1040                 return FALSE;
1041
1042         p = tcore_server_find_plugin(ctx->server, modem_name);
1043         free(modem_name);
1044         if (!p)
1045                 return FALSE;
1046
1047         co_list = tcore_plugin_get_core_objects_bytype(p, CORE_OBJECT_TYPE_SMS);
1048         if (!co_list) {
1049                 return FALSE;
1050         }
1051
1052         co_sms = (CoreObject *)co_list->data;
1053         g_slist_free(co_list);
1054
1055         if (!co_sms) {
1056                 return FALSE;
1057         }
1058
1059         switch (command) {
1060                 case TRESP_SMS_SEND_UMTS_MSG: {
1061                         const struct tresp_sms_send_umts_msg *resp = data;
1062
1063                         dbg("receive TRESP_SMS_SEND_UMTS_MSG (result:[0x%x])", resp->result);
1064                         telephony_sms_complete_send_msg(dbus_info->interface_object, dbus_info->invocation, resp->result);
1065
1066                         }
1067                         break;
1068
1069                 case TRESP_SMS_SEND_CDMA_MSG: {
1070                         const struct tresp_sms_send_cdma_msg *resp = data;
1071
1072                         dbg("receive TRESP_SMS_SEND_CDMA_MSG (result:[0x%x])", resp->result);
1073                         }
1074                         break;
1075
1076                 case TRESP_SMS_READ_MSG: {
1077                         const struct tresp_sms_read_msg *resp = data;
1078                         GVariant *sca = 0, *packet_sca = 0;
1079                         GVariant *tpdu = 0, *packet_tpdu = 0;
1080                         GVariantBuilder b;
1081
1082                         dbg("receive TRESP_SMS_READ_MSG (result:[0x%x])", resp->result);
1083                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1084
1085                         for( i=0; i<SMS_SMSP_ADDRESS_LEN; i++) {
1086                                 g_variant_builder_add(&b, "y", resp->dataInfo.smsData.sca[i] );
1087                         }
1088                         sca = g_variant_builder_end(&b);
1089
1090                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1091
1092                         for( i=0; i<SMS_SMDATA_SIZE_MAX + 1; i++) {
1093                                 g_variant_builder_add(&b, "y", resp->dataInfo.smsData.tpduData[i] );
1094                         }
1095                         tpdu = g_variant_builder_end(&b);
1096
1097                         packet_sca = g_variant_new("v", sca);
1098                         packet_tpdu = g_variant_new("v", tpdu);
1099
1100                         telephony_sms_complete_read_msg(dbus_info->interface_object, dbus_info->invocation,
1101                                 resp->result,
1102                                 resp->dataInfo.simIndex,
1103                                 resp->dataInfo.msgStatus,
1104                                 packet_sca,
1105                                 resp->dataInfo.smsData.msgLength,
1106                                 packet_tpdu);
1107                         }
1108                         break;
1109
1110                 case TRESP_SMS_SAVE_MSG: {
1111                         const struct tresp_sms_save_msg *resp = data;
1112
1113                         dbg("receive TRESP_SMS_SAVE_MSG (result:[0x%x])", resp->result);
1114                         telephony_sms_complete_save_msg (dbus_info->interface_object, dbus_info->invocation,
1115                                 resp->result,
1116                                 resp->index);
1117                         }
1118                         break;
1119
1120                 case TRESP_SMS_DELETE_MSG: {
1121                         const struct tresp_sms_delete_msg *resp = data;
1122
1123                         dbg("receive TRESP_SMS_DELETE_MSG (result:[0x%x])", resp->result);
1124                         telephony_sms_complete_delete_msg(dbus_info->interface_object, dbus_info->invocation,
1125                                 resp->result, resp->index);
1126
1127                         }
1128                         break;
1129
1130                 case TRESP_SMS_GET_STORED_MSG_COUNT: {
1131                         const struct tresp_sms_get_storedMsgCnt *resp = data;
1132                         GVariant *list;
1133                         GVariantBuilder b;
1134                         unsigned int loop_var;
1135
1136                         dbg("receive TRESP_SMS_GET_STORED_MSG_COUNT (result:[0x%x])", resp->result);
1137                         g_variant_builder_init (&b, G_VARIANT_TYPE("ai"));
1138
1139                         for (loop_var=0; loop_var<resp->storedMsgCnt.totalCount; loop_var++) {
1140                                 g_variant_builder_add(&b, "i", resp->storedMsgCnt.indexList[loop_var]);
1141                         }
1142                         list = g_variant_builder_end(&b);
1143
1144                         telephony_sms_complete_get_msg_count(dbus_info->interface_object, dbus_info->invocation,
1145                                 resp->result,
1146                                 resp->storedMsgCnt.totalCount,
1147                                 resp->storedMsgCnt.usedCount,
1148                                 list);
1149                         }
1150                         break;
1151
1152                 case TRESP_SMS_GET_SCA: {
1153                         const struct tresp_sms_get_sca *resp = data;
1154                         GVariant *sca = 0, *packet_sca = 0;
1155                         GVariantBuilder b;
1156
1157                         dbg("receive TRESP_SMS_GET_SCA (result:[0x%x])", resp->result);
1158                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1159
1160                         for( i=0; i<SMS_SMSP_ADDRESS_LEN + 1; i++) {
1161                                 g_variant_builder_add(&b, "y", resp->scaAddress.diallingNum[i] );
1162                         }
1163                         sca = g_variant_builder_end(&b);
1164
1165                         packet_sca = g_variant_new("v", sca);
1166
1167                         telephony_sms_complete_get_sca(dbus_info->interface_object, dbus_info->invocation,
1168                                 resp->result,
1169                                 resp->scaAddress.typeOfNum,
1170                                 resp->scaAddress.numPlanId,
1171                                 resp->scaAddress.dialNumLen,
1172                                 packet_sca);
1173                         }
1174                         break;
1175
1176                 case TRESP_SMS_SET_SCA: {
1177                         const struct tresp_sms_set_sca *resp = data;
1178
1179                         dbg("receive TRESP_SMS_SET_SCA (result:[0x%x])", resp->result);
1180                         telephony_sms_complete_set_sca(dbus_info->interface_object, dbus_info->invocation,
1181                                 resp->result);
1182
1183                         }
1184                         break;
1185
1186                 case TRESP_SMS_GET_CB_CONFIG: {
1187                         const struct tresp_sms_get_cb_config *resp = data;
1188                         GVariant *result = NULL;
1189                         GVariantBuilder b;
1190
1191                         dbg("receive TRESP_SMS_GET_CB_CONFIG (result:[0x%x])", resp->result);
1192                         g_variant_builder_init(&b, G_VARIANT_TYPE("aa{sv}"));
1193
1194                         for (i = 0; i < resp->cbConfig.msgIdRangeCount; i++) {
1195                                 g_variant_builder_open(&b, G_VARIANT_TYPE("a{sv}"));
1196
1197                                 if( resp->cbConfig.net3gppType == SMS_NETTYPE_3GPP ) {
1198                                         g_variant_builder_add(&b, "{sv}", "FromMsgId", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp.fromMsgId));
1199                                         g_variant_builder_add(&b, "{sv}", "ToMsgId", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp.toMsgId));
1200                                 } else if( resp->cbConfig.net3gppType == SMS_NETTYPE_3GPP2) {
1201                                         g_variant_builder_add(&b, "{sv}", "CBCategory", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp2.cbCategory));
1202                                         g_variant_builder_add(&b, "{sv}", "CBLanguage", g_variant_new_uint16(resp->cbConfig.msgIDs[i].net3gpp2.cbLanguage));
1203                                 } else {
1204                                         dbg("Unknown 3gpp type");
1205                                         return FALSE;
1206                                 }
1207
1208                                 g_variant_builder_add(&b, "{sv}", "Selected", g_variant_new_byte(resp->cbConfig.msgIDs[i].net3gpp.selected));
1209
1210                                 g_variant_builder_close(&b);
1211                         }
1212
1213                         result = g_variant_builder_end(&b);
1214
1215                         telephony_sms_complete_get_cb_config(dbus_info->interface_object, dbus_info->invocation,
1216                                 resp->result,
1217                                 resp->cbConfig.net3gppType,
1218                                 resp->cbConfig.cbEnabled,
1219                                 resp->cbConfig.msgIdMaxCount,
1220                                 resp->cbConfig.msgIdRangeCount,
1221                                 result);
1222                         }
1223                         break;
1224
1225                 case TRESP_SMS_SET_CB_CONFIG: {
1226                         const struct tresp_sms_set_cb_config *resp = data;
1227
1228                         dbg("receive TRESP_SMS_SET_CB_CONFIG (result:[0x%x])", resp->result);
1229                         telephony_sms_complete_set_cb_config(dbus_info->interface_object, dbus_info->invocation,
1230                                 resp->result);
1231
1232                         }
1233                         break;
1234
1235                 case TRESP_SMS_SET_MEM_STATUS: {
1236                         const struct tresp_sms_set_mem_status *resp = data;
1237
1238                         dbg("receive TRESP_SMS_SET_MEM_STATUS (result:[0x%x])", resp->result);
1239                         telephony_sms_complete_set_mem_status(dbus_info->interface_object, dbus_info->invocation,
1240                                 resp->result);
1241
1242                         }
1243                         break;
1244                 case TRESP_SMS_GET_PREF_BEARER: {
1245                         const struct tresp_sms_get_pref_bearer *resp = data;
1246
1247                         dbg("receive TRESP_SMS_GET_PREF_BEARER (result:[0x%x])", resp->result);
1248                         telephony_sms_complete_get_pref_bearer(dbus_info->interface_object, dbus_info->invocation,
1249                                 resp->result);
1250
1251                         }
1252                         break;
1253
1254                 case TRESP_SMS_SET_PREF_BEARER: {
1255                         const struct tresp_sms_set_pref_bearer *resp = data;
1256
1257                         dbg("receive TRESP_SMS_SET_PREF_BEARER (result:[0x%x])", resp->result);
1258                         telephony_sms_complete_set_pref_bearer(dbus_info->interface_object, dbus_info->invocation,
1259                                 resp->result);
1260
1261                         }
1262                         break;
1263
1264                 case TRESP_SMS_SET_DELIVERY_REPORT: {
1265                         const struct tresp_sms_set_delivery_report *resp = data;
1266
1267                         dbg("receive TRESP_SMS_SET_DELIVERY_REPORT (result:[0x%x])", resp->result);
1268                         telephony_sms_complete_set_delivery_report(dbus_info->interface_object, dbus_info->invocation,
1269                                 resp->result);
1270
1271                         }
1272                         break;
1273
1274                 case TRESP_SMS_SET_MSG_STATUS: {
1275                         const struct tresp_sms_set_mem_status *resp = data;
1276
1277                         dbg("receive TRESP_SMS_SET_MSG_STATUS (result:[0x%x])", resp->result);
1278                         telephony_sms_complete_set_msg_status(dbus_info->interface_object, dbus_info->invocation,
1279                                 resp->result);
1280
1281                         }
1282                         break;
1283
1284                 case TRESP_SMS_GET_PARAMS: {
1285                         const struct tresp_sms_get_params *resp = data;
1286                         GVariant *alphaId = 0, *packet_alphaId = 0;
1287                         GVariant *destDialNum = 0, *packet_destDialNum = 0;
1288                         GVariant *scaDialNum = 0, *packet_scaDialNum = 0;
1289                         GVariantBuilder b;
1290
1291                         dbg("receive TRESP_SMS_GET_PARAMS (result:[0x%x])", resp->result);
1292                         g_variant_builder_init(&b, G_VARIANT_TYPE("ay"));
1293                         for( i=0; i<SMS_SMSP_ALPHA_ID_LEN_MAX + 1; i++) {
1294                                 g_variant_builder_add(&b, "y", resp->paramsInfo.szAlphaId[i] );
1295                         }
1296                         alphaId = g_variant_builder_end(&b);
1297
1298                         g_variant_builder_init(&b, G_VARIANT_TYPE("ay"));
1299                         for( i=0; i<SMS_SMSP_ADDRESS_LEN + 1; i++) {
1300                                 g_variant_builder_add(&b, "y", resp->paramsInfo.tpDestAddr.diallingNum[i] );
1301                         }
1302                         destDialNum = g_variant_builder_end(&b);
1303
1304                         g_variant_builder_init(&b, G_VARIANT_TYPE("ay"));
1305                         for( i=0; i<SMS_SMSP_ADDRESS_LEN + 1; i++) {
1306                                 g_variant_builder_add(&b, "y", resp->paramsInfo.tpSvcCntrAddr.diallingNum[i] );
1307                         }
1308                         scaDialNum = g_variant_builder_end(&b);
1309
1310                         packet_alphaId = g_variant_new("v", alphaId);
1311                         packet_destDialNum = g_variant_new("v", destDialNum);
1312                         packet_scaDialNum = g_variant_new("v", scaDialNum);
1313
1314                         telephony_sms_complete_get_sms_params(dbus_info->interface_object, dbus_info->invocation,
1315                                 resp->result,
1316                                 resp->paramsInfo.recordIndex,
1317                                 resp->paramsInfo.recordLen,
1318                                 resp->paramsInfo.alphaIdLen,
1319                                 packet_alphaId,
1320                                 resp->paramsInfo.paramIndicator,
1321                                 resp->paramsInfo.tpDestAddr.dialNumLen,
1322                                 resp->paramsInfo.tpDestAddr.typeOfNum,
1323                                 resp->paramsInfo.tpDestAddr.numPlanId,
1324                                 packet_destDialNum,
1325                                 resp->paramsInfo.tpSvcCntrAddr.dialNumLen,
1326                                 resp->paramsInfo.tpSvcCntrAddr.typeOfNum,
1327                                 resp->paramsInfo.tpSvcCntrAddr.numPlanId,
1328                                 packet_scaDialNum,
1329                                 resp->paramsInfo.tpProtocolId,
1330                                 resp->paramsInfo.tpDataCodingScheme,
1331                                 resp->paramsInfo.tpValidityPeriod);
1332                         }
1333                         break;
1334
1335                 case TRESP_SMS_SET_PARAMS:{
1336                         const struct tresp_sms_set_params *resp = data;
1337
1338                         dbg("receive TRESP_SMS_SET_PARAMS (result:[0x%x])", resp->result);
1339                         telephony_sms_complete_set_sms_params(dbus_info->interface_object, dbus_info->invocation,
1340                                 resp->result);
1341
1342                         }
1343                         break;
1344
1345                 case TRESP_SMS_GET_PARAMCNT: {
1346                         const struct tresp_sms_get_paramcnt *resp = data;
1347
1348                         dbg("receive TRESP_SMS_GET_PARAMCNT (result:[0x%x])", resp->result);
1349                         telephony_sms_complete_get_sms_param_cnt(dbus_info->interface_object, dbus_info->invocation,
1350                                 resp->result,
1351                                 resp->recordCount);
1352
1353                         }
1354                         break;
1355
1356                 default:
1357                         break;
1358         }
1359
1360         return TRUE;
1361 }
1362
1363 gboolean dbus_plugin_sms_notification(struct custom_data *ctx, CoreObject *source, TelephonyObjectSkeleton *object, enum tcore_notification_command command, unsigned int data_len, const void *data)
1364 {
1365         TelephonySms *sms;
1366         const char *cp_name;
1367
1368         cp_name = tcore_server_get_cp_name_by_plugin(tcore_object_ref_plugin(source));
1369
1370         sms = telephony_object_peek_sms(TELEPHONY_OBJECT(object));
1371
1372         switch (command) {
1373                 case TNOTI_SMS_INCOM_MSG: {
1374                         const struct tnoti_sms_umts_msg *noti = data;
1375
1376                         GVariant *sca = 0, *packet_sca = 0;
1377                         GVariant *tpdu = 0, *packet_tpdu = 0;
1378                         GVariantBuilder b;
1379                         unsigned int i;
1380
1381                         info("[DBUSINFO][%s] SMS_INCOM_MSG (len[%d])", cp_name, data_len);
1382
1383                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1384                         for( i=0; i<SMS_SMSP_ADDRESS_LEN; i++) {
1385                                 g_variant_builder_add(&b, "y", noti->msgInfo.sca[i] );
1386                         }
1387                         sca = g_variant_builder_end(&b);
1388
1389                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1390                         for( i=0; i<SMS_SMDATA_SIZE_MAX + 1; i++) {
1391                                 g_variant_builder_add(&b, "y", noti->msgInfo.tpduData[i] );
1392                         }
1393                         tpdu = g_variant_builder_end(&b);
1394
1395                         packet_sca = g_variant_new("v", sca);
1396                         packet_tpdu = g_variant_new("v", tpdu);
1397
1398                         telephony_sms_emit_incomming_msg(sms,
1399                                 packet_sca,
1400                                 noti->msgInfo.msgLength,
1401                                 packet_tpdu);
1402                         }
1403                         break;
1404
1405                 case TNOTI_SMS_CB_INCOM_MSG: {
1406                         const struct tnoti_sms_cellBroadcast_msg *noti = data;
1407                         GVariant *msgData = 0, *packet_msgData = 0;
1408                         GVariantBuilder b;
1409                         int i;
1410
1411                         info("[DBUSINFO][%s] SMS_CB_INCOM_MSG (len[%d])", cp_name, data_len);
1412
1413                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1414
1415                         for( i=0; i < (int)noti->cbMsg.length + 1; i++) {
1416                                 g_variant_builder_add(&b, "y", noti->cbMsg.msgData[i] );
1417                         }
1418                         msgData = g_variant_builder_end(&b);
1419                         packet_msgData = g_variant_new("v", msgData);
1420
1421                         telephony_sms_emit_incomming_cb_msg(sms,
1422                                 noti->cbMsg.cbMsgType,
1423                                 noti->cbMsg.length,
1424                                 packet_msgData);
1425                         }
1426                         break;
1427
1428                 case TNOTI_SMS_ETWS_INCOM_MSG: {
1429                         const struct tnoti_sms_etws_msg *noti = data;
1430                         GVariant *msgData = 0, *packet_msgData = 0;
1431                         GVariantBuilder b;
1432                         unsigned int i;
1433
1434                         info("[DBUSINFO][%s] ETWS_INCOM_MSG (len[%d])", cp_name, data_len);
1435
1436                         g_variant_builder_init (&b, G_VARIANT_TYPE("ay"));
1437
1438                         for( i=0; i<SMS_ETWS_SIZE_MAX + 1; i++) {
1439                                 g_variant_builder_add(&b, "y", noti->etwsMsg.msgData[i] );
1440                         }
1441                         msgData = g_variant_builder_end(&b);
1442                         packet_msgData = g_variant_new("v", msgData);
1443
1444                         telephony_sms_emit_incomming_etws_msg(sms,
1445                                 noti->etwsMsg.etwsMsgType,
1446                                 noti->etwsMsg.length,
1447                                 packet_msgData);
1448                         }
1449                         break;
1450
1451                 case TNOTI_SMS_INCOM_EX_MSG: {
1452                         info("[DBUSINFO][%s] SMS_INCOM_EX_MSG (len[%d])", cp_name, data_len);
1453                         }
1454                         break;
1455
1456                 case TNOTI_SMS_CB_INCOM_EX_MSG: {
1457                         info("[DBUSINFO][%s] CB_INCOM_EX_MSG (len[%d])", cp_name, data_len);
1458                         }
1459                         break;
1460
1461                 case TNOTI_SMS_MEMORY_STATUS: {
1462                         const struct tnoti_sms_memory_status *noti = data;
1463                         info("[DBUSINFO][%s] SMS_MEMORY_STATUS (%d)", cp_name, noti->status);
1464                         telephony_sms_emit_memory_status(sms, noti->status);
1465                         }
1466                         break;
1467
1468                 case TNOTI_SMS_DEVICE_READY: {
1469                         const struct tnoti_sms_ready_status *noti = data;
1470                         info("[DBUSINFO][%s] SMS_DEVICE_READY (%d)", cp_name, noti->status);
1471 #ifdef ENABLE_KPI_LOGS
1472                         if (noti->status == TRUE)
1473                                 TIME_CHECK("[%s] SMS Service Ready", cp_name);
1474 #endif
1475                         telephony_sms_emit_sms_ready(sms, noti->status);
1476
1477                         }
1478                         break;
1479
1480                 default:
1481                         dbg("unknown notification");
1482                         return FALSE;
1483                         break;
1484         }
1485
1486         return TRUE;
1487 }