mapi/msg_message.cpp

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