mapi/msg_svc.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 <string.h>
  18
  19 #include "MsgDebug.h"
  20 #include "MsgTypes.h"
  21 #include "MsgHandle.h"
  22 #include "MsgTextConvert.h"
  23 #include "MsgException.h"
  24
  25 #include "msg_private.h"
  26 #include "msg.h"
  27
  28 #define MSG_TYPE_CHECK(a, b) \
  29                 ({\
  30                         if(a != (b & 0xff00)) return MSG_ERR_INVALID_PARAMETER; \
  31                 })\
  32
  33
  34
  35 EXPORT_API msg_struct_t msg_create_struct(int field)
  36 {
  37         msg_struct_s *msg_struct = new msg_struct_s;
  38         memset(msg_struct, 0x00, sizeof(msg_struct_s));
  39
  40         msg_struct->type = field;
  41
  42         switch(field)
  43         {
  44         case MSG_STRUCT_MESSAGE_INFO :
  45                 msg_message_create_struct(msg_struct);
  46                 break;
  47         case MSG_STRUCT_CONV_INFO:
  48         {
  49                 msg_struct->data = (void *)new MSG_CONVERSATION_VIEW_S;
  50                 memset(msg_struct->data, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
  51                 break;
  52         }
  53         case MSG_STRUCT_FILTER:
  54         {
  55                 msg_struct->data = (void *)new MSG_FILTER_S;
  56                 memset(msg_struct->data, 0x00, sizeof(MSG_FILTER_S));
  57                 break;
  58         }
  59         case MSG_STRUCT_THREAD_INFO:
  60         {
  61                 msg_struct->data = (void *)new MSG_THREAD_VIEW_S;
  62                 memset(msg_struct->data, 0x00, sizeof(MSG_THREAD_VIEW_S));
  63                 break;
  64         }
  65         case MSG_STRUCT_SENDOPT:
  66         {
  67                 MSG_SENDINGOPT_S *pOpt = (MSG_SENDINGOPT_S *)new MSG_SENDINGOPT_S;
  68                 memset(pOpt, 0x00, sizeof(MSG_SENDINGOPT_S));
  69                 msg_struct->data = pOpt;
  70
  71                 msg_struct_s *pSms = new msg_struct_s;
  72                 msg_struct_s *pMms = new msg_struct_s;
  73
  74                 pOpt->mmsSendOpt = (msg_struct_t)pMms;
  75                 pOpt->smsSendOpt = (msg_struct_t)pSms;
  76
  77                 pMms->type = MSG_STRUCT_MMS_SENDOPT;
  78                 pMms->data = new MMS_SENDINGOPT_S;
  79                 memset(pMms->data, 0x00, sizeof(MMS_SENDINGOPT_S));
  80
  81                 pSms->type = MSG_STRUCT_SMS_SENDOPT;
  82                 pSms->data = new SMS_SENDINGOPT_S;
  83                 memset(pSms->data, 0x00, sizeof(SMS_SENDINGOPT_S));
  84                 break;
  85         }
  86         case MSG_STRUCT_SYNCML_INFO:
  87         {
  88                 MSG_SYNCML_MESSAGE_S *pSyncML= (MSG_SYNCML_MESSAGE_S *)new MSG_SYNCML_MESSAGE_S;
  89                 memset(pSyncML, 0x00, sizeof(MSG_SYNCML_MESSAGE_S));
  90                 msg_struct->data = pSyncML;
  91
  92                 msg_struct_s *pStruct = new msg_struct_s;
  93                 pSyncML->msg = (msg_struct_t)pStruct;
  94                 pStruct->type = MSG_STRUCT_MESSAGE_INFO;
  95                 msg_message_create_struct(pStruct);
  96
  97                 break;
  98         }
  99         case MSG_STRUCT_COUNT_INFO:
 100         {
 101                 msg_struct->data = new MSG_COUNT_INFO_S;
 102                 memset(msg_struct->data, 0x00, sizeof(MSG_COUNT_INFO_S));
 103                 break;
 104         }
 105         case MSG_STRUCT_THREAD_COUNT_INFO:
 106         {
 107                 msg_struct->data = new MSG_THREAD_COUNT_INFO_S;
 108                 memset(msg_struct->data, 0x00, sizeof(MSG_THREAD_COUNT_INFO_S));
 109                 break;
 110         }
 111         case MSG_STRUCT_THREAD_LIST_INDEX:
 112         {
 113                 MSG_THREAD_LIST_INDEX_INFO_S * pThread = (MSG_THREAD_LIST_INDEX_INFO_S *)new MSG_THREAD_LIST_INDEX_INFO_S;
 114                 memset(pThread, 0x00, sizeof(MSG_THREAD_LIST_INDEX_INFO_S));
 115
 116                 msg_struct->data = (void *)pThread;
 117
 118                 msg_struct_s *pStruct = new msg_struct_s;
 119                 pThread->msgAddrInfo = (msg_struct_t)pStruct;
 120
 121                 pStruct->type = MSG_STRUCT_ADDRESS_INFO;
 122                 pStruct->data = new MSG_ADDRESS_INFO_S;
 123                 memset(pStruct->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 124
 125                 break;
 126         }
 127         case MSG_STRUCT_SORT_RULE:
 128         {
 129                 msg_struct->data = new MSG_SORT_RULE_S;
 130                 memset(msg_struct->data, 0x00, sizeof(MSG_SORT_RULE_S));
 131                 break;
 132         }
 133         case MSG_STRUCT_FOLDER_INFO:
 134         {
 135                 msg_struct->data = new MSG_FOLDER_INFO_S;
 136                 memset(msg_struct->data, 0x00, sizeof(MSG_FOLDER_INFO_S));
 137                 break;
 138         }
 139         case MSG_STRUCT_SEARCH_CONDITION:
 140         {
 141                 msg_struct->data = new MSG_SEARCH_CONDITION_S;
 142                 memset(msg_struct->data, 0x00, sizeof(MSG_SEARCH_CONDITION_S));
 143                 break;
 144         }
 145         case MSG_STRUCT_REPORT_STATUS_INFO:
 146         {
 147                 msg_struct->data = new MSG_REPORT_STATUS_INFO_S;
 148                 memset(msg_struct->data, 0x00, sizeof(MSG_REPORT_STATUS_INFO_S));
 149                 break;
 150         }
 151         case MSG_STRUCT_SETTING_SMSC_OPT :
 152         {
 153         msg_struct->data = new MSG_SMSC_LIST_HIDDEN_S;
 154         memset(msg_struct->data, 0x00, sizeof(MSG_SMSC_LIST_HIDDEN_S));
 155
 156         MSG_SMSC_LIST_HIDDEN_S *pTmp = (MSG_SMSC_LIST_HIDDEN_S *)msg_struct->data;
 157
 158         msg_struct_list_s *smsc_list = (msg_struct_list_s *)new msg_struct_list_s;
 159         memset(smsc_list, 0x00, sizeof(msg_struct_list_s));
 160
 161         pTmp->smsc_list = smsc_list;
 162
 163         smsc_list->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t)*SMSC_LIST_MAX];
 164
 165         msg_struct_s *pStructTmp = NULL;
 166
 167         for (int i = 0; i < SMSC_LIST_MAX; i++) {
 168                 pStructTmp = (msg_struct_s *)new msg_struct_s;
 169                 pStructTmp->type = MSG_STRUCT_SETTING_SMSC_INFO;
 170                 pStructTmp->data = new MSG_SMSC_DATA_S;
 171                 memset(pStructTmp->data, 0x00, sizeof(MSG_SMSC_DATA_S));
 172                 smsc_list->msg_struct_info[i] = (msg_struct_t)pStructTmp;
 173         }
 174                 break;
 175         }
 176         case MSG_STRUCT_SETTING_SMSC_INFO :
 177         {
 178                 msg_struct->data = new MSG_SMSC_DATA_S;
 179                 memset(msg_struct->data, 0x00, sizeof(MSG_SMSC_DATA_S));
 180                 break;
 181         }
 182         case MSG_STRUCT_SETTING_CB_OPT :
 183         {
 184         msg_struct->data = new MSG_CBMSG_OPT_HIDDEN_S;
 185         memset(msg_struct->data, 0x00, sizeof(MSG_CBMSG_OPT_HIDDEN_S));
 186
 187         MSG_CBMSG_OPT_HIDDEN_S *pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)msg_struct->data;
 188
 189         pTmp->channelData = (msg_struct_list_s *)new msg_struct_list_s;
 190         memset(pTmp->channelData, 0x00, sizeof(msg_struct_list_s));
 191
 192         pTmp->channelData->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t)*CB_CHANNEL_MAX];
 193
 194         msg_struct_s *pStructTmp = NULL;
 195
 196         for (int i = 0; i < CB_CHANNEL_MAX; i++) {
 197                 pStructTmp = (msg_struct_s *)new msg_struct_s;
 198                 pStructTmp->type = MSG_STRUCT_SETTING_CB_CHANNEL_INFO;
 199                 pStructTmp->data = new MSG_CB_CHANNEL_INFO_S;
 200
 201                 memset(pStructTmp->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
 202                 pTmp->channelData->msg_struct_info[i] = (msg_struct_t)pStructTmp;
 203         }
 204
 205                 break;
 206         }
 207         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 208         {
 209                 msg_struct->data = new MSG_CB_CHANNEL_INFO_S;
 210                 memset(msg_struct->data, 0x00, sizeof(MSG_CB_CHANNEL_INFO_S));
 211                 break;
 212         }
 213         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
 214         {
 215         msg_struct->data = new MSG_SMS_SENDOPT_S;
 216         memset(msg_struct->data, 0x00, sizeof(MSG_SMS_SENDOPT_S));
 217                 break;
 218         }
 219         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
 220         {
 221                 msg_struct->data = new MSG_MMS_SENDOPT_S;
 222                 memset(msg_struct->data, 0x00, sizeof(MSG_MMS_SENDOPT_S));
 223                 break;
 224         }
 225         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
 226         {
 227                 msg_struct->data = new MSG_MMS_RECVOPT_S;
 228                 memset(msg_struct->data, 0x00, sizeof(MSG_MMS_RECVOPT_S));
 229                 break;
 230         }
 231         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
 232         {
 233                 msg_struct->data = new MSG_PUSHMSG_OPT_S;
 234                 memset(msg_struct->data, 0x00, sizeof(MSG_PUSHMSG_OPT_S));
 235                 break;
 236         }
 237         case MSG_STRUCT_SETTING_VOICE_MSG_OPT :
 238         {
 239                 msg_struct->data = new MSG_VOICEMAIL_OPT_S;
 240                 memset(msg_struct->data, 0x00, sizeof(MSG_VOICEMAIL_OPT_S));
 241                 break;
 242         }
 243         case MSG_STRUCT_SETTING_GENERAL_OPT :
 244         {
 245                 msg_struct->data = new MSG_GENERAL_OPT_S;
 246                 memset(msg_struct->data, 0x00, sizeof(MSG_GENERAL_OPT_S));
 247                 break;
 248         }
 249         case MSG_STRUCT_SETTING_MSGSIZE_OPT :
 250         {
 251                 msg_struct->data = new MSG_MSGSIZE_OPT_S;
 252                 memset(msg_struct->data, 0x00, sizeof(MSG_MSGSIZE_OPT_S));
 253                 break;
 254         }
 255         case MSG_STRUCT_SMS_SENDOPT:
 256         {
 257                 msg_struct->data = new SMS_SENDINGOPT_S;
 258                 memset(msg_struct->data, 0x00, sizeof(SMS_SENDINGOPT_S));
 259                 break;
 260         }
 261         case MSG_STRUCT_MMS_SENDOPT:
 262         {
 263                 msg_struct->data = new MMS_SENDINGOPT_S;
 264                 memset(msg_struct->data, 0x00, sizeof(MMS_SENDINGOPT_S));
 265                 break;
 266         }
 267         case MSG_STRUCT_REQUEST_INFO:
 268         {
 269                 MSG_REQUEST_S *pRequest = (MSG_REQUEST_S *)new MSG_REQUEST_S;
 270                 memset(pRequest, 0x00, sizeof(MSG_REQUEST_S));
 271                 msg_struct->data = pRequest;
 272
 273                 msg_struct_s *pMsg = (msg_struct_s *)new msg_struct_s;
 274                 msg_struct_s *pOpt = (msg_struct_s *)new msg_struct_s;
 275
 276                 pRequest->msg = (msg_struct_t)pMsg;
 277                 pRequest->sendOpt = (msg_struct_t)pOpt;
 278
 279                 pMsg->type = MSG_STRUCT_MESSAGE_INFO;
 280                 msg_message_create_struct(pMsg);
 281
 282                 pOpt->type = MSG_STRUCT_SENDOPT;
 283                 pOpt->data = new MSG_SENDINGOPT_S;
 284                 memset(pOpt->data, 0x00, sizeof(MSG_SENDINGOPT_S));
 285                 msg_struct_s *pSms = new msg_struct_s;
 286                 msg_struct_s *pMms = new msg_struct_s;
 287
 288                 MSG_SENDINGOPT_S *sendOpt = (MSG_SENDINGOPT_S *)pOpt->data;
 289
 290                 sendOpt->mmsSendOpt = (msg_struct_t)pMms;
 291                 sendOpt->smsSendOpt = (msg_struct_t)pSms;
 292
 293                 pMms->type = MSG_STRUCT_MMS_SENDOPT;
 294                 pMms->data = new MMS_SENDINGOPT_S;
 295                 memset(pMms->data, 0x00, sizeof(MMS_SENDINGOPT_S));
 296
 297                 pSms->type = MSG_STRUCT_SMS_SENDOPT;
 298                 pSms->data = new SMS_SENDINGOPT_S;
 299                 memset(pSms->data, 0x00, sizeof(SMS_SENDINGOPT_S));
 300                 break;
 301         }
 302         case MSG_STRUCT_MMS:
 303         case MSG_STRUCT_MMS_PAGE:
 304         case MSG_STRUCT_MMS_MEDIA:
 305         case MSG_STRUCT_MMS_ATTACH:
 306         case MSG_STRUCT_MMS_REGION:
 307         case MSG_STRUCT_MMS_TRANSITION:
 308         case MSG_STRUCT_MMS_META:
 309         case MSG_STRUCT_MMS_SMIL_TEXT:
 310         case MSG_STRUCT_MMS_SMIL_AVI:
 311                 msg_struct->data = msg_mms_create_struct_data(field);
 312                 break;
 313         case MSG_STRUCT_PUSH_CONFIG_INFO:
 314                 msg_struct->data = new MSG_PUSH_EVENT_INFO_S;
 315                 memset(msg_struct->data, 0x00, sizeof(MSG_PUSH_EVENT_INFO_S));
 316                 break;
 317         }
 318
 319         return (msg_struct_t) msg_struct;
 320 }
 321
 322
 323 EXPORT_API int msg_release_struct(msg_struct_t *msg_struct_handle)
 324 {
 325         msg_error_t err = MSG_SUCCESS;
 326
 327         if (msg_struct_handle == NULL || *msg_struct_handle == NULL)
 328                 return MSG_ERR_NULL_POINTER;
 329
 330         msg_struct_s *msg_struct = (msg_struct_s *)*msg_struct_handle;
 331
 332         switch(msg_struct->type)
 333         {
 334         case MSG_STRUCT_MESSAGE_INFO :
 335         {
 336                 msg_message_release(&msg_struct);
 337
 338                 *msg_struct_handle = NULL;
 339                 break;
 340         }
 341         case MSG_STRUCT_FILTER:
 342         {
 343                 delete (MSG_FILTER_S*)(msg_struct->data);
 344                 msg_struct->data = NULL;
 345
 346                 delete msg_struct;
 347                 *msg_struct_handle = NULL;
 348                 break;
 349         }
 350         case MSG_STRUCT_CONV_INFO:
 351         {
 352                 MSG_CONVERSATION_VIEW_S *pConv = (MSG_CONVERSATION_VIEW_S*)(msg_struct->data);
 353
 354                 if (pConv->pText) {
 355                         delete [] pConv->pText;
 356                         pConv->pText = NULL;
 357                 }
 358
 359                 delete pConv;
 360                 msg_struct->data = NULL;
 361
 362                 delete msg_struct;
 363                 *msg_struct_handle = NULL;
 364                 break;
 365         }
 366         case MSG_STRUCT_THREAD_INFO:
 367         {
 368                 delete (MSG_THREAD_VIEW_S*)(msg_struct->data);
 369                 msg_struct->data = NULL;
 370
 371                 delete msg_struct;
 372                 *msg_struct_handle = NULL;
 373                 break;
 374         }
 375         case MSG_STRUCT_SENDOPT:
 376         {
 377                 MSG_SENDINGOPT_S *pOpt = (MSG_SENDINGOPT_S*)(msg_struct->data);
 378                 delete (MMS_SENDINGOPT_S *)(((msg_struct_s *)pOpt->mmsSendOpt)->data);
 379                 ((msg_struct_s *)pOpt->mmsSendOpt)->data = NULL;
 380                 delete (msg_struct_s *)pOpt->mmsSendOpt;
 381                 pOpt->mmsSendOpt = NULL;
 382
 383                 delete (SMS_SENDINGOPT_S *)(((msg_struct_s *)pOpt->smsSendOpt)->data);
 384                 ((msg_struct_s *)pOpt->smsSendOpt)->data = NULL;
 385                 delete (msg_struct_s *)pOpt->smsSendOpt;
 386                 pOpt->smsSendOpt = NULL;
 387
 388                 delete pOpt;
 389                 msg_struct->data = NULL;
 390
 391                 delete msg_struct;
 392                 *msg_struct_handle = NULL;
 393
 394                 break;
 395         }
 396         case MSG_STRUCT_SYNCML_INFO:
 397         {
 398                 MSG_SYNCML_MESSAGE_S *pSyncML = (MSG_SYNCML_MESSAGE_S*)(msg_struct->data);
 399                 msg_struct_s *msg = (msg_struct_s *)pSyncML->msg;
 400                 msg_message_release(&msg);
 401
 402                 delete pSyncML;
 403                 msg_struct->data = NULL;
 404
 405                 delete msg_struct;
 406                 *msg_struct_handle = NULL;
 407                 break;
 408         }
 409         case MSG_STRUCT_COUNT_INFO:
 410         {
 411                 delete (MSG_COUNT_INFO_S*)(msg_struct->data);
 412                 msg_struct->data = NULL;
 413
 414                 delete msg_struct;
 415                 *msg_struct_handle = NULL;
 416                 break;
 417         }
 418         case MSG_STRUCT_THREAD_COUNT_INFO:
 419         {
 420                 delete (MSG_THREAD_COUNT_INFO_S*)(msg_struct->data);
 421                 msg_struct->data = NULL;
 422
 423                 delete msg_struct;
 424                 *msg_struct_handle = NULL;
 425
 426                 break;
 427         }
 428         case MSG_STRUCT_THREAD_LIST_INDEX:
 429         {
 430                 MSG_THREAD_LIST_INDEX_INFO_S *pThread = (MSG_THREAD_LIST_INDEX_INFO_S*)(msg_struct->data);
 431                 delete (MSG_ADDRESS_INFO_S *)(((msg_struct_s *)pThread->msgAddrInfo)->data);
 432                 ((msg_struct_s *)pThread->msgAddrInfo)->data = NULL;
 433                 delete (msg_struct_s *)pThread->msgAddrInfo;
 434                 pThread->msgAddrInfo = NULL;
 435                 delete pThread;
 436                 msg_struct->data = NULL;
 437
 438                 delete msg_struct;
 439                 *msg_struct_handle = NULL;
 440
 441                 break;
 442         }
 443         case MSG_STRUCT_SORT_RULE:
 444         {
 445                 delete (MSG_SORT_RULE_S*)(msg_struct->data);
 446                 msg_struct->data = NULL;
 447
 448                 delete msg_struct;
 449                 *msg_struct_handle = NULL;
 450
 451                 break;
 452         }
 453         case MSG_STRUCT_FOLDER_INFO:
 454         {
 455                 delete (MSG_FOLDER_INFO_S*)(msg_struct->data);
 456                 msg_struct->data = NULL;
 457
 458                 delete msg_struct;
 459                 *msg_struct_handle = NULL;
 460
 461                 break;
 462         }
 463         case MSG_STRUCT_SEARCH_CONDITION:
 464         {
 465                 delete (MSG_SEARCH_CONDITION_S*)(msg_struct->data);
 466                 msg_struct->data = NULL;
 467
 468                 delete msg_struct;
 469                 *msg_struct_handle = NULL;
 470
 471                 break;
 472         }
 473         case MSG_STRUCT_REPORT_STATUS_INFO:
 474         {
 475                 delete (MSG_REPORT_STATUS_INFO_S*)(msg_struct->data);
 476                 msg_struct->data = NULL;
 477
 478                 delete msg_struct;
 479                 *msg_struct_handle = NULL;
 480
 481                 break;
 482         }
 483         case MSG_STRUCT_SMS_SENDOPT:
 484         {
 485                 delete (SMS_SENDINGOPT_S*)(msg_struct->data);
 486                 msg_struct->data = NULL;
 487
 488                 delete msg_struct;
 489                 *msg_struct_handle = NULL;
 490
 491                 break;
 492         }
 493         case MSG_STRUCT_MMS_SENDOPT:
 494         {
 495                 delete (MMS_SENDINGOPT_S*)(msg_struct->data);
 496                 msg_struct->data = NULL;
 497
 498                 delete msg_struct;
 499                 *msg_struct_handle = NULL;
 500
 501                 break;
 502         }
 503         case MSG_STRUCT_REQUEST_INFO:
 504         {
 505                 MSG_REQUEST_S *pRequest = (MSG_REQUEST_S*)(msg_struct->data);
 506
 507                 MSG_SENDINGOPT_S *pSendingOpt = (MSG_SENDINGOPT_S *)(((msg_struct_s *)pRequest->sendOpt)->data);
 508
 509                 msg_struct_s *pMmsOpt = (msg_struct_s *)pSendingOpt->mmsSendOpt;
 510                 msg_struct_s *pSmsOpt = (msg_struct_s *)pSendingOpt->smsSendOpt;
 511
 512                 delete (MMS_SENDINGOPT_S *)(pMmsOpt->data);
 513                 pMmsOpt->data = NULL;
 514                 delete (msg_struct_s *)pSendingOpt->mmsSendOpt;
 515                 pSendingOpt->mmsSendOpt = NULL;
 516                 delete (MMS_SENDINGOPT_S *)(pSmsOpt->data);
 517                 pSmsOpt->data = NULL;
 518                 delete (msg_struct_s *)pSendingOpt->smsSendOpt;
 519                 pSendingOpt->smsSendOpt = NULL;
 520
 521                 delete (MSG_SENDINGOPT_S *)pSendingOpt;
 522                 ((msg_struct_s *)pRequest->sendOpt)->data = NULL;
 523                 delete (msg_struct_s *)pRequest->sendOpt;
 524                 pRequest->sendOpt = NULL;
 525
 526                 msg_struct_s *msg = (msg_struct_s *)pRequest->msg;
 527                 msg_message_release(&msg);
 528
 529                 delete pRequest;
 530                 msg_struct->data = NULL;
 531
 532                 delete msg_struct;
 533                 *msg_struct_handle = NULL;
 534                 break;
 535         }
 536         case MSG_STRUCT_MMS:
 537         case MSG_STRUCT_MMS_PAGE:
 538         case MSG_STRUCT_MMS_MEDIA:
 539         case MSG_STRUCT_MMS_ATTACH:
 540         case MSG_STRUCT_MMS_REGION:
 541         case MSG_STRUCT_MMS_TRANSITION:
 542         case MSG_STRUCT_MMS_META:
 543         case MSG_STRUCT_MMS_SMIL_TEXT:
 544         case MSG_STRUCT_MMS_SMIL_AVI:
 545         {
 546                 msg_mms_release_struct(&msg_struct);
 547                 *msg_struct_handle = NULL;
 548                 break;
 549         }
 550         case MSG_STRUCT_SETTING_SMSC_OPT :
 551         {
 552                 msg_struct_list_s *smsc_list = NULL;
 553                 msg_struct_s *smsc_info = NULL;
 554                 MSG_SMSC_LIST_HIDDEN_S *pTmp = NULL;
 555
 556                 pTmp = (MSG_SMSC_LIST_HIDDEN_S *)msg_struct->data;
 557                 smsc_list = (msg_struct_list_s *)pTmp->smsc_list;
 558
 559                 for (int i = 0; i < SMSC_LIST_MAX; i++) {
 560                         smsc_info = (msg_struct_s *)smsc_list->msg_struct_info[i];
 561                         delete [] (MSG_SMSC_DATA_S*)(smsc_info->data);
 562                         delete [] smsc_info;
 563                 }
 564
 565                 delete [] smsc_list->msg_struct_info;
 566
 567                 delete [] (MSG_SMSC_LIST_HIDDEN_S*)pTmp;
 568                 msg_struct->data = NULL;
 569
 570                 delete msg_struct;
 571                 *msg_struct_handle = NULL;
 572                 break;
 573         }
 574         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 575         {
 576                 delete (MSG_CB_CHANNEL_INFO_S*)(msg_struct->data);
 577                 msg_struct->data = NULL;
 578
 579                 delete msg_struct;
 580                 *msg_struct_handle = NULL;
 581                 break;
 582         }
 583         case MSG_STRUCT_SETTING_CB_OPT :
 584         {
 585                 msg_struct_list_s *cb_list = NULL;
 586                 msg_struct_s *cb_info = NULL;
 587                 MSG_CBMSG_OPT_HIDDEN_S *pTmp = NULL;
 588
 589                 pTmp = (MSG_CBMSG_OPT_HIDDEN_S *)msg_struct->data;
 590                 cb_list = (msg_struct_list_s *)pTmp->channelData;
 591
 592                 for (int i = 0; i < CB_CHANNEL_MAX; i++) {
 593                         cb_info = (msg_struct_s *)cb_list->msg_struct_info[i];
 594                         delete [] (MSG_CB_CHANNEL_INFO_S*)(cb_info->data);
 595                         delete [] cb_info;
 596                 }
 597
 598                 delete [] cb_list->msg_struct_info;
 599
 600                 delete [] (MSG_CBMSG_OPT_HIDDEN_S*)pTmp;
 601                 msg_struct->data = NULL;
 602
 603                 delete msg_struct;
 604                 *msg_struct_handle = NULL;
 605                 break;
 606         }
 607         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
 608         {
 609                 delete (MSG_SMS_SENDOPT_S*)(msg_struct->data);
 610                 msg_struct->data = NULL;
 611
 612                 delete msg_struct;
 613                 *msg_struct_handle = NULL;
 614                 break;
 615         }
 616         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
 617         {
 618                 delete (MSG_MMS_SENDOPT_S*)(msg_struct->data);
 619                 msg_struct->data = NULL;
 620
 621                 delete msg_struct;
 622                 *msg_struct_handle = NULL;
 623                 break;
 624         }
 625         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
 626         {
 627                 delete (MSG_MMS_RECVOPT_S*)(msg_struct->data);
 628                 msg_struct->data = NULL;
 629
 630                 delete msg_struct;
 631                 *msg_struct_handle = NULL;
 632                 break;
 633         }
 634         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
 635         {
 636                 delete (MSG_PUSHMSG_OPT_S*)(msg_struct->data);
 637                 msg_struct->data = NULL;
 638
 639                 delete msg_struct;
 640                 *msg_struct_handle = NULL;
 641                 break;
 642         }
 643         case MSG_STRUCT_SETTING_VOICE_MSG_OPT :
 644         {
 645                 delete (MSG_VOICEMAIL_OPT_S*)(msg_struct->data);
 646                 msg_struct->data = NULL;
 647
 648                 delete msg_struct;
 649                 *msg_struct_handle = NULL;
 650                 break;
 651         }
 652         case MSG_STRUCT_SETTING_GENERAL_OPT :
 653         {
 654                 delete (MSG_GENERAL_OPT_S*)(msg_struct->data);
 655                 msg_struct->data = NULL;
 656
 657                 delete msg_struct;
 658                 *msg_struct_handle = NULL;
 659                 break;
 660         }
 661         case MSG_STRUCT_SETTING_MSGSIZE_OPT :
 662         {
 663                 delete (MSG_MSGSIZE_OPT_S*)(msg_struct->data);
 664                 msg_struct->data = NULL;
 665
 666                 delete msg_struct;
 667                 *msg_struct_handle = NULL;
 668                 break;
 669         }
 670         case MSG_STRUCT_ADDRESS_INFO :
 671         {
 672                 delete (MSG_ADDRESS_INFO_S*)(msg_struct->data);
 673                 msg_struct->data = NULL;
 674
 675                 delete msg_struct;
 676                 *msg_struct_handle = NULL;
 677                 break;
 678         }
 679         case MSG_STRUCT_PUSH_CONFIG_INFO:
 680         {
 681                 delete (MSG_PUSH_EVENT_INFO_S*)(msg_struct->data);
 682                 msg_struct->data = NULL;
 683
 684                 delete msg_struct;
 685                 *msg_struct_handle = NULL;
 686                 break;
 687         }
 688         default :
 689                 err = MSG_ERR_INVALID_PARAMETER;
 690                 break;
 691         }
 692
 693         return err;
 694 }
 695
 696 int msg_release_list_struct(msg_struct_list_s *msg_struct_list)
 697 {
 698         msg_error_t err = MSG_SUCCESS;
 699
 700         if (msg_struct_list == NULL)
 701                 return MSG_ERR_NULL_POINTER;
 702
 703         if (msg_struct_list->msg_struct_info == NULL) {
 704                 if (msg_struct_list->nCount > 0)
 705                         msg_struct_list->nCount = 0;
 706                 return err;
 707         }
 708
 709         if(msg_struct_list->nCount > 0) {
 710                 int structType = ((msg_struct_s *)msg_struct_list->msg_struct_info[0])->type;
 711                 int listCnt = msg_struct_list->nCount;
 712
 713                 switch (structType)
 714                 {
 715                 case MSG_STRUCT_ADDRESS_INFO :
 716                 {
 717                         listCnt = MAX_TO_ADDRESS_CNT;
 718                         break;
 719                 }
 720                 default :
 721                         break;
 722                 }
 723
 724                 for(int i = 0; i < listCnt; i++) {
 725                         msg_release_struct(&(msg_struct_list->msg_struct_info[i]));
 726                 }
 727         }
 728
 729         //free peer info list
 730         delete [] msg_struct_list->msg_struct_info;
 731         msg_struct_list->msg_struct_info = NULL;
 732
 733         return err;
 734 }
 735
 736 EXPORT_API int msg_get_int_value(msg_struct_t msg_struct_handle, int field, int *value)
 737 {
 738
 739         msg_error_t err = MSG_SUCCESS;
 740
 741         if (msg_struct_handle == NULL)
 742                 return MSG_ERR_NULL_POINTER;
 743
 744         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
 745         MSG_TYPE_CHECK(msg_struct->type, field);
 746
 747         if (msg_struct->data == NULL)
 748                 return MSG_ERR_NULL_POINTER;
 749
 750         switch (msg_struct->type)
 751         {
 752         case MSG_STRUCT_MESSAGE_INFO :
 753                 err = msg_message_get_int_value(msg_struct->data, field, value);
 754                 break;
 755         case MSG_STRUCT_FILTER:
 756                 *value = msg_get_filter_info_int(msg_struct->data, field);
 757                 break;
 758         case MSG_STRUCT_SYNCML_INFO :
 759                 *value = msg_syncml_info_get_int(msg_struct->data, field);
 760                 break;
 761         case MSG_STRUCT_COUNT_INFO :
 762                 *value = msg_count_info_get_int(msg_struct->data, field);
 763                 break;
 764         case MSG_STRUCT_THREAD_COUNT_INFO :
 765                 *value = msg_thread_count_get_int(msg_struct->data, field);
 766                 break;
 767         case MSG_STRUCT_THREAD_LIST_INDEX :
 768                 *value = msg_thread_index_get_int(msg_struct->data, field);
 769                 break;
 770         case MSG_STRUCT_SORT_RULE :
 771                 *value = msg_sortrule_get_int(msg_struct->data, field);
 772                 break;
 773         case MSG_STRUCT_FOLDER_INFO :
 774                 *value = msg_folder_info_get_int(msg_struct->data, field);
 775                 break;
 776         case MSG_STRUCT_THREAD_INFO :
 777                 *value = msg_thread_info_get_int(msg_struct->data, field);
 778                 break;
 779         case MSG_STRUCT_CONV_INFO :
 780                 *value = msg_conv_info_get_int(msg_struct->data, field);
 781                 break;
 782         case MSG_STRUCT_SEARCH_CONDITION :
 783                 *value = msg_search_condition_get_int(msg_struct->data, field);
 784                 break;
 785         case MSG_STRUCT_REPORT_STATUS_INFO :
 786                 *value = msg_report_status_get_int(msg_struct->data, field);
 787                 break;
 788         case MSG_STRUCT_ADDRESS_INFO :
 789                 *value = msg_address_info_get_int(msg_struct->data, field);
 790                 break;
 791         case MSG_STRUCT_MMS_SENDOPT :
 792                 *value = msg_mms_sendopt_get_int(msg_struct->data, field);
 793                 break;
 794         case MSG_STRUCT_REJECT_MSG_INFO :
 795                 *value = msg_reject_message_get_int(msg_struct->data, field);
 796                 break;
 797         case MSG_STRUCT_REQUEST_INFO :
 798                 *value = msg_request_get_int(msg_struct->data, field);
 799                 break;
 800         case MSG_STRUCT_SENT_STATUS_INFO :
 801                 *value = msg_sent_status_get_int((MSG_SENT_STATUS_S *)msg_struct->data, field);
 802                 break;
 803         case MSG_STRUCT_CB_MSG :
 804                 err = msg_cb_message_get_int_value (msg_struct->data, field, value);
 805                 break;
 806         case MSG_STRUCT_MMS:
 807         case MSG_STRUCT_MMS_PAGE:
 808         case MSG_STRUCT_MMS_MEDIA:
 809         case MSG_STRUCT_MMS_ATTACH:
 810         case MSG_STRUCT_MMS_REGION:
 811         case MSG_STRUCT_MMS_TRANSITION:
 812         case MSG_STRUCT_MMS_META:
 813         case MSG_STRUCT_MMS_SMIL_TEXT:
 814         case MSG_STRUCT_MMS_SMIL_AVI:
 815                 err = msg_mms_get_int_value(msg_struct, field, value);
 816                 break;
 817         case MSG_STRUCT_SETTING_SMSC_OPT :
 818         case MSG_STRUCT_SETTING_SMSC_INFO :
 819         case MSG_STRUCT_SETTING_CB_OPT :
 820         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 821         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
 822         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
 823         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
 824         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
 825         case MSG_STRUCT_SETTING_GENERAL_OPT :
 826         case MSG_STRUCT_SETTING_MSGSIZE_OPT :
 827                 err = msg_setting_get_int_value(msg_struct, field, value);
 828                 break;
 829         default :
 830                 err = MSG_ERR_INVALID_PARAMETER;
 831                 break;
 832         }
 833
 834         return err;
 835 }
 836
 837 EXPORT_API int msg_get_str_value(msg_struct_t msg_struct_handle, int field, char *src, int size)
 838 {
 839         msg_error_t err = MSG_SUCCESS;
 840
 841         if (msg_struct_handle == NULL)
 842                 return MSG_ERR_NULL_POINTER;
 843
 844         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
 845
 846         if (msg_struct->data == NULL)
 847                 return MSG_ERR_NULL_POINTER;
 848
 849         char *ret_str = NULL;
 850
 851         switch (msg_struct->type)
 852         {
 853         case MSG_STRUCT_MESSAGE_INFO :
 854                 err = msg_message_get_str_value(msg_struct->data, field, src, size);
 855                 break;
 856         case MSG_STRUCT_FILTER:
 857                 ret_str = msg_get_filter_info_str(msg_struct->data, field);
 858                         if (ret_str == NULL)
 859                                 err = MSG_ERR_UNKNOWN;
 860                         else
 861                                 strncpy(src, ret_str, size);
 862                 break;
 863         case MSG_STRUCT_FOLDER_INFO :
 864                 ret_str = msg_folder_info_get_str(msg_struct->data, field);
 865                 if (ret_str == NULL)
 866                         err = MSG_ERR_UNKNOWN;
 867                 else
 868                         strncpy(src, ret_str, size);
 869                 break;
 870         case MSG_STRUCT_THREAD_INFO :
 871                 ret_str = msg_thread_info_get_str(msg_struct->data, field);
 872                 if (ret_str == NULL)
 873                         err = MSG_ERR_UNKNOWN;
 874                 else
 875                         strncpy(src, ret_str, size);
 876                 break;
 877         case MSG_STRUCT_CONV_INFO :
 878                 ret_str = msg_conv_info_get_str(msg_struct->data, field);
 879                 if (ret_str == NULL)
 880                         err = MSG_ERR_UNKNOWN;
 881                 else
 882                         strncpy(src, ret_str, size);
 883                 break;
 884         case MSG_STRUCT_SEARCH_CONDITION :
 885                 ret_str = msg_search_condition_get_str(msg_struct->data, field, size);
 886                 if (ret_str == NULL)
 887                         err = MSG_ERR_UNKNOWN;
 888                 else
 889                         strncpy(src, ret_str, size);
 890                 break;
 891
 892         case MSG_STRUCT_ADDRESS_INFO :
 893                 ret_str = msg_address_info_get_str(msg_struct->data, field, size);
 894                 if (ret_str == NULL)
 895                         err = MSG_ERR_UNKNOWN;
 896                 else
 897                         strncpy(src, ret_str, size);
 898                 break;
 899
 900         case MSG_STRUCT_REJECT_MSG_INFO :
 901                 ret_str = msg_reject_message_get_str(msg_struct->data, field, size);
 902                 if (ret_str == NULL)
 903                         err = MSG_ERR_UNKNOWN;
 904                 else
 905                         strncpy(src, ret_str, size);
 906                 break;
 907         case MSG_STRUCT_MMS:
 908         case MSG_STRUCT_MMS_PAGE:
 909         case MSG_STRUCT_MMS_MEDIA:
 910         case MSG_STRUCT_MMS_ATTACH:
 911         case MSG_STRUCT_MMS_REGION:
 912         case MSG_STRUCT_MMS_TRANSITION:
 913         case MSG_STRUCT_MMS_META:
 914         case MSG_STRUCT_MMS_SMIL_TEXT:
 915         case MSG_STRUCT_MMS_SMIL_AVI:
 916                 err = msg_mms_get_str_value(msg_struct, field, src, size);
 917                 break;
 918         case MSG_STRUCT_SETTING_SMSC_INFO :
 919         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 920         case MSG_STRUCT_SETTING_VOICE_MSG_OPT :
 921                 err = msg_setting_get_str_value(msg_struct, field, src, size);
 922                 break;
 923         case MSG_STRUCT_PUSH_CONFIG_INFO :
 924                 ret_str = msg_push_config_get_str(msg_struct->data, field, size);
 925                 if (ret_str == NULL)
 926                         err = MSG_ERR_UNKNOWN;
 927                 else
 928                         strncpy(src, ret_str, size);
 929                 break;
 930         case MSG_STRUCT_REPORT_STATUS_INFO:
 931                 ret_str = msg_report_status_get_str(msg_struct->data, field);
 932                 if (ret_str == NULL)
 933                         err = MSG_ERR_UNKNOWN;
 934                 else
 935                         strncpy(src, ret_str, size);
 936                 break;
 937         case MSG_STRUCT_CB_MSG :
 938                 err = msg_cb_message_get_str_value(msg_struct->data, field, src, size);
 939                 break;
 940         default :
 941                 err = MSG_ERR_INVALID_PARAMETER;
 942                 break;
 943         }
 944
 945         return err;
 946 }
 947
 948 EXPORT_API int msg_get_bool_value(msg_struct_t msg_struct_handle, int field, bool *value)
 949 {
 950         msg_error_t err = MSG_SUCCESS;
 951
 952         if (msg_struct_handle == NULL)
 953                 return MSG_ERR_NULL_POINTER;
 954
 955         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
 956
 957         if (msg_struct->data == NULL)
 958                 return MSG_ERR_NULL_POINTER;
 959
 960         switch (msg_struct->type)
 961         {
 962         case MSG_STRUCT_FILTER :
 963                 *value = msg_get_filter_info_bool(msg_struct->data, field);
 964                 break;
 965         case MSG_STRUCT_MESSAGE_INFO :
 966                 err = msg_message_get_bool_value(msg_struct->data, field, value);
 967                 break;
 968         case MSG_STRUCT_THREAD_INFO :
 969                 *value = msg_thread_info_get_bool(msg_struct->data, field);
 970                 break;
 971         case MSG_STRUCT_CONV_INFO:
 972                 *value = msg_conv_get_bool(msg_struct->data, field);
 973                 break;
 974         case MSG_STRUCT_SENDOPT:
 975                 *value = msg_sendopt_get_bool(msg_struct->data, field);
 976                 break;
 977         case MSG_STRUCT_SORT_RULE:
 978                 *value = msg_sortrule_get_bool(msg_struct->data, field);
 979                 break;
 980         case MSG_STRUCT_MMS_SENDOPT:
 981                 *value = msg_mms_sendopt_get_bool(msg_struct->data, field);
 982                 break;
 983         case MSG_STRUCT_SMS_SENDOPT:
 984                 *value = msg_sms_sendopt_get_bool(msg_struct->data, field);
 985                 break;
 986         case MSG_STRUCT_MMS:
 987         case MSG_STRUCT_MMS_PAGE:
 988         case MSG_STRUCT_MMS_MEDIA:
 989         case MSG_STRUCT_MMS_ATTACH:
 990         case MSG_STRUCT_MMS_REGION:
 991         case MSG_STRUCT_MMS_TRANSITION:
 992         case MSG_STRUCT_MMS_META:
 993         case MSG_STRUCT_MMS_SMIL_TEXT:
 994         case MSG_STRUCT_MMS_SMIL_AVI:
 995                 err = msg_mms_get_bool_value(msg_struct, field, value);
 996                 break;
 997         case MSG_STRUCT_SETTING_CB_OPT :
 998         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
 999         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
1000         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
1001         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
1002         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
1003         case MSG_STRUCT_SETTING_GENERAL_OPT :
1004                 err = msg_setting_get_bool_value(msg_struct, field, value);
1005                 break;
1006         default :
1007                 err = MSG_ERR_INVALID_PARAMETER;
1008                 break;
1009         }
1010
1011         return err;
1012 }
1013
1014 EXPORT_API int msg_get_struct_handle(msg_struct_t msg_struct_handle, int field, msg_struct_t *value)
1015 {
1016         msg_error_t err = MSG_SUCCESS;
1017
1018         if (msg_struct_handle == NULL)
1019                 return MSG_ERR_NULL_POINTER;
1020
1021         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1022
1023         if (msg_struct->data == NULL)
1024                 return MSG_ERR_NULL_POINTER;
1025
1026         switch (msg_struct->type)
1027         {
1028         case MSG_STRUCT_MESSAGE_INFO :
1029                 err = msg_message_get_struct_hnd(msg_struct->data, field, (void **)value);
1030                 break;
1031         case MSG_STRUCT_SENDOPT:
1032                 err = msg_sendopt_get_struct_handle(msg_struct, field, (void **)value);
1033                 break;
1034         case MSG_STRUCT_SYNCML_INFO:
1035                 err = msg_syncml_get_struct_handle(msg_struct, field, (void **)value);
1036                 break;
1037         case MSG_STRUCT_THREAD_LIST_INDEX:
1038                 err = msg_thread_index_get_struct_handle(msg_struct, field, (void **)value);
1039                 break;
1040         case MSG_STRUCT_MMS_MEDIA:
1041                 err = msg_mms_get_struct_handle(msg_struct, field, (msg_struct_s**)value);
1042                 break;
1043         case MSG_STRUCT_REQUEST_INFO:
1044                 err = msg_request_get_struct_handle(msg_struct, field, (void **)value);
1045                 break;
1046         default :
1047                 err = MSG_ERR_INVALID_PARAMETER;
1048                 break;
1049         }
1050
1051         return err;
1052 }
1053
1054 EXPORT_API int msg_get_list_handle(msg_struct_t msg_struct_handle, int field, void **value)
1055 {
1056         msg_error_t err = MSG_SUCCESS;
1057
1058         if (msg_struct_handle == NULL)
1059                 return MSG_ERR_NULL_POINTER;
1060
1061         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1062
1063         if (msg_struct->data == NULL)
1064                 return MSG_ERR_NULL_POINTER;
1065
1066         switch (msg_struct->type)
1067         {
1068         case MSG_STRUCT_MESSAGE_INFO :
1069                 err = msg_message_get_list_hnd(msg_struct->data, field, value);
1070                 break;
1071         case MSG_STRUCT_MMS:
1072         case MSG_STRUCT_MMS_PAGE:
1073                 err = msg_mms_get_list_handle(msg_struct, field, (msg_list_handle_t *)value);
1074                 break;
1075         case MSG_STRUCT_SETTING_CB_OPT :
1076         case MSG_STRUCT_SETTING_SMSC_OPT :
1077                 err = msg_setting_get_list_handle(msg_struct, field, value);
1078                 break;
1079         default :
1080                 err = MSG_ERR_INVALID_PARAMETER;
1081                 break;
1082         }
1083
1084         return err;
1085 }
1086
1087 EXPORT_API int msg_set_int_value(msg_struct_t msg_struct_handle, int field, int value)
1088 {
1089         msg_error_t err = MSG_SUCCESS;
1090
1091         if (msg_struct_handle == NULL)
1092                 return MSG_ERR_NULL_POINTER;
1093
1094         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1095
1096         if (msg_struct->data == NULL)
1097                 return MSG_ERR_NULL_POINTER;
1098
1099         switch (msg_struct->type)
1100         {
1101         case MSG_STRUCT_MESSAGE_INFO :
1102                 err = msg_message_set_int_value(msg_struct->data, field, value);
1103                 break;
1104         case MSG_STRUCT_FILTER :
1105                 err = msg_set_filter_info_int(msg_struct->data, field, value);
1106                 break;
1107         case MSG_STRUCT_SYNCML_INFO :
1108                 err = msg_syncml_info_set_int(msg_struct->data, field, value);
1109                 break;
1110         case MSG_STRUCT_COUNT_INFO :
1111                 err = msg_count_info_set_int(msg_struct->data, field, value);
1112                 break;
1113         case MSG_STRUCT_THREAD_COUNT_INFO :
1114                 err = msg_thread_count_set_int(msg_struct->data, field, value);
1115                 break;
1116         case MSG_STRUCT_THREAD_LIST_INDEX :
1117                 err = msg_thread_index_set_int(msg_struct->data, field, value);
1118                 break;
1119         case MSG_STRUCT_SORT_RULE :
1120                 err = msg_sortrule_set_int(msg_struct->data, field, value);
1121                 break;
1122         case MSG_STRUCT_FOLDER_INFO :
1123                 err = msg_folder_info_set_int(msg_struct->data, field, value);
1124                 break;
1125         case MSG_STRUCT_SEARCH_CONDITION :
1126                 err = msg_search_condition_set_int(msg_struct->data, field, value);
1127                 break;
1128         case MSG_STRUCT_REPORT_STATUS_INFO :
1129                 err = msg_report_status_set_int(msg_struct->data, field, value);
1130                 break;
1131         case MSG_STRUCT_ADDRESS_INFO :
1132                 err = msg_address_info_set_int(msg_struct->data, field, value);
1133                 break;
1134         case MSG_STRUCT_MMS_SENDOPT :
1135                 err = msg_mms_sendopt_set_int(msg_struct->data, field, value);
1136                 break;
1137         case MSG_STRUCT_REJECT_MSG_INFO :
1138                 err = msg_reject_message_set_int(msg_struct->data, field, value);
1139                 break;
1140         case MSG_STRUCT_REQUEST_INFO :
1141                 err = msg_request_set_int(msg_struct->data, field, value);
1142                 break;
1143         case MSG_STRUCT_MMS:
1144         case MSG_STRUCT_MMS_PAGE:
1145         case MSG_STRUCT_MMS_MEDIA:
1146         case MSG_STRUCT_MMS_ATTACH:
1147         case MSG_STRUCT_MMS_REGION:
1148         case MSG_STRUCT_MMS_TRANSITION:
1149         case MSG_STRUCT_MMS_META:
1150         case MSG_STRUCT_MMS_SMIL_TEXT:
1151         case MSG_STRUCT_MMS_SMIL_AVI:
1152                 err = msg_mms_set_int_value(msg_struct, field, value);
1153                 break;
1154         case MSG_STRUCT_SETTING_SMSC_OPT :
1155         case MSG_STRUCT_SETTING_SMSC_INFO :
1156         case MSG_STRUCT_SETTING_CB_OPT :
1157         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
1158         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
1159         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
1160         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
1161         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
1162         case MSG_STRUCT_SETTING_GENERAL_OPT :
1163         case MSG_STRUCT_SETTING_MSGSIZE_OPT :
1164                 err = msg_setting_set_int_value(msg_struct, field, value);
1165                 break;
1166         default :
1167                 err = MSG_ERR_INVALID_PARAMETER;
1168                 break;
1169         }
1170
1171         return err;
1172 }
1173
1174 EXPORT_API int msg_set_str_value(msg_struct_t msg_struct_handle, int field, char *value, int size)
1175 {
1176         msg_error_t err = MSG_SUCCESS;
1177
1178         if (msg_struct_handle == NULL)
1179                 return MSG_ERR_NULL_POINTER;
1180
1181         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1182
1183         if (msg_struct->data == NULL)
1184                 return MSG_ERR_NULL_POINTER;
1185
1186         switch (msg_struct->type)
1187         {
1188         case MSG_STRUCT_MESSAGE_INFO :
1189                 err = msg_message_set_str_value(msg_struct->data, field, value, size);
1190                 break;
1191         case MSG_STRUCT_FILTER :
1192                 err = msg_set_filter_info_str(msg_struct->data, field, value, size);
1193                 break;
1194         case MSG_STRUCT_FOLDER_INFO :
1195                 err = msg_folder_info_set_str(msg_struct->data, field, value, size);
1196                 break;
1197         case MSG_STRUCT_SEARCH_CONDITION :
1198                 err = msg_search_condition_set_str(msg_struct->data, field, value, size);
1199                 break;
1200         case MSG_STRUCT_ADDRESS_INFO :
1201                 err = msg_address_info_set_str(msg_struct->data, field, value, size);
1202                 break;
1203         case MSG_STRUCT_REJECT_MSG_INFO :
1204                 err = msg_reject_message_set_str(msg_struct->data, field, value, size);
1205                 break;
1206         case MSG_STRUCT_MMS:
1207         case MSG_STRUCT_MMS_PAGE:
1208         case MSG_STRUCT_MMS_MEDIA:
1209         case MSG_STRUCT_MMS_ATTACH:
1210         case MSG_STRUCT_MMS_REGION:
1211         case MSG_STRUCT_MMS_TRANSITION:
1212         case MSG_STRUCT_MMS_META:
1213         case MSG_STRUCT_MMS_SMIL_TEXT:
1214         case MSG_STRUCT_MMS_SMIL_AVI:
1215                 err = msg_mms_set_str_value(msg_struct, field, value, size);
1216                 break;
1217         case MSG_STRUCT_SETTING_SMSC_INFO :
1218         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
1219         case MSG_STRUCT_SETTING_VOICE_MSG_OPT :
1220                 err = msg_setting_set_str_value(msg_struct, field, value, size);
1221                 break;
1222         case MSG_STRUCT_PUSH_CONFIG_INFO:
1223                 err = msg_push_config_set_str(msg_struct->data, field, value, size);
1224                 break;
1225         default :
1226                 err = MSG_ERR_INVALID_PARAMETER;
1227                 break;
1228         }
1229
1230         return err;
1231 }
1232
1233 EXPORT_API int msg_set_bool_value(msg_struct_t msg_struct_handle, int field, bool value)
1234 {
1235         msg_error_t err = MSG_SUCCESS;
1236
1237         if (msg_struct_handle == NULL)
1238                 return MSG_ERR_NULL_POINTER;
1239
1240         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1241
1242         if (msg_struct->data == NULL)
1243                 return MSG_ERR_NULL_POINTER;
1244
1245         switch (msg_struct->type)
1246         {
1247         case MSG_STRUCT_FILTER :
1248                 err = msg_set_filter_info_bool(msg_struct->data, field, value);
1249                 break;
1250         case MSG_STRUCT_MESSAGE_INFO :
1251                 err = msg_message_set_bool_value(msg_struct->data, field, value);
1252                 break;
1253         case MSG_STRUCT_SENDOPT:
1254                 err = msg_sendopt_set_bool(msg_struct->data, field, value);
1255                 break;
1256         case MSG_STRUCT_SORT_RULE:
1257                 err = msg_sortrule_set_bool(msg_struct->data, field, value);
1258                 break;
1259         case MSG_STRUCT_MMS_SENDOPT:
1260                 err = msg_mms_sendopt_set_bool(msg_struct->data, field, value);
1261                 break;
1262         case MSG_STRUCT_SMS_SENDOPT:
1263                 err = msg_sms_sendopt_set_bool(msg_struct->data, field, value);
1264                 break;
1265         case MSG_STRUCT_MMS:
1266         case MSG_STRUCT_MMS_PAGE:
1267         case MSG_STRUCT_MMS_MEDIA:
1268         case MSG_STRUCT_MMS_ATTACH:
1269         case MSG_STRUCT_MMS_REGION:
1270         case MSG_STRUCT_MMS_TRANSITION:
1271         case MSG_STRUCT_MMS_META:
1272         case MSG_STRUCT_MMS_SMIL_TEXT:
1273         case MSG_STRUCT_MMS_SMIL_AVI:
1274                 err = msg_mms_set_bool_value(msg_struct, field, value);
1275                 break;
1276         case MSG_STRUCT_SETTING_CB_OPT :
1277         case MSG_STRUCT_SETTING_CB_CHANNEL_INFO :
1278         case MSG_STRUCT_SETTING_SMS_SEND_OPT :
1279         case MSG_STRUCT_SETTING_MMS_SEND_OPT :
1280         case MSG_STRUCT_SETTING_MMS_RECV_OPT :
1281         case MSG_STRUCT_SETTING_PUSH_MSG_OPT :
1282         case MSG_STRUCT_SETTING_GENERAL_OPT :
1283                 err = msg_setting_set_bool_value(msg_struct, field, value);
1284                 break;
1285         case MSG_STRUCT_PUSH_CONFIG_INFO:
1286                 err = msg_push_config_set_bool(msg_struct->data, field, value);
1287                 break;
1288         default :
1289                 err = MSG_ERR_INVALID_PARAMETER;
1290                 break;
1291         }
1292
1293         return err;
1294 }
1295
1296 EXPORT_API int msg_set_struct_handle(msg_struct_t msg_struct_handle, int field, msg_struct_t value)
1297 {
1298         msg_error_t err = MSG_SUCCESS;
1299
1300         if (msg_struct_handle == NULL)
1301                 return MSG_ERR_NULL_POINTER;
1302
1303         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1304
1305         if (msg_struct->data == NULL)
1306                 return MSG_ERR_NULL_POINTER;
1307
1308         switch (msg_struct->type)
1309         {
1310         case MSG_STRUCT_MESSAGE_INFO :
1311                 err = msg_message_set_struct_hnd(msg_struct->data, field, (void *)value);
1312                 break;
1313         case MSG_STRUCT_SENDOPT:
1314                 err = msg_sendopt_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1315                 break;
1316         case MSG_STRUCT_SYNCML_INFO:
1317                 err = msg_syncml_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1318                 break;
1319         case MSG_STRUCT_THREAD_LIST_INDEX:
1320                 err = msg_thread_index_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1321                 break;
1322         case MSG_STRUCT_MMS_MEDIA:
1323                 err = msg_mms_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1324                 break;
1325         case MSG_STRUCT_REQUEST_INFO:
1326                 err = msg_request_set_struct_handle(msg_struct, field, (msg_struct_s *)value);
1327                 break;
1328         default :
1329                 err = MSG_ERR_INVALID_PARAMETER;
1330                 break;
1331         }
1332
1333         return err;
1334 }
1335
1336 EXPORT_API int msg_set_list_handle(msg_struct_t msg_struct_handle, int field, void *value)
1337 {
1338         msg_error_t err = MSG_SUCCESS;
1339
1340         if (msg_struct_handle == NULL)
1341                 return MSG_ERR_NULL_POINTER;
1342
1343         msg_struct_s *msg_struct = (msg_struct_s *) msg_struct_handle;
1344
1345         if (msg_struct->data == NULL)
1346                 return MSG_ERR_NULL_POINTER;
1347
1348         switch (msg_struct->type)
1349         {
1350         default :
1351                 err = MSG_ERR_INVALID_PARAMETER;
1352                 break;
1353         }
1354         return err;
1355 }
1356
1357 EXPORT_API msg_struct_t msg_list_nth_data(msg_list_handle_t list_handle, int index)
1358 {
1359         return (msg_struct_t)g_list_nth_data((GList *)list_handle,(guint)index);
1360 }
1361
1362 EXPORT_API int msg_list_length(msg_list_handle_t list_handle)
1363 {
1364         return (int)g_list_length((GList *)list_handle);
1365 }
1366
1367 EXPORT_API int msg_util_calculate_text_length(const char* msg_text, msg_encode_type_t msg_encode_type_to, unsigned int *text_size, unsigned int *segment_size, msg_encode_type_t *msg_encode_type_in)
1368 {
1369         msg_error_t err = MSG_SUCCESS;
1370
1371         if (msg_text == NULL || text_size == NULL || segment_size == NULL) {
1372                 err = MSG_ERR_INVALID_PARAMETER;
1373                 return err;
1374         }
1375
1376         msg_encode_type_t encodeType = MSG_ENCODE_AUTO;
1377         MSG_LANGUAGE_ID_T langId = MSG_LANG_ID_RESERVED;
1378
1379         int decodeLen = 0;
1380         int bufSize = (160*MAX_SEGMENT_NUM) + 1;
1381         int textSize = 0;
1382
1383         bool bAbnormal = false;
1384
1385         textSize = strlen(msg_text);
1386
1387         unsigned char decodeData[bufSize];
1388         memset(decodeData, 0x00, sizeof(decodeData));
1389
1390         MsgTextConvert textCvt;
1391
1392         *text_size = 0;
1393         *segment_size = 0;
1394
1395         switch (msg_encode_type_to)
1396         {
1397         case MSG_ENCODE_GSM7BIT :
1398                 decodeLen = textCvt.convertUTF8ToGSM7bit(decodeData, bufSize, (const unsigned char*)msg_text, textSize, &langId, &bAbnormal);
1399                 break;
1400         case MSG_ENCODE_UCS2 :
1401                 decodeLen = textCvt.convertUTF8ToUCS2(decodeData, bufSize, (const unsigned char*)msg_text, textSize);
1402                 break;
1403         case MSG_ENCODE_AUTO :
1404                 decodeLen = textCvt.convertUTF8ToAuto(decodeData, bufSize, (const unsigned char*)msg_text, textSize, &encodeType);
1405                 break;
1406         default :
1407                 err = MSG_ERR_INVALID_PARAMETER;
1408                 return err;
1409                 break;
1410         }
1411
1412         // calculate segment size.
1413         int headerLen = 1;
1414         int concat = 5;
1415 //      int lang = 3;
1416
1417 //      int headerSize = 0;
1418         int segSize = 0;
1419
1420 //      if (langId != MSG_LANG_ID_RESERVED) {
1421 //              MSG_DEBUG("National Language Exists");
1422 //              headerSize += lang;
1423 //      }
1424
1425         if (msg_encode_type_to == MSG_ENCODE_GSM7BIT || encodeType == MSG_ENCODE_GSM7BIT) {
1426                 MSG_DEBUG("MSG_ENCODE_GSM7BIT");
1427
1428 //              if (((decodeLen+headerSize)/160) > 1)
1429 //                      segSize = ((140*8) - ((headerLen + concat + headerSize)*8)) / 7;
1430                 if(decodeLen > 160)
1431                         segSize = ((140*8) - ((headerLen + concat)*8)) / 7;
1432                 else
1433                         segSize = 160;
1434
1435                 if (bAbnormal)
1436                         *msg_encode_type_in = MSG_ENCODE_GSM7BIT_ABNORMAL;
1437                 else
1438                         *msg_encode_type_in = MSG_ENCODE_GSM7BIT;
1439
1440         } else if (msg_encode_type_to == MSG_ENCODE_UCS2 || encodeType == MSG_ENCODE_UCS2) {
1441                 MSG_DEBUG("MSG_ENCODE_UCS2");
1442
1443 //              if (((decodeLen+headerSize)/140) > 1)
1444 //                      segSize = 140 - (headerLen + concat + headerSize);
1445                 if(decodeLen > 140)
1446                         segSize = 140 - (headerLen + concat);
1447                 else
1448                         segSize = 140;
1449
1450                 *msg_encode_type_in = MSG_ENCODE_UCS2;
1451
1452         } else {
1453                 MSG_DEBUG("Unsupported encode type.");
1454                 err = MSG_ERR_INVALID_PARAMETER;
1455                 return err;
1456         }
1457
1458         *text_size = decodeLen;
1459         *segment_size = segSize;
1460
1461         return err;
1462 }