mapi/msg_mms.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 <stdio.h>
  18 #include <string.h>
  19 #include <sys/stat.h>
  20
  21 #include <MsgHandle.h>
  22 #include <MsgException.h>
  23 #include "MsgTypes.h"
  24 #include "MsgMmsTypes.h"
  25 #include "MsgMmsMessage.h"
  26 #include "MsgDebug.h"
  27 #include "MsgUtilFile.h"
  28
  29 #include "msg.h"
  30 #include "msg_private.h"
  31
  32 /* Internel Struct */
  33 typedef struct {
  34         GList                   *pagelist;
  35         GList                   *regionlist;
  36         GList                   *attachlist;
  37         GList                   *transitionlist;
  38         GList                   *metalist;
  39         MMS_SMIL_ROOTLAYOUT     rootlayout;
  40         MMS_APPID_INFO_S        msgAppId;
  41         MMS_HEADER_DATA_S header;
  42         MMS_MULTIPART_DATA_S smil;
  43         GList *multipartlist; /* MMS_MULTIPART_DATA_S */
  44 } MMS_DATA_HIDDEN_S;
  45
  46 typedef struct {
  47         MmsSmilMediaType        mediatype; /**< Indicates the SMIL media type. see enum MmsSmilMediaType */
  48
  49         char                    szSrc[MSG_FILEPATH_LEN_MAX + 1];/**< Indicates the media source name */
  50         char                    szFileName[MSG_FILENAME_LEN_MAX + 1]; /**< Indicates the file name */
  51         char                    szFilePath[MSG_FILEPATH_LEN_MAX + 1]; /**< Indicates the file path */
  52         char                    szContentID[MSG_MSG_ID_LEN + 1]; /**< Indicates the content id */
  53         char                    regionId[MAX_SMIL_REGION_ID + 1]; /**< Indicates the region id */
  54         char                    szAlt[MAX_SMIL_ALT_LEN + 1]; /**< Indicates the alternative text to be displayed in failure case */
  55         MsgDrmType              drmType; /**< Indicates the drm type. see enum MsgDrmType */
  56         char                    szDrm2FullPath[MSG_FILEPATH_LEN_MAX + 1];  /**< Indicates the fullpath of the DRM */
  57         msg_struct_s *pText;
  58         msg_struct_s *pAVI;
  59         char szContentType[MSG_MSG_ID_LEN + 1];
  60         char szContentLocation[MSG_MSG_ID_LEN + 1];
  61 } MMS_MEDIA_HIDDEN_S;
  62
  63 static void __msg_mms_data_struct_init(MMS_DATA_HIDDEN_S *pMmsDataHidden);
  64 static void __msg_mms_release_mms(msg_struct_s *mms_struct);
  65 static void __msg_mms_release_page(msg_struct_s *page_struct);
  66 static void __msg_mms_release_media(msg_struct_s *media_struct);
  67 static void __msg_mms_release_region(msg_struct_s *region_struct);
  68 static void __msg_mms_release_attach(msg_struct_s *attach_struct);
  69 static void __msg_mms_release_transition(msg_struct_s *transition_struct);
  70 static void __msg_mms_release_meta(msg_struct_s *meta_struct);
  71 static void __msg_mms_release_multipart(msg_struct_s *multipart_struct);
  72
  73 /*==================================================================================================
  74                                      FUNCTION IMPLEMENTATION
  75 ==================================================================================================*/
  76 static void __removeLessGreaterMark(const char *szSrcID, char *szDest, int destSize)
  77 {
  78         char szBuf[MSG_MSG_ID_LEN + 1] = {0, };
  79         int cLen = strlen(szSrcID);
  80
  81         if (cLen == 0)
  82                 return;
  83
  84         if (cLen > 1 && szSrcID[0] == '<' && szSrcID[cLen - 1] == '>') {
  85                 strncpy(szBuf, &szSrcID[1], cLen - 2);
  86                 szBuf[cLen - 2] = '\0';
  87         } else if (cLen > 1 && szSrcID[0] == '"' && szSrcID[cLen-1] == '"') {
  88                 strncpy(szBuf, &szSrcID[1], cLen - 2);
  89                 szBuf[cLen - 2] = '\0';
  90         } else {
  91                 strncpy(szBuf, szSrcID, cLen);
  92                 szBuf[cLen] = '\0';
  93         }
  94
  95         int wrn = snprintf(szDest, destSize, "%s", szBuf);
  96         if(wrn<0)
  97                 MSG_DEBUG("snprintf was failed");
  98 }
  99
 100 static inline void *get_msg_struct_data(msg_struct_s *msg_struct)
 101 {
 102         if (msg_struct == NULL)
 103                 return NULL;
 104
 105         return msg_struct->data;
 106 }
 107
 108 msg_struct_s *msg_mms_create_struct(int type)
 109 {
 110         msg_struct_s *msg_struct = new msg_struct_s;
 111         bzero(msg_struct, sizeof(msg_struct_s));
 112
 113         msg_struct->type = type;
 114         msg_struct->data = msg_mms_create_struct_data(type);
 115
 116         return msg_struct;
 117 }
 118
 119 void *msg_mms_create_struct_data(int field)
 120 {
 121         void *data = NULL;
 122
 123         switch (field) {
 124         case MSG_STRUCT_MMS:
 125                 data = (void *)new MMS_DATA_HIDDEN_S;
 126                 bzero(data, sizeof(MMS_DATA_HIDDEN_S));
 127                 __msg_mms_data_struct_init((MMS_DATA_HIDDEN_S *)data);
 128                 break;
 129         case MSG_STRUCT_MMS_PAGE:
 130                 data = (void *)new MMS_PAGE_S;
 131                 bzero(data, sizeof(MMS_PAGE_S));
 132                 break;
 133         case MSG_STRUCT_MMS_MEDIA: {
 134                 MMS_MEDIA_HIDDEN_S *media = new MMS_MEDIA_HIDDEN_S;
 135                 bzero(media, sizeof(MMS_MEDIA_HIDDEN_S));
 136
 137                 media->pText = msg_mms_create_struct(MSG_STRUCT_MMS_SMIL_TEXT);
 138                 media->pAVI = msg_mms_create_struct(MSG_STRUCT_MMS_SMIL_AVI);
 139                 data = (void *)media;
 140         }
 141                 break;
 142         case MSG_STRUCT_MMS_ATTACH:
 143                 data = (void *)new MMS_ATTACH_S;
 144                 bzero(data, sizeof(MMS_ATTACH_S));
 145                 break;
 146         case MSG_STRUCT_MMS_REGION:
 147                 data = (void *)new MMS_SMIL_REGION;
 148                 bzero(data, sizeof(MMS_SMIL_REGION));
 149                 ((MMS_SMIL_REGION *)data)->fit = MMSUI_IMAGE_REGION_FIT_MEET;
 150                 break;
 151         case MSG_STRUCT_MMS_TRANSITION:
 152                 data = (void *)new MMS_SMIL_TRANSITION;
 153                 bzero(data, sizeof(MMS_SMIL_TRANSITION));
 154                 break;
 155         case MSG_STRUCT_MMS_META:
 156                 data = (void *)new MMS_SMIL_META;
 157                 bzero(data, sizeof(MMS_SMIL_META));
 158                 break;
 159         case MSG_STRUCT_MMS_SMIL_TEXT:
 160                 data = (void *)new MmsSmilText;
 161                 bzero(data, sizeof(MmsSmilText));
 162                 break;
 163         case MSG_STRUCT_MMS_SMIL_AVI:
 164                 data = (void *)new MmsSmilAVI;
 165                 bzero(data, sizeof(MmsSmilAVI));
 166                 break;
 167         case MSG_STRUCT_MULTIPART_INFO:
 168                 data = new MMS_MULTIPART_DATA_S;
 169                 bzero(data, sizeof(MMS_MULTIPART_DATA_S));
 170                 MsgMmsInitMultipart((MMS_MULTIPART_DATA_S *)data);
 171                 break;
 172         }
 173
 174         return data;
 175 }
 176
 177 void msg_mms_list_item_free_func(gpointer data)
 178 {
 179         msg_struct_s *msg_struct = (msg_struct_s *)data;
 180
 181         switch (msg_struct->type) {
 182         case MSG_STRUCT_MMS_MEDIA:
 183                 __msg_mms_release_media(msg_struct);
 184                 break;
 185         case MSG_STRUCT_MMS_PAGE:
 186                 __msg_mms_release_page(msg_struct);
 187                 break;
 188         case MSG_STRUCT_MMS_ATTACH:
 189                 __msg_mms_release_attach(msg_struct);
 190                 break;
 191         case MSG_STRUCT_MMS_REGION:
 192                 __msg_mms_release_region(msg_struct);
 193                 break;
 194         case MSG_STRUCT_MMS_TRANSITION:
 195                 __msg_mms_release_transition(msg_struct);
 196                 break;
 197         case MSG_STRUCT_MMS_META:
 198                 __msg_mms_release_meta(msg_struct);
 199                 break;
 200         case MSG_STRUCT_MULTIPART_INFO:
 201                 __msg_mms_release_multipart(msg_struct);
 202                 break;
 203         default:
 204                 break;
 205         }
 206 }
 207
 208 void __msg_mms_release_page(msg_struct_s *page_struct)
 209 {
 210         if (page_struct) {
 211                 MMS_PAGE_S *page = (MMS_PAGE_S *)page_struct->data;
 212
 213                 if (page) {
 214                         if (page->medialist) {
 215                                  g_list_free_full(page->medialist, msg_mms_list_item_free_func);
 216                         }
 217
 218                         delete (MMS_PAGE_S *)page;
 219                         page_struct->data = NULL;
 220                 }
 221
 222                 delete page_struct;
 223         }
 224 }
 225
 226 void __msg_mms_release_media(msg_struct_s *media_struct)
 227 {
 228         if (media_struct) {
 229                 MMS_MEDIA_HIDDEN_S *media = (MMS_MEDIA_HIDDEN_S *)media_struct->data;
 230
 231                 if (media) {
 232                         if (media->pText)
 233                                 msg_mms_release_struct(&media->pText);
 234
 235                         if (media->pAVI)
 236                                 msg_mms_release_struct(&media->pAVI);
 237
 238                         delete (MMS_MEDIA_HIDDEN_S *)media;
 239
 240                         media_struct->data = NULL;
 241                 }
 242
 243                 delete media_struct;
 244         }
 245 }
 246
 247 void __msg_mms_release_attach(msg_struct_s *attach_struct)
 248 {
 249         if (attach_struct) {
 250                 MMS_ATTACH_S *attach = (MMS_ATTACH_S *)attach_struct->data;
 251
 252                 if (attach)
 253                         delete (MMS_ATTACH_S *)attach;
 254
 255                 attach_struct->data = NULL;
 256
 257                 delete attach_struct;
 258         }
 259 }
 260
 261 void __msg_mms_release_region(msg_struct_s *region_struct)
 262 {
 263         if (region_struct) {
 264                 MMS_SMIL_REGION *region = (MMS_SMIL_REGION *)region_struct->data;
 265
 266                 if (region)
 267                         delete (MMS_SMIL_REGION *)region;
 268
 269                 region_struct->data = NULL;
 270
 271                 delete region_struct;
 272         }
 273 }
 274
 275 void __msg_mms_release_transition(msg_struct_s *transition_struct)
 276 {
 277         if (transition_struct) {
 278                 MMS_SMIL_TRANSITION *transition = (MMS_SMIL_TRANSITION *)transition_struct->data;
 279
 280                 if (transition)
 281                         delete (MMS_SMIL_TRANSITION *)transition;
 282
 283                 transition_struct->data = NULL;
 284
 285                 delete transition_struct;
 286         }
 287 }
 288
 289 void __msg_mms_release_meta(msg_struct_s *meta_struct)
 290 {
 291         if (meta_struct) {
 292                 MMS_SMIL_META *meta = (MMS_SMIL_META *)meta_struct->data;
 293
 294                 if (meta)
 295                         delete (MMS_SMIL_META *)meta;
 296
 297                 meta_struct->data = NULL;
 298
 299                 delete meta_struct;
 300         }
 301 }
 302
 303 void __msg_mms_release_multipart(msg_struct_s *multipart_struct)
 304 {
 305         if (multipart_struct) {
 306                 MMS_MULTIPART_DATA_S *multipart = (MMS_MULTIPART_DATA_S *)multipart_struct->data;
 307
 308                 if (multipart) {
 309                         g_free(multipart->pMultipartData); multipart->pMultipartData = NULL;
 310                         delete (MMS_MULTIPART_DATA_S *)multipart;
 311                 }
 312
 313                 multipart_struct->data = NULL;
 314
 315                 delete multipart_struct;
 316         }
 317 }
 318
 319 void __msg_mms_release_mms(msg_struct_s *mms_struct)
 320 {
 321         MMS_DATA_HIDDEN_S *mms = (MMS_DATA_HIDDEN_S *)mms_struct->data;
 322
 323         if (mms->pagelist) {
 324                 g_list_free_full(mms->pagelist, msg_mms_list_item_free_func);
 325                 mms->pagelist = NULL;
 326         }
 327
 328         if (mms->regionlist) {
 329                 g_list_free_full(mms->regionlist, msg_mms_list_item_free_func);
 330                 mms->regionlist = NULL;
 331         }
 332
 333         if (mms->attachlist) {
 334                 g_list_free_full(mms->attachlist, msg_mms_list_item_free_func);
 335                 mms->attachlist = NULL;
 336         }
 337
 338         if (mms->transitionlist) {
 339                 g_list_free_full(mms->transitionlist, msg_mms_list_item_free_func);
 340                 mms->transitionlist = NULL;
 341         }
 342
 343         if (mms->metalist) {
 344                 g_list_free_full(mms->metalist, msg_mms_list_item_free_func);
 345                 mms->metalist = NULL;
 346         }
 347
 348         if (mms->multipartlist) {
 349                 g_list_free_full(mms->multipartlist, msg_mms_list_item_free_func);
 350                 mms->multipartlist = NULL;
 351         }
 352
 353         if (mms->smil.pMultipartData) {
 354                 g_free(mms->smil.pMultipartData);
 355                 mms->smil.pMultipartData = NULL;
 356         }
 357
 358         delete (MMS_DATA_HIDDEN_S *)mms;
 359
 360         mms_struct->data = NULL;
 361
 362         delete mms_struct;
 363 }
 364
 365 int msg_mms_release_struct(msg_struct_s **msg_struct_data)
 366 {
 367         msg_struct_s *msg_struct = (msg_struct_s *)*msg_struct_data;
 368         int type = msg_struct->type;
 369
 370         switch (type) {
 371         case MSG_STRUCT_MMS:
 372                 __msg_mms_release_mms(*msg_struct_data);
 373                 *msg_struct_data = NULL;
 374                 break;
 375         case MSG_STRUCT_MMS_PAGE:
 376                 __msg_mms_release_page(*msg_struct_data);
 377                 *msg_struct_data = NULL;
 378                 break;
 379         case MSG_STRUCT_MMS_MEDIA:
 380                 __msg_mms_release_media(*msg_struct_data);
 381                 *msg_struct_data = NULL;
 382                 break;
 383         case MSG_STRUCT_MMS_ATTACH:
 384                 __msg_mms_release_attach(*msg_struct_data);
 385                 *msg_struct_data = NULL;
 386                 break;
 387         case MSG_STRUCT_MMS_REGION:
 388                 __msg_mms_release_attach(*msg_struct_data);
 389                 *msg_struct_data = NULL;
 390                 break;
 391         case MSG_STRUCT_MMS_TRANSITION:
 392                 __msg_mms_release_transition(*msg_struct_data);
 393                 *msg_struct_data = NULL;
 394                 break;
 395         case MSG_STRUCT_MMS_META:
 396                 __msg_mms_release_meta(*msg_struct_data);
 397                 *msg_struct_data = NULL;
 398                 break;
 399         case MSG_STRUCT_MMS_SMIL_TEXT:
 400                 if (msg_struct->data) {
 401                         delete (MmsSmilText*)msg_struct->data;
 402                         msg_struct->data = NULL;
 403                 }
 404                 delete msg_struct;
 405                 *msg_struct_data = NULL;
 406                 break;
 407         case MSG_STRUCT_MMS_SMIL_AVI:
 408                 if (msg_struct->data) {
 409                         delete (MmsSmilAVI*)msg_struct->data;
 410                         msg_struct->data = NULL;
 411                 }
 412                 delete msg_struct;
 413                 *msg_struct_data = NULL;
 414                 break;
 415         case MSG_STRUCT_MULTIPART_INFO: {
 416                 if (msg_struct->data) {
 417                         delete (MMS_MULTIPART_DATA_S *)(msg_struct->data);
 418                         msg_struct->data = NULL;
 419                 }
 420                 delete msg_struct;
 421                 *msg_struct_data = NULL;
 422                 break;
 423         }
 424         }
 425
 426         return 0;
 427 }
 428
 429 int msg_mms_get_int_value(msg_struct_s *msg_struct, int field, int *value)
 430 {
 431         msg_error_t err = MSG_SUCCESS;
 432
 433         switch (msg_struct->type) {
 434         case MSG_STRUCT_MMS: {
 435                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 436                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_INT) {
 437                         *value = mms_data->rootlayout.width.value;
 438                 } else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_INT) {
 439                         *value = mms_data->rootlayout.height.value;
 440                 } else if (field == MSG_MMS_ROOTLAYOUT_BGCOLOR_INT) {
 441                         *value = mms_data->rootlayout.bgColor;
 442                 } else if (field == MSG_MMS_HEADER_DATE_INT) {
 443                         *value = mms_data->header.date;
 444                 } else if (field == MSG_MMS_HEADER_DELIVERY_REPORT_INT) {
 445                         *value = mms_data->header.bDeliveryReport;
 446                 } else if (field == MSG_MMS_HEADER_DELIVERY_TIME_INT) {
 447                         *value = mms_data->header.delivery.time;
 448                 } else if (field == MSG_MMS_HEADER_EXPIRY_TIME_INT) {
 449                         *value = mms_data->header.expiry.time;
 450                 } else if (field == MSG_MMS_HEADER_MESSAGE_CLASS_INT) {
 451                         *value = mms_data->header.messageClass;
 452                 } else if (field == MSG_MMS_HEADER_MESSAGE_TYPE_INT) {
 453                         *value = mms_data->header.messageType;
 454                 } else if (field == MSG_MMS_HEADER_VERSION_INT) {
 455                         *value = mms_data->header.mmsVersion;
 456                 } else if (field == MSG_MMS_HEADER_SIZE_INT) {
 457                         *value = mms_data->header.messageSize;
 458                 } else if (field == MSG_MMS_HEADER_PRIORITY_INT) {
 459                         *value = mms_data->header.mmsPriority;
 460                 } else if (field == MSG_MMS_HEADER_READ_REPORT_INT) {
 461                         *value = mms_data->header.bReadReport;
 462                 } else if (field == MSG_MMS_HEADER_HIDE_ADDRESS_INT) {
 463                         *value = mms_data->header.bHideAddress;
 464                 } else if (field == MSG_MMS_HEADER_MMS_STATUS_INT) {
 465                         *value = mms_data->header.mmsStatus;
 466                 } else if (field == MSG_MMS_HEADER_CONTENT_CLASS_INT) {
 467                         *value = mms_data->header.contentClass;
 468                 } else {
 469                         err = MSG_ERR_INVALID_PARAMETER;
 470                 }
 471         }
 472         break;
 473         case MSG_STRUCT_MMS_PAGE: {
 474                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
 475                 if (field == MSG_MMS_PAGE_PAGE_DURATION_INT)
 476                         *value = mms_page_data->nDur;
 477                 else if (field == MSG_MMS_PAGE_BEGIN_TIME_INT)
 478                         *value = mms_page_data->nBegin;
 479                 else if (field == MSG_MMS_PAGE_END_TIME_INT)
 480                         *value = mms_page_data->nEnd;
 481                 else if (field == MSG_MMS_PAGE_MIN_INT)
 482                         *value = mms_page_data->nMin;
 483                 else if (field == MSG_MMS_PAGE_MAX_INT)
 484                         *value = mms_page_data->nMax;
 485                 else if (field == MSG_MMS_PAGE_REPEAT_INT)
 486                         *value = mms_page_data->nRepeat;
 487                 else
 488                         err = MSG_ERR_INVALID_PARAMETER;
 489         }
 490         break;
 491         case MSG_STRUCT_MMS_MEDIA: {
 492                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 493                 if (field == MSG_MMS_MEDIA_TYPE_INT)
 494                         *value = mms_media_data->mediatype;
 495                 else if (field == MSG_MMS_MEDIA_DRM_TYPE_INT)
 496                         *value = mms_media_data->drmType;
 497                 else
 498                         err = MSG_ERR_INVALID_PARAMETER;
 499         }
 500         break;
 501         case MSG_STRUCT_MMS_ATTACH: {
 502                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 503                 if (field == MSG_MMS_ATTACH_MIME_TYPE_INT)
 504                         *value = mms_attach_data->mediatype;
 505                 else if (field == MSG_MMS_ATTACH_FILESIZE_INT)
 506                         *value = mms_attach_data->fileSize;
 507                 else if (field == MSG_MMS_ATTACH_DRM_TYPE_INT)
 508                         *value = mms_attach_data->drmType;
 509                 else
 510                         err = MSG_ERR_INVALID_PARAMETER;
 511         }
 512         break;
 513         case MSG_STRUCT_MMS_REGION: {
 514                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 515                 if (field == MSG_MMS_REGION_LENGTH_LEFT_INT)
 516                         *value = mms_region_data->nLeft.value;
 517                 else if (field == MSG_MMS_REGION_LENGTH_TOP_INT)
 518                         *value = mms_region_data->nTop.value;
 519                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_INT)
 520                         *value = mms_region_data->width.value;
 521                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_INT)
 522                         *value = mms_region_data->height.value;
 523                 else if (field == MSG_MMS_REGION_BGCOLOR_INT)
 524                         *value = mms_region_data->bgColor;
 525                 else if (field == MSG_MMS_REGION_FIT_TYPE_INT)
 526                         *value = mms_region_data->fit;
 527                 else
 528                         err = MSG_ERR_INVALID_PARAMETER;
 529         }
 530         break;
 531         case MSG_STRUCT_MMS_TRANSITION: {
 532                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 533                 if (field == MSG_MMS_TRANSITION_TYPE_INT)
 534                         *value = mms_transition_data->nType;
 535                 else if (field == MSG_MMS_TRANSITION_SUBTYPE_INT)
 536                         *value = mms_transition_data->nSubType;
 537                 else if (field == MSG_MMS_TRANSITION_DURATION_INT)
 538                         *value = mms_transition_data->nDur;
 539                 else
 540                         err = MSG_ERR_INVALID_PARAMETER;
 541         }
 542         break;
 543         case MSG_STRUCT_MMS_SMIL_TEXT: {
 544                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 545                 if (field == MSG_MMS_SMIL_TEXT_REPEAT_INT)
 546                         *value = mms_smil_text_data->nRepeat;
 547                 else if (field == MSG_MMS_SMIL_TEXT_BEGIN_INT)
 548                         *value = mms_smil_text_data->nBegin;
 549                 else if (field == MSG_MMS_SMIL_TEXT_END_INT)
 550                         *value = mms_smil_text_data->nEnd;
 551                 else if (field == MSG_MMS_SMIL_TEXT_DURTIME_INT)
 552                         *value = mms_smil_text_data->nDurTime;
 553                 else if (field == MSG_MMS_SMIL_TEXT_BGCOLOR_INT)
 554                         *value = mms_smil_text_data->nBgColor;
 555                 else if (field == MSG_MMS_SMIL_TEXT_DIRECTION_TYPE_INT)
 556                         *value = mms_smil_text_data->nDirection;
 557                 else if (field == MSG_MMS_SMIL_TEXT_SIZE_INT)
 558                         *value = mms_smil_text_data->nSize;
 559                 else if (field == MSG_MMS_SMIL_TEXT_COLOR_INT)
 560                         *value = mms_smil_text_data->nColor;
 561                 else
 562                         err = MSG_ERR_INVALID_PARAMETER;
 563         }
 564         break;
 565         case MSG_STRUCT_MMS_SMIL_AVI: {
 566                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 567                 if (field == MSG_MMS_SMIL_AVI_REPEAT_INT)
 568                         *value = mms_smil_avi_data->nRepeat;
 569                 else if (field == MSG_MMS_SMIL_AVI_BEGIN_INT)
 570                         *value = mms_smil_avi_data->nBegin;
 571                 else if (field == MSG_MMS_SMIL_AVI_END_INT)
 572                         *value = mms_smil_avi_data->nEnd;
 573                 else if (field == MSG_MMS_SMIL_AVI_DURTIME_INT)
 574                         *value = mms_smil_avi_data->nDurTime;
 575                 else if (field == MSG_MMS_SMIL_AVI_BGCOLOR_INT)
 576                         *value = mms_smil_avi_data->nBgColor;
 577                 else
 578                         err = MSG_ERR_INVALID_PARAMETER;
 579         }
 580         break;
 581         case MSG_STRUCT_MULTIPART_INFO:
 582                 err = msg_multipart_get_int_value(msg_struct->data, field, value);
 583                 break;
 584
 585         default:
 586                 err = MSG_ERR_INVALID_PARAMETER;
 587                 break;
 588         }
 589         return err;
 590 }
 591
 592 int msg_mms_get_str_value(msg_struct_s *msg_struct, int field, char *value, int size)
 593 {
 594         msg_error_t err = MSG_SUCCESS;
 595
 596         switch (msg_struct->type) {
 597         case MSG_STRUCT_MMS: {
 598                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 599                 if (field == MSG_MMS_HEADER_CONTENT_LOCATION_STR) { /* mms header */
 600                         strncpy(value, mms_data->header.contentLocation, size);
 601                 } else if (field == MSG_MMS_HEADER_CONTENT_TYPE_STR) {
 602                         strncpy(value, mms_data->header.szContentType, size);
 603                 } else if (field == MSG_MMS_HEADER_FROM_STR) {
 604                         strncpy(value, mms_data->header.szFrom, size);
 605                 } else if (field == MSG_MMS_HEADER_MESSAGE_ID_STR) {
 606                         strncpy(value, mms_data->header.messageID, size);
 607                 } else if (field == MSG_MMS_HEADER_TR_ID_STR) {
 608                         strncpy(value, mms_data->header.trID, size);
 609
 610                 } else if (field == MSG_MMS_SMIL_MULTIPART_CONTENT_TYPE_STR) { /* smil */
 611                         strncpy(value, mms_data->smil.szContentType, size);
 612                 } else if (field == MSG_MMS_SMIL_MULTIPART_NAME_STR) {
 613                         strncpy(value, mms_data->smil.szFileName, size);
 614                 } else if (field == MSG_MMS_SMIL_MULTIPART_FILEPATH_STR) {
 615                         strncpy(value, mms_data->smil.szFilePath, size);
 616                 } else if (field == MSG_MMS_SMIL_MULTIPART_CONTENT_ID_STR) {
 617                         strncpy(value, mms_data->smil.szContentID, size);
 618                 } else if (field == MSG_MMS_SMIL_MULTIPART_CONTENT_LOCATION_STR) {
 619                         strncpy(value, mms_data->smil.szContentLocation, size);
 620                 } else {
 621                         err = MSG_ERR_INVALID_PARAMETER;
 622                 }
 623         }
 624         break;
 625         case MSG_STRUCT_MMS_MEDIA: {
 626                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 627                 if (field == MSG_MMS_MEDIA_SRC_STR) {
 628                         strncpy(value, mms_media_data->szSrc, size);
 629                 } else if (field == MSG_MMS_MEDIA_FILENAME_STR) {
 630                         strncpy(value, mms_media_data->szFileName, size);
 631                 } else if (field == MSG_MMS_MEDIA_FILEPATH_STR) {
 632                         strncpy(value, mms_media_data->szFilePath, size);
 633                 } else if (field == MSG_MMS_MEDIA_CONTENT_ID_STR) {
 634                         if (strlen(mms_media_data->szContentID) > 0)
 635                                 snprintf(value, size, "<%s>", mms_media_data->szContentID);
 636                 } else if (field == MSG_MMS_MEDIA_REGION_ID_STR) {
 637                         strncpy(value, mms_media_data->regionId, size);
 638                 } else if (field == MSG_MMS_MEDIA_ALTERNATIVE_STR) {
 639                         strncpy(value, mms_media_data->szAlt, size);
 640                 } else if (field == MSG_MMS_MEDIA_DRM_FULLPATH_STR) {
 641                         strncpy(value, mms_media_data->szDrm2FullPath, size);
 642                 } else if (field == MSG_MMS_MEDIA_CONTENT_LOCATION_STR) {
 643                         strncpy(value, mms_media_data->szContentLocation, size);
 644                 } else if (field == MSG_MMS_MEDIA_CONTENT_TYPE_STR) {
 645                         strncpy(value, mms_media_data->szContentType, size);
 646                 } else {
 647                         err = MSG_ERR_INVALID_PARAMETER;
 648                 }
 649         }
 650         break;
 651         case MSG_STRUCT_MMS_ATTACH: {
 652                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 653                 if (field == MSG_MMS_ATTACH_FILENAME_STR)
 654                         strncpy(value, mms_attach_data->szFileName, size);
 655                 else if (field == MSG_MMS_ATTACH_FILEPATH_STR)
 656                         strncpy(value, mms_attach_data->szFilePath, size);
 657                 else if (field == MSG_MMS_ATTACH_DRM_FULLPATH_STR)
 658                         strncpy(value, mms_attach_data->szDrm2FullPath, size);
 659                 else if (field == MSG_MMS_ATTACH_CONTENT_TYPE_STR)
 660                         strncpy(value, mms_attach_data->szContentType, size);
 661                 else
 662                         err = MSG_ERR_INVALID_PARAMETER;
 663         }
 664         break;
 665         case MSG_STRUCT_MMS_REGION: {
 666                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 667                 if (field == MSG_MMS_REGION_ID_STR)
 668                         strncpy(value, mms_region_data->szID, size);
 669                 else
 670                         err = MSG_ERR_INVALID_PARAMETER;
 671         }
 672         break;
 673         case MSG_STRUCT_MMS_TRANSITION: {
 674                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 675                 if (field == MSG_MMS_TRANSITION_ID_STR)
 676                         strncpy(value, mms_transition_data->szID, size);
 677                 else
 678                         err = MSG_ERR_INVALID_PARAMETER;
 679         }
 680         break;
 681         case MSG_STRUCT_MMS_META: {
 682                 MMS_SMIL_META *mms_meta_data = (MMS_SMIL_META *)msg_struct->data;
 683                 if (field == MSG_MMS_META_ID_STR)
 684                         strncpy(value, mms_meta_data->szID, size);
 685                 else if (field == MSG_MMS_META_NAME_STR)
 686                         strncpy(value, mms_meta_data->szName, size);
 687                 else if (field == MSG_MMS_META_CONTENT_STR)
 688                         strncpy(value, mms_meta_data->szContent, size);
 689                 else
 690                         err = MSG_ERR_INVALID_PARAMETER;
 691         }
 692         break;
 693         case MSG_STRUCT_MMS_SMIL_TEXT: {
 694                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 695                 if (field == MSG_MMS_SMIL_TEXT_TRANSITION_IN_ID_STR)
 696                         strncpy(value, mms_smil_text_data->szTransInId, size);
 697                 else if (field == MSG_MMS_SMIL_TEXT_TRANSITION_OUT_ID_STR)
 698                         strncpy(value, mms_smil_text_data->szTransOutId, size);
 699                 else
 700                         err = MSG_ERR_INVALID_PARAMETER;
 701         }
 702         break;
 703         case MSG_STRUCT_MMS_SMIL_AVI: {
 704                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 705                 if (field == MSG_MMS_SMIL_AVI_TRANSITION_IN_ID_STR)
 706                         strncpy(value, mms_smil_avi_data->szTransInId, size);
 707                 else if (field == MSG_MMS_SMIL_AVI_TRANSITION_OUT_ID_STR)
 708                         strncpy(value, mms_smil_avi_data->szTransOutId, size);
 709                 else
 710                         err = MSG_ERR_INVALID_PARAMETER;
 711         }
 712         break;
 713         case MSG_STRUCT_MULTIPART_INFO:
 714                 err = msg_multipart_get_str_value(msg_struct->data, field, value, size);
 715         break;
 716
 717         default:
 718                 err = MSG_ERR_INVALID_PARAMETER;
 719                 break;
 720         }
 721         return err;
 722 }
 723
 724 int msg_mms_get_bool_value(msg_struct_s *msg_struct, int field, bool *value)
 725 {
 726         msg_error_t err = MSG_SUCCESS;
 727
 728         switch (msg_struct->type) {
 729         case MSG_STRUCT_MMS: {
 730                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 731                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_PERCENT_BOOL)
 732                         *value = mms_data->rootlayout.width.bUnitPercent;
 733                 else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_PERCENT_BOOL)
 734                         *value = mms_data->rootlayout.height.bUnitPercent;
 735                 else if (field == MSG_MMS_ROOTLAYOUT_BGCOLOR_BOOL)
 736                         *value = mms_data->rootlayout.bBgColor;
 737                 else
 738                         err = MSG_ERR_INVALID_PARAMETER;
 739         }
 740         break;
 741         case MSG_STRUCT_MMS_REGION: {
 742                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 743                 if (field == MSG_MMS_REGION_LENGTH_LEFT_PERCENT_BOOL)
 744                         *value = mms_region_data->nLeft.bUnitPercent;
 745                 else if (field == MSG_MMS_REGION_LENGTH_TOP_PERCENT_BOOL)
 746                         *value = mms_region_data->nTop.bUnitPercent;
 747                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_PERCENT_BOOL)
 748                         *value = mms_region_data->width.bUnitPercent;
 749                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_PERCENT_BOOL)
 750                         *value = mms_region_data->height.bUnitPercent;
 751                 else if (field == MSG_MMS_REGION_BGCOLOR_BOOL)
 752                         *value = mms_region_data->bBgColor;
 753                 else
 754                         err = MSG_ERR_INVALID_PARAMETER;
 755         }
 756         break;
 757         case MSG_STRUCT_MMS_SMIL_TEXT: {
 758                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 759                 if (field == MSG_MMS_SMIL_TEXT_BOLD_BOOL)
 760                         *value = mms_smil_text_data->bBold;
 761                 else if (field == MSG_MMS_SMIL_TEXT_UNDERLINE_BOOL)
 762                         *value = mms_smil_text_data->bUnderLine;
 763                 else if (field == MSG_MMS_SMIL_TEXT_ITALIC_BOOL)
 764                         *value = mms_smil_text_data->bItalic;
 765                 else if (field == MSG_MMS_SMIL_TEXT_REVERSE_BOOL)
 766                         *value = mms_smil_text_data->bReverse;
 767                 else
 768                         err = MSG_ERR_INVALID_PARAMETER;
 769         }
 770         break;
 771         default:
 772                 err = MSG_ERR_INVALID_PARAMETER;
 773                 break;
 774         }
 775         return err;
 776 }
 777
 778 int msg_mms_get_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s **value)
 779 {
 780         msg_error_t err = MSG_SUCCESS;
 781
 782         switch (msg_struct->type) {
 783         case MSG_STRUCT_MMS_MEDIA: {
 784                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 785                 if (field == MSG_MMS_MEDIA_SMIL_TEXT_HND)
 786                         *value = mms_media_data->pText;
 787                 else if (field == MSG_MMS_MEDIA_SMIL_AVI_HND)
 788                         *value = mms_media_data->pAVI;
 789                 else
 790                         err = MSG_ERR_INVALID_PARAMETER;
 791         }
 792         break;
 793         default:
 794                 err = MSG_ERR_INVALID_PARAMETER;
 795                 break;
 796         }
 797         return err;
 798 }
 799
 800 int msg_mms_get_list_handle(msg_struct_s *msg_struct, int field, msg_list_handle_t *value)
 801 {
 802         msg_error_t err = MSG_SUCCESS;
 803
 804         switch (msg_struct->type) {
 805         case MSG_STRUCT_MMS: {
 806                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 807                 if (field == MSG_MMS_PAGE_LIST_HND)
 808                         *value = (msg_list_handle_t)mms_data->pagelist;
 809                 else if (field == MSG_MMS_REGION_LIST_HND)
 810                         *value = (msg_list_handle_t)mms_data->regionlist;
 811                 else if (field == MSG_MMS_ATTACH_LIST_HND)
 812                         *value = (msg_list_handle_t)mms_data->attachlist;
 813                 else if (field == MSG_MMS_TRANSITION_LIST_HND)
 814                         *value = (msg_list_handle_t)mms_data->transitionlist;
 815                 else if (field == MSG_MMS_META_LIST_HND)
 816                         *value = (msg_list_handle_t)mms_data->metalist;
 817                 else if (field == MSG_MMS_MULTIPART_LIST_HND)
 818                         *value = (msg_list_handle_t)mms_data->multipartlist;
 819                 else
 820                         err = MSG_ERR_INVALID_PARAMETER;
 821         }
 822         break;
 823         case MSG_STRUCT_MMS_PAGE: {
 824                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
 825                 if (field == MSG_MMS_PAGE_MEDIA_LIST_HND)
 826                         *value = (msg_list_handle_t)mms_page_data->medialist;
 827                 else
 828                         err = MSG_ERR_INVALID_PARAMETER;
 829         }
 830         break;
 831         default:
 832                 err = MSG_ERR_INVALID_PARAMETER;
 833                 break;
 834         }
 835         return err;
 836 }
 837 /*SET*/
 838 int msg_mms_set_int_value(msg_struct_s *msg_struct, int field, int value)
 839 {
 840         msg_error_t err = MSG_SUCCESS;
 841
 842         switch (msg_struct->type) {
 843         case MSG_STRUCT_MMS: {
 844                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
 845                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_INT) {
 846                         mms_data->rootlayout.width.value = value;
 847                 } else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_INT) {
 848                         mms_data->rootlayout.height.value = value;
 849                 } else if (field == MSG_MMS_ROOTLAYOUT_BGCOLOR_INT) {
 850                         mms_data->rootlayout.bBgColor = true;
 851                         mms_data->rootlayout.bgColor = value;
 852                 } else if (field == MSG_MMS_HEADER_DATE_INT) {
 853                         mms_data->header.date = value;
 854                 } else if (field == MSG_MMS_HEADER_DELIVERY_REPORT_INT) {
 855                         mms_data->header.bDeliveryReport = (bool)value;
 856                 } else if (field == MSG_MMS_HEADER_DELIVERY_TIME_INT) {
 857                         mms_data->header.delivery.time = value;
 858                 } else if (field == MSG_MMS_HEADER_EXPIRY_TIME_INT) {
 859                         mms_data->header.expiry.time = value;
 860                 } else if (field == MSG_MMS_HEADER_MESSAGE_CLASS_INT) {
 861                         mms_data->header.messageClass = value;
 862                 } else if (field == MSG_MMS_HEADER_MESSAGE_TYPE_INT) {
 863                         mms_data->header.messageType = value;
 864                 } else if (field == MSG_MMS_HEADER_VERSION_INT) {
 865                         mms_data->header.mmsVersion = value;
 866                 } else if (field == MSG_MMS_HEADER_SIZE_INT) {
 867                         mms_data->header.messageSize = value;
 868                 } else if (field == MSG_MMS_HEADER_PRIORITY_INT) {
 869                         mms_data->header.mmsPriority = value;
 870                 } else if (field == MSG_MMS_HEADER_READ_REPORT_INT) {
 871                         mms_data->header.bReadReport = (bool)value;
 872                 } else if (field == MSG_MMS_HEADER_HIDE_ADDRESS_INT) {
 873                         mms_data->header.bHideAddress = value;
 874                 } else if (field == MSG_MMS_HEADER_MMS_STATUS_INT) {
 875                         mms_data->header.mmsStatus = value;
 876                 } else if (field == MSG_MMS_HEADER_CONTENT_CLASS_INT) {
 877                         mms_data->header.contentClass = value;
 878                 } else {
 879                         err = MSG_ERR_INVALID_PARAMETER;
 880                 }
 881         }
 882         break;
 883         case MSG_STRUCT_MMS_PAGE: {
 884                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
 885                 if (field == MSG_MMS_PAGE_PAGE_DURATION_INT)
 886                         mms_page_data->nDur = value;
 887                 else if (field == MSG_MMS_PAGE_BEGIN_TIME_INT)
 888                         mms_page_data->nBegin = value;
 889                 else if (field == MSG_MMS_PAGE_END_TIME_INT)
 890                         mms_page_data->nEnd = value;
 891                 else if (field == MSG_MMS_PAGE_MIN_INT)
 892                         mms_page_data->nMin = value;
 893                 else if (field == MSG_MMS_PAGE_MAX_INT)
 894                         mms_page_data->nMax = value;
 895                 else if (field == MSG_MMS_PAGE_REPEAT_INT)
 896                         mms_page_data->nRepeat = value;
 897                 else
 898                         err = MSG_ERR_INVALID_PARAMETER;
 899         }
 900         break;
 901         case MSG_STRUCT_MMS_MEDIA: {
 902                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
 903                 if (field == MSG_MMS_MEDIA_TYPE_INT)
 904                         mms_media_data->mediatype = (MmsSmilMediaType)value;
 905                 else if (field == MSG_MMS_MEDIA_DRM_TYPE_INT)
 906                         mms_media_data->drmType = (MsgDrmType)value;
 907                 else
 908                         err = MSG_ERR_INVALID_PARAMETER;
 909         }
 910         break;
 911         case MSG_STRUCT_MMS_ATTACH: {
 912                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
 913                 if (field == MSG_MMS_ATTACH_MIME_TYPE_INT)
 914                         mms_attach_data->mediatype = (MimeType)value;
 915                 else if (field == MSG_MMS_ATTACH_FILESIZE_INT)
 916                         mms_attach_data->fileSize = value;
 917                 else if (field == MSG_MMS_ATTACH_DRM_TYPE_INT)
 918                         mms_attach_data->drmType = (MsgDrmType)value;
 919                 else
 920                         err = MSG_ERR_INVALID_PARAMETER;
 921         }
 922         break;
 923         case MSG_STRUCT_MMS_REGION: {
 924                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
 925                 if (field == MSG_MMS_REGION_LENGTH_LEFT_INT) {
 926                         mms_region_data->nLeft.value = value;
 927                 } else if (field == MSG_MMS_REGION_LENGTH_TOP_INT) {
 928                         mms_region_data->nTop.value = value;
 929                 } else if (field == MSG_MMS_REGION_LENGTH_WIDTH_INT) {
 930                         mms_region_data->width.value = value;
 931                 } else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_INT) {
 932                         mms_region_data->height.value = value;
 933                 } else if (field == MSG_MMS_REGION_BGCOLOR_INT) {
 934                         mms_region_data->bBgColor = true;
 935                         mms_region_data->bgColor = value;
 936                 } else if (field == MSG_MMS_REGION_FIT_TYPE_INT) {
 937                         mms_region_data->fit = (REGION_FIT_TYPE_T)value;
 938                 } else {
 939                         err = MSG_ERR_INVALID_PARAMETER;
 940                 }
 941         }
 942         break;
 943         case MSG_STRUCT_MMS_TRANSITION: {
 944                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
 945                 if (field == MSG_MMS_TRANSITION_TYPE_INT)
 946                         mms_transition_data->nType = (MmsSmilTransType)value;
 947                 else if (field == MSG_MMS_TRANSITION_SUBTYPE_INT)
 948                         mms_transition_data->nSubType = (MmsSmilTransSubType)value;
 949                 else if (field == MSG_MMS_TRANSITION_DURATION_INT)
 950                         mms_transition_data->nDur = value;
 951                 else
 952                         err = MSG_ERR_INVALID_PARAMETER;
 953         }
 954         break;
 955         case MSG_STRUCT_MMS_SMIL_TEXT: {
 956                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
 957                 if (field == MSG_MMS_SMIL_TEXT_REPEAT_INT)
 958                         mms_smil_text_data->nRepeat = value;
 959                 else if (field == MSG_MMS_SMIL_TEXT_BEGIN_INT)
 960                         mms_smil_text_data->nBegin = value;
 961                 else if (field == MSG_MMS_SMIL_TEXT_END_INT)
 962                         mms_smil_text_data->nEnd = value;
 963                 else if (field == MSG_MMS_SMIL_TEXT_DURTIME_INT)
 964                         mms_smil_text_data->nDurTime = value;
 965                 else if (field == MSG_MMS_SMIL_TEXT_BGCOLOR_INT)
 966                         mms_smil_text_data->nBgColor = value;
 967                 else if (field == MSG_MMS_SMIL_TEXT_DIRECTION_TYPE_INT)
 968                         mms_smil_text_data->nDirection = (MmsTextDirection)value;
 969                 else if (field == MSG_MMS_SMIL_TEXT_SIZE_INT)
 970                         mms_smil_text_data->nSize = value;
 971                 else if (field == MSG_MMS_SMIL_TEXT_COLOR_INT)
 972                         mms_smil_text_data->nColor = value;
 973                 else
 974                         err = MSG_ERR_INVALID_PARAMETER;
 975         }
 976         break;
 977         case MSG_STRUCT_MMS_SMIL_AVI: {
 978                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
 979                 if (field == MSG_MMS_SMIL_AVI_REPEAT_INT)
 980                         mms_smil_avi_data->nRepeat = value;
 981                 else if (field == MSG_MMS_SMIL_AVI_BEGIN_INT)
 982                         mms_smil_avi_data->nBegin = value;
 983                 else if (field == MSG_MMS_SMIL_AVI_END_INT)
 984                         mms_smil_avi_data->nEnd = value;
 985                 else if (field == MSG_MMS_SMIL_AVI_DURTIME_INT)
 986                         mms_smil_avi_data->nDurTime = value;
 987                 else if (field == MSG_MMS_SMIL_AVI_BGCOLOR_INT)
 988                         mms_smil_avi_data->nBgColor = value;
 989                 else
 990                         err = MSG_ERR_INVALID_PARAMETER;
 991         }
 992         break;
 993         default:
 994                 err = MSG_ERR_INVALID_PARAMETER;
 995                 break;
 996         }
 997         return err;
 998 }
 999
1000 int msg_mms_set_str_value(msg_struct_s *msg_struct, int field, const char *value, int size)
1001 {
1002         if (value == NULL)
1003                 return MSG_ERR_NULL_POINTER;
1004
1005         msg_error_t err = MSG_SUCCESS;
1006
1007         switch (msg_struct->type) {
1008         case MSG_STRUCT_MMS_MEDIA: {
1009                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
1010                 if (field == MSG_MMS_MEDIA_SRC_STR) {
1011                         strncpy(mms_media_data->szSrc, value, MSG_FILEPATH_LEN_MAX);
1012                 } else if (field == MSG_MMS_MEDIA_FILENAME_STR) {
1013                         strncpy(mms_media_data->szFileName, value, MSG_FILEPATH_LEN_MAX);
1014                 } else if (field == MSG_MMS_MEDIA_FILEPATH_STR) {
1015                         MSG_SEC_DEBUG("media file path = %s", value);
1016                         strncpy(mms_media_data->szFilePath, value, MSG_FILEPATH_LEN_MAX);
1017
1018                         char *filename = NULL;
1019                         filename = (char *)strrchr(value, '/');
1020
1021                         if (filename != NULL) {
1022                                 strncpy(mms_media_data->szFileName, filename + 1, MSG_FILENAME_LEN_MAX);
1023                                 strncpy(mms_media_data->szContentID, filename + 1, MSG_MSG_ID_LEN);
1024                         } else {
1025                                 strncpy(mms_media_data->szFileName, value, MSG_FILENAME_LEN_MAX);
1026                                 strncpy(mms_media_data->szContentID, value, MSG_MSG_ID_LEN);
1027                         }
1028                 } else if (field == MSG_MMS_MEDIA_CONTENT_ID_STR) {
1029                         __removeLessGreaterMark(value, mms_media_data->szContentID, MSG_MSG_ID_LEN);
1030                 } else if (field == MSG_MMS_MEDIA_REGION_ID_STR) {
1031                         strncpy(mms_media_data->regionId, value, MAX_SMIL_REGION_ID);
1032                 } else if (field == MSG_MMS_MEDIA_ALTERNATIVE_STR) {
1033                         strncpy(mms_media_data->szAlt, value, MAX_SMIL_ALT_LEN);
1034                 } else if (field == MSG_MMS_MEDIA_DRM_FULLPATH_STR) {
1035                         strncpy(mms_media_data->szDrm2FullPath, value, MSG_FILEPATH_LEN_MAX);
1036                 } else if (field == MSG_MMS_MEDIA_CONTENT_LOCATION_STR) {
1037                         strncpy(mms_media_data->szContentLocation, value, MSG_MSG_ID_LEN);
1038                 } else if (field == MSG_MMS_MEDIA_CONTENT_TYPE_STR) {
1039                         strncpy(mms_media_data->szContentType, value, MSG_MSG_ID_LEN);
1040                 } else {
1041                         err = MSG_ERR_INVALID_PARAMETER;
1042                 }
1043         }
1044         break;
1045         case MSG_STRUCT_MMS_ATTACH: {
1046                 MMS_ATTACH_S *mms_attach_data = (MMS_ATTACH_S *)msg_struct->data;
1047                 if (field == MSG_MMS_ATTACH_FILENAME_STR) {
1048                         strncpy(mms_attach_data->szFileName, value, MSG_FILENAME_LEN_MAX);
1049                 } else if (field == MSG_MMS_ATTACH_FILEPATH_STR) {
1050                         MSG_SEC_DEBUG("attach file path = %s", value);
1051                         mms_attach_data->mediatype = MIME_UNKNOWN;
1052                         mms_attach_data->fileSize = -1;
1053
1054                         strncpy(mms_attach_data->szFilePath, value, MSG_FILEPATH_LEN_MAX);
1055
1056                         char *filename = NULL;
1057                         filename = (char *)strrchr(value, '/');
1058                         if (filename != NULL) {
1059                                 strncpy(mms_attach_data->szFileName, filename + 1, MSG_FILENAME_LEN_MAX);
1060                         } else {
1061                                 strncpy(mms_attach_data->szFileName, value, MSG_FILENAME_LEN_MAX);
1062                         }
1063                 } else if (field == MSG_MMS_ATTACH_DRM_FULLPATH_STR) {
1064                         strncpy(mms_attach_data->szDrm2FullPath, value, MSG_FILEPATH_LEN_MAX);
1065                 } else if (field == MSG_MMS_ATTACH_CONTENT_TYPE_STR) {
1066                         strncpy(mms_attach_data->szContentType, value, MSG_MSG_ID_LEN);
1067                 } else {
1068                         err = MSG_ERR_INVALID_PARAMETER;
1069                 }
1070         }
1071         break;
1072         case MSG_STRUCT_MMS_REGION: {
1073                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
1074                 if (field == MSG_MMS_REGION_ID_STR)
1075                         strncpy(mms_region_data->szID, value, MAX_SMIL_REGION_ID);
1076                 else
1077                         err = MSG_ERR_INVALID_PARAMETER;
1078         }
1079         break;
1080         case MSG_STRUCT_MMS_TRANSITION: {
1081                 MMS_SMIL_TRANSITION *mms_transition_data = (MMS_SMIL_TRANSITION *)msg_struct->data;
1082                 if (field == MSG_MMS_TRANSITION_ID_STR)
1083                         strncpy(mms_transition_data->szID, value, MAX_SMIL_TRANSITION_ID);
1084                 else
1085                         err = MSG_ERR_INVALID_PARAMETER;
1086         }
1087         break;
1088         case MSG_STRUCT_MMS_META: {
1089                 MMS_SMIL_META *mms_meta_data = (MMS_SMIL_META *)msg_struct->data;
1090                 if (field == MSG_MMS_META_ID_STR)
1091                         strncpy(mms_meta_data->szID, value, MAX_SMIL_META_ID);
1092                 else if (field == MSG_MMS_META_NAME_STR)
1093                         strncpy(mms_meta_data->szName, value, MAX_SMIL_META_NAME);
1094                 else if (field == MSG_MMS_META_CONTENT_STR)
1095                         strncpy(mms_meta_data->szContent, value, MAX_SMIL_META_CONTENT);
1096                 else
1097                         err = MSG_ERR_INVALID_PARAMETER;
1098         }
1099         break;
1100         case MSG_STRUCT_MMS_SMIL_TEXT: {
1101                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
1102                 if (field == MSG_MMS_SMIL_TEXT_TRANSITION_IN_ID_STR)
1103                         strncpy(mms_smil_text_data->szTransInId, value, MAX_SMIL_TRANSIN_ID);
1104                 else if (field == MSG_MMS_SMIL_TEXT_TRANSITION_OUT_ID_STR)
1105                         strncpy(mms_smil_text_data->szTransOutId, value, MAX_SMIL_TRANSOUT_ID);
1106                 else
1107                         err = MSG_ERR_INVALID_PARAMETER;
1108         }
1109         break;
1110         case MSG_STRUCT_MMS_SMIL_AVI: {
1111                 MmsSmilAVI *mms_smil_avi_data = (MmsSmilAVI *)msg_struct->data;
1112                 if (field == MSG_MMS_SMIL_AVI_TRANSITION_IN_ID_STR)
1113                         strncpy(mms_smil_avi_data->szTransInId, value, MAX_SMIL_TRANSIN_ID);
1114                 else if (field == MSG_MMS_SMIL_AVI_TRANSITION_OUT_ID_STR)
1115                         strncpy(mms_smil_avi_data->szTransOutId, value, MAX_SMIL_TRANSOUT_ID);
1116                 else
1117                         err = MSG_ERR_INVALID_PARAMETER;
1118         }
1119         break;
1120         case MSG_STRUCT_MMS: {
1121                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
1122                 if (field == MSG_MMS_HEADER_CONTENT_LOCATION_STR) { /* mms header */
1123                         strncpy(mms_data->header.contentLocation, value, sizeof(mms_data->header.contentLocation) - 1 );
1124                 } else if (field == MSG_MMS_HEADER_CONTENT_TYPE_STR) {
1125                         strncpy(mms_data->header.szContentType, value, sizeof(mms_data->header.szContentType) - 1 );
1126                 } else if (field == MSG_MMS_HEADER_FROM_STR) {
1127                         strncpy(mms_data->header.szFrom, value, sizeof(mms_data->header.szFrom) - 1 );
1128                 } else if (field == MSG_MMS_HEADER_MESSAGE_ID_STR) {
1129                         strncpy(mms_data->header.messageID, value, sizeof(mms_data->header.messageID) - 1 );
1130                 } else if (field == MSG_MMS_HEADER_TR_ID_STR) {
1131                         strncpy(mms_data->header.trID, value, sizeof(mms_data->header.trID) - 1 );
1132
1133                 } else if (field == MSG_MMS_SMIL_MULTIPART_CONTENT_TYPE_STR) { /* smil */
1134                         strncpy(mms_data->smil.szContentType, value, sizeof(mms_data->smil.szContentType) - 1 );
1135                 } else if (field == MSG_MMS_SMIL_MULTIPART_NAME_STR) {
1136                         strncpy(mms_data->smil.szFileName, value, sizeof(mms_data->smil.szFileName) - 1 );
1137                 } else if (field == MSG_MMS_SMIL_MULTIPART_FILEPATH_STR) {
1138                         strncpy(mms_data->smil.szFilePath, value, sizeof(mms_data->smil.szFilePath) - 1 );
1139                 } else if (field == MSG_MMS_SMIL_MULTIPART_CONTENT_ID_STR) {
1140                         strncpy(mms_data->smil.szContentID, value, sizeof(mms_data->smil.szContentID) - 1 );
1141                 } else if (field == MSG_MMS_SMIL_MULTIPART_CONTENT_LOCATION_STR) {
1142                         strncpy(mms_data->smil.szContentLocation, value, sizeof(mms_data->smil.szContentLocation) - 1 );
1143                 } else {
1144                         err = MSG_ERR_INVALID_PARAMETER;
1145                 }
1146         }
1147         break;
1148         case MSG_STRUCT_MULTIPART_INFO:
1149                 err = msg_multipart_set_str_value(msg_struct->data, field, value, size);
1150         break;
1151
1152         default:
1153                 err = MSG_ERR_INVALID_PARAMETER;
1154                 break;
1155         }
1156
1157         return err;
1158 }
1159
1160 int msg_mms_set_bool_value(msg_struct_s *msg_struct, int field, bool value)
1161 {
1162         msg_error_t err = MSG_SUCCESS;
1163
1164         switch (msg_struct->type) {
1165         case MSG_STRUCT_MMS: {
1166                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
1167                 if (field == MSG_MMS_ROOTLAYOUT_WIDTH_PERCENT_BOOL)
1168                         mms_data->rootlayout.width.bUnitPercent = value;
1169                 else if (field == MSG_MMS_ROOTLAYOUT_HEIGHT_PERCENT_BOOL)
1170                         mms_data->rootlayout.height.bUnitPercent = value;
1171                 else
1172                         err  = MSG_ERR_INVALID_PARAMETER;
1173         }
1174         break;
1175         case MSG_STRUCT_MMS_REGION: {
1176                 MMS_SMIL_REGION *mms_region_data = (MMS_SMIL_REGION *)msg_struct->data;
1177                 if (field == MSG_MMS_REGION_LENGTH_LEFT_PERCENT_BOOL)
1178                         mms_region_data->nLeft.bUnitPercent = value;
1179                 else if (field == MSG_MMS_REGION_LENGTH_TOP_PERCENT_BOOL)
1180                         mms_region_data->nTop.bUnitPercent = value;
1181                 else if (field == MSG_MMS_REGION_LENGTH_WIDTH_PERCENT_BOOL)
1182                         mms_region_data->width.bUnitPercent = value;
1183                 else if (field == MSG_MMS_REGION_LENGTH_HEIGHT_PERCENT_BOOL)
1184                         mms_region_data->height.bUnitPercent = value;
1185                 else
1186                         err = MSG_ERR_INVALID_PARAMETER;
1187         }
1188         break;
1189         case MSG_STRUCT_MMS_SMIL_TEXT: {
1190                 MmsSmilText *mms_smil_text_data = (MmsSmilText *)msg_struct->data;
1191                 if (field == MSG_MMS_SMIL_TEXT_BOLD_BOOL)
1192                         mms_smil_text_data->bBold = value;
1193                 else if (field == MSG_MMS_SMIL_TEXT_UNDERLINE_BOOL)
1194                         mms_smil_text_data->bUnderLine = value;
1195                 else if (field == MSG_MMS_SMIL_TEXT_ITALIC_BOOL)
1196                         mms_smil_text_data->bItalic = value;
1197                 else if (field == MSG_MMS_SMIL_TEXT_REVERSE_BOOL)
1198                         mms_smil_text_data->bReverse = value;
1199                 else
1200                         err = MSG_ERR_INVALID_PARAMETER;
1201         }
1202         break;
1203         default:
1204                 err = MSG_ERR_INVALID_PARAMETER;
1205                 break;
1206         }
1207         return err;
1208 }
1209
1210 int msg_mms_set_struct_handle(msg_struct_s *msg_struct, int field, msg_struct_s *value)
1211 {
1212         msg_error_t err = MSG_SUCCESS;
1213
1214         switch (msg_struct->type) {
1215         case MSG_STRUCT_MMS_MEDIA: {
1216                 MMS_MEDIA_HIDDEN_S *mms_media_data = (MMS_MEDIA_HIDDEN_S *)msg_struct->data;
1217
1218                 if (field == MSG_MMS_MEDIA_SMIL_TEXT_HND)
1219                         memcpy(mms_media_data->pText->data, value->data, sizeof(MmsSmilText));
1220                 else if (field == MSG_MMS_MEDIA_SMIL_AVI_HND)
1221                         memcpy(mms_media_data->pAVI->data, value->data, sizeof(MmsSmilAVI));
1222                 else
1223                         err = MSG_ERR_INVALID_PARAMETER;
1224         }
1225         break;
1226         default:
1227                 err = MSG_ERR_INVALID_PARAMETER;
1228                 break;
1229         }
1230         return err;
1231 }
1232
1233 int msg_mms_list_append(msg_struct_t msg_struct_handle, int field, msg_struct_t *item)
1234 {
1235         msg_error_t err = MSG_SUCCESS;
1236         msg_struct_s *msg_struct = (msg_struct_s *)msg_struct_handle;
1237
1238         msg_struct_s *msg_struct_item = NULL;
1239         switch (msg_struct->type) {
1240         case MSG_STRUCT_MMS: {
1241                 MMS_DATA_HIDDEN_S *mms_data = (MMS_DATA_HIDDEN_S *)msg_struct->data;
1242
1243                 if (field == MSG_STRUCT_MMS_PAGE) {
1244                         msg_struct_item = msg_mms_create_struct(MSG_STRUCT_MMS_PAGE);
1245                         mms_data->pagelist = g_list_append(mms_data->pagelist, msg_struct_item);
1246                         *item = (msg_struct_t)msg_struct_item;
1247                 } else if (field == MSG_STRUCT_MMS_REGION) {
1248                         msg_struct_item = msg_mms_create_struct(MSG_STRUCT_MMS_REGION);
1249                         mms_data->regionlist = g_list_append(mms_data->regionlist, msg_struct_item);
1250                         *item = (msg_struct_t)msg_struct_item;
1251                 } else if (field == MSG_STRUCT_MMS_ATTACH) {
1252                         msg_struct_item = msg_mms_create_struct(MSG_STRUCT_MMS_ATTACH);
1253                         mms_data->attachlist = g_list_append(mms_data->attachlist, msg_struct_item);
1254                         *item = (msg_struct_t)msg_struct_item;
1255                 } else if (field == MSG_STRUCT_MMS_TRANSITION) {
1256                         msg_struct_item = msg_mms_create_struct(MSG_STRUCT_MMS_TRANSITION);
1257                         mms_data->transitionlist = g_list_append(mms_data->transitionlist, msg_struct_item);
1258                         *item = (msg_struct_t)msg_struct_item;
1259                 } else if (field == MSG_STRUCT_MMS_META) {
1260                         msg_struct_item = msg_mms_create_struct(MSG_STRUCT_MMS_META);
1261                         mms_data->metalist = g_list_append(mms_data->metalist, msg_struct_item);
1262                         *item = (msg_struct_t)msg_struct_item;
1263                 } else if (field == MSG_MMS_MULTIPART_LIST_HND) {
1264                         msg_struct_item = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MULTIPART_INFO);
1265                         mms_data->multipartlist = g_list_append(mms_data->multipartlist, msg_struct_item);
1266                         *item = (msg_struct_t)msg_struct_item;
1267                 } else {
1268                         err = MSG_ERR_INVALID_PARAMETER;
1269                 }
1270         }
1271         break;
1272         case MSG_STRUCT_MMS_PAGE: {
1273                 MMS_PAGE_S *mms_page_data = (MMS_PAGE_S *)msg_struct->data;
1274
1275                 if (field == MSG_STRUCT_MMS_MEDIA) {
1276                         msg_struct_item = msg_mms_create_struct(field);
1277                         mms_page_data->medialist = g_list_append(mms_page_data->medialist, msg_struct_item);
1278                         *item = (msg_struct_t)msg_struct_item;
1279                 } else {
1280                         err = MSG_ERR_INVALID_PARAMETER;
1281                 }
1282         }
1283         break;
1284         default:
1285                 err = MSG_ERR_INVALID_PARAMETER;
1286                 break;
1287         }
1288
1289         return err;
1290 }
1291
1292 void convert_to_media_data(const msg_struct_s *pSrc, MMS_MEDIA_S *pDest)
1293 {
1294         const MMS_MEDIA_HIDDEN_S *src_media = (MMS_MEDIA_HIDDEN_S *)pSrc->data;
1295         MMS_MEDIA_S *dst_media = pDest;
1296
1297         dst_media->mediatype = src_media->mediatype;
1298         memcpy(dst_media->szSrc, src_media->szSrc, MSG_FILEPATH_LEN_MAX);
1299         memcpy(dst_media->szFileName, src_media->szFileName, MSG_FILEPATH_LEN_MAX);
1300         memcpy(dst_media->szFilePath, src_media->szFilePath, MSG_FILEPATH_LEN_MAX);
1301         memcpy(dst_media->szContentID, src_media->szContentID, MSG_MSG_ID_LEN);
1302         memcpy(dst_media->regionId, src_media->regionId, MAX_SMIL_REGION_ID);
1303         memcpy(dst_media->szAlt, src_media->szAlt, MAX_SMIL_ALT_LEN);
1304         memcpy(dst_media->szDrm2FullPath, src_media->szDrm2FullPath, MSG_FILEPATH_LEN_MAX);
1305         memcpy(dst_media->szContentType, src_media->szContentType, MSG_MSG_ID_LEN);
1306         memcpy(dst_media->szContentLocation, src_media->szContentLocation, MSG_MSG_ID_LEN);
1307         dst_media->drmType = src_media->drmType;
1308
1309         if (src_media->mediatype == MMS_SMIL_MEDIA_TEXT) {
1310                 msg_struct_s *smil_struct = (msg_struct_s *)src_media->pText;
1311                 MmsSmilText *smiltext = (MmsSmilText *)smil_struct->data;
1312                 memcpy(&dst_media->sMedia.sText, smiltext, sizeof(MmsSmilText));
1313         } else {
1314                 msg_struct_s *smil_struct = (msg_struct_s *)src_media->pAVI;
1315                 MmsSmilAVI *smilavi = (MmsSmilAVI *)smil_struct->data;
1316                 memcpy(&dst_media->sMedia.sAVI, smilavi, sizeof(MmsSmilAVI));
1317         }
1318 }
1319
1320 void convert_from_media_data(const MMS_MEDIA_S *pSrc, msg_struct_s *pDest)
1321 {
1322         const MMS_MEDIA_S *src_media = pSrc;
1323         MMS_MEDIA_HIDDEN_S *dst_media = (MMS_MEDIA_HIDDEN_S *)pDest->data;
1324
1325         dst_media->mediatype = src_media->mediatype;
1326         memcpy(dst_media->szSrc, src_media->szSrc, MSG_FILEPATH_LEN_MAX);
1327         memcpy(dst_media->szFileName, src_media->szFileName, MSG_FILEPATH_LEN_MAX);
1328         memcpy(dst_media->szFilePath, src_media->szFilePath, MSG_FILEPATH_LEN_MAX);
1329         memcpy(dst_media->szContentID, src_media->szContentID, MSG_MSG_ID_LEN);
1330         memcpy(dst_media->regionId, src_media->regionId, MAX_SMIL_REGION_ID);
1331         memcpy(dst_media->szAlt, src_media->szAlt, MAX_SMIL_ALT_LEN);
1332         memcpy(dst_media->szDrm2FullPath, src_media->szDrm2FullPath, MSG_FILEPATH_LEN_MAX);
1333         memcpy(dst_media->szContentType, src_media->szContentType, MSG_MSG_ID_LEN);
1334         memcpy(dst_media->szContentLocation, src_media->szContentLocation, MSG_MSG_ID_LEN);
1335         dst_media->drmType = src_media->drmType;
1336
1337         if (src_media->mediatype == MMS_SMIL_MEDIA_TEXT) {
1338                 msg_struct_s *dst_smil_struct = (msg_struct_s *)dst_media->pText;
1339                 MmsSmilText *dst_smiltext = (MmsSmilText *)dst_smil_struct->data;
1340                 memcpy(dst_smiltext, &src_media->sMedia.sText, sizeof(MmsSmilText));
1341         } else {
1342                 msg_struct_s *dst_smil_struct = (msg_struct_s *)dst_media->pAVI;
1343                 MmsSmilAVI *dst_smilavi = (MmsSmilAVI *)dst_smil_struct->data;
1344                 memcpy(dst_smilavi, &src_media->sMedia.sAVI, sizeof(MmsSmilAVI));
1345         }
1346 }
1347
1348 void convert_to_mmsdata2(MMS_DATA_HIDDEN_S *pSrcMms, MMS_MESSAGE_DATA_S *pDest)
1349 {
1350         int i, j;
1351
1352         pDest->pageCnt = g_list_length(pSrcMms->pagelist);
1353
1354         for (i = 0; i < pDest->pageCnt; i++) {
1355                 MMS_PAGE_S *page = (MMS_PAGE_S *)calloc(1, sizeof(MMS_PAGE_S));
1356                 MMS_PAGE_S *src_page = (MMS_PAGE_S *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->pagelist, i));
1357                 if (page) {
1358                         page->mediaCnt = g_list_length(src_page->medialist);
1359
1360                         for (j = 0; j < page->mediaCnt; j++) {
1361                                 MMS_MEDIA_S *dst_media = (MMS_MEDIA_S *)calloc(1, sizeof(MMS_MEDIA_S));
1362                                 msg_struct_s *src_media_s = (msg_struct_s *)g_list_nth_data(src_page->medialist, j);
1363
1364                                 if (dst_media) {
1365                                         convert_to_media_data(src_media_s, dst_media);
1366
1367                                         page->medialist = g_list_append(page->medialist, dst_media);
1368                                 }
1369                         }
1370
1371                         page->nDur = src_page->nDur;
1372                         page->nBegin = src_page->nBegin;
1373                         page->nEnd = src_page->nEnd;
1374                         page->nMin = src_page->nMin;
1375                         page->nMax = src_page->nMax;
1376                         page->nRepeat = src_page->nRepeat;
1377
1378                         pDest->pagelist = g_list_append(pDest->pagelist, page);
1379                 }
1380         }
1381
1382         pDest->regionCnt = g_list_length(pSrcMms->regionlist);
1383
1384         for (i = 0; i < pDest->regionCnt; i++) {
1385                 MMS_SMIL_REGION *region = (MMS_SMIL_REGION *)calloc(1, sizeof(MMS_SMIL_REGION));
1386                 MMS_SMIL_REGION *src_region = (MMS_SMIL_REGION *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->regionlist, i));
1387                 if (region) {
1388                         memcpy(region, src_region, sizeof(MMS_SMIL_REGION));
1389                         pDest->regionlist = g_list_append(pDest->regionlist, region);
1390                 }
1391         }
1392
1393         pDest->attachCnt = g_list_length(pSrcMms->attachlist);
1394
1395         for (i = 0; i < pDest->attachCnt; i++) {
1396                 MMS_ATTACH_S *attach = (MMS_ATTACH_S *)calloc(1, sizeof(MMS_ATTACH_S));
1397                 MMS_ATTACH_S *src_attach = (MMS_ATTACH_S *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->attachlist, i));
1398                 if (attach) {
1399                         memcpy(attach, src_attach, sizeof(MMS_ATTACH_S));
1400                         pDest->attachlist = g_list_append(pDest->attachlist, attach);
1401                 }
1402         }
1403
1404         pDest->transitionCnt = g_list_length(pSrcMms->transitionlist);
1405
1406         for (i = 0; i < pDest->transitionCnt; i++) {
1407                 MMS_SMIL_TRANSITION *transition = (MMS_SMIL_TRANSITION *)calloc(1, sizeof(MMS_SMIL_TRANSITION));
1408                 MMS_SMIL_TRANSITION *src_transition = (MMS_SMIL_TRANSITION *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->transitionlist, i));
1409                 if (transition) {
1410                         memcpy(transition, src_transition, sizeof(MMS_SMIL_TRANSITION));
1411                         pDest->transitionlist = g_list_append(pDest->transitionlist, transition);
1412                 }
1413         }
1414
1415         pDest->metaCnt = g_list_length(pSrcMms->metalist);
1416
1417         for (i = 0; i < pDest->metaCnt; i++) {
1418                 MMS_SMIL_META *meta = (MMS_SMIL_META *)calloc(1, sizeof(MMS_SMIL_META));
1419                 MMS_SMIL_META *src_meta = (MMS_SMIL_META *)get_msg_struct_data((msg_struct_s *)g_list_nth_data(pSrcMms->metalist, i));
1420                 if (meta) {
1421                         memcpy(meta, src_meta, sizeof(MMS_SMIL_META));
1422                         pDest->metalist = g_list_append(pDest->metalist, meta);
1423                 }
1424         }
1425
1426         memcpy(&pDest->rootlayout, &pSrcMms->rootlayout, sizeof(MMS_SMIL_ROOTLAYOUT));
1427
1428         memcpy(&pDest->msgAppId, &pSrcMms->msgAppId, sizeof(MMS_APPID_INFO_S));
1429         memcpy(&pDest->header, &pSrcMms->header, sizeof(MMS_HEADER_DATA_S));
1430         memcpy(&pDest->smil, &pSrcMms->smil, sizeof(MMS_MULTIPART_DATA_S));
1431 }
1432
1433 void convert_from_mmsdata2(const MMS_MESSAGE_DATA_S *pSrc, MMS_DATA_HIDDEN_S *pDestMms)
1434 {
1435         int i, j;
1436
1437         for (i = 0; i < pSrc->pageCnt; i++) {
1438                 msg_struct_s *page_struct = msg_mms_create_struct(MSG_STRUCT_MMS_PAGE);
1439                 MMS_PAGE_S *page = (MMS_PAGE_S *)page_struct->data;
1440
1441                 MMS_PAGE_S *src_page = (MMS_PAGE_S *)g_list_nth_data(pSrc->pagelist, i);
1442                 page->mediaCnt = g_list_length(src_page->medialist);
1443
1444                 for (j = 0; j < page->mediaCnt; j++) {
1445                         msg_struct_s *dst_media_s = msg_mms_create_struct(MSG_STRUCT_MMS_MEDIA);
1446
1447                         MMS_MEDIA_S *src_media = (MMS_MEDIA_S *)g_list_nth_data(src_page->medialist, j);
1448
1449                         convert_from_media_data(src_media, dst_media_s);
1450
1451                         page->medialist = g_list_append(page->medialist, dst_media_s);
1452                 }
1453
1454                 page->nDur = src_page->nDur;
1455                 page->nBegin = src_page->nBegin;
1456                 page->nEnd = src_page->nEnd;
1457                 page->nMin = src_page->nMin;
1458                 page->nMax = src_page->nMax;
1459                 page->nRepeat = src_page->nRepeat;
1460
1461                 pDestMms->pagelist = g_list_append(pDestMms->pagelist, page_struct);
1462         }
1463
1464         for (i = 0; i < pSrc->regionCnt; i++) {
1465                 msg_struct_s *region_struct = msg_mms_create_struct(MSG_STRUCT_MMS_REGION);
1466                 MMS_SMIL_REGION *region = (MMS_SMIL_REGION *)region_struct->data;
1467                 MMS_SMIL_REGION *src_region = (MMS_SMIL_REGION *)g_list_nth_data(pSrc->regionlist, i);
1468                 memcpy(region, src_region, sizeof(MMS_SMIL_REGION));
1469                 pDestMms->regionlist = g_list_append(pDestMms->regionlist, region_struct);
1470         }
1471
1472         for (i = 0; i < pSrc->attachCnt; i++) {
1473                 msg_struct_s *attach_struct = msg_mms_create_struct(MSG_STRUCT_MMS_ATTACH);
1474                 MMS_ATTACH_S *attach = (MMS_ATTACH_S *)attach_struct->data;
1475                 MMS_ATTACH_S *src_attach = (MMS_ATTACH_S *)g_list_nth_data(pSrc->attachlist, i);
1476                 memcpy(attach, src_attach, sizeof(MMS_ATTACH_S));
1477                 pDestMms->attachlist = g_list_append(pDestMms->attachlist, attach_struct);
1478         }
1479
1480         for (i = 0; i < pSrc->transitionCnt; i++) {
1481                 msg_struct_s *transition_struct = msg_mms_create_struct(MSG_STRUCT_MMS_TRANSITION);
1482                 MMS_SMIL_TRANSITION *transition = (MMS_SMIL_TRANSITION *)transition_struct->data;
1483                 MMS_SMIL_TRANSITION *src_transition = (MMS_SMIL_TRANSITION *)g_list_nth_data(pSrc->transitionlist, i);
1484                 memcpy(transition, src_transition, sizeof(MMS_SMIL_TRANSITION));
1485                 pDestMms->transitionlist = g_list_append(pDestMms->transitionlist, transition_struct);
1486         }
1487
1488         for (i = 0; i < pSrc->metaCnt; i++) {
1489                 msg_struct_s *meta_struct = msg_mms_create_struct(MSG_STRUCT_MMS_META);
1490                 MMS_SMIL_META *meta = (MMS_SMIL_META *)meta_struct->data;
1491                 MMS_SMIL_META *src_meta = (MMS_SMIL_META *)g_list_nth_data(pSrc->metalist, i);
1492
1493                 memcpy(meta, src_meta, sizeof(MMS_SMIL_META));
1494                 pDestMms->metalist = g_list_append(pDestMms->metalist, meta_struct);
1495         }
1496
1497         memcpy(&pDestMms->rootlayout, &pSrc->rootlayout, sizeof(MMS_SMIL_ROOTLAYOUT));
1498
1499         memcpy(&pDestMms->msgAppId, &pSrc->msgAppId, sizeof(MMS_APPID_INFO_S));
1500
1501         memcpy(&pDestMms->header, &pSrc->header, sizeof(MMS_HEADER_DATA_S));
1502         memcpy(&pDestMms->smil, &pSrc->smil, sizeof(MMS_MULTIPART_DATA_S));
1503 }
1504
1505
1506 int msg_multipart_get_str_value(void *data, int field, char *value, int size)
1507 {
1508         if (!data || !value)
1509                 return MSG_ERR_NULL_POINTER;
1510
1511         int ret = MSG_SUCCESS;
1512
1513         MMS_MULTIPART_DATA_S *msg_data = (MMS_MULTIPART_DATA_S *)data;
1514
1515         switch (field) {
1516         case MSG_MMS_MULTIPART_CONTENT_TYPE_STR:
1517                 strncpy(value, msg_data->szContentType, size);
1518                 break;
1519         case MSG_MMS_MULTIPART_NAME_STR:
1520                 strncpy(value, msg_data->szFileName, size);
1521                 break;
1522         case MSG_MMS_MULTIPART_FILEPATH_STR:
1523                 strncpy(value, msg_data->szFilePath, size);
1524                 break;
1525         case MSG_MMS_MULTIPART_THUMBNAIL_FILEPATH_STR:
1526                 strncpy(value, msg_data->szThumbFilePath, size);
1527                 break;
1528         case MSG_MMS_MULTIPART_CONTENT_ID_STR:
1529                 strncpy(value, msg_data->szContentID, size);
1530                 break;
1531         case MSG_MMS_MULTIPART_CONTENT_LOCATION_STR:
1532                 strncpy(value, msg_data->szContentLocation, size);
1533                 break;
1534
1535         default:
1536                 ret = MSG_ERR_INVALID_PARAMETER;
1537                 break;
1538         }
1539
1540         return ret;
1541 }
1542
1543 int msg_multipart_get_int_value(void *data, int field, int *value)
1544 {
1545         if (!data || !value)
1546                 return MSG_ERR_NULL_POINTER;
1547
1548         int ret = MSG_SUCCESS;
1549
1550         MMS_MULTIPART_DATA_S *msg_data = (MMS_MULTIPART_DATA_S *)data;
1551
1552         switch (field) {
1553         case MSG_MMS_MULTIPART_TCS_LEVEL_INT:
1554                 *value = msg_data->tcs_bc_level;
1555                 break;
1556         case MSG_MMS_MULTIPART_MALWARE_ALLOW_INT:
1557                 *value = msg_data->malware_allow;
1558                 break;
1559         default:
1560                 ret = MSG_ERR_INVALID_PARAMETER;
1561                 break;
1562         }
1563
1564         return ret;
1565 }
1566
1567 int msg_multipart_set_str_value(void *data, int field, const char *value, int size)
1568 {
1569         if (!data || !value)
1570                 return MSG_ERR_NULL_POINTER;
1571
1572         int ret = MSG_SUCCESS;
1573
1574         MMS_MULTIPART_DATA_S *msg_data = (MMS_MULTIPART_DATA_S *)data;
1575
1576         /* CID 41980: Reducing the size argument to strncpy calls to accomodate string termination '\0' in case source string is larger than size */
1577         switch (field) {
1578         case MSG_MMS_MULTIPART_CONTENT_TYPE_STR:
1579                 strncpy(msg_data->szContentType, value, MSG_MSG_ID_LEN);
1580                 break;
1581         case MSG_MMS_MULTIPART_NAME_STR:
1582                 strncpy(msg_data->szFileName, value, MSG_FILENAME_LEN_MAX);
1583                 break;
1584         case MSG_MMS_MULTIPART_FILEPATH_STR:
1585                 strncpy(msg_data->szFilePath, value, MSG_FILEPATH_LEN_MAX);
1586                 break;
1587         case MSG_MMS_MULTIPART_THUMBNAIL_FILEPATH_STR:
1588                 strncpy(msg_data->szThumbFilePath, value, MSG_FILEPATH_LEN_MAX);
1589                 break;
1590         case MSG_MMS_MULTIPART_CONTENT_ID_STR:
1591                 strncpy(msg_data->szContentID, value, MSG_MSG_ID_LEN);
1592                 break;
1593         case MSG_MMS_MULTIPART_CONTENT_LOCATION_STR:
1594                 strncpy(msg_data->szContentLocation, value, MSG_MSG_ID_LEN);
1595                 break;
1596         default:
1597                 ret = MSG_ERR_INVALID_PARAMETER;
1598                 break;
1599         }
1600
1601         return ret;
1602 }
1603 void convert_to_hidden_mmsdata(MMS_DATA_S *pSrc, msg_struct_s *pDest)
1604 {
1605         MMS_DATA_HIDDEN_S *pDestMms = (MMS_DATA_HIDDEN_S *)pDest->data;
1606
1607         MMS_MESSAGE_DATA_S *MmsMessageData = NULL;
1608         unique_ptr<MMS_MESSAGE_DATA_S*, void(*)(MMS_MESSAGE_DATA_S**)> buf(&MmsMessageData, unique_ptr_deleter);
1609         MmsMessageData = (MMS_MESSAGE_DATA_S *)new char[sizeof(MMS_MESSAGE_DATA_S)];
1610         memset(MmsMessageData, 0x00, sizeof(MMS_MESSAGE_DATA_S));
1611
1612         MsgMmsConvertMmsDataToMmsMessageData(pSrc, MmsMessageData);
1613
1614         convert_from_mmsdata2(MmsMessageData, pDestMms);
1615
1616         MsgMmsReleaseMmsLists(MmsMessageData);
1617
1618         if (pSrc->header) {
1619                 memcpy(&pDestMms->header, pSrc->header, sizeof(MMS_HEADER_DATA_S));
1620         }
1621
1622         if (pSrc->smil) {
1623                 memcpy(&pDestMms->smil, pSrc->smil, sizeof(MMS_MULTIPART_DATA_S));
1624                 pDestMms->smil.type = MIME_APPLICATION_SMIL;
1625                 pDestMms->smil.pMultipartData = (char *)calloc(1,  pDestMms->smil.nMultipartDataLen+1);
1626                 if (pDestMms->smil.pMultipartData)
1627                         memcpy(pDestMms->smil.pMultipartData, pSrc->smil->pMultipartData, pDestMms->smil.nMultipartDataLen);
1628         }
1629
1630         if (pSrc->multipartlist) {
1631                 int list_cnt = g_list_length(pSrc->multipartlist);
1632
1633                 for (int i = 0; i < list_cnt; i++) {
1634                         MMS_MULTIPART_DATA_S *src_multipart = (MMS_MULTIPART_DATA_S *)g_list_nth_data(pSrc->multipartlist, i);
1635
1636                         if (src_multipart) {
1637                                 msg_struct_s *multipart_struct = (msg_struct_s *)msg_create_struct(MSG_STRUCT_MULTIPART_INFO);
1638
1639                                 if (multipart_struct) {
1640                                         MMS_MULTIPART_DATA_S *dst_multipart = (MMS_MULTIPART_DATA_S*)multipart_struct->data;
1641                                         memcpy(dst_multipart, src_multipart, sizeof(MMS_MULTIPART_DATA_S));
1642                                         pDestMms->multipartlist = g_list_append(pDestMms->multipartlist, multipart_struct);
1643                                 }
1644                         }
1645                 }
1646         }
1647 }
1648
1649 void convert_from_hidden_mmsdata(msg_struct_s *pSrc, MMS_DATA_S *pDest)
1650 {
1651         MMS_DATA_HIDDEN_S *pSrcMms = (MMS_DATA_HIDDEN_S *)pSrc->data;
1652
1653         MMS_MESSAGE_DATA_S *MmsMessageData = NULL;
1654         unique_ptr<MMS_MESSAGE_DATA_S*, void(*)(MMS_MESSAGE_DATA_S**)> buf(&MmsMessageData, unique_ptr_deleter);
1655         MmsMessageData = (MMS_MESSAGE_DATA_S *)new char[sizeof(MMS_MESSAGE_DATA_S)];
1656         memset(MmsMessageData, 0x00, sizeof(MMS_MESSAGE_DATA_S));
1657
1658         convert_to_mmsdata2(pSrcMms, MmsMessageData);
1659
1660         MsgMmsConvertMmsMessageDataToMmsData(MmsMessageData, pDest);
1661
1662         MsgMmsReleaseMmsLists(MmsMessageData);
1663 }
1664
1665 void __msg_mms_data_struct_init(MMS_DATA_HIDDEN_S *pMmsDataHidden)
1666 {
1667         if (pMmsDataHidden) {
1668                 pMmsDataHidden->pagelist = NULL;
1669                 pMmsDataHidden->regionlist = NULL;
1670                 pMmsDataHidden->attachlist = NULL;
1671                 pMmsDataHidden->transitionlist = NULL;
1672                 pMmsDataHidden->metalist = NULL;
1673
1674                 MsgMmsInitHeader(&pMmsDataHidden->header);
1675                 MsgMmsInitMultipart(&pMmsDataHidden->smil);
1676                 pMmsDataHidden->smil.type = MIME_APPLICATION_SMIL;
1677                 snprintf(pMmsDataHidden->smil.szContentType, sizeof(pMmsDataHidden->smil.szContentType), "%s", "application/smil");
1678         }
1679 }