mapi/msg_setting.cpp

   1 /*
   2 * Copyright 2012-2013  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.1 (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://floralicense.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 <errno.h>
  18 #include <MsgException.h>
  19 #include "MsgHandle.h"
  20 #include "MsgDebug.h"
  21
  22 #include "msg_private.h"
  23 #include "msg.h"
  24
  25 /*******************************************************************************
  26  *                                                                       SMSC                                                                  *
  27  *******************************************************************************/
  28
  29 int msg_setting_get_int_value(msg_struct_s *msg_struct, int field, int *value)
  30 {
  31         int err = MSG_SUCCESS;
  32
  33         switch (msg_struct->type) {
  34         case MSG_STRUCT_SETTING_SMSC_OPT :
  35                 *value = msg_get_smsc_opt_int(msg_struct->data, field);
  36                 break;
  37         case MSG_STRUCT_SETTING_SMSC_INFO :
  38                 *value = msg_get_smsc_info_int(msg_struct->data, field);
  39                 break;
  40         case MSG_STRUCT_SETTING_CB_OPT :
  41                 *value = msg_get_cb_option_int(msg_struct->data, field);
  42                 break;
  43         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
  44                 *value = msg_get_cb_channel_info_int(msg_struct->data, field);
  45                 break;
  46         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
  47                 *value = msg_get_sms_send_opt_int(msg_struct->data, field);
  48                 break;
  49         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
  50                 *value = msg_get_mms_send_opt_int(msg_struct->data, field);
  51                 break;
  52         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
  53                 *value = msg_get_mms_recv_opt_int(msg_struct->data, field);
  54                 break;
  55         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
  56                 *value = msg_get_push_msg_opt_int(msg_struct->data, field);
  57                 break;
  58         case MSG_STRUCT_SETTING_GENERAL_OPT :
  59                 *value = msg_get_general_opt_int(msg_struct->data, field);
  60                 break;
  61         case MSG_STRUCT_SETTING_MSGSIZE_OPT :
  62                 *value = msg_get_msgsize_opt_int(msg_struct->data, field);
  63                 break;
  64         default :
  65                 err = MSG_ERR_INVALID_PARAMETER;
  66                 break;
  67         }
  68
  69         return err;
  70 }
  71
  72 int msg_setting_get_str_value(msg_struct_s *msg_struct, int field, char *src, int size)
  73 {
  74         int err = MSG_SUCCESS;
  75         char *ret_str = NULL;
  76
  77         switch (msg_struct->type)
  78         {
  79         case MSG_STRUCT_SETTING_SMSC_INFO :
  80                 ret_str = msg_get_smsc_info_str(msg_struct->data, field);
  81                 if (ret_str == NULL)
  82                         err = MSG_ERR_UNKNOWN;
  83                 else
  84                         strncpy(src, ret_str, size);
  85                 break;
  86         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
  87                 ret_str = msg_get_cb_channel_info_str(msg_struct->data, field);
  88                 if (ret_str == NULL)
  89                         err = MSG_ERR_UNKNOWN;
  90                 else
  91                         strncpy(src, ret_str, size);
  92                 break;
  93         case MSG_STRUCT_SETTING_VOICE_MSG_OPT :
  94                 ret_str = msg_get_voice_msg_opt_str(msg_struct->data, field);
  95                 if (ret_str == NULL)
  96                         err = MSG_ERR_UNKNOWN;
  97                 else
  98                         strncpy(src, ret_str, size);
  99                 break;
 100         default :
 101                 err = MSG_ERR_INVALID_PARAMETER;
 102                 break;
 103         }
 104
 105         return err;
 106 }
 107
 108 int msg_setting_get_bool_value(msg_struct_s *msg_struct, int field, bool *value)
 109 {
 110         int err = MSG_SUCCESS;
 111
 112         switch (msg_struct->type) {
 113         case MSG_STRUCT_SETTING_CB_OPT :
 114                 *value = msg_get_cb_option_bool(msg_struct->data, field);
 115                 break;
 116         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 117                 *value = msg_get_cb_channel_info_bool(msg_struct->data, field);
 118                 break;
 119         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
 120                 *value = msg_get_sms_send_opt_bool(msg_struct->data, field);
 121                 break;
 122         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
 123                 *value = msg_get_mms_send_opt_bool(msg_struct->data, field);
 124                 break;
 125         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
 126                 *value = msg_get_mms_recv_opt_bool(msg_struct->data, field);
 127                 break;
 128         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
 129                 *value = msg_get_push_msg_opt_bool(msg_struct->data, field);
 130                 break;
 131         case MSG_STRUCT_SETTING_GENERAL_OPT :
 132                 *value = msg_get_general_opt_bool(msg_struct->data, field);
 133                 break;
 134         default :
 135                 err = MSG_ERR_INVALID_PARAMETER;
 136                 break;
 137         }
 138
 139         return err;
 140 }
 141
 142 int msg_setting_get_list_handle(msg_struct_s *msg_struct, int field, void **value)
 143 {
 144         int err = MSG_SUCCESS;
 145
 146         switch (msg_struct->type) {
 147         case MSG_STRUCT_SETTING_SMSC_OPT :
 148                 err = msg_get_smsc_opt_list(msg_struct->data, field, value);
 149                 break;
 150         case MSG_STRUCT_SETTING_CB_OPT :
 151                 err = msg_get_cb_option_list(msg_struct->data, field, value);
 152                 break;
 153         default :
 154                 break;
 155         }
 156
 157         return err;
 158 }
 159
 160 int msg_setting_set_int_value(msg_struct_s *msg_struct, int field, int value)
 161 {
 162         int err = MSG_SUCCESS;
 163
 164         switch (msg_struct->type) {
 165         case MSG_STRUCT_SETTING_SMSC_OPT :
 166                 err = msg_set_smsc_opt_int(msg_struct->data, field, value);
 167                 break;
 168         case MSG_STRUCT_SETTING_SMSC_INFO :
 169                 err = msg_set_smsc_info_int(msg_struct->data, field, value);
 170                 break;
 171         case MSG_STRUCT_SETTING_CB_OPT :
 172                 err = msg_set_cb_option_int(msg_struct->data, field, value);
 173                 break;
 174         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 175                 err = msg_set_cb_channel_info_int(msg_struct->data, field, value);
 176                 break;
 177         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
 178                 err = msg_set_sms_send_opt_int(msg_struct->data, field, value);
 179                 break;
 180         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
 181                 err = msg_set_mms_send_opt_int(msg_struct->data, field, value);
 182                 break;
 183         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
 184                 err = msg_set_mms_recv_opt_int(msg_struct->data, field, value);
 185                 break;
 186         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
 187                 err = msg_set_push_msg_opt_int(msg_struct->data, field, value);
 188                 break;
 189         case MSG_STRUCT_SETTING_GENERAL_OPT :
 190                 err = msg_set_general_opt_int(msg_struct->data, field, value);
 191                 break;
 192         case MSG_STRUCT_SETTING_MSGSIZE_OPT :
 193                 err = msg_set_msgsize_opt_int(msg_struct->data, field, value);
 194                 break;
 195         default :
 196                 err = MSG_ERR_INVALID_PARAMETER;
 197                 break;
 198         }
 199
 200         return err;
 201 }
 202
 203 int msg_setting_set_str_value(msg_struct_s *msg_struct, int field, char *value, int size)
 204 {
 205         int err = MSG_SUCCESS;
 206
 207         switch (msg_struct->type)
 208         {
 209         case MSG_STRUCT_SETTING_SMSC_INFO :
 210                 err = msg_set_smsc_info_str(msg_struct->data, field, value, size);
 211                 break;
 212         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 213                 err = msg_set_cb_channel_info_str(msg_struct->data, field, value, size);
 214                 break;
 215         case MSG_STRUCT_SETTING_VOICE_MSG_OPT :
 216                 err = msg_set_voice_msg_opt_str(msg_struct->data, field, value, size);
 217                 break;
 218         default :
 219                 err = MSG_ERR_INVALID_PARAMETER;
 220                 break;
 221         }
 222
 223         return err;
 224 }
 225
 226 int msg_setting_set_bool_value(msg_struct_s *msg_struct, int field, bool value)
 227 {
 228         int err = MSG_SUCCESS;
 229
 230         switch (msg_struct->type) {
 231         case MSG_STRUCT_SETTING_CB_OPT :
 232                 err = msg_set_cb_option_bool(msg_struct->data, field, value);
 233                 break;
 234         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 235                 err = msg_set_cb_channel_info_bool(msg_struct->data, field, value);
 236                 break;
 237         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
 238                 err = msg_set_sms_send_opt_bool(msg_struct->data, field, value);
 239                 break;
 240         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
 241                 err = msg_set_mms_send_opt_bool(msg_struct->data, field, value);
 242                 break;
 243         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
 244                 err = msg_set_mms_recv_opt_bool(msg_struct->data, field, value);
 245                 break;
 246         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
 247                 err = msg_set_push_msg_opt_bool(msg_struct->data, field, value);
 248                 break;
 249         case MSG_STRUCT_SETTING_GENERAL_OPT :
 250                 err = msg_set_general_opt_bool(msg_struct->data, field, value);
 251                 break;
 252         default :
 253                 err = MSG_ERR_INVALID_PARAMETER;
 254                 break;
 255         }
 256
 257         return err;
 258 }
 259
 260
 261 EXPORT_API int msg_get_smsc_opt(msg_handle_t handle, msg_struct_t msg_struct)
 262 {
 263
 264         msg_error_t err =  MSG_SUCCESS;
 265
 266         if (handle == NULL)
 267         {
 268                 return -EINVAL;
 269         }
 270
 271         MsgHandle* pHandle = (MsgHandle*)handle;
 272
 273         try
 274         {
 275                 err = pHandle->getSMSCOption(msg_struct);
 276         }
 277         catch (MsgException& e)
 278         {
 279                 MSG_FATAL("%s", e.what());
 280                 return MSG_ERR_SET_READ_ERROR;
 281         }
 282
 283         return err;
 284 }
 285
 286 EXPORT_API int msg_set_smsc_opt(msg_handle_t handle, msg_struct_t msg_struct)
 287 {
 288
 289         msg_error_t err =  MSG_SUCCESS;
 290
 291         if (handle == NULL || msg_struct == NULL)
 292         {
 293                 return -EINVAL;
 294         }
 295
 296         MsgHandle* pHandle = (MsgHandle*)handle;
 297
 298         try
 299         {
 300                 err = pHandle->setSMSCOption(msg_struct);
 301         }
 302         catch (MsgException& e)
 303         {
 304                 MSG_FATAL("%s", e.what());
 305                 return MSG_ERR_SET_READ_ERROR;
 306         }
 307
 308         return err;
 309 }
 310
 311 int msg_get_smsc_opt_list(void *smsc_opt, int field, void **value)
 312 {
 313         if (!smsc_opt)
 314                 return MSG_ERR_NULL_POINTER;
 315
 316         MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
 317
 318         int ret = MSG_SUCCESS;
 319
 320         switch (field)
 321         {
 322         case MSG_SMSC_LIST_STRUCT :
 323                 *value = (void *)smsc_opt_data->smsc_list;
 324                 break;
 325         default :
 326                 break;
 327         }
 328
 329         return ret;
 330 }
 331
 332 int msg_get_smsc_opt_int(void *smsc_opt, int field)
 333 {
 334         if (!smsc_opt)
 335                 return MSG_ERR_NULL_POINTER;
 336
 337         int ret = MSG_SUCCESS;
 338
 339         MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
 340
 341         switch (field)
 342         {
 343         case MSG_SMSC_SELECTED_ID_INT :
 344                 ret = smsc_opt_data->selected;
 345                 break;
 346         default :
 347                 return MSG_ERR_INVALID_PARAMETER;
 348         }
 349
 350         return ret;
 351 }
 352
 353 int msg_set_smsc_opt_int(void *smsc_opt, int field, int value)
 354 {
 355         if (!smsc_opt)
 356                 return MSG_ERR_NULL_POINTER;
 357
 358         int ret = MSG_SUCCESS;
 359
 360         MSG_SMSC_LIST_HIDDEN_S *smsc_opt_data = (MSG_SMSC_LIST_HIDDEN_S *)smsc_opt;
 361
 362         switch (field)
 363         {
 364         case MSG_SMSC_SELECTED_ID_INT :
 365                 smsc_opt_data->selected = value;
 366                 break;
 367         default :
 368                 ret = MSG_ERR_INVALID_PARAMETER;
 369                 break;
 370         }
 371
 372         return ret;
 373 }
 374
 375 int msg_get_smsc_info_int(void *smsc_info, int field)
 376 {
 377         if (!smsc_info)
 378                 return MSG_ERR_NULL_POINTER;
 379
 380         int ret = MSG_SUCCESS;
 381
 382         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 383
 384         switch (field)
 385         {
 386         case MSG_SMSC_ADDR_TON_INT :
 387                 ret = smsc_data->smscAddr.ton;
 388                 break;
 389         case MSG_SMSC_ADDR_NPI_INT :
 390                 ret = smsc_data->smscAddr.npi;
 391                 break;
 392         case MSG_SMSC_PID_INT :
 393                 ret = smsc_data->pid;
 394                 break;
 395         case MSG_SMSC_VAL_PERIOD_INT :
 396                 ret = smsc_data->valPeriod;
 397                 break;
 398         default :
 399                 return MSG_ERR_INVALID_PARAMETER;
 400         }
 401
 402         return ret;
 403 }
 404
 405 int msg_set_smsc_info_int(void *smsc_info, int field, int value)
 406 {
 407         if (!smsc_info)
 408                 return MSG_ERR_NULL_POINTER;
 409
 410         int err = MSG_SUCCESS;
 411
 412         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 413
 414         switch (field)
 415         {
 416         case MSG_SMSC_ADDR_TON_INT :
 417                 smsc_data->smscAddr.ton = value;
 418                 break;
 419         case MSG_SMSC_ADDR_NPI_INT :
 420                 smsc_data->smscAddr.npi = value;
 421                 break;
 422         case MSG_SMSC_PID_INT :
 423                 smsc_data->pid = value;
 424                 break;
 425         case MSG_SMSC_VAL_PERIOD_INT :
 426                 smsc_data->valPeriod = value;
 427                 break;
 428         default :
 429                 err = MSG_ERR_INVALID_PARAMETER;
 430                 break;
 431         }
 432
 433         return err;
 434 }
 435
 436 char *msg_get_smsc_info_str(void *smsc_info, int field)
 437 {
 438         if (!smsc_info)
 439                 return NULL;
 440
 441         char *ret_str = NULL;
 442
 443         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 444
 445         switch (field)
 446         {
 447         case MSG_SMSC_ADDR_STR :
 448                 ret_str = smsc_data->smscAddr.address;
 449                 break;
 450         case MSG_SMSC_NAME_STR :
 451                 ret_str = smsc_data->name;
 452                 break;
 453         default :
 454                 return NULL;
 455         }
 456
 457         return ret_str;
 458 }
 459
 460 int msg_set_smsc_info_str(void *smsc_info, int field, char *val, int size)
 461 {
 462         if (!smsc_info)
 463                 return MSG_ERR_NULL_POINTER;
 464
 465         int err = MSG_SUCCESS;
 466
 467         MSG_SMSC_DATA_S *smsc_data = (MSG_SMSC_DATA_S *)smsc_info;
 468
 469         switch (field)
 470         {
 471         case MSG_SMSC_ADDR_STR :
 472                 bzero(smsc_data->smscAddr.address, sizeof(smsc_data->smscAddr.address));
 473                 snprintf(smsc_data->smscAddr.address, sizeof(smsc_data->smscAddr.address), "%s", val);
 474                 break;
 475         case MSG_SMSC_NAME_STR :
 476                 bzero(smsc_data->name, sizeof(smsc_data->name));
 477                 snprintf(smsc_data->name, sizeof(smsc_data->name), "%s", val);
 478                 break;
 479         default :
 480                 err = MSG_ERR_INVALID_PARAMETER;
 481                 break;
 482         }
 483
 484         return err;
 485 }
 486
 487 EXPORT_API int msg_get_cb_opt(msg_handle_t handle, msg_struct_t msg_struct)
 488 {
 489
 490         msg_error_t err =  MSG_SUCCESS;
 491
 492         if (handle == NULL)
 493         {
 494                 return -EINVAL;
 495         }
 496
 497         MsgHandle* pHandle = (MsgHandle*)handle;
 498
 499         try
 500         {
 501                 err = pHandle->getCBOption(msg_struct);
 502         }
 503         catch (MsgException& e)
 504         {
 505                 MSG_FATAL("%s", e.what());
 506                 return MSG_ERR_SET_READ_ERROR;
 507         }
 508
 509         return err;
 510 }
 511
 512 EXPORT_API int msg_set_cb_opt(msg_handle_t handle, msg_struct_t msg_struct)
 513 {
 514
 515         msg_error_t err =  MSG_SUCCESS;
 516
 517         if (handle == NULL || msg_struct == NULL)
 518         {
 519                 return -EINVAL;
 520         }
 521
 522         MsgHandle* pHandle = (MsgHandle*)handle;
 523
 524         try
 525         {
 526                 err = pHandle->setCBOption(msg_struct);
 527         }
 528         catch (MsgException& e)
 529         {
 530                 MSG_FATAL("%s", e.what());
 531                 return MSG_ERR_SET_READ_ERROR;
 532         }
 533
 534         return err;
 535 }
 536
 537 int msg_get_cb_option_int(void *cb_opt, int field)
 538 {
 539         if (!cb_opt)
 540                 return MSG_ERR_NULL_POINTER;
 541
 542         int ret = MSG_SUCCESS;
 543
 544         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 545
 546         switch (field)
 547         {
 548         case MSG_CB_MAX_SIM_COUNT_INT :
 549                 ret = cb_opt_data->maxSimCnt;
 550                 break;
 551         default :
 552                 ret = MSG_ERR_INVALID_PARAMETER;
 553                 break;
 554         }
 555
 556         return ret;
 557 }
 558
 559 int msg_set_cb_option_int(void *cb_opt, int field, int value)
 560 {
 561         if (!cb_opt)
 562                 return MSG_ERR_NULL_POINTER;
 563
 564         int ret = MSG_SUCCESS;
 565
 566         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 567
 568         switch (field)
 569         {
 570         case MSG_CB_MAX_SIM_COUNT_INT :
 571                 cb_opt_data->maxSimCnt = value;
 572                 break;
 573         default :
 574                 ret = MSG_ERR_INVALID_PARAMETER;
 575                 break;
 576         }
 577
 578         return ret;
 579 }
 580
 581
 582 bool msg_get_cb_option_bool(void *cb_opt, int field)
 583 {
 584         if (!cb_opt)
 585                 return false;
 586
 587         bool ret = false;
 588
 589         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 590
 591         switch (field)
 592         {
 593         case MSG_CB_RECEIVE_BOOL :
 594                 ret = cb_opt_data->bReceive;
 595                 break;
 596         case MSG_CB_LANGUAGE_TYPE_ALL_BOOL :
 597                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ALL];
 598                 break;
 599         case MSG_CB_LANGUAGE_TYPE_ENG_BOOL :
 600                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ENG];
 601                 break;
 602         case MSG_CB_LANGUAGE_TYPE_GER_BOOL :
 603                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_GER];
 604                 break;
 605         case MSG_CB_LANGUAGE_TYPE_FRE_BOOL :
 606                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_FRE];
 607                 break;
 608         case MSG_CB_LANGUAGE_TYPE_ITA_BOOL :
 609                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ITA];
 610                 break;
 611         case MSG_CB_LANGUAGE_TYPE_NED_BOOL :
 612                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_NED];
 613                 break;
 614         case MSG_CB_LANGUAGE_TYPE_SPA_BOOL :
 615                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SPA];
 616                 break;
 617         case MSG_CB_LANGUAGE_TYPE_POR_BOOL :
 618                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_POR];
 619                 break;
 620         case MSG_CB_LANGUAGE_TYPE_SWE_BOOL :
 621                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SWE];
 622                 break;
 623         case MSG_CB_LANGUAGE_TYPE_TUR_BOOL :
 624                 ret = cb_opt_data->bLanguage[MSG_CBLANG_TYPE_TUR];
 625                 break;
 626         default :
 627                 break;
 628         }
 629
 630         return ret;
 631 }
 632
 633 int msg_set_cb_option_bool(void *cb_opt, int field, bool value)
 634 {
 635         if (!cb_opt)
 636                 return MSG_ERR_NULL_POINTER;
 637
 638         int ret = MSG_SUCCESS;
 639
 640         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 641
 642         switch (field)
 643         {
 644         case MSG_CB_RECEIVE_BOOL :
 645                 cb_opt_data->bReceive = value;
 646                 break;
 647         case MSG_CB_LANGUAGE_TYPE_ALL_BOOL :
 648                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ALL] = value;
 649                 break;
 650         case MSG_CB_LANGUAGE_TYPE_ENG_BOOL :
 651                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ENG] = value;
 652                 break;
 653         case MSG_CB_LANGUAGE_TYPE_GER_BOOL :
 654                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_GER] = value;
 655                 break;
 656         case MSG_CB_LANGUAGE_TYPE_FRE_BOOL :
 657                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_FRE] = value;
 658                 break;
 659         case MSG_CB_LANGUAGE_TYPE_ITA_BOOL :
 660                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_ITA] = value;
 661                 break;
 662         case MSG_CB_LANGUAGE_TYPE_NED_BOOL :
 663                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_NED] = value;
 664                 break;
 665         case MSG_CB_LANGUAGE_TYPE_SPA_BOOL :
 666                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SPA] = value;
 667                 break;
 668         case MSG_CB_LANGUAGE_TYPE_POR_BOOL :
 669                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_POR] = value;
 670                 break;
 671         case MSG_CB_LANGUAGE_TYPE_SWE_BOOL :
 672                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_SWE] = value;
 673                 break;
 674         case MSG_CB_LANGUAGE_TYPE_TUR_BOOL :
 675                 cb_opt_data->bLanguage[MSG_CBLANG_TYPE_TUR] = value;
 676                 break;
 677         default :
 678                 ret = MSG_ERR_INVALID_PARAMETER;
 679                 break;
 680         }
 681
 682         return ret;
 683 }
 684
 685 int msg_get_cb_option_list(void *cb_opt, int field, void **value)
 686 {
 687         if (!cb_opt)
 688                 return MSG_ERR_NULL_POINTER;
 689
 690         MSG_CBMSG_OPT_HIDDEN_S *cb_opt_data = (MSG_CBMSG_OPT_HIDDEN_S *)cb_opt;
 691
 692         int ret = MSG_SUCCESS;
 693
 694         switch (field)
 695         {
 696         case MSG_CB_CHANNEL_LIST_STRUCT :
 697                 *value = (void *)cb_opt_data->channelData;
 698                 break;
 699         default :
 700                 break;
 701         }
 702
 703         return ret;
 704 }
 705
 706 int msg_get_cb_channel_info_int(void *cb_ch_info, int field)
 707 {
 708         if (!cb_ch_info)
 709                 return MSG_ERR_NULL_POINTER;
 710
 711         int ret = MSG_ERR_INVALID_PARAMETER;
 712
 713         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 714
 715         switch (field)
 716         {
 717         case MSG_CB_CHANNEL_ID_FROM_INT :
 718                 ret = cb_ch_data->from;
 719                 break;
 720         case MSG_CB_CHANNEL_ID_TO_INT :
 721                 ret = cb_ch_data->to;
 722                 break;
 723         default :
 724                 break;
 725         }
 726
 727         return ret;
 728 }
 729
 730 int msg_set_cb_channel_info_int(void *cb_ch_info, int field, int value)
 731 {
 732         if (!cb_ch_info)
 733                 return MSG_ERR_NULL_POINTER;
 734
 735         int ret = MSG_SUCCESS;
 736
 737         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 738
 739         switch (field)
 740         {
 741         case MSG_CB_CHANNEL_ID_FROM_INT :
 742                 cb_ch_data->from = value;
 743                 break;
 744         case MSG_CB_CHANNEL_ID_TO_INT :
 745                 cb_ch_data->to = value;
 746                 break;
 747         default :
 748                 ret = MSG_ERR_INVALID_PARAMETER;
 749                 break;
 750         }
 751
 752         return ret;
 753 }
 754
 755 bool msg_get_cb_channel_info_bool(void *cb_ch_info, int field)
 756 {
 757         if (!cb_ch_info)
 758                 return false;
 759
 760         bool ret = false;
 761
 762         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 763
 764         switch (field)
 765         {
 766         case MSG_CB_CHANNEL_ACTIVATE_BOOL :
 767                 ret = cb_ch_data->bActivate;
 768                 break;
 769         default :
 770                 break;
 771         }
 772
 773         return ret;
 774 }
 775
 776 int msg_set_cb_channel_info_bool(void *cb_ch_info, int field, bool value)
 777 {
 778         if (!cb_ch_info)
 779                 return MSG_ERR_NULL_POINTER;
 780
 781         int ret = MSG_SUCCESS;
 782
 783         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 784
 785         switch (field)
 786         {
 787         case MSG_CB_CHANNEL_ACTIVATE_BOOL :
 788                 cb_ch_data->bActivate = value;
 789                 break;
 790         default :
 791                 ret = MSG_ERR_INVALID_PARAMETER;
 792                 break;
 793         }
 794
 795         return ret;
 796 }
 797
 798 char *msg_get_cb_channel_info_str(void *cb_ch_info, int field)
 799 {
 800         if (!cb_ch_info)
 801                 return NULL;
 802
 803         char *ret_str = NULL;
 804
 805         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 806
 807         switch (field)
 808         {
 809         case MSG_CB_CHANNEL_NAME_STR :
 810                 ret_str = cb_ch_data->name;
 811                 break;
 812         default :
 813                 break;
 814         }
 815
 816         return ret_str;
 817 }
 818
 819 int msg_set_cb_channel_info_str(void *cb_ch_info, int field, char *val, int size)
 820 {
 821         if (!cb_ch_info)
 822                 return MSG_ERR_NULL_POINTER;
 823
 824         int ret = MSG_SUCCESS;
 825
 826         MSG_CB_CHANNEL_INFO_S *cb_ch_data = (MSG_CB_CHANNEL_INFO_S *)cb_ch_info;
 827
 828         switch (field)
 829         {
 830         case MSG_CB_CHANNEL_NAME_STR :
 831                 bzero(cb_ch_data->name, sizeof(cb_ch_data->name));
 832                 snprintf(cb_ch_data->name, sizeof(cb_ch_data->name), "%s", val);
 833                 break;
 834         default :
 835                 ret = MSG_ERR_INVALID_PARAMETER;
 836                 break;
 837         }
 838
 839         return ret;
 840 }
 841
 842 EXPORT_API int msg_get_sms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 843 {
 844
 845         msg_error_t err =  MSG_SUCCESS;
 846
 847         if (handle == NULL)
 848         {
 849                 return -EINVAL;
 850         }
 851
 852         MsgHandle* pHandle = (MsgHandle*)handle;
 853
 854         try
 855         {
 856                 err = pHandle->getSmsSendOpt(msg_struct);
 857         }
 858         catch (MsgException& e)
 859         {
 860                 MSG_FATAL("%s", e.what());
 861                 return MSG_ERR_SET_READ_ERROR;
 862         }
 863
 864         return err;
 865 }
 866
 867 EXPORT_API int msg_set_sms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 868 {
 869
 870         msg_error_t err =  MSG_SUCCESS;
 871
 872         if (handle == NULL || msg_struct == NULL)
 873         {
 874                 return -EINVAL;
 875         }
 876
 877         MsgHandle* pHandle = (MsgHandle*)handle;
 878
 879         try
 880         {
 881                 err = pHandle->setSmsSendOpt(msg_struct);
 882         }
 883         catch (MsgException& e)
 884         {
 885                 MSG_FATAL("%s", e.what());
 886                 return MSG_ERR_SET_READ_ERROR;
 887         }
 888
 889         return err;
 890 }
 891
 892 int msg_get_sms_send_opt_int(void *sms_send_opt, int field)
 893 {
 894         if (!sms_send_opt)
 895                 return MSG_ERR_NULL_POINTER;
 896
 897         int ret = MSG_ERR_INVALID_PARAMETER;
 898
 899         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 900
 901         switch (field)
 902         {
 903         case MSG_SMS_SENDOPT_ENCODE_TYPE_INT :
 904                 ret = send_opt->dcs;
 905                 break;
 906         case MSG_SMS_SENDOPT_NETWORK_MODE_INT :
 907                 ret = send_opt->netMode;
 908                 break;
 909         case MSG_SMS_SENDOPT_SAVE_STORAGE_INT :
 910                 ret = send_opt->saveStorage;
 911                 break;
 912         default :
 913                 break;
 914         }
 915
 916         return ret;
 917 }
 918
 919 int msg_set_sms_send_opt_int(void *sms_send_opt, int field, int value)
 920 {
 921         if (!sms_send_opt)
 922                 return MSG_ERR_NULL_POINTER;
 923
 924         int ret = MSG_SUCCESS;
 925
 926         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 927
 928         switch (field)
 929         {
 930         case MSG_SMS_SENDOPT_ENCODE_TYPE_INT :
 931                 send_opt->dcs = value;
 932                 break;
 933         case MSG_SMS_SENDOPT_NETWORK_MODE_INT :
 934                 send_opt->netMode = value;
 935                 break;
 936         case MSG_SMS_SENDOPT_SAVE_STORAGE_INT :
 937                 send_opt->saveStorage = value;
 938                 break;
 939         default :
 940                 ret = MSG_ERR_INVALID_PARAMETER;
 941                 break;
 942         }
 943
 944         return ret;
 945 }
 946
 947 bool msg_get_sms_send_opt_bool(void *sms_send_opt, int field)
 948 {
 949         if (!sms_send_opt)
 950                 return false;
 951
 952         bool ret = false;
 953
 954         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 955
 956         switch (field)
 957         {
 958         case MSG_SMS_SENDOPT_REPLY_PATH_BOOL :
 959                 ret = send_opt->bReplyPath;
 960                 break;
 961         case MSG_SMS_SENDOPT_DELIVERY_REPORT_BOOL :
 962                 ret = send_opt->bDeliveryReport;
 963                 break;
 964         default :
 965                 break;
 966         }
 967
 968         return ret;
 969 }
 970
 971 int msg_set_sms_send_opt_bool(void *sms_send_opt, int field, bool value)
 972 {
 973         if (!sms_send_opt)
 974                 return false;
 975
 976         int ret = MSG_SUCCESS;
 977
 978         MSG_SMS_SENDOPT_S *send_opt = (MSG_SMS_SENDOPT_S *)sms_send_opt;
 979
 980         switch (field)
 981         {
 982         case MSG_SMS_SENDOPT_REPLY_PATH_BOOL :
 983                 send_opt->bReplyPath = value;
 984                 break;
 985         case MSG_SMS_SENDOPT_DELIVERY_REPORT_BOOL :
 986                 send_opt->bDeliveryReport = value;
 987                 break;
 988         default :
 989                 ret = MSG_ERR_INVALID_PARAMETER;
 990                 break;
 991         }
 992
 993         return ret;
 994 }
 995
 996 EXPORT_API int msg_get_mms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
 997 {
 998
 999         msg_error_t err =  MSG_SUCCESS;
1000
1001         if (handle == NULL)
1002         {
1003                 return -EINVAL;
1004         }
1005
1006         MsgHandle* pHandle = (MsgHandle*)handle;
1007
1008         try
1009         {
1010                 err = pHandle->getMmsSendOpt(msg_struct);
1011         }
1012         catch (MsgException& e)
1013         {
1014                 MSG_FATAL("%s", e.what());
1015                 return MSG_ERR_SET_READ_ERROR;
1016         }
1017
1018         return err;
1019 }
1020
1021 EXPORT_API int msg_set_mms_send_opt(msg_handle_t handle, msg_struct_t msg_struct)
1022 {
1023
1024         msg_error_t err =  MSG_SUCCESS;
1025
1026         if (handle == NULL || msg_struct == NULL)
1027         {
1028                 return -EINVAL;
1029         }
1030
1031         MsgHandle* pHandle = (MsgHandle*)handle;
1032
1033         try
1034         {
1035                 err = pHandle->setMmsSendOpt(msg_struct);
1036         }
1037         catch (MsgException& e)
1038         {
1039                 MSG_FATAL("%s", e.what());
1040                 return MSG_ERR_SET_READ_ERROR;
1041         }
1042
1043         return err;
1044 }
1045
1046
1047 int msg_get_mms_send_opt_int(void *mms_send_opt, int field)
1048 {
1049         if (!mms_send_opt)
1050                 return MSG_ERR_NULL_POINTER;
1051
1052         int ret = MSG_ERR_INVALID_PARAMETER;
1053
1054         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1055
1056         switch (field)
1057         {
1058         case MSG_MMS_SENDOPT_CLASS_TYPE_INT :
1059                 ret = send_opt->msgClass;
1060                 break;
1061         case MSG_MMS_SENDOPT_PRIORITY_TYPE_INT :
1062                 ret = send_opt->priority;
1063                 break;
1064         case MSG_MMS_SENDOPT_EXPIRY_TIME_INT :
1065                 ret = send_opt->expiryTime;
1066                 break;
1067         case MSG_MMS_SENDOPT_DELIVERY_TIME_INT :
1068                 ret = send_opt->deliveryTime;
1069                 break;
1070         case MSG_MMS_SENDOPT_CUSTOM_DELIVERY_TIME_INT :
1071                 ret = send_opt->customDeliveryTime;
1072                 break;
1073         case MSG_MMS_SENDOPT_REPLY_CHARGING_INT :
1074                 ret = send_opt->replyCharging;
1075                 break;
1076         case MSG_MMS_SENDOPT_REPLY_CHARGING_DEADLINE_INT :
1077                 ret = send_opt->replyChargingDeadline;
1078                 break;
1079         case MSG_MMS_SENDOPT_REPLY_CHARGING_SIZE_INT :
1080                 ret = send_opt->replyChargingSize;
1081                 break;
1082         case MSG_MMS_SENDOPT_CREATION_MODE_INT :
1083                 ret = send_opt->creationMode;
1084                 break;
1085         default :
1086                 break;
1087         }
1088
1089         return ret;
1090 }
1091
1092 int msg_set_mms_send_opt_int(void *mms_send_opt, int field, int value)
1093 {
1094         if (!mms_send_opt)
1095                 return MSG_ERR_NULL_POINTER;
1096
1097         int ret = MSG_SUCCESS;
1098
1099         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1100
1101         switch (field)
1102         {
1103         case MSG_MMS_SENDOPT_CLASS_TYPE_INT :
1104                 send_opt->msgClass = value;
1105                 break;
1106         case MSG_MMS_SENDOPT_PRIORITY_TYPE_INT :
1107                 send_opt->priority = value;
1108                 break;
1109         case MSG_MMS_SENDOPT_EXPIRY_TIME_INT :
1110                 send_opt->expiryTime = value;
1111                 break;
1112         case MSG_MMS_SENDOPT_DELIVERY_TIME_INT :
1113                 send_opt->deliveryTime = value;
1114                 break;
1115         case MSG_MMS_SENDOPT_CUSTOM_DELIVERY_TIME_INT :
1116                 send_opt->customDeliveryTime = value;
1117                 break;
1118         case MSG_MMS_SENDOPT_REPLY_CHARGING_INT :
1119                 send_opt->replyCharging = value;
1120                 break;
1121         case MSG_MMS_SENDOPT_REPLY_CHARGING_DEADLINE_INT :
1122                 send_opt->replyChargingDeadline = value;
1123                 break;
1124         case MSG_MMS_SENDOPT_REPLY_CHARGING_SIZE_INT :
1125                 send_opt->replyChargingSize = value;
1126                 break;
1127         case MSG_MMS_SENDOPT_CREATION_MODE_INT :
1128                 send_opt->creationMode = value;
1129                 break;
1130         default :
1131                 ret = MSG_ERR_INVALID_PARAMETER;
1132                 break;
1133         }
1134
1135         return ret;
1136 }
1137
1138 bool msg_get_mms_send_opt_bool(void *mms_send_opt, int field)
1139 {
1140         if (!mms_send_opt)
1141                 return false;
1142
1143         bool ret = false;
1144
1145         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1146
1147         switch (field)
1148         {
1149         case MSG_MMS_SENDOPT_SENDER_VISIBILITY_BOOL :
1150                 ret = send_opt->bSenderVisibility;
1151                 break;
1152         case MSG_MMS_SENDOPT_DELIVERY_REPORT_BOOL :
1153                 ret = send_opt->bDeliveryReport;
1154                 break;
1155         case MSG_MMS_SENDOPT_READ_REPLY_BOOL :
1156                 ret = send_opt->bReadReply;
1157                 break;
1158         case MSG_MMS_SENDOPT_KEEP_COPY_BOOL :
1159                 ret = send_opt->bKeepCopy;
1160                 break;
1161         case MSG_MMS_SENDOPT_BODY_REPLYING_BOOL :
1162                 ret = send_opt->bBodyReplying;
1163                 break;
1164         case MSG_MMS_SENDOPT_HIDE_RECIPIENTS_BOOL :
1165                 ret = send_opt->bHideRecipients;
1166                 break;
1167         default :
1168                 break;
1169         }
1170
1171         return ret;
1172 }
1173
1174 int msg_set_mms_send_opt_bool(void *mms_send_opt, int field, bool value)
1175 {
1176         if (!mms_send_opt)
1177                 return MSG_ERR_NULL_POINTER;
1178
1179         int ret = MSG_SUCCESS;
1180
1181         MSG_MMS_SENDOPT_S *send_opt = (MSG_MMS_SENDOPT_S *)mms_send_opt;
1182
1183         switch (field)
1184         {
1185         case MSG_MMS_SENDOPT_SENDER_VISIBILITY_BOOL :
1186                 send_opt->bSenderVisibility = value;
1187                 break;
1188         case MSG_MMS_SENDOPT_DELIVERY_REPORT_BOOL :
1189                 send_opt->bDeliveryReport = value;
1190                 break;
1191         case MSG_MMS_SENDOPT_READ_REPLY_BOOL :
1192                 send_opt->bReadReply = value;
1193                 break;
1194         case MSG_MMS_SENDOPT_KEEP_COPY_BOOL :
1195                 send_opt->bKeepCopy = value;
1196                 break;
1197         case MSG_MMS_SENDOPT_BODY_REPLYING_BOOL :
1198                 send_opt->bBodyReplying = value;
1199                 break;
1200         case MSG_MMS_SENDOPT_HIDE_RECIPIENTS_BOOL :
1201                 send_opt->bHideRecipients = value;
1202                 break;
1203         default :
1204                 ret = MSG_ERR_INVALID_PARAMETER;
1205                 break;
1206         }
1207
1208         return ret;
1209 }
1210
1211 EXPORT_API int msg_get_mms_recv_opt(msg_handle_t handle, msg_struct_t msg_struct)
1212 {
1213
1214         msg_error_t err =  MSG_SUCCESS;
1215
1216         if (handle == NULL)
1217         {
1218                 return -EINVAL;
1219         }
1220
1221         MsgHandle* pHandle = (MsgHandle*)handle;
1222
1223         try
1224         {
1225                 err = pHandle->getMmsRecvOpt(msg_struct);
1226         }
1227         catch (MsgException& e)
1228         {
1229                 MSG_FATAL("%s", e.what());
1230                 return MSG_ERR_SET_READ_ERROR;
1231         }
1232
1233         return err;
1234 }
1235
1236 EXPORT_API int msg_set_mms_recv_opt(msg_handle_t handle, msg_struct_t msg_struct)
1237 {
1238
1239         msg_error_t err =  MSG_SUCCESS;
1240
1241         if (handle == NULL || msg_struct == NULL)
1242         {
1243                 return -EINVAL;
1244         }
1245
1246         MsgHandle* pHandle = (MsgHandle*)handle;
1247
1248         try
1249         {
1250                 err = pHandle->setMmsRecvOpt(msg_struct);
1251         }
1252         catch (MsgException& e)
1253         {
1254                 MSG_FATAL("%s", e.what());
1255                 return MSG_ERR_SET_READ_ERROR;
1256         }
1257
1258         return err;
1259 }
1260
1261 int msg_get_mms_recv_opt_int(void *mms_recv_opt, int field)
1262 {
1263         if (!mms_recv_opt)
1264                 return MSG_ERR_NULL_POINTER;
1265
1266         int ret = MSG_ERR_INVALID_PARAMETER;
1267
1268         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1269
1270         switch (field)
1271         {
1272         case MSG_MMS_RECVOPT_HOME_RETRIEVE_TYPE_INT :
1273                 ret = recv_opt->homeNetwork;
1274                 break;
1275         case MSG_MMS_RECVOPT_ABROAD_RETRIEVE_TYPE_INT :
1276                 ret = recv_opt->abroadNetwok;
1277                 break;
1278         default :
1279                 break;
1280         }
1281
1282         return ret;
1283 }
1284
1285 int msg_set_mms_recv_opt_int(void *mms_recv_opt, int field, int value)
1286 {
1287         if (!mms_recv_opt)
1288                 return MSG_ERR_NULL_POINTER;
1289
1290         int ret = MSG_SUCCESS;
1291
1292         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1293
1294         switch (field)
1295         {
1296         case MSG_MMS_RECVOPT_HOME_RETRIEVE_TYPE_INT :
1297                 recv_opt->homeNetwork = value;
1298                 break;
1299         case MSG_MMS_RECVOPT_ABROAD_RETRIEVE_TYPE_INT :
1300                 recv_opt->abroadNetwok = value;
1301                 break;
1302         default :
1303                 ret = MSG_ERR_INVALID_PARAMETER;
1304                 break;
1305         }
1306
1307         return ret;
1308 }
1309
1310 bool msg_get_mms_recv_opt_bool(void *mms_recv_opt, int field)
1311 {
1312         if (!mms_recv_opt)
1313                 return false;
1314
1315         bool ret = false;
1316
1317         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1318
1319         switch (field)
1320         {
1321         case MSG_MMS_RECVOPT_READ_REPORT_BOOL :
1322                 ret = recv_opt->readReceipt;
1323                 break;
1324         case MSG_MMS_RECVOPT_DELIVERY_REPORT_BOOL :
1325                 ret = recv_opt->bDeliveryReceipt;
1326                 break;
1327         case MSG_MMS_RECVOPT_REJECT_UNKNOWN_BOOL :
1328                 ret = recv_opt->bRejectUnknown;
1329                 break;
1330         case MSG_MMS_RECVOPT_REJECT_ADVERTISEMENT_BOOL :
1331                 ret = recv_opt->bRejectAdvertisement;
1332                 break;
1333         default :
1334                 break;
1335         }
1336
1337         return ret;
1338 }
1339
1340 int msg_set_mms_recv_opt_bool(void *mms_recv_opt, int field, bool value)
1341 {
1342         if (!mms_recv_opt)
1343                 return MSG_ERR_NULL_POINTER;
1344
1345         int ret = MSG_SUCCESS;
1346
1347         MSG_MMS_RECVOPT_S *recv_opt = (MSG_MMS_RECVOPT_S *)mms_recv_opt;
1348
1349         switch (field)
1350         {
1351         case MSG_MMS_RECVOPT_READ_REPORT_BOOL :
1352                 recv_opt->readReceipt = value;
1353                 break;
1354         case MSG_MMS_RECVOPT_DELIVERY_REPORT_BOOL :
1355                 recv_opt->bDeliveryReceipt = value;
1356                 break;
1357         case MSG_MMS_RECVOPT_REJECT_UNKNOWN_BOOL :
1358                 recv_opt->bRejectUnknown = value;
1359                 break;
1360         case MSG_MMS_RECVOPT_REJECT_ADVERTISEMENT_BOOL :
1361                 recv_opt->bRejectAdvertisement = value;
1362                 break;
1363         default :
1364                 ret = MSG_ERR_INVALID_PARAMETER;
1365                 break;
1366         }
1367
1368         return ret;
1369 }
1370
1371 EXPORT_API int msg_get_push_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1372 {
1373         msg_error_t err =  MSG_SUCCESS;
1374
1375         if (handle == NULL)
1376         {
1377                 return -EINVAL;
1378         }
1379
1380         MsgHandle* pHandle = (MsgHandle*)handle;
1381
1382         try
1383         {
1384                 err = pHandle->getPushMsgOpt(msg_struct);
1385         }
1386         catch (MsgException& e)
1387         {
1388                 MSG_FATAL("%s", e.what());
1389                 return MSG_ERR_SET_READ_ERROR;
1390         }
1391
1392         return err;
1393 }
1394
1395 EXPORT_API int msg_set_push_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1396 {
1397         msg_error_t err =  MSG_SUCCESS;
1398
1399         if (handle == NULL || msg_struct == NULL)
1400         {
1401                 return -EINVAL;
1402         }
1403
1404         MsgHandle* pHandle = (MsgHandle*)handle;
1405
1406         try
1407         {
1408                 err = pHandle->setPushMsgOpt(msg_struct);
1409         }
1410         catch (MsgException& e)
1411         {
1412                 MSG_FATAL("%s", e.what());
1413                 return MSG_ERR_SET_READ_ERROR;
1414         }
1415
1416         return err;
1417 }
1418
1419 int msg_get_push_msg_opt_int(void *push_msg_opt, int field)
1420 {
1421         if (!push_msg_opt)
1422                 return MSG_ERR_NULL_POINTER;
1423
1424         int ret = MSG_ERR_INVALID_PARAMETER;
1425
1426         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1427
1428         switch (field)
1429         {
1430         case MSG_PUSHMSG_SERVICE_TYPE_INT :
1431                 ret = push_opt->serviceType;
1432                 break;
1433         default :
1434                 break;
1435         }
1436
1437         return ret;
1438 }
1439
1440 int msg_set_push_msg_opt_int(void *push_msg_opt, int field, int value)
1441 {
1442         if (!push_msg_opt)
1443                 return MSG_ERR_NULL_POINTER;
1444
1445         int ret = MSG_SUCCESS;
1446
1447         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1448
1449         switch (field)
1450         {
1451         case MSG_PUSHMSG_SERVICE_TYPE_INT :
1452                 push_opt->serviceType = value;
1453                 break;
1454         default :
1455                 ret = MSG_ERR_INVALID_PARAMETER;
1456                 break;
1457         }
1458
1459         return ret;
1460 }
1461
1462 bool msg_get_push_msg_opt_bool(void *push_msg_opt, int field)
1463 {
1464         if (!push_msg_opt)
1465                 return false;
1466
1467         bool ret = false;
1468
1469         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1470
1471         switch (field)
1472         {
1473         case MSG_PUSHMSG_RECEIVE_BOOL :
1474                 ret = push_opt->bReceive;
1475                 break;
1476         default :
1477                 break;
1478         }
1479
1480         return ret;
1481 }
1482
1483 int msg_set_push_msg_opt_bool(void *push_msg_opt, int field, bool value)
1484 {
1485         if (!push_msg_opt)
1486                 return MSG_ERR_NULL_POINTER;
1487
1488         int ret = MSG_SUCCESS;
1489
1490         MSG_PUSHMSG_OPT_S *push_opt = (MSG_PUSHMSG_OPT_S *)push_msg_opt;
1491
1492         switch (field)
1493         {
1494         case MSG_PUSHMSG_RECEIVE_BOOL :
1495                 push_opt->bReceive = value;
1496                 break;
1497         default :
1498                 ret = MSG_ERR_INVALID_PARAMETER;
1499                 break;
1500         }
1501
1502         return ret;
1503 }
1504
1505 EXPORT_API int msg_get_voice_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1506 {
1507         msg_error_t err =  MSG_SUCCESS;
1508
1509         if (handle == NULL)
1510         {
1511                 return -EINVAL;
1512         }
1513
1514         MsgHandle* pHandle = (MsgHandle*)handle;
1515
1516         try
1517         {
1518                 err = pHandle->getVoiceMsgOpt(msg_struct);
1519         }
1520         catch (MsgException& e)
1521         {
1522                 MSG_FATAL("%s", e.what());
1523                 return MSG_ERR_SET_READ_ERROR;
1524         }
1525
1526         return err;
1527 }
1528
1529 EXPORT_API int msg_set_voice_msg_opt(msg_handle_t handle, msg_struct_t msg_struct)
1530 {
1531         msg_error_t err =  MSG_SUCCESS;
1532
1533         if (handle == NULL || msg_struct == NULL)
1534         {
1535                 return -EINVAL;
1536         }
1537
1538         MsgHandle* pHandle = (MsgHandle*)handle;
1539
1540         try
1541         {
1542                 err = pHandle->setVoiceMsgOpt(msg_struct);
1543         }
1544         catch (MsgException& e)
1545         {
1546                 MSG_FATAL("%s", e.what());
1547                 return MSG_ERR_SET_READ_ERROR;
1548         }
1549
1550         return err;
1551 }
1552
1553 char *msg_get_voice_msg_opt_str(void *voice_msg_opt, int field)
1554 {
1555         if (!voice_msg_opt)
1556                 return NULL;
1557
1558         char *ret_str = NULL;
1559
1560         MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1561
1562         switch (field)
1563         {
1564         case MSG_VOICEMSG_ADDRESS_STR :
1565                 ret_str = voice_opt->mailNumber;
1566                 break;
1567         default :
1568                 break;
1569         }
1570
1571         return ret_str;
1572 }
1573
1574 int msg_set_voice_msg_opt_str(void *voice_msg_opt, int field, char *val, int size)
1575 {
1576         if (!voice_msg_opt)
1577                 return MSG_ERR_NULL_POINTER;
1578
1579         int ret = MSG_SUCCESS;
1580
1581         MSG_VOICEMAIL_OPT_S *voice_opt = (MSG_VOICEMAIL_OPT_S *)voice_msg_opt;
1582
1583         switch (field)
1584         {
1585         case MSG_VOICEMSG_ADDRESS_STR :
1586                 bzero(voice_opt->mailNumber, sizeof(voice_opt->mailNumber));
1587                 snprintf(voice_opt->mailNumber, sizeof(voice_opt->mailNumber), "%s", val);
1588                 break;
1589         default :
1590                 ret = MSG_ERR_INVALID_PARAMETER;
1591                 break;
1592         }
1593
1594         return ret;
1595 }
1596
1597 EXPORT_API int msg_get_general_opt(msg_handle_t handle, msg_struct_t msg_struct)
1598 {
1599         msg_error_t err =  MSG_SUCCESS;
1600
1601         if (handle == NULL)
1602         {
1603                 return -EINVAL;
1604         }
1605
1606         MsgHandle* pHandle = (MsgHandle*)handle;
1607
1608         try
1609         {
1610                 err = pHandle->getGeneralOpt(msg_struct);
1611         }
1612         catch (MsgException& e)
1613         {
1614                 MSG_FATAL("%s", e.what());
1615                 return MSG_ERR_SET_READ_ERROR;
1616         }
1617
1618         return err;
1619 }
1620
1621 EXPORT_API int msg_set_general_opt(msg_handle_t handle, msg_struct_t msg_struct)
1622 {
1623         msg_error_t err =  MSG_SUCCESS;
1624
1625         if (handle == NULL || msg_struct == NULL)
1626         {
1627                 return -EINVAL;
1628         }
1629
1630         MsgHandle* pHandle = (MsgHandle*)handle;
1631
1632         try
1633         {
1634                 err = pHandle->setGeneralOpt(msg_struct);
1635         }
1636         catch (MsgException& e)
1637         {
1638                 MSG_FATAL("%s", e.what());
1639                 return MSG_ERR_SET_READ_ERROR;
1640         }
1641
1642         return err;
1643 }
1644
1645 int msg_get_general_opt_int(void *general_opt, int field)
1646 {
1647         if (!general_opt)
1648                 return MSG_ERR_NULL_POINTER;
1649
1650         int ret = MSG_ERR_INVALID_PARAMETER;
1651
1652         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1653
1654         switch (field)
1655         {
1656         case MSG_GENERAL_ALERT_TONE_INT :
1657                 ret = opt->alertTone;
1658                 break;
1659         default :
1660                 break;
1661         }
1662
1663         return ret;
1664 }
1665
1666 int msg_set_general_opt_int(void *general_opt, int field, int value)
1667 {
1668         if (!general_opt)
1669                 return MSG_ERR_NULL_POINTER;
1670
1671         int ret = MSG_SUCCESS;
1672
1673         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1674
1675         switch (field)
1676         {
1677         case MSG_GENERAL_ALERT_TONE_INT :
1678                 opt->alertTone = value;
1679                 break;
1680         default :
1681                 ret = MSG_ERR_INVALID_PARAMETER;
1682                 break;
1683         }
1684
1685         return ret;
1686 }
1687
1688 bool msg_get_general_opt_bool(void *general_opt, int field)
1689 {
1690         if (!general_opt)
1691                 return false;
1692
1693         int ret = false;
1694
1695         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1696
1697         switch (field)
1698         {
1699         case MSG_GENERAL_KEEP_COPY_BOOL :
1700                 ret = opt->bKeepCopy;
1701                 break;
1702         case MSG_GENERAL_AUTO_ERASE_BOOL :
1703                 ret = opt->bAutoErase;
1704                 break;
1705         default :
1706                 break;
1707         }
1708
1709         return ret;
1710 }
1711
1712 int msg_set_general_opt_bool(void *general_opt, int field, bool value)
1713 {
1714         if (!general_opt)
1715                 return MSG_ERR_NULL_POINTER;
1716
1717         int ret = MSG_SUCCESS;
1718
1719         MSG_GENERAL_OPT_S *opt = (MSG_GENERAL_OPT_S *)general_opt;
1720
1721         switch (field)
1722         {
1723         case MSG_GENERAL_KEEP_COPY_BOOL :
1724                 opt->bKeepCopy = value;
1725                 break;
1726         case MSG_GENERAL_AUTO_ERASE_BOOL :
1727                 opt->bAutoErase = value;
1728                 break;
1729         default :
1730                 ret = MSG_ERR_INVALID_PARAMETER;
1731                 break;
1732         }
1733
1734         return ret;
1735 }
1736
1737 EXPORT_API int msg_get_msgsize_opt(msg_handle_t handle, msg_struct_t msg_struct)
1738 {
1739         msg_error_t err =  MSG_SUCCESS;
1740
1741         if (handle == NULL)
1742         {
1743                 return -EINVAL;
1744         }
1745
1746         MsgHandle* pHandle = (MsgHandle*)handle;
1747
1748         try
1749         {
1750                 err = pHandle->getMsgSizeOpt(msg_struct);
1751         }
1752         catch (MsgException& e)
1753         {
1754                 MSG_FATAL("%s", e.what());
1755                 return MSG_ERR_SET_READ_ERROR;
1756         }
1757
1758         return err;
1759 }
1760
1761 EXPORT_API int msg_set_msgsize_opt(msg_handle_t handle, msg_struct_t msg_struct)
1762 {
1763         msg_error_t err =  MSG_SUCCESS;
1764
1765         if (handle == NULL || msg_struct == NULL)
1766         {
1767                 return -EINVAL;
1768         }
1769
1770         MsgHandle* pHandle = (MsgHandle*)handle;
1771
1772         try
1773         {
1774                 err = pHandle->setMsgSizeOpt(msg_struct);
1775         }
1776         catch (MsgException& e)
1777         {
1778                 MSG_FATAL("%s", e.what());
1779                 return MSG_ERR_SET_READ_ERROR;
1780         }
1781
1782         return err;
1783 }
1784
1785 int msg_get_msgsize_opt_int(void *size_opt, int field)
1786 {
1787         if (!size_opt)
1788                 return MSG_ERR_NULL_POINTER;
1789
1790         int ret = MSG_ERR_INVALID_PARAMETER;
1791
1792         MSG_MSGSIZE_OPT_S *msg_opt = (MSG_MSGSIZE_OPT_S *)size_opt;
1793
1794         switch (field)
1795         {
1796         case MSG_MESSAGE_SIZE_INT :
1797                 ret = msg_opt->nMsgSize;
1798                 break;
1799         default :
1800                 break;
1801         }
1802
1803         return ret;
1804 }
1805
1806 int msg_set_msgsize_opt_int(void *size_opt, int field, int value)
1807 {
1808         if (!size_opt)
1809                 return MSG_ERR_NULL_POINTER;
1810
1811         int ret = MSG_SUCCESS;
1812
1813         MSG_MSGSIZE_OPT_S *msg_opt = (MSG_MSGSIZE_OPT_S *)size_opt;
1814
1815         switch (field)
1816         {
1817         case MSG_MESSAGE_SIZE_INT :
1818                 msg_opt->nMsgSize = value;
1819                 break;
1820         default :
1821                 ret = MSG_ERR_INVALID_PARAMETER;
1822                 break;
1823         }
1824
1825         return ret;
1826 }