proxy/MsgHandleSetting.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15 */
  16
  17 #include "MsgDebug.h"
  18 #include "MsgUtilFunction.h"
  19 #include "MsgCppTypes.h"
  20 #include "MsgException.h"
  21 #include "MsgHandle.h"
  22
  23
  24 #define MSG_NULL_CHECK(a) \
  25         do { \
  26                 if (a == NULL) { \
  27                         return MSG_ERR_NULL_POINTER; \
  28                 } \
  29         } while (0)
  30
  31 /*==================================================================================================
  32                                      IMPLEMENTATION OF MsgHandle - Setting Member Functions
  33 ==================================================================================================*/
  34
  35 msg_error_t MsgHandle::getSMSCOption(msg_struct_t msg_struct)
  36 {
  37         msg_struct_s *smsc_opt = (msg_struct_s *)msg_struct;
  38         MSG_TYPE_CHECK(smsc_opt->type, MSG_STRUCT_SETTING_SMSC_OPT);
  39         MSG_NULL_CHECK(smsc_opt->data);
  40
  41         /* Allocate Memory to Command Data */
  42         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T) + sizeof(msg_sim_slot_id_t);
  43
  44         char cmdBuf[cmdSize];
  45         bzero(cmdBuf, cmdSize);
  46         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
  47
  48         /* Set Command Parameters */
  49         pCmd->cmdType = MSG_CMD_GET_SMSC_OPT;
  50
  51         /* Set option type */
  52         MSG_OPTION_TYPE_T opt_type = MSG_SMSC_LIST;
  53
  54         /* Copy Cookie */
  55         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
  56
  57         /* Copy Command Data */
  58         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
  59
  60         msg_sim_slot_id_t simIndex = ((MSG_SMSC_LIST_HIDDEN_S *)smsc_opt->data)->simIndex;
  61         if (simIndex <= 0) {
  62                 THROW(MsgException::INVALID_PARAM, "Invalid SIM Index");
  63         }
  64         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_OPTION_TYPE_T)), &simIndex, sizeof(msg_sim_slot_id_t));
  65
  66         /* Send Command to Messaging FW */
  67         char* pEventData = NULL;
  68         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
  69
  70         write((char*)pCmd, cmdSize, &pEventData);
  71
  72         /* Get Return Data */
  73         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
  74
  75         if (pEvent->eventType != MSG_EVENT_GET_SMSC_OPT) {
  76                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
  77         }
  78
  79         if (pEvent->result == MSG_SUCCESS) {
  80                 MSG_SMSC_LIST_S smsc_list_tmp = {0, };
  81                 int dataSize = 0;
  82
  83                 dataSize = sizeof(MSG_SMSC_LIST_S);
  84                 memcpy(&smsc_list_tmp, pEvent->data, dataSize);
  85
  86                 MSG_SMSC_LIST_HIDDEN_S *pTmp = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt->data;
  87
  88                 pTmp->selected = smsc_list_tmp.selected;
  89                 pTmp->smsc_list->nCount = smsc_list_tmp.totalCnt;
  90                 pTmp->index = smsc_list_tmp.selected;
  91                 pTmp->simIndex = smsc_list_tmp.simIndex;
  92
  93                 msg_struct_s *pStructTmp = NULL;
  94
  95                 for (int i = 0; i < pTmp->smsc_list->nCount; i++) {
  96                         pStructTmp = (msg_struct_s *)pTmp->smsc_list->msg_struct_info[i];
  97                         memset(pStructTmp->data, 0x00, sizeof(MSG_SMSC_DATA_S));
  98                         memcpy(pStructTmp->data, &(smsc_list_tmp.smscData[i]), sizeof(MSG_SMSC_DATA_S));
  99                 }
 100         }
 101
 102         return pEvent->result;
 103 }
 104
 105
 106 msg_error_t MsgHandle::setSMSCOption(msg_struct_t msg_struct)
 107 {
 108         msg_struct_s *smsc_opt = (msg_struct_s *)msg_struct;
 109         MSG_TYPE_CHECK(smsc_opt->type, MSG_STRUCT_SETTING_SMSC_OPT);
 110         MSG_NULL_CHECK(smsc_opt->data);
 111
 112         /* Allocate Memory to Command Data */
 113         MSG_OPTION_TYPE_T optionType = MSG_SMSC_LIST;
 114         int cmdSize = getSettingCmdSize(optionType);
 115
 116         char cmdBuf[cmdSize];
 117         bzero(cmdBuf, cmdSize);
 118         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 119         int i = 0;
 120
 121         msg_struct_s *pTmp = (msg_struct_s *)msg_struct;
 122         MSG_SMSC_LIST_HIDDEN_S *pTmpList = (MSG_SMSC_LIST_HIDDEN_S *)pTmp->data;
 123
 124         MSG_SMSC_LIST_S smsc_list_tmp = {0, };
 125
 126         smsc_list_tmp.totalCnt = pTmpList->smsc_list->nCount;
 127         smsc_list_tmp.selected = pTmpList->selected;
 128         smsc_list_tmp.index = pTmpList->index;
 129         smsc_list_tmp.simIndex = pTmpList->simIndex;
 130
 131         if (smsc_list_tmp.totalCnt > SMSC_LIST_MAX) {
 132                 MSG_ERR("SMSC count is invaild value[Max:%d, Input:%d]", SMSC_LIST_MAX, smsc_list_tmp.totalCnt);
 133                 return MSG_ERR_INVALID_PARAMETER;
 134         }
 135
 136         MSG_DEBUG("SMSC totalcnt:%d selected:%d, index:%d ", smsc_list_tmp.totalCnt, smsc_list_tmp.selected, smsc_list_tmp.index);
 137
 138         msg_struct_s *pStructTmp = NULL;
 139
 140         for (i=0; i < smsc_list_tmp.totalCnt; i++) {
 141                 pStructTmp = (msg_struct_s *)pTmpList->smsc_list->msg_struct_info[i];
 142                 MSG_TYPE_CHECK(pStructTmp->type, MSG_STRUCT_SETTING_SMSC_INFO);
 143                 memcpy(&(smsc_list_tmp.smscData[i]), pStructTmp->data, sizeof(MSG_SMSC_DATA_S));
 144         }
 145
 146         /* Set Command Parameters */
 147         pCmd->cmdType = MSG_CMD_SET_SMSC_OPT;
 148
 149         /* Copy Cookie */
 150         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 151
 152         MSG_SETTING_S pSetting = {0, };
 153
 154         pSetting.type = optionType;
 155         memcpy(&(pSetting.option.smscList), &smsc_list_tmp, sizeof(MSG_SMSC_LIST_S));
 156
 157         /* Copy Command Data */
 158         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 159
 160         /* Send Command to Messaging FW */
 161         char* pEventData = NULL;
 162         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 163
 164         write((char*)pCmd, cmdSize, &pEventData);
 165
 166         /* Get Return Data */
 167         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 168
 169         if (pEvent->eventType != MSG_EVENT_SET_SMSC_OPT) {
 170                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 171         }
 172
 173         return pEvent->result;
 174 }
 175
 176
 177 msg_error_t MsgHandle::getCBOption(msg_struct_t msg_struct)
 178 {
 179         msg_struct_s *cb_opt = (msg_struct_s *)msg_struct;
 180         MSG_TYPE_CHECK(cb_opt->type, MSG_STRUCT_SETTING_CB_OPT);
 181         MSG_NULL_CHECK(cb_opt->data);
 182
 183         /* Allocate Memory to Command Data */
 184         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T) + sizeof(msg_sim_slot_id_t);
 185
 186         char cmdBuf[cmdSize];
 187         bzero(cmdBuf, cmdSize);
 188         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 189
 190         /* Set Command Parameters */
 191         pCmd->cmdType = MSG_CMD_GET_CB_OPT;
 192
 193         /* Set option type */
 194         MSG_OPTION_TYPE_T opt_type = MSG_CBMSG_OPT;
 195
 196         /* Copy Cookie */
 197         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 198
 199         /* Copy Command Data */
 200         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 201
 202         msg_sim_slot_id_t simIndex = ((MSG_CBMSG_OPT_HIDDEN_S*)cb_opt->data)->simIndex;
 203         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_OPTION_TYPE_T)), &simIndex, sizeof(msg_sim_slot_id_t));
 204
 205         /* Send Command to Messaging FW */
 206         char* pEventData = NULL;
 207         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 208
 209         write((char*)pCmd, cmdSize, &pEventData);
 210
 211         /* Get Return Data */
 212         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 213
 214         if (pEvent->eventType != MSG_EVENT_GET_CB_OPT) {
 215                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 216         }
 217
 218         if (pEvent->result == MSG_SUCCESS) {
 219                 int i = 0;
 220                 MSG_CBMSG_OPT_S cb_opt_tmp = {0, };
 221                 memcpy(&cb_opt_tmp, pEvent->data, sizeof(MSG_CBMSG_OPT_S));
 222
 223                 MSG_CBMSG_OPT_HIDDEN_S *pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
 224                 pTmp->bReceive = cb_opt_tmp.bReceive;
 225                 pTmp->maxSimCnt = cb_opt_tmp.maxSimCnt;
 226                 pTmp->simIndex = cb_opt_tmp.simIndex;
 227
 228                 for (i = 0; i < CB_LANG_TYPE_MAX; i++)
 229                         pTmp->bLanguage[i] = cb_opt_tmp.bLanguage[i];
 230
 231                 pTmp->channelData->nCount = cb_opt_tmp.channelData.channelCnt;
 232
 233                 msg_struct_s *pStructTmp = NULL;
 234
 235                 for (i = 0; i < pTmp->channelData->nCount; i++) {
 236                         pStructTmp = (msg_struct_s *)pTmp->channelData->msg_struct_info[i];
 237                         memset(pStructTmp->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
 238                         memcpy(pStructTmp->data, &(cb_opt_tmp.channelData.channelInfo[i]), sizeof(MSG_CB_CHANNEL_INFO_S));
 239                 }
 240         }
 241
 242         return pEvent->result;
 243 }
 244
 245
 246 msg_error_t MsgHandle::setCBOption(msg_struct_t msg_struct)
 247 {
 248         msg_struct_s *cb_opt = (msg_struct_s *)msg_struct;
 249         MSG_TYPE_CHECK(cb_opt->type, MSG_STRUCT_SETTING_CB_OPT);
 250         MSG_NULL_CHECK(cb_opt->data);
 251
 252         /* Allocate Memory to Command Data */
 253         MSG_OPTION_TYPE_T optionType = MSG_CBMSG_OPT;
 254         int cmdSize = getSettingCmdSize(optionType);
 255
 256         char cmdBuf[cmdSize];
 257         bzero(cmdBuf, cmdSize);
 258         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 259         int i = 0;
 260
 261         /* Set Command Parameters */
 262         pCmd->cmdType = MSG_CMD_SET_CB_OPT;
 263
 264         /* Copy Cookie */
 265         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 266
 267         /* Copy Command Data */
 268         MSG_CBMSG_OPT_S cb_opt_tmp = {0, };
 269         MSG_CBMSG_OPT_HIDDEN_S *cb_msg_opt = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
 270
 271         cb_opt_tmp.bReceive = cb_msg_opt->bReceive;
 272         cb_opt_tmp.maxSimCnt = cb_msg_opt->maxSimCnt;
 273         cb_opt_tmp.simIndex = cb_msg_opt->simIndex;
 274         for (int i = 0; i < CB_LANG_TYPE_MAX; i++)
 275                 cb_opt_tmp.bLanguage[i] = cb_msg_opt->bLanguage[i];
 276
 277         msg_struct_list_s *cb_ch_list = cb_msg_opt->channelData;
 278         msg_struct_s *pStructTmp = NULL;
 279
 280         cb_opt_tmp.channelData.channelCnt = cb_ch_list->nCount;
 281
 282         for (i = 0; i < cb_opt_tmp.channelData.channelCnt; i++) {
 283                 pStructTmp = (msg_struct_s *)cb_ch_list->msg_struct_info[i];
 284                 memcpy(&(cb_opt_tmp.channelData.channelInfo[i]), pStructTmp->data, sizeof(MSG_CB_CHANNEL_INFO_S));
 285         }
 286
 287         MSG_SETTING_S pSetting = {0, };
 288         pSetting.type = optionType;
 289
 290         memcpy(&(pSetting.option.cbMsgOpt), &cb_opt_tmp, sizeof(MSG_CBMSG_OPT_S));
 291
 292         /* Copy Command Data */
 293         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 294
 295         /* Send Command to Messaging FW */
 296         char* pEventData = NULL;
 297         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 298
 299         write((char*)pCmd, cmdSize, &pEventData);
 300
 301         /* Get Return Data */
 302         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 303
 304         if (pEvent->eventType != MSG_EVENT_SET_CB_OPT) {
 305                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 306         }
 307
 308         return pEvent->result;
 309 }
 310
 311
 312 msg_error_t MsgHandle::getSmsSendOpt(msg_struct_t msg_struct)
 313 {
 314         msg_struct_s *sms_send_opt = (msg_struct_s *)msg_struct;
 315         MSG_TYPE_CHECK(sms_send_opt->type, MSG_STRUCT_SETTING_SMS_SEND_OPT);
 316         MSG_NULL_CHECK(sms_send_opt->data);
 317
 318         /* Allocate Memory to Command Data */
 319         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
 320
 321         char cmdBuf[cmdSize];
 322         bzero(cmdBuf, cmdSize);
 323         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 324
 325         /* Set Command Parameters */
 326         pCmd->cmdType = MSG_CMD_GET_SMS_SEND_OPT;
 327
 328         /* Set option type */
 329         MSG_OPTION_TYPE_T opt_type = MSG_SMS_SENDOPT;
 330
 331         /* Copy Cookie */
 332         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 333
 334         /* Copy Command Data */
 335         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 336
 337         /* Send Command to Messaging FW */
 338         char* pEventData = NULL;
 339         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 340
 341         write((char*)pCmd, cmdSize, &pEventData);
 342
 343         /* Get Return Data */
 344         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 345
 346         if (pEvent->eventType != MSG_EVENT_GET_SMS_SEND_OPT) {
 347                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 348         }
 349
 350         if (pEvent->result == MSG_SUCCESS) {
 351                 memcpy(sms_send_opt->data, pEvent->data, sizeof(MSG_SMS_SENDOPT_S));
 352         }
 353
 354         return pEvent->result;
 355 }
 356
 357
 358 msg_error_t MsgHandle::setSmsSendOpt(msg_struct_t msg_struct)
 359 {
 360         msg_struct_s *sms_send_opt = (msg_struct_s *)msg_struct;
 361         MSG_TYPE_CHECK(sms_send_opt->type, MSG_STRUCT_SETTING_SMS_SEND_OPT);
 362         MSG_NULL_CHECK(sms_send_opt->data);
 363
 364         /* Allocate Memory to Command Data */
 365         MSG_OPTION_TYPE_T optionType = MSG_SMS_SENDOPT;
 366         int cmdSize = getSettingCmdSize(optionType);
 367
 368         char cmdBuf[cmdSize];
 369         bzero(cmdBuf, cmdSize);
 370         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 371
 372         /* Set Command Parameters */
 373         pCmd->cmdType = MSG_CMD_SET_SMS_SEND_OPT;
 374
 375         /* Copy Cookie */
 376         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 377
 378         /* Copy Command Data */
 379         MSG_SETTING_S pSetting = {0, };
 380         pSetting.type = optionType;
 381
 382         memcpy(&(pSetting.option.smsSendOpt), sms_send_opt->data, sizeof(MSG_SMS_SENDOPT_S));
 383
 384         /*py Command Data */
 385         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 386
 387         /* Send Command to Messaging FW */
 388         char* pEventData = NULL;
 389         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 390
 391         write((char*)pCmd, cmdSize, &pEventData);
 392
 393         /* Get Return Data */
 394         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 395
 396         if (pEvent->eventType != MSG_EVENT_SET_SMS_SEND_OPT) {
 397                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 398         }
 399
 400         return pEvent->result;
 401 }
 402
 403
 404 msg_error_t MsgHandle::getMmsSendOpt(msg_struct_t msg_struct)
 405 {
 406         msg_struct_s *mms_send_opt = (msg_struct_s *)msg_struct;
 407         MSG_TYPE_CHECK(mms_send_opt->type, MSG_STRUCT_SETTING_MMS_SEND_OPT);
 408         MSG_NULL_CHECK(mms_send_opt->data);
 409
 410         /* Allocate Memory to Command Data */
 411         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
 412
 413         char cmdBuf[cmdSize];
 414         bzero(cmdBuf, cmdSize);
 415         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 416
 417         /* Set Command Parameters */
 418         pCmd->cmdType = MSG_CMD_GET_MMS_SEND_OPT;
 419
 420         /* Set option type */
 421         MSG_OPTION_TYPE_T opt_type = MSG_MMS_SENDOPT;
 422
 423         /* Copy Cookie*/
 424         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 425
 426         /* Copy Command Data */
 427         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 428
 429         /* Send Command to Messaging FW */
 430         char* pEventData = NULL;
 431         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 432
 433         write((char*)pCmd, cmdSize, &pEventData);
 434
 435         /* Get Return Data */
 436         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 437
 438         if (pEvent->eventType != MSG_EVENT_GET_MMS_SEND_OPT) {
 439                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 440         }
 441
 442         if (pEvent->result == MSG_SUCCESS) {
 443                 memcpy(mms_send_opt->data, pEvent->data, sizeof(MSG_MMS_SENDOPT_S));
 444         }
 445
 446         return pEvent->result;
 447 }
 448
 449
 450 msg_error_t MsgHandle::setMmsSendOpt(msg_struct_t msg_struct)
 451 {
 452         msg_struct_s *mms_send_opt = (msg_struct_s *)msg_struct;
 453         MSG_TYPE_CHECK(mms_send_opt->type, MSG_STRUCT_SETTING_MMS_SEND_OPT);
 454         MSG_NULL_CHECK(mms_send_opt->data);
 455
 456         /* Allocate Memory to Command Data */
 457         MSG_OPTION_TYPE_T optionType = MSG_MMS_SENDOPT;
 458         int cmdSize = getSettingCmdSize(optionType);
 459
 460         char cmdBuf[cmdSize];
 461         bzero(cmdBuf, cmdSize);
 462         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 463
 464         /* Set Command Parameters */
 465         pCmd->cmdType = MSG_CMD_SET_MMS_SEND_OPT;
 466
 467         /* Copy Cookie */
 468         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 469
 470         /* Copy Command Data */
 471         MSG_SETTING_S pSetting = {0, };
 472         pSetting.type = optionType;
 473
 474         memcpy(&(pSetting.option.mmsSendOpt), mms_send_opt->data, sizeof(MSG_MMS_SENDOPT_S));
 475
 476         /* Copy Command Data */
 477         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 478
 479         /* Send Command to Messaging FW */
 480         char* pEventData = NULL;
 481         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 482
 483         write((char*)pCmd, cmdSize, &pEventData);
 484
 485         /* Get Return Data */
 486         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 487
 488         if (pEvent->eventType != MSG_EVENT_SET_MMS_SEND_OPT) {
 489                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 490         }
 491
 492         return pEvent->result;
 493 }
 494
 495
 496 msg_error_t MsgHandle::getMmsRecvOpt(msg_struct_t msg_struct)
 497 {
 498         msg_struct_s *mms_recv_opt = (msg_struct_s *)msg_struct;
 499         MSG_TYPE_CHECK(mms_recv_opt->type, MSG_STRUCT_SETTING_MMS_RECV_OPT);
 500         MSG_NULL_CHECK(mms_recv_opt->data);
 501
 502         /* Allocate Memory to Command Data */
 503         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
 504
 505         char cmdBuf[cmdSize];
 506         bzero(cmdBuf, cmdSize);
 507         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 508
 509         /* Set Command Parameters */
 510         pCmd->cmdType = MSG_CMD_GET_MMS_RECV_OPT;
 511
 512         /* Set option type */
 513         MSG_OPTION_TYPE_T opt_type = MSG_MMS_RECVOPT;
 514
 515         /* Copy Cookie */
 516         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 517
 518         /* Copy Command Data */
 519         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 520
 521         /* Send Command to Messaging FW */
 522         char* pEventData = NULL;
 523         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 524
 525         write((char*)pCmd, cmdSize, &pEventData);
 526
 527         /* Get Return Data */
 528         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 529
 530         if (pEvent->eventType != MSG_EVENT_GET_MMS_RECV_OPT) {
 531                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 532         }
 533
 534         if (pEvent->result == MSG_SUCCESS) {
 535                 memcpy(mms_recv_opt->data, pEvent->data, sizeof(MSG_MMS_RECVOPT_S));
 536         }
 537
 538         return pEvent->result;
 539 }
 540
 541
 542 msg_error_t MsgHandle::setMmsRecvOpt(msg_struct_t msg_struct)
 543 {
 544         msg_struct_s *mms_recv_opt = (msg_struct_s *)msg_struct;
 545         MSG_TYPE_CHECK(mms_recv_opt->type, MSG_STRUCT_SETTING_MMS_RECV_OPT);
 546         MSG_NULL_CHECK(mms_recv_opt->data);
 547
 548         /* Allocate Memory to Command Data */
 549         MSG_OPTION_TYPE_T optionType = MSG_MMS_RECVOPT;
 550         int cmdSize = getSettingCmdSize(optionType);
 551
 552         char cmdBuf[cmdSize];
 553         bzero(cmdBuf, cmdSize);
 554         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 555
 556         /* Set Command Parameters */
 557         pCmd->cmdType = MSG_CMD_SET_MMS_RECV_OPT;
 558
 559         /* Copy Cookie */
 560         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 561
 562         /* Copy Command Data */
 563         MSG_SETTING_S pSetting = {0, };
 564         pSetting.type = optionType;
 565
 566         memcpy(&(pSetting.option.mmsRecvOpt), mms_recv_opt->data, sizeof(MSG_MMS_RECVOPT_S));
 567
 568         /* Copy Command Data */
 569         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 570
 571         /* Send Command to Messaging FW */
 572         char* pEventData = NULL;
 573         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 574
 575         write((char*)pCmd, cmdSize, &pEventData);
 576
 577         /* Get Return Data */
 578         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 579
 580         if (pEvent->eventType != MSG_EVENT_SET_MMS_RECV_OPT) {
 581                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 582         }
 583
 584         return pEvent->result;
 585 }
 586
 587
 588 msg_error_t MsgHandle::getPushMsgOpt(msg_struct_t msg_struct)
 589 {
 590         msg_struct_s *push_opt = (msg_struct_s *)msg_struct;
 591         MSG_TYPE_CHECK(push_opt->type, MSG_STRUCT_SETTING_PUSH_MSG_OPT);
 592         MSG_NULL_CHECK(push_opt->data);
 593
 594         /* Allocate Memory to Command Data */
 595         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
 596
 597         char cmdBuf[cmdSize];
 598         bzero(cmdBuf, cmdSize);
 599         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 600
 601         /* Set Command Parameters */
 602         pCmd->cmdType = MSG_CMD_GET_PUSH_MSG_OPT;
 603
 604         /* Set option type */
 605         MSG_OPTION_TYPE_T opt_type = MSG_PUSHMSG_OPT;
 606
 607         /* Copy Cookie */
 608         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 609
 610         /* Copy Command Data */
 611         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 612
 613         /* Send Command to Messaging FW */
 614         char* pEventData = NULL;
 615         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 616
 617         write((char*)pCmd, cmdSize, &pEventData);
 618
 619         /* Get Return Data */
 620         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 621
 622         if (pEvent->eventType != MSG_EVENT_GET_PUSH_MSG_OPT) {
 623                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 624         }
 625
 626         if (pEvent->result == MSG_SUCCESS) {
 627                 memcpy(push_opt->data, pEvent->data, sizeof(MSG_PUSHMSG_OPT_S));
 628         }
 629
 630         return pEvent->result;
 631 }
 632
 633
 634 msg_error_t MsgHandle::setPushMsgOpt(msg_struct_t msg_struct)
 635 {
 636         msg_struct_s *push_opt = (msg_struct_s *)msg_struct;
 637         MSG_TYPE_CHECK(push_opt->type, MSG_STRUCT_SETTING_PUSH_MSG_OPT);
 638         MSG_NULL_CHECK(push_opt->data);
 639
 640         /* Allocate Memory to Command Data */
 641         MSG_OPTION_TYPE_T optionType = MSG_PUSHMSG_OPT;
 642         int cmdSize = getSettingCmdSize(optionType);
 643
 644         char cmdBuf[cmdSize];
 645         bzero(cmdBuf, cmdSize);
 646         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 647
 648         /* Set Command Parameters */
 649         pCmd->cmdType = MSG_CMD_SET_PUSH_MSG_OPT;
 650
 651         /* Copy Cookie */
 652         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 653
 654         /* Copy Command Data */
 655         MSG_SETTING_S pSetting = {0, };
 656         pSetting.type = optionType;
 657
 658         memcpy(&(pSetting.option.pushMsgOpt), push_opt->data, sizeof(MSG_PUSHMSG_OPT_S));
 659
 660         /* Copy Command Data */
 661         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 662
 663         /* Send Command to Messaging FW */
 664         char* pEventData = NULL;
 665         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 666
 667         write((char*)pCmd, cmdSize, &pEventData);
 668
 669         /* Get Return Data */
 670         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 671
 672         if (pEvent->eventType != MSG_EVENT_SET_PUSH_MSG_OPT) {
 673                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 674         }
 675
 676         return pEvent->result;
 677 }
 678
 679
 680 msg_error_t MsgHandle::getVoiceMsgOpt(msg_struct_t msg_struct)
 681 {
 682         msg_struct_s *voice_opt = (msg_struct_s *)msg_struct;
 683         MSG_TYPE_CHECK(voice_opt->type, MSG_STRUCT_SETTING_VOICE_MSG_OPT);
 684         MSG_NULL_CHECK(voice_opt->data);
 685
 686         /* Allocate Memory to Command Data */
 687         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T) + sizeof(msg_sim_slot_id_t);
 688
 689         char cmdBuf[cmdSize];
 690         bzero(cmdBuf, cmdSize);
 691         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 692
 693         /* Set Command Parameters */
 694         pCmd->cmdType = MSG_CMD_GET_VOICE_MSG_OPT;
 695
 696         /* Set option type */
 697         MSG_OPTION_TYPE_T opt_type = MSG_VOICEMAIL_OPT;
 698
 699         /* Copy Cookie */
 700         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 701
 702         /* Copy Command Data */
 703         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 704
 705         msg_sim_slot_id_t simIndex = ((MSG_VOICEMAIL_OPT_S *)voice_opt->data)->simIndex;
 706         if (simIndex <= 0) {
 707                 THROW(MsgException::INVALID_PARAM, "Invalid SIM Index : [index=%d]", simIndex);
 708         }
 709         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN+sizeof(MSG_OPTION_TYPE_T)), &simIndex, sizeof(msg_sim_slot_id_t));
 710
 711         /* Send Command to Messaging FW */
 712         char* pEventData = NULL;
 713         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 714
 715         write((char*)pCmd, cmdSize, &pEventData);
 716
 717         /* Get Return Data */
 718         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 719
 720         if (pEvent->eventType != MSG_EVENT_GET_VOICE_MSG_OPT) {
 721                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 722         }
 723
 724         if (pEvent->result == MSG_SUCCESS) {
 725                 memcpy(voice_opt->data, pEvent->data, sizeof(MSG_VOICEMAIL_OPT_S));
 726         }
 727
 728         return pEvent->result;
 729 }
 730
 731
 732 msg_error_t MsgHandle::setVoiceMsgOpt(msg_struct_t msg_struct)
 733 {
 734         msg_struct_s *voice_opt = (msg_struct_s *)msg_struct;
 735         MSG_TYPE_CHECK(voice_opt->type, MSG_STRUCT_SETTING_VOICE_MSG_OPT);
 736         MSG_NULL_CHECK(voice_opt->data);
 737
 738         /* Allocate Memory to Command Data */
 739         MSG_OPTION_TYPE_T optionType = MSG_VOICEMAIL_OPT;
 740         int cmdSize = getSettingCmdSize(optionType);
 741
 742         char cmdBuf[cmdSize];
 743         bzero(cmdBuf, cmdSize);
 744         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 745
 746         /* Set Command Parameters */
 747         pCmd->cmdType = MSG_CMD_SET_VOICE_MSG_OPT;
 748
 749         /* Copy Cookie */
 750         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 751
 752         /* Copy Command Data */
 753         MSG_SETTING_S pSetting = {0, };
 754         pSetting.type = optionType;
 755
 756         memcpy(&(pSetting.option.voiceMailOpt), voice_opt->data, sizeof(MSG_VOICEMAIL_OPT_S));
 757
 758         /* Copy Command Data */
 759         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 760
 761         /* Send Command to Messaging FW */
 762         char* pEventData = NULL;
 763         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 764
 765         write((char*)pCmd, cmdSize, &pEventData);
 766
 767         /* Get Return Data */
 768         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 769
 770         if (pEvent->eventType != MSG_EVENT_SET_VOICE_MSG_OPT) {
 771                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 772         }
 773
 774         return pEvent->result;
 775 }
 776
 777
 778 msg_error_t MsgHandle::getGeneralOpt(msg_struct_t msg_struct)
 779 {
 780         msg_struct_s *general_opt = (msg_struct_s *)msg_struct;
 781         MSG_TYPE_CHECK(general_opt->type, MSG_STRUCT_SETTING_GENERAL_OPT);
 782         MSG_NULL_CHECK(general_opt->data);
 783
 784         /* Allocate Memory to Command Data */
 785         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
 786
 787         char cmdBuf[cmdSize];
 788         bzero(cmdBuf, cmdSize);
 789         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 790
 791         /* Set Command Parameters */
 792         pCmd->cmdType = MSG_CMD_GET_GENERAL_MSG_OPT;
 793
 794         /* Set option type */
 795         MSG_OPTION_TYPE_T opt_type = MSG_GENERAL_OPT;
 796
 797         /* Copy Cookie */
 798         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 799
 800         /* Copy Command Data */
 801         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 802
 803         /* Send Command to Messaging FW */
 804         char* pEventData = NULL;
 805         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 806
 807         write((char*)pCmd, cmdSize, &pEventData);
 808
 809         /* Get Return Data */
 810         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 811
 812         if (pEvent->eventType != MSG_EVENT_GET_GENERAL_MSG_OPT) {
 813                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 814         }
 815
 816         if (pEvent->result == MSG_SUCCESS) {
 817                 memcpy(general_opt->data, pEvent->data, sizeof(MSG_GENERAL_OPT_S));
 818         }
 819
 820         return pEvent->result;
 821 }
 822
 823
 824 msg_error_t MsgHandle::setGeneralOpt(msg_struct_t msg_struct)
 825 {
 826         msg_struct_s *general_opt = (msg_struct_s *)msg_struct;
 827         MSG_TYPE_CHECK(general_opt->type, MSG_STRUCT_SETTING_GENERAL_OPT);
 828         MSG_NULL_CHECK(general_opt->data);
 829
 830         /* Allocate Memory to Command Data */
 831         MSG_OPTION_TYPE_T optionType = MSG_GENERAL_OPT;
 832         int cmdSize = getSettingCmdSize(optionType);
 833
 834         char cmdBuf[cmdSize];
 835         bzero(cmdBuf, cmdSize);
 836         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 837
 838         /* Set Command Parameters */
 839         pCmd->cmdType = MSG_CMD_SET_GENERAL_MSG_OPT;
 840
 841         /* Copy Cookie */
 842         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 843
 844         /* Copy Command Data */
 845         MSG_SETTING_S pSetting = {0, };
 846         pSetting.type = optionType;
 847
 848         memcpy(&(pSetting.option.generalOpt), general_opt->data, sizeof(MSG_GENERAL_OPT_S));
 849
 850         /* Copy Command Data */
 851         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 852
 853         /* Send Command to Messaging FW */
 854         char* pEventData = NULL;
 855         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 856
 857         write((char*)pCmd, cmdSize, &pEventData);
 858
 859         /* Get Return Data */
 860         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 861
 862         if (pEvent->eventType != MSG_EVENT_SET_GENERAL_MSG_OPT) {
 863                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 864         }
 865
 866         return pEvent->result;
 867 }
 868
 869
 870 msg_error_t MsgHandle::getMsgSizeOpt(msg_struct_t msg_struct)
 871 {
 872         msg_struct_s *msg_size_opt = (msg_struct_s *)msg_struct;
 873         MSG_TYPE_CHECK(msg_size_opt->type, MSG_STRUCT_SETTING_MSGSIZE_OPT);
 874         MSG_NULL_CHECK(msg_size_opt->data);
 875
 876         /* Allocate Memory to Command Data */
 877         int cmdSize = sizeof(MSG_CMD_S) + sizeof(MSG_OPTION_TYPE_T);
 878
 879         char cmdBuf[cmdSize];
 880         bzero(cmdBuf, cmdSize);
 881         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 882
 883         /* Set Command Parameters */
 884         pCmd->cmdType = MSG_CMD_GET_MSG_SIZE_OPT;
 885
 886         /* Set option type */
 887         MSG_OPTION_TYPE_T opt_type = MSG_MSGSIZE_OPT;
 888
 889         /* Copy Cookie */
 890         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 891
 892         /* Copy Command Data */
 893         memcpy((void*)((char*)pCmd+sizeof(MSG_CMD_TYPE_T)+MAX_COOKIE_LEN), &opt_type, sizeof(MSG_OPTION_TYPE_T));
 894
 895         /* Send Command to Messaging FW */
 896         char* pEventData = NULL;
 897         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 898
 899         write((char*)pCmd, cmdSize, &pEventData);
 900
 901         /* Get Return Data */
 902         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 903
 904         if (pEvent->eventType != MSG_EVENT_GET_MSG_SIZE_OPT) {
 905                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 906         }
 907
 908         if (pEvent->result == MSG_SUCCESS) {
 909                 memcpy(msg_size_opt->data, pEvent->data, sizeof(MSG_MSGSIZE_OPT_S));
 910         }
 911
 912         return pEvent->result;
 913 }
 914
 915
 916 msg_error_t MsgHandle::setMsgSizeOpt(msg_struct_t msg_struct)
 917 {
 918         msg_struct_s *msg_size_opt = (msg_struct_s *)msg_struct;
 919         MSG_TYPE_CHECK(msg_size_opt->type, MSG_STRUCT_SETTING_MSGSIZE_OPT);
 920         MSG_NULL_CHECK(msg_size_opt->data);
 921
 922         /* Allocate Memory to Command Data */
 923         MSG_OPTION_TYPE_T optionType = MSG_MSGSIZE_OPT;
 924         int cmdSize = getSettingCmdSize(optionType);
 925
 926         char cmdBuf[cmdSize];
 927         bzero(cmdBuf, cmdSize);
 928         MSG_CMD_S* pCmd = (MSG_CMD_S*)cmdBuf;
 929
 930         /* Set Command Parameters */
 931         pCmd->cmdType = MSG_CMD_SET_MSG_SIZE_OPT;
 932
 933         /* Copy Cookie */
 934         memcpy(pCmd->cmdCookie, mCookie, MAX_COOKIE_LEN);
 935
 936         /* Copy Command Data */
 937         MSG_SETTING_S pSetting = {0, };
 938         pSetting.type = optionType;
 939
 940         memcpy(&(pSetting.option.msgSizeOpt), msg_size_opt->data, sizeof(MSG_MSGSIZE_OPT_S));
 941
 942         /* Copy Command Data */
 943         memcpy(pCmd->cmdData, &pSetting, cmdSize-sizeof(MSG_CMD_S));
 944
 945         /* Send Command to Messaging FW */
 946         char* pEventData = NULL;
 947         unique_ptr<char*, void(*)(char**)> eventBuf(&pEventData, unique_ptr_deleter);
 948
 949         write((char*)pCmd, cmdSize, &pEventData);
 950
 951         /* Get Return Data */
 952         MSG_EVENT_S* pEvent = (MSG_EVENT_S*)pEventData;
 953
 954         if (pEvent->eventType != MSG_EVENT_SET_MSG_SIZE_OPT) {
 955                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 956         }
 957
 958         return pEvent->result;
 959 }