mapi/msg_message.cpp

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