proxy/MsgHandleSetting.cpp

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