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
 155                                 *value = MSG_TYPE_SMS;
 156         }
 157         else if (msg_data->mainType == MSG_MMS_TYPE)
 158         {
 159                         if (msg_data->subType == MSG_NOTIFICATIONIND_MMS)
 160                                 *value = MSG_TYPE_MMS_NOTI;
 161                         else if (msg_data->subType == MSG_SENDREQ_JAVA_MMS)
 162                                 *value = MSG_TYPE_MMS_JAVA;
 163                         else
 164                                 *value = MSG_TYPE_MMS;
 165         }
 166         else
 167                 *value = MSG_TYPE_INVALID;
 168
 169         break;
 170         }
 171         case MSG_MESSAGE_CLASS_TYPE_INT :
 172                 *value = msg_data->classType;
 173                 break;
 174         case MSG_MESSAGE_STORAGE_ID_INT :
 175                 *value = msg_data->storageId;
 176                 break;
 177         case MSG_MESSAGE_DISPLAY_TIME_INT :
 178                 *value = msg_data->displayTime;
 179                 break;
 180         case MSG_MESSAGE_NETWORK_STATUS_INT :
 181                 *value = msg_data->networkStatus;
 182                 break;
 183         case MSG_MESSAGE_ENCODE_TYPE_INT :
 184                 *value = msg_data->encodeType;
 185                 break;
 186         case MSG_MESSAGE_PRIORITY_INT :
 187                 *value = msg_data->priority;
 188                 break;
 189         case MSG_MESSAGE_DIRECTION_INT :
 190                 *value = msg_data->direction;
 191                 break;
 192         case MSG_MESSAGE_DEST_PORT_INT :
 193                 *value = msg_data->dstPort;
 194                 break;
 195         case MSG_MESSAGE_SRC_PORT_INT :
 196                 *value = msg_data->srcPort;
 197                 break;
 198         case MSG_MESSAGE_ATTACH_COUNT_INT :
 199                 *value = msg_data->attachCount;
 200                 break;
 201         case MSG_MESSAGE_DATA_SIZE_INT :
 202                 *value = msg_data->dataSize;
 203                 break;
 204         default :
 205                 ret = MSG_ERR_INVALID_PARAMETER;
 206                 break;
 207         }
 208
 209         return ret;
 210 }
 211
 212 int msg_message_get_bool_value(void *data, int field, bool *value)
 213 {
 214         if (!data)
 215                 return MSG_ERR_NULL_POINTER;
 216
 217         int ret = MSG_SUCCESS;
 218
 219         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 220
 221         switch (field) {
 222         case MSG_MESSAGE_READ_BOOL :
 223                 *value = msg_data->bRead;
 224                 break;
 225         case MSG_MESSAGE_PROTECTED_BOOL :
 226                 *value = msg_data->bProtected;
 227                 break;
 228         case MSG_MESSAGE_BACKUP_BOOL :
 229                 *value = msg_data->bBackup;
 230                 break;
 231         case MSG_MESSAGE_PORT_VALID_BOOL :
 232                 *value = msg_data->bPortValid;
 233                 break;
 234         default :
 235                 ret = MSG_ERR_INVALID_PARAMETER;
 236                 break;
 237         }
 238
 239         return ret;
 240 }
 241
 242 int msg_message_get_str_value(void *data, int field, char *value, int size)
 243 {
 244         if (!data || !value)
 245                 return MSG_ERR_NULL_POINTER;
 246
 247         int ret = MSG_SUCCESS;
 248
 249         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 250
 251         switch (field) {
 252         case MSG_MESSAGE_REPLY_ADDR_STR :
 253                 strncpy(value, msg_data->replyAddress, size);
 254                 break;
 255         case MSG_MESSAGE_SUBJECT_STR :
 256                 strncpy(value, msg_data->subject, size);
 257                 break;
 258         case MSG_MESSAGE_THUMBNAIL_PATH_STR :
 259                 strncpy(value, msg_data->thumbPath, size);
 260                 break;
 261         case MSG_MESSAGE_SMS_DATA_STR :
 262         case MSG_MESSAGE_MMS_TEXT_STR :
 263                 if (msg_data->pData != NULL)
 264                         strncpy(value, (char *)msg_data->pData, size);
 265                 break;
 266         default :
 267                 ret = MSG_ERR_INVALID_PARAMETER;
 268                 break;
 269         }
 270
 271         return ret;
 272 }
 273
 274 int msg_message_get_struct_hnd(void *data, int field, void **value)
 275 {
 276         if (!data)
 277                 return MSG_ERR_NULL_POINTER;
 278
 279         int ret = MSG_SUCCESS;
 280
 281         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 282
 283         switch (field) {
 284         default :
 285                 ret = MSG_ERR_INVALID_PARAMETER;
 286                 break;
 287         }
 288
 289         return ret;
 290 }
 291
 292 int msg_message_get_list_hnd(void *data, int field, void **value)
 293 {
 294         if (!data)
 295                 return MSG_ERR_NULL_POINTER;
 296
 297         int ret = MSG_SUCCESS;
 298
 299         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 300
 301         switch (field) {
 302         case MSG_MESSAGE_ADDR_LIST_STRUCT :
 303                 *value = (void *)msg_data->addr_list;
 304                 break;
 305         default :
 306                 ret = MSG_ERR_INVALID_PARAMETER;
 307                 break;
 308         }
 309
 310         return ret;
 311 }
 312
 313 int msg_message_set_int_value(void *data, int field, int value)
 314 {
 315         if (!data)
 316                 return MSG_ERR_NULL_POINTER;
 317
 318         int ret = MSG_SUCCESS;
 319
 320         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 321
 322         switch (field)
 323         {
 324         case MSG_MESSAGE_ID_INT :
 325                 msg_data->msgId = value;
 326                 break;
 327         case MSG_MESSAGE_THREAD_ID_INT :
 328                 msg_data->threadId = value;
 329                 break;
 330         case MSG_MESSAGE_FOLDER_ID_INT :
 331                 msg_data->folderId = value;
 332                 break;
 333         case MSG_MESSAGE_TYPE_INT :
 334         {
 335         if (value == MSG_TYPE_SMS) {
 336                 msg_data->mainType = MSG_SMS_TYPE;
 337                 msg_data->subType = MSG_NORMAL_SMS;
 338         } else if (value == MSG_TYPE_MMS) {
 339                 msg_data->mainType = MSG_MMS_TYPE;
 340                 msg_data->subType = MSG_SENDREQ_MMS;
 341         } else if (value == MSG_TYPE_MMS_JAVA) {
 342                 msg_data->mainType = MSG_MMS_TYPE;
 343                         msg_data->subType = MSG_SENDREQ_JAVA_MMS;
 344         } else if (value == MSG_TYPE_SMS_SYNCML) {
 345                 msg_data->mainType = MSG_SMS_TYPE;
 346                 msg_data->subType = MSG_SYNCML_CP;
 347         } else if (value == MSG_TYPE_SMS_REJECT) {
 348                 msg_data->mainType = MSG_SMS_TYPE;
 349                 msg_data->subType = MSG_REJECT_SMS;
 350         }
 351         break;
 352         }
 353         case MSG_MESSAGE_CLASS_TYPE_INT :
 354                 msg_data->classType = value;
 355                 break;
 356         case MSG_MESSAGE_STORAGE_ID_INT :
 357                 msg_data->storageId = value;
 358                 break;
 359         case MSG_MESSAGE_DISPLAY_TIME_INT :
 360                 msg_data->displayTime = value;
 361                 break;
 362         case MSG_MESSAGE_NETWORK_STATUS_INT :
 363                 msg_data->networkStatus = value;
 364                 break;
 365         case MSG_MESSAGE_ENCODE_TYPE_INT :
 366                 msg_data->encodeType = value;
 367                 break;
 368         case MSG_MESSAGE_PRIORITY_INT :
 369                 msg_data->priority = value;
 370                 break;
 371         case MSG_MESSAGE_DIRECTION_INT :
 372                 msg_data->direction = value;
 373                 break;
 374         case MSG_MESSAGE_DEST_PORT_INT :
 375                 msg_data->dstPort = value;
 376                 break;
 377         case MSG_MESSAGE_SRC_PORT_INT :
 378                 msg_data->srcPort = value;
 379                 break;
 380         case MSG_MESSAGE_ATTACH_COUNT_INT :
 381                  msg_data->attachCount = value;
 382                 break;
 383         case MSG_MESSAGE_DATA_SIZE_INT :
 384                 msg_data->dataSize = value;
 385                 break;
 386         default :
 387                 ret = MSG_ERR_INVALID_PARAMETER;
 388                 break;
 389         }
 390
 391         return ret;
 392 }
 393
 394 int msg_message_set_bool_value(void *data, int field, bool value)
 395 {
 396         if (!data)
 397                 return MSG_ERR_NULL_POINTER;
 398
 399         int ret = MSG_SUCCESS;
 400
 401         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 402
 403         switch (field) {
 404         case MSG_MESSAGE_READ_BOOL :
 405                 msg_data->bRead = value;
 406                 break;
 407         case MSG_MESSAGE_PROTECTED_BOOL :
 408                 msg_data->bProtected = value;
 409                 break;
 410         case MSG_MESSAGE_BACKUP_BOOL :
 411                 msg_data->bBackup = value;
 412                 break;
 413         case MSG_MESSAGE_PORT_VALID_BOOL :
 414                 msg_data->bPortValid = value;
 415                 break;
 416         default :
 417                 ret = MSG_ERR_INVALID_PARAMETER;
 418                 break;
 419         }
 420
 421         return ret;
 422 }
 423
 424 int msg_message_set_str_value(void *data, int field, char *value, int size)
 425 {
 426         if (!data || !value)
 427                 return MSG_ERR_NULL_POINTER;
 428
 429         int ret = MSG_SUCCESS;
 430
 431         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 432
 433         switch (field) {
 434         case MSG_MESSAGE_REPLY_ADDR_STR :
 435                 snprintf(msg_data->replyAddress, sizeof(msg_data->replyAddress), "%s", value);
 436                 break;
 437         case MSG_MESSAGE_SUBJECT_STR :
 438                 snprintf(msg_data->subject, sizeof(msg_data->subject), "%s",value);
 439                 break;
 440         case MSG_MESSAGE_THUMBNAIL_PATH_STR :
 441                 snprintf(msg_data->thumbPath, sizeof(msg_data->thumbPath), "%s",value);
 442                 break;
 443         case MSG_MESSAGE_SMS_DATA_STR :
 444         {
 445                  if (msg_data->pData)
 446                         delete [] static_cast<char*>(msg_data->pData);
 447
 448                 msg_data->dataSize = size;
 449
 450                 msg_data->pData = (void*)new char[msg_data->dataSize+1];
 451
 452                 memcpy((char *)msg_data->pData, value, msg_data->dataSize);
 453
 454                 ((char*) msg_data->pData)[msg_data->dataSize] = '\0';
 455         }
 456                 break;
 457         default :
 458                 ret = MSG_ERR_INVALID_PARAMETER;
 459                 break;
 460         }
 461
 462         return ret;
 463 }
 464
 465 int msg_message_set_struct_hnd(void *data, int field, void *value)
 466 {
 467         if (!data)
 468                 return MSG_ERR_NULL_POINTER;
 469
 470         int ret = MSG_SUCCESS;
 471
 472         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)data;
 473
 474         switch (field) {
 475         default :
 476                 ret = MSG_ERR_INVALID_PARAMETER;
 477                 break;
 478         }
 479
 480         return ret;
 481 }
 482
 483 void msg_message_copy_message(MSG_MESSAGE_HIDDEN_S *pSrc, MSG_MESSAGE_HIDDEN_S *pDst)
 484 {
 485
 486         pDst->msgId = pSrc->msgId;
 487         pDst->threadId = pSrc->msgId;
 488         pDst->folderId = pSrc->folderId;
 489         pDst->mainType = pSrc->mainType;
 490         pDst->subType = pSrc->subType;
 491         pDst->classType = pSrc->classType;
 492         pDst->storageId = pSrc->storageId;
 493         pDst->displayTime = pSrc->displayTime;
 494         pDst->networkStatus = pSrc->networkStatus;
 495         pDst->encodeType = pSrc->encodeType;
 496         pDst->bRead = pSrc->bRead;
 497         pDst->bProtected = pSrc->bProtected;
 498         pDst->bBackup = pSrc->bBackup;
 499         pDst->priority = pSrc->priority;
 500         pDst->direction = pSrc->direction;
 501         pDst->bPortValid = pSrc->bPortValid;
 502         pDst->dataSize = pSrc->dataSize;
 503         memcpy(pDst->subject, pSrc->subject, sizeof(pDst->subject));
 504         if(pSrc->dataSize)
 505         {
 506                 if(pSrc->pMmsData)
 507                 {
 508                         pDst->pMmsData = new char[pSrc->dataSize + 1];
 509                         memcpy(pDst->pMmsData, pSrc->pMmsData, pSrc->dataSize);
 510                 }
 511                 if(pSrc->pData)
 512                 {
 513                         int data_len = strlen((const char *)pSrc->pData);
 514                         pDst->pData = new char[data_len + 1];
 515                         strncpy((char *)pDst->pData, (const char *)pSrc->pData, data_len);
 516                 }
 517         }
 518         msg_struct_list_s *src_addrlist = pSrc->addr_list;
 519         msg_struct_list_s *dst_addrlist = pDst->addr_list;
 520         dst_addrlist->nCount = src_addrlist->nCount;
 521
 522         for(int i=0; i < MAX_TO_ADDRESS_CNT; ++i)
 523         {
 524                 msg_struct_s *src_addr = (msg_struct_s *)src_addrlist->msg_struct_info[i];
 525                 msg_struct_s *dst_addr = (msg_struct_s *)dst_addrlist->msg_struct_info[i];
 526                 memcpy(dst_addr->data, src_addr->data, sizeof(MSG_ADDRESS_INFO_S));
 527         }
 528 }
 529
 530 EXPORT_API int msg_get_mms_struct(msg_struct_t msg_struct_handle, msg_struct_t mms_struct_handle)
 531 {
 532         //TODO :: check message type is MMS
 533         int ret = MSG_SUCCESS;
 534         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
 535         msg_struct_s *mms_struct = (msg_struct_s *)mms_struct_handle;
 536
 537         if (msg_struct == NULL || mms_struct == NULL) {
 538                 return MSG_ERR_INVALID_PARAMETER;
 539         }
 540
 541         if (msg_struct->data == NULL || mms_struct->data == NULL) {
 542                 return MSG_ERR_INVALID_PARAMETER;
 543         }
 544
 545         if (msg_struct->type != MSG_STRUCT_MESSAGE_INFO || mms_struct->type != MSG_STRUCT_MMS) {
 546                 return MSG_ERR_INVALID_PARAMETER;
 547         }
 548
 549         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)msg_struct->data;
 550
 551         MMS_MESSAGE_DATA_S *tmp_mms_data  = (MMS_MESSAGE_DATA_S *)calloc(1, sizeof(MMS_MESSAGE_DATA_S));
 552
 553         _MsgMmsDeserializeMessageData(tmp_mms_data, (char*)msg_data->pMmsData);
 554
 555         convert_from_mmsdata(tmp_mms_data, mms_struct);
 556
 557         _MsgMmsReleasePageList(tmp_mms_data);
 558         _MsgMmsReleaseRegionList(tmp_mms_data);
 559         _MsgMmsReleaseAttachList(tmp_mms_data);
 560         _MsgMmsReleaseTransitionList(tmp_mms_data);
 561         _MsgMmsReleaseMetaList(tmp_mms_data);
 562         free(tmp_mms_data);
 563
 564         return ret;
 565 }
 566
 567 EXPORT_API int msg_set_mms_struct(msg_struct_t msg_struct_handle, msg_struct_t mms_struct_handle)
 568 {
 569         //TODO :: check message type is MMS
 570         int ret = MSG_SUCCESS;
 571         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
 572         msg_struct_s *mms_struct = (msg_struct_s *)mms_struct_handle;
 573
 574         if (msg_struct == NULL || mms_struct == NULL) {
 575                 return MSG_ERR_INVALID_PARAMETER;
 576         }
 577
 578         if (msg_struct->data == NULL || mms_struct->data == NULL) {
 579                 return MSG_ERR_INVALID_PARAMETER;
 580         }
 581
 582         if (msg_struct->type != MSG_STRUCT_MESSAGE_INFO || mms_struct->type != MSG_STRUCT_MMS) {
 583                 return MSG_ERR_INVALID_PARAMETER;
 584         }
 585
 586         MSG_MESSAGE_HIDDEN_S *msg_data = (MSG_MESSAGE_HIDDEN_S *)msg_struct->data;
 587
 588         MMS_MESSAGE_DATA_S *tmp_mms_data = (MMS_MESSAGE_DATA_S *)calloc(1,sizeof(MMS_MESSAGE_DATA_S));
 589
 590         convert_to_mmsdata(mms_struct, tmp_mms_data);
 591
 592         msg_data->pMmsData = _MsgMmsSerializeMessageData(tmp_mms_data, &(msg_data->dataSize));
 593
 594         _MsgMmsReleasePageList(tmp_mms_data);
 595         _MsgMmsReleaseRegionList(tmp_mms_data);
 596         _MsgMmsReleaseAttachList(tmp_mms_data);
 597         _MsgMmsReleaseTransitionList(tmp_mms_data);
 598         _MsgMmsReleaseMetaList(tmp_mms_data);
 599         free(tmp_mms_data);
 600         return ret;
 601 }
 602