mapi/msg_message.cpp

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