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