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