mapi/msg_message.cpp

   1 /*
   2 * Copyright 2012  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *    http://www.tizenopensource.org/license
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <string.h>
  18
  19 #include "MsgTypes.h"
  20 #include "MsgStorageTypes.h"
  21 #include "MsgInternalTypes.h"
  22 #include "MsgMmsMessage.h"
  23
  24 #include "msg.h"
  25 #include "msg_private.h"
  26
  27 void msg_message_create_struct(msg_struct_s *msg_struct)
  28 {
  29         MSG_MESSAGE_HIDDEN_S *msg = (MSG_MESSAGE_HIDDEN_S *)new MSG_MESSAGE_HIDDEN_S;
  30         memset(msg, 0x00, sizeof(MSG_MESSAGE_HIDDEN_S));
  31
  32         /* set default value to message*/
  33         msg->msgId = 0;
  34         msg->threadId = 0;
  35         msg->folderId = MSG_DRAFT_ID;
  36         msg->mainType= MSG_SMS_TYPE;
  37         msg->subType = MSG_NORMAL_SMS;
  38         msg->classType = MSG_CLASS_NONE;
  39         msg->storageId = MSG_STORAGE_PHONE;
  40         time_t curTime = time(NULL);
  41         msg->displayTime = curTime;
  42         msg->networkStatus = MSG_NETWORK_NOT_SEND;
  43         msg->encodeType = MSG_ENCODE_AUTO;
  44         msg->bRead = false;
  45         msg->bProtected = false;
  46         msg->bBackup = false;
  47         msg->priority = MSG_MESSAGE_PRIORITY_NORMAL;
  48         msg->direction = MSG_DIRECTION_TYPE_MO;
  49         msg->bPortValid = false;
  50         msg->dataSize = 0;
  51         msg->pData = NULL;
  52         msg->pMmsData = NULL;
  53
  54         /* Allocate memory for address list of message */
  55         msg_struct_list_s *addr_list = (msg_struct_list_s *)new msg_struct_list_s;
  56
  57         addr_list->nCount = 0;
  58         addr_list->msg_struct_info = (msg_struct_t *)new char[sizeof(MSG_ADDRESS_INFO_S *)*MAX_TO_ADDRESS_CNT];
  59
  60         msg_struct_s *pTmp = NULL;
  61
  62         for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
  63                 addr_list->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
  64                 pTmp = (msg_struct_s *)addr_list->msg_struct_info[i];
  65                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
  66                 pTmp->data = new MSG_ADDRESS_INFO_S;
  67                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
  68
  69                 addr_list->msg_struct_info[i] = (msg_struct_t)pTmp;
  70         }
  71
  72         msg->addr_list = addr_list;
  73
  74         msg_struct->data = (int *)msg;
  75 }
  76
  77 int msg_message_release(msg_struct_s **msg_struct)
  78 {
  79         MSG_MESSAGE_HIDDEN_S *msg = (MSG_MESSAGE_HIDDEN_S *)(*msg_struct)->data;
  80
  81         if (msg->pData) {
  82                 delete [] static_cast<char*>(msg->pData);
  83                 msg->pData = NULL;
  84         }
  85
  86         if (msg->pMmsData) {
  87                 delete [] static_cast<char*>(msg->pMmsData);
  88                 msg->pMmsData = NULL;
  89         }
  90
  91         // Memory Free
  92         if (msg->addr_list!= NULL)
  93         {
  94                 for(int i=0; i<MAX_TO_ADDRESS_CNT; i++) {
  95                         msg_struct_s * addrInfo = (msg_struct_s *)msg->addr_list->msg_struct_info[i];
  96                         delete (MSG_ADDRESS_INFO_S *)addrInfo->data;
  97                         addrInfo->data = NULL;
  98                         delete (msg_struct_s *)msg->addr_list->msg_struct_info[i];
  99                         msg->addr_list->msg_struct_info[i] = NULL;
 100                 }
 101
 102                 delete [] msg->addr_list->msg_struct_info;
 103
 104                 delete msg->addr_list;
 105                 msg->addr_list = NULL;
 106         }
 107
 108         delete msg;
 109         (*msg_struct)->data = NULL;
 110
 111         delete (msg_struct_s *)*msg_struct;
 112         *msg_struct = NULL;
 113
 114         return MSG_SUCCESS;
 115 }
 116
 117 int msg_message_get_int_value(void *data, int field, int *value)
 118 {
 119         if (!data)
 120                 return MSG_ERR_NULL_POINTER;
 121
 122         int ret = MSG_SUCCESS;
 123
 124         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 125
 126         switch (field)
 127         {
 128         case MSG_MESSAGE_ID_INT :
 129                 *value = msg_data->msgId;
 130                 break;
 131         case MSG_MESSAGE_THREAD_ID_INT :
 132                 *value = msg_data->threadId;
 133                 break;
 134         case MSG_MESSAGE_FOLDER_ID_INT :
 135                 *value = msg_data->folderId;
 136                 break;
 137         case MSG_MESSAGE_TYPE_INT :
 138         {
 139         if (msg_data->mainType == MSG_SMS_TYPE)
 140         {
 141                         if (msg_data->subType == MSG_CB_SMS)
 142                                 *value = MSG_TYPE_SMS_CB;
 143                         else if (msg_data->subType == MSG_JAVACB_SMS)
 144                                 *value = MSG_TYPE_SMS_JAVACB;
 145                         else if (msg_data->subType == MSG_WAP_SI_SMS || msg_data->subType == MSG_WAP_SL_SMS)
 146                                 *value = MSG_TYPE_SMS_WAPPUSH;
 147                         else if (msg_data->subType == MSG_MWI_VOICE_SMS || msg_data->subType == MSG_MWI_FAX_SMS
 148                                         || msg_data->subType == MSG_MWI_EMAIL_SMS || msg_data->subType == MSG_MWI_OTHER_SMS)
 149                                 *value = MSG_TYPE_SMS_MWI;
 150                         else if (msg_data->subType == MSG_SYNCML_CP)
 151                                 *value = MSG_TYPE_SMS_SYNCML;
 152                         else if (msg_data->subType == MSG_REJECT_SMS)
 153                                 *value = MSG_TYPE_SMS_REJECT;
 154                         else if (msg_data->subType == MSG_ETWS_SMS)
 155                                 *value = MSG_TYPE_SMS_ETWS_PRIMARY;
 156                         else
 157                                 *value = MSG_TYPE_SMS;
 158         }
 159         else if (msg_data->mainType == MSG_MMS_TYPE)
 160         {
 161                         if (msg_data->subType == MSG_NOTIFICATIONIND_MMS)
 162                                 *value = MSG_TYPE_MMS_NOTI;
 163                         else if (msg_data->subType == MSG_SENDREQ_JAVA_MMS)
 164                                 *value = MSG_TYPE_MMS_JAVA;
 165                         else
 166                                 *value = MSG_TYPE_MMS;
 167         }
 168         else
 169                 *value = MSG_TYPE_INVALID;
 170
 171         break;
 172         }
 173         case MSG_MESSAGE_CLASS_TYPE_INT :
 174                 *value = msg_data->classType;
 175                 break;
 176         case MSG_MESSAGE_STORAGE_ID_INT :
 177                 *value = msg_data->storageId;
 178                 break;
 179         case MSG_MESSAGE_DISPLAY_TIME_INT :
 180                 *value = msg_data->displayTime;
 181                 break;
 182         case MSG_MESSAGE_NETWORK_STATUS_INT :
 183                 *value = msg_data->networkStatus;
 184                 break;
 185         case MSG_MESSAGE_ENCODE_TYPE_INT :
 186                 *value = msg_data->encodeType;
 187                 break;
 188         case MSG_MESSAGE_PRIORITY_INT :
 189                 *value = msg_data->priority;
 190                 break;
 191         case MSG_MESSAGE_DIRECTION_INT :
 192                 *value = msg_data->direction;
 193                 break;
 194         case MSG_MESSAGE_DEST_PORT_INT :
 195                 *value = msg_data->dstPort;
 196                 break;
 197         case MSG_MESSAGE_SRC_PORT_INT :
 198                 *value = msg_data->srcPort;
 199                 break;
 200         case MSG_MESSAGE_ATTACH_COUNT_INT :
 201                 *value = msg_data->attachCount;
 202                 break;
 203         case MSG_MESSAGE_DATA_SIZE_INT :
 204                 *value = msg_data->dataSize;
 205                 break;
 206         default :
 207                 ret = MSG_ERR_INVALID_PARAMETER;
 208                 break;
 209         }
 210
 211         return ret;
 212 }
 213
 214 int msg_message_get_bool_value(void *data, int field, bool *value)
 215 {
 216         if (!data)
 217                 return MSG_ERR_NULL_POINTER;
 218
 219         int ret = MSG_SUCCESS;
 220
 221         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 222
 223         switch (field) {
 224         case MSG_MESSAGE_READ_BOOL :
 225                 *value = msg_data->bRead;
 226                 break;
 227         case MSG_MESSAGE_PROTECTED_BOOL :
 228                 *value = msg_data->bProtected;
 229                 break;
 230         case MSG_MESSAGE_BACKUP_BOOL :
 231                 *value = msg_data->bBackup;
 232                 break;
 233         case MSG_MESSAGE_PORT_VALID_BOOL :
 234                 *value = msg_data->bPortValid;
 235                 break;
 236         default :
 237                 ret = MSG_ERR_INVALID_PARAMETER;
 238                 break;
 239         }
 240
 241         return ret;
 242 }
 243
 244 int msg_message_get_str_value(void *data, int field, char *value, int size)
 245 {
 246         if (!data || !value)
 247                 return MSG_ERR_NULL_POINTER;
 248
 249         int ret = MSG_SUCCESS;
 250
 251         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 252
 253         switch (field) {
 254         case MSG_MESSAGE_REPLY_ADDR_STR :
 255                 strncpy(value, msg_data->replyAddress, size);
 256                 break;
 257         case MSG_MESSAGE_SUBJECT_STR :
 258                 strncpy(value, msg_data->subject, size);
 259                 break;
 260         case MSG_MESSAGE_THUMBNAIL_PATH_STR :
 261                 strncpy(value, msg_data->thumbPath, size);
 262                 break;
 263         case MSG_MESSAGE_SMS_DATA_STR :
 264         case MSG_MESSAGE_MMS_TEXT_STR :
 265                 if (msg_data->pData)
 266                 {
 267                         int data_len = 0;
 268                         (size >= msg_data->dataSize)? (data_len = msg_data->dataSize) : data_len = size;
 269                         memset(value, 0, size);
 270                         memcpy(value, msg_data->pData, data_len);
 271                 }
 272                 break;
 273         default :
 274                 ret = MSG_ERR_INVALID_PARAMETER;
 275                 break;
 276         }
 277
 278         return ret;
 279 }
 280
 281 int msg_message_get_struct_hnd(void *data, int field, void **value)
 282 {
 283         if (!data)
 284                 return MSG_ERR_NULL_POINTER;
 285
 286         int ret = MSG_SUCCESS;
 287
 288         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 289
 290         switch (field) {
 291         default :
 292                 ret = MSG_ERR_INVALID_PARAMETER;
 293                 break;
 294         }
 295
 296         return ret;
 297 }
 298
 299 int msg_message_get_list_hnd(void *data, int field, void **value)
 300 {
 301         if (!data)
 302                 return MSG_ERR_NULL_POINTER;
 303
 304         int ret = MSG_SUCCESS;
 305
 306         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 307
 308         switch (field) {
 309         case MSG_MESSAGE_ADDR_LIST_STRUCT :
 310                 *value = (void *)msg_data->addr_list;
 311                 break;
 312         default :
 313                 ret = MSG_ERR_INVALID_PARAMETER;
 314                 break;
 315         }
 316
 317         return ret;
 318 }
 319
 320 int msg_message_set_int_value(void *data, int field, int value)
 321 {
 322         if (!data)
 323                 return MSG_ERR_NULL_POINTER;
 324
 325         int ret = MSG_SUCCESS;
 326
 327         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 328
 329         switch (field)
 330         {
 331         case MSG_MESSAGE_ID_INT :
 332                 msg_data->msgId = value;
 333                 break;
 334         case MSG_MESSAGE_THREAD_ID_INT :
 335                 msg_data->threadId = value;
 336                 break;
 337         case MSG_MESSAGE_FOLDER_ID_INT :
 338                 msg_data->folderId = value;
 339                 break;
 340         case MSG_MESSAGE_TYPE_INT :
 341         {
 342         if (value == MSG_TYPE_SMS) {
 343                 msg_data->mainType = MSG_SMS_TYPE;
 344                 msg_data->subType = MSG_NORMAL_SMS;
 345         } else if (value == MSG_TYPE_MMS) {
 346                 msg_data->mainType = MSG_MMS_TYPE;
 347                 msg_data->subType = MSG_SENDREQ_MMS;
 348         } else if (value == MSG_TYPE_MMS_JAVA) {
 349                 msg_data->mainType = MSG_MMS_TYPE;
 350                         msg_data->subType = MSG_SENDREQ_JAVA_MMS;
 351         } else if (value == MSG_TYPE_SMS_SYNCML) {
 352                 msg_data->mainType = MSG_SMS_TYPE;
 353                 msg_data->subType = MSG_SYNCML_CP;
 354         } else if (value == MSG_TYPE_SMS_REJECT) {
 355                 msg_data->mainType = MSG_SMS_TYPE;
 356                 msg_data->subType = MSG_REJECT_SMS;
 357         }
 358         break;
 359         }
 360         case MSG_MESSAGE_CLASS_TYPE_INT :
 361                 msg_data->classType = value;
 362                 break;
 363         case MSG_MESSAGE_STORAGE_ID_INT :
 364                 msg_data->storageId = value;
 365                 break;
 366         case MSG_MESSAGE_DISPLAY_TIME_INT :
 367                 msg_data->displayTime = value;
 368                 break;
 369         case MSG_MESSAGE_NETWORK_STATUS_INT :
 370                 msg_data->networkStatus = value;
 371                 break;
 372         case MSG_MESSAGE_ENCODE_TYPE_INT :
 373                 msg_data->encodeType = value;
 374                 break;
 375         case MSG_MESSAGE_PRIORITY_INT :
 376                 msg_data->priority = value;
 377                 break;
 378         case MSG_MESSAGE_DIRECTION_INT :
 379                 msg_data->direction = value;
 380                 break;
 381         case MSG_MESSAGE_DEST_PORT_INT :
 382                 msg_data->dstPort = value;
 383                 break;
 384         case MSG_MESSAGE_SRC_PORT_INT :
 385                 msg_data->srcPort = value;
 386                 break;
 387         case MSG_MESSAGE_ATTACH_COUNT_INT :
 388                  msg_data->attachCount = value;
 389                 break;
 390         case MSG_MESSAGE_DATA_SIZE_INT :
 391                 msg_data->dataSize = value;
 392                 break;
 393         default :
 394                 ret = MSG_ERR_INVALID_PARAMETER;
 395                 break;
 396         }
 397
 398         return ret;
 399 }
 400
 401 int msg_message_set_bool_value(void *data, int field, bool value)
 402 {
 403         if (!data)
 404                 return MSG_ERR_NULL_POINTER;
 405
 406         int ret = MSG_SUCCESS;
 407
 408         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 409
 410         switch (field) {
 411         case MSG_MESSAGE_READ_BOOL :
 412                 msg_data->bRead = value;
 413                 break;
 414         case MSG_MESSAGE_PROTECTED_BOOL :
 415                 msg_data->bProtected = value;
 416                 break;
 417         case MSG_MESSAGE_BACKUP_BOOL :
 418                 msg_data->bBackup = value;
 419                 break;
 420         case MSG_MESSAGE_PORT_VALID_BOOL :
 421                 msg_data->bPortValid = value;
 422                 break;
 423         default :
 424                 ret = MSG_ERR_INVALID_PARAMETER;
 425                 break;
 426         }
 427
 428         return ret;
 429 }
 430
 431 int msg_message_set_str_value(void *data, int field, char *value, int size)
 432 {
 433         if (!data || !value)
 434                 return MSG_ERR_NULL_POINTER;
 435
 436         int ret = MSG_SUCCESS;
 437
 438         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 439
 440         switch (field) {
 441         case MSG_MESSAGE_REPLY_ADDR_STR :
 442                 snprintf(msg_data->replyAddress, sizeof(msg_data->replyAddress), "%s", value);
 443                 break;
 444         case MSG_MESSAGE_SUBJECT_STR :
 445                 snprintf(msg_data->subject, sizeof(msg_data->subject), "%s",value);
 446                 break;
 447         case MSG_MESSAGE_THUMBNAIL_PATH_STR :
 448                 snprintf(msg_data->thumbPath, sizeof(msg_data->thumbPath), "%s",value);
 449                 break;
 450         case MSG_MESSAGE_SMS_DATA_STR :
 451         {
 452                 if (msg_data->pData)
 453                         delete [] static_cast<char*>(msg_data->pData);
 454
 455                 msg_data->dataSize = size;
 456                 msg_data->pData = (void*)new char[msg_data->dataSize+1];
 457                 memcpy((char *)msg_data->pData, value, msg_data->dataSize);
 458                 ((char*) msg_data->pData)[msg_data->dataSize] = '\0';
 459         }
 460                 break;
 461         default :
 462                 ret = MSG_ERR_INVALID_PARAMETER;
 463                 break;
 464         }
 465
 466         return ret;
 467 }
 468
 469 int msg_message_set_struct_hnd(void *data, int field, void *value)
 470 {
 471         if (!data)
 472                 return MSG_ERR_NULL_POINTER;
 473
 474         int ret = MSG_SUCCESS;
 475
 476         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 477
 478         switch (field) {
 479         default :
 480                 ret = MSG_ERR_INVALID_PARAMETER;
 481                 break;
 482         }
 483
 484         return ret;
 485 }
 486
 487 void msg_message_copy_message(MSG_MESSAGE_HIDDEN_S *pSrc, MSG_MESSAGE_HIDDEN_S *pDst)
 488 {
 489
 490         pDst->msgId = pSrc->msgId;
 491         pDst->threadId = pSrc->msgId;
 492         pDst->folderId = pSrc->folderId;
 493         pDst->mainType = pSrc->mainType;
 494         pDst->subType = pSrc->subType;
 495         pDst->classType = pSrc->classType;
 496         pDst->storageId = pSrc->storageId;
 497         pDst->displayTime = pSrc->displayTime;
 498         pDst->networkStatus = pSrc->networkStatus;
 499         pDst->encodeType = pSrc->encodeType;
 500         pDst->bRead = pSrc->bRead;
 501         pDst->bProtected = pSrc->bProtected;
 502         pDst->bBackup = pSrc->bBackup;
 503         pDst->priority = pSrc->priority;
 504         pDst->direction = pSrc->direction;
 505         pDst->bPortValid = pSrc->bPortValid;
 506         pDst->dataSize = pSrc->dataSize;
 507         memcpy(pDst->subject, pSrc->subject, sizeof(pDst->subject));
 508         if(pSrc->dataSize)
 509         {
 510                 if(pSrc->pMmsData)
 511                 {
 512                         pDst->pMmsData = new char[pSrc->dataSize + 1];
 513                         memcpy(pDst->pMmsData, pSrc->pMmsData, pSrc->dataSize);
 514                 }
 515                 if(pSrc->pData)
 516                 {
 517                         int data_len = strlen((const char *)pSrc->pData);
 518                         pDst->pData = new char[data_len + 1];
 519                         memset(pDst->pData, 0x00, data_len + 1);
 520                         strncpy((char *)pDst->pData, (const char *)pSrc->pData, data_len);
 521                 }
 522         }
 523         msg_struct_list_s *src_addrlist = pSrc->addr_list;
 524         msg_struct_list_s *dst_addrlist = pDst->addr_list;
 525         dst_addrlist->nCount = src_addrlist->nCount;
 526
 527         for(int i=0; i < MAX_TO_ADDRESS_CNT; ++i)
 528         {
 529                 msg_struct_s *src_addr = (msg_struct_s *)src_addrlist->msg_struct_info[i];
 530                 msg_struct_s *dst_addr = (msg_struct_s *)dst_addrlist->msg_struct_info[i];
 531                 memcpy(dst_addr->data, src_addr->data, sizeof(MSG_ADDRESS_INFO_S));
 532         }
 533 }
 534
 535 int msg_cb_message_get_int_value(void *data, int field, int *value)
 536 {
 537         if (!data)
 538                 return MSG_ERR_NULL_POINTER;
 539
 540         int ret = MSG_SUCCESS;
 541
 542         MSG_CB_MSG_S *cb_msg = (MSG_CB_MSG_S *)data;
 543
 544         *value = 0;
 545
 546         switch (field)
 547         {
 548                 case MSG_CB_MSG_TYPE_INT :
 549                         {
 550                                 if ( cb_msg->type == MSG_ETWS_SMS )
 551                                         *value = MSG_TYPE_SMS_ETWS_PRIMARY;
 552                                 else if ( cb_msg->type == MSG_CB_SMS )
 553                                         *value = ((cb_msg->messageId & 0xFFF8) == 0x1100 ) ? MSG_TYPE_SMS_ETWS_SECONDARY : MSG_TYPE_SMS_CB;
 554                                 else
 555                                         ret = MSG_ERR_UNKNOWN;
 556                         }
 557                         break;
 558                 case MSG_CB_MSG_RECV_TIME_INT :
 559                         *value = cb_msg->receivedTime;
 560                         break;
 561                 case MSG_CB_MSG_SERIAL_NUM_INT :
 562                         *value = cb_msg->serialNum;
 563                         break;
 564                 case MSG_CB_MSG_MSG_ID_INT :
 565                         *value = cb_msg->messageId;
 566                         break;
 567                 case MSG_CB_MSG_DCS_INT :
 568                         *value = (int)cb_msg->dcs;
 569                         break;
 570                 case MSG_CB_MSG_CB_TEXT_LEN_INT :
 571                         *value = cb_msg->cbTextLen;
 572                         break;
 573                 case MSG_CB_MSG_ETWS_WARNING_TYPE_INT :
 574                         *value = cb_msg->etwsWarningType;
 575                 default :
 576                         ret = MSG_ERR_INVALID_PARAMETER;
 577                         break;
 578         }
 579
 580         return ret;
 581 }
 582
 583 int msg_cb_message_get_str_value(void *data, int field, char *value, int size)
 584 {
 585         if (!data || !value)
 586                 return MSG_ERR_NULL_POINTER;
 587
 588         int ret = MSG_SUCCESS;
 589
 590         MSG_CB_MSG_S *cb_msg = (MSG_CB_MSG_S *)data;
 591
 592         switch (field) {
 593                 case MSG_CB_MSG_CB_TEXT_STR:
 594                         {
 595                                 int     copylen = 0;
 596                                 copylen = (size > cb_msg->cbTextLen) ? cb_msg->cbTextLen : size - 1;
 597                                 memcpy (value, cb_msg->cbText, copylen);
 598                                 value[copylen] = '\0';
 599                         }
 600                         break;
 601                 case MSG_CB_MSG_ETWS_WARNING_SECU_INFO_STR:
 602                         {
 603                                 if (size < sizeof(cb_msg->etwsWarningSecurityInfo))
 604                                         ret = MSG_ERR_INVALID_PARAMETER;
 605                                 else
 606                                         memcpy (value, cb_msg->etwsWarningSecurityInfo, sizeof(cb_msg->etwsWarningSecurityInfo));
 607                         }
 608                         break;
 609
 610                 default :
 611                         ret = MSG_ERR_INVALID_PARAMETER;
 612                         break;
 613         }
 614
 615         return ret;
 616 }
 617
 618
 619
 620 EXPORT_API int msg_get_mms_struct(msg_struct_t msg_struct_handle, msg_struct_t mms_struct_handle)
 621 {
 622         //TODO :: check message type is MMS
 623         int ret = MSG_SUCCESS;
 624         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
 625         msg_struct_s *mms_struct = (msg_struct_s *)mms_struct_handle;
 626
 627         if (msg_struct == NULL || mms_struct == NULL) {
 628                 return MSG_ERR_INVALID_PARAMETER;
 629         }
 630
 631         if (msg_struct->data == NULL || mms_struct->data == NULL) {
 632                 return MSG_ERR_INVALID_PARAMETER;
 633         }
 634
 635         if (msg_struct->type != MSG_STRUCT_MESSAGE_INFO || mms_struct->type != MSG_STRUCT_MMS) {
 636                 return MSG_ERR_INVALID_PARAMETER;
 637         }
 638
 639         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)msg_struct->data;
 640
 641         MMS_MESSAGE_DATA_S *tmp_mms_data  = (MMS_MESSAGE_DATA_S *)calloc(1, sizeof(MMS_MESSAGE_DATA_S));
 642
 643         _MsgMmsDeserializeMessageData(tmp_mms_data, (char*)msg_data->pMmsData);
 644
 645         convert_from_mmsdata(tmp_mms_data, mms_struct);
 646
 647         _MsgMmsReleasePageList(tmp_mms_data);
 648         _MsgMmsReleaseRegionList(tmp_mms_data);
 649         _MsgMmsReleaseAttachList(tmp_mms_data);
 650         _MsgMmsReleaseTransitionList(tmp_mms_data);
 651         _MsgMmsReleaseMetaList(tmp_mms_data);
 652         free(tmp_mms_data);
 653
 654         return ret;
 655 }
 656
 657 EXPORT_API int msg_set_mms_struct(msg_struct_t msg_struct_handle, msg_struct_t mms_struct_handle)
 658 {
 659         //TODO :: check message type is MMS
 660         int ret = MSG_SUCCESS;
 661         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
 662         msg_struct_s *mms_struct = (msg_struct_s *)mms_struct_handle;
 663
 664         if (msg_struct == NULL || mms_struct == NULL) {
 665                 return MSG_ERR_INVALID_PARAMETER;
 666         }
 667
 668         if (msg_struct->data == NULL || mms_struct->data == NULL) {
 669                 return MSG_ERR_INVALID_PARAMETER;
 670         }
 671
 672         if (msg_struct->type != MSG_STRUCT_MESSAGE_INFO || mms_struct->type != MSG_STRUCT_MMS) {
 673                 return MSG_ERR_INVALID_PARAMETER;
 674         }
 675
 676         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)msg_struct->data;
 677
 678         MMS_MESSAGE_DATA_S *tmp_mms_data = (MMS_MESSAGE_DATA_S *)calloc(1,sizeof(MMS_MESSAGE_DATA_S));
 679
 680         convert_to_mmsdata(mms_struct, tmp_mms_data);
 681
 682         msg_data->pMmsData = _MsgMmsSerializeMessageData(tmp_mms_data, &(msg_data->dataSize));
 683
 684         _MsgMmsReleasePageList(tmp_mms_data);
 685         _MsgMmsReleaseRegionList(tmp_mms_data);
 686         _MsgMmsReleaseAttachList(tmp_mms_data);
 687         _MsgMmsReleaseTransitionList(tmp_mms_data);
 688         _MsgMmsReleaseMetaList(tmp_mms_data);
 689         free(tmp_mms_data);
 690         return ret;
 691 }
 692