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         {
  77                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
  78         }
  79
  80         if (pEvent->result == MSG_SUCCESS) {
  81                 MSG_SMSC_LIST_S smsc_list_tmp = {0,};
  82                 int dataSize = 0;
  83
  84                 dataSize = sizeof(MSG_SMSC_LIST_S);
  85                 memcpy(&smsc_list_tmp, pEvent->data, dataSize);
  86
  87                 MSG_SMSC_LIST_HIDDEN_S *pTmp = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt->data;
  88
  89                 pTmp->selected = smsc_list_tmp.selected;
  90                 pTmp->smsc_list->nCount = smsc_list_tmp.totalCnt;
  91                 pTmp->index = smsc_list_tmp.selected;
  92                 pTmp->simIndex = smsc_list_tmp.simIndex;
  93
  94                 msg_struct_s *pStructTmp = NULL;
  95
  96                 for (int i = 0; i < pTmp->smsc_list->nCount; i++) {
  97                         pStructTmp = (msg_struct_s *)pTmp->smsc_list->msg_struct_info[i];
  98                         memset(pStructTmp->data, 0x00, sizeof(MSG_SMSC_DATA_S));
  99                         memcpy(pStructTmp->data, &(smsc_list_tmp.smscData[i]), sizeof(MSG_SMSC_DATA_S));
 100                 }
 101         }
 102
 103         return pEvent->result;
 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         {
 171                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 172         }
 173
 174         return pEvent->result;
 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         {
 216                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 217         }
 218
 219         if (pEvent->result == MSG_SUCCESS) {
 220                 int i = 0;
 221                 MSG_CBMSG_OPT_S cb_opt_tmp = {0,};
 222                 memcpy(&cb_opt_tmp, pEvent->data, sizeof(MSG_CBMSG_OPT_S));
 223
 224                 MSG_CBMSG_OPT_HIDDEN_S *pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt->data;
 225                 pTmp->bReceive = cb_opt_tmp.bReceive;
 226                 pTmp->maxSimCnt = cb_opt_tmp.maxSimCnt;
 227                 pTmp->simIndex = cb_opt_tmp.simIndex;
 228
 229                 for (i = 0; i < CB_LANG_TYPE_MAX; i++)
 230                         pTmp->bLanguage[i] = cb_opt_tmp.bLanguage[i];
 231
 232                 pTmp->channelData->nCount = cb_opt_tmp.channelData.channelCnt;
 233
 234                 msg_struct_s *pStructTmp = NULL;
 235
 236                 for (i = 0; i < pTmp->channelData->nCount; i++) {
 237                         pStructTmp = (msg_struct_s *)pTmp->channelData->msg_struct_info[i];
 238                         memset(pStructTmp->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
 239                         memcpy(pStructTmp->data, &(cb_opt_tmp.channelData.channelInfo[i]), sizeof(MSG_CB_CHANNEL_INFO_S));
 240                 }
 241         }
 242
 243         return pEvent->result;
 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         {
 306                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 307         }
 308
 309         return pEvent->result;
 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         {
 348                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 349         }
 350
 351         if (pEvent->result == MSG_SUCCESS) {
 352                 memcpy(sms_send_opt->data, pEvent->data, sizeof(MSG_SMS_SENDOPT_S));
 353         }
 354
 355         return pEvent->result;
 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     // Copy 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         {
 398                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 399         }
 400
 401         return pEvent->result;
 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         {
 440                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 441         }
 442
 443         if (pEvent->result == MSG_SUCCESS) {
 444                 memcpy(mms_send_opt->data, pEvent->data, sizeof(MSG_MMS_SENDOPT_S));
 445         }
 446
 447         return pEvent->result;
 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         {
 490                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 491         }
 492
 493         return pEvent->result;
 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         {
 532                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 533         }
 534
 535         if (pEvent->result == MSG_SUCCESS) {
 536                 memcpy(mms_recv_opt->data, pEvent->data, sizeof(MSG_MMS_RECVOPT_S));
 537         }
 538
 539         return pEvent->result;
 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         {
 582                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 583         }
 584
 585         return pEvent->result;
 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         {
 624                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 625         }
 626
 627         if (pEvent->result == MSG_SUCCESS) {
 628                 memcpy(push_opt->data, pEvent->data, sizeof(MSG_PUSHMSG_OPT_S));
 629         }
 630
 631         return pEvent->result;
 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         {
 674                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 675         }
 676
 677         return pEvent->result;
 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         {
 722                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 723         }
 724
 725         if (pEvent->result == MSG_SUCCESS) {
 726                 memcpy(voice_opt->data, pEvent->data, sizeof(MSG_VOICEMAIL_OPT_S));
 727         }
 728
 729         return pEvent->result;
 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         {
 772                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 773         }
 774
 775         return pEvent->result;
 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         {
 814                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 815         }
 816
 817         if (pEvent->result == MSG_SUCCESS) {
 818                 memcpy(general_opt->data, pEvent->data, sizeof(MSG_GENERAL_OPT_S));
 819         }
 820
 821         return pEvent->result;
 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         {
 864                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 865         }
 866
 867         return pEvent->result;
 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         {
 906                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 907         }
 908
 909         if (pEvent->result == MSG_SUCCESS) {
 910                 memcpy(msg_size_opt->data, pEvent->data, sizeof(MSG_MSGSIZE_OPT_S));
 911         }
 912
 913         return pEvent->result;
 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         {
 956                 THROW(MsgException::INVALID_RESULT, "Event Data Error");
 957         }
 958
 959         return pEvent->result;
 960 }