mapi/msg_message.cpp

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