utils/MsgUtilFunction.cpp

   1 /*
   2 *
   3 * Copyright (c) 2000-2012 Samsung Electronics Co., Ltd. All Rights Reserved.
   4 *
   5 * This file is part of msg-service.
   6 *
   7 * Contact: Jaeyun Jeong <jyjeong@samsung.com>
   8 *          Sangkoo Kim <sangkoo.kim@samsung.com>
   9 *          Seunghwan Lee <sh.cat.lee@samsung.com>
  10 *          SoonMin Jung <sm0415.jung@samsung.com>
  11 *          Jae-Young Lee <jy4710.lee@samsung.com>
  12 *          KeeBum Kim <keebum.kim@samsung.com>
  13 *
  14 * PROPRIETARY/CONFIDENTIAL
  15 *
  16 * This software is the confidential and proprietary information of
  17 * SAMSUNG ELECTRONICS ("Confidential Information"). You shall not
  18 * disclose such Confidential Information and shall use it only in
  19 * accordance with the terms of the license agreement you entered
  20 * into with SAMSUNG ELECTRONICS.
  21 *
  22 * SAMSUNG make no representations or warranties about the suitability
  23 * of the software, either express or implied, including but not limited
  24 * to the implied warranties of merchantability, fitness for a particular
  25 * purpose, or non-infringement. SAMSUNG shall not be liable for any
  26 * damages suffered by licensee as a result of using, modifying or
  27 * distributing this software or its derivatives.
  28 *
  29 */
  30
  31 #include "MsgDebug.h"
  32 #include "MsgUtilFunction.h"
  33
  34  /*==================================================================================================
  35                                      FUNCTION IMPLEMENTATION
  36 ==================================================================================================*/
  37
  38 // Encoders
  39 int MsgEncodeCountInfo(MSG_COUNT_INFO_S *pCountInfo, char **ppDest)
  40 {
  41         int dataSize = 0;
  42
  43         dataSize = sizeof(MSG_COUNT_INFO_S);
  44
  45         *ppDest = (char*)new char[dataSize];
  46
  47         void* p = (void*)*ppDest;
  48
  49         memcpy(p, pCountInfo, dataSize);
  50
  51         return dataSize;
  52 }
  53
  54
  55 int MsgEncodeRecipientList(MSG_RECIPIENTS_LIST_S *pRecipientList, char **ppDest)
  56 {
  57         int count = 0, dataSize = 0;
  58
  59         count = pRecipientList->recipientCnt;
  60         dataSize = sizeof(int) + (sizeof(MSG_ADDRESS_INFO_S)*count);
  61
  62         *ppDest = (char*)new char[dataSize];
  63
  64         void* p = (void*)*ppDest;
  65
  66         memcpy(p, &count, sizeof(int));
  67         p = (void*)((char*)p + sizeof(int));
  68
  69         for (int i = 0; i < count; i++)
  70         {
  71                 memcpy(p, &(pRecipientList->recipientAddr[i]), sizeof(MSG_ADDRESS_INFO_S));
  72                 p = (void*)((char*)p + sizeof(MSG_ADDRESS_INFO_S));
  73         }
  74
  75         return dataSize;
  76 }
  77
  78
  79 int MsgEncodeCountByMsgType(int MsgCount, char **ppDest)
  80 {
  81         int dataSize = 0;
  82
  83         dataSize = sizeof(int);
  84
  85         *ppDest = (char*)new char[dataSize];
  86
  87         void* p = (void*)*ppDest;
  88
  89         memcpy(p, &MsgCount, dataSize);
  90
  91         return dataSize;
  92 }
  93
  94
  95 int MsgEncodeMsgId(MSG_MESSAGE_ID_T *pMsgId, char **ppDest)
  96 {
  97         int dataSize = 0;
  98
  99         dataSize = (sizeof(MSG_MESSAGE_ID_T));
 100
 101         *ppDest = (char*)new char[dataSize];
 102
 103         void* p = (void*)*ppDest;
 104
 105         memcpy(p, pMsgId, dataSize);
 106
 107         return dataSize;
 108 }
 109
 110
 111 int MsgEncodeMsgInfo(MSG_MESSAGE_INFO_S *pMsgInfo, char **ppDest)
 112 {
 113         int dataSize = 0;
 114
 115         dataSize = sizeof(MSG_MESSAGE_INFO_S);
 116
 117         *ppDest = (char*)new char[dataSize];
 118
 119         void* p = (void*)*ppDest;
 120
 121         memcpy(p, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 122
 123         p = (void*)((char*)p + sizeof(MSG_MESSAGE_INFO_S));
 124
 125         return dataSize;
 126 }
 127
 128
 129 int MsgEncodeMsgInfo(MSG_MESSAGE_INFO_S *pMsgInfo, MSG_SENDINGOPT_INFO_S* pSendOptInfo, char **ppDest)
 130 {
 131         int dataSize = 0;
 132
 133         dataSize = (sizeof(MSG_MESSAGE_INFO_S) + sizeof(MSG_SENDINGOPT_INFO_S));
 134
 135         *ppDest = (char*)new char[dataSize];
 136
 137         void* p = (void*)*ppDest;
 138
 139         memcpy(p, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 140
 141         p = (void*)((char*)p + sizeof(MSG_MESSAGE_INFO_S));
 142
 143         memcpy(p, pSendOptInfo, sizeof(MSG_SENDINGOPT_INFO_S));
 144
 145         return dataSize;
 146 }
 147
 148
 149 int MsgEncodeFolderViewList(MSG_LIST_S *pFolderViewList, char **ppDest)
 150 {
 151         int count = 0, dataSize = 0;
 152
 153         count = pFolderViewList->nCount;
 154
 155         dataSize = sizeof(int) + (sizeof(MSG_MESSAGE_S)*count);
 156
 157         *ppDest = (char*)new char[dataSize];
 158
 159         void* p = (void*)*ppDest;
 160
 161         memcpy(p, &count, sizeof(int));
 162         p = (void*)((char*)p + sizeof(int));
 163
 164         for (int i = 0; i < count; i++)
 165         {
 166                 memcpy(p, &(pFolderViewList->msgInfo[i]), sizeof(MSG_MESSAGE_S));
 167                 p = (void*)((char*)p + sizeof(MSG_MESSAGE_S));
 168         }
 169
 170         return dataSize;
 171 }
 172
 173
 174 int MsgEncodeFolderList(MSG_FOLDER_LIST_S *pFolderList, char **ppDest)
 175 {
 176         int count = 0, dataSize = 0;
 177
 178         count = pFolderList->nCount;
 179         dataSize = sizeof(int) + (sizeof(MSG_FOLDER_INFO_S)*count);
 180
 181         *ppDest = (char*)new char[dataSize];
 182
 183         void* p = (void*)*ppDest;
 184
 185         memcpy(p, &count, sizeof(int));
 186         p = (void*)((char*)p + sizeof(int));
 187
 188         for (int i = 0; i < count; i++)
 189         {
 190                 memcpy(p, &(pFolderList->folderInfo[i]), sizeof(MSG_FOLDER_INFO_S));
 191                 p = (void*)((char*)p + sizeof(MSG_FOLDER_INFO_S));
 192         }
 193
 194         return dataSize;
 195 }
 196
 197
 198 int MsgEncodeSetting(MSG_SETTING_S *pSetting, char **ppDest)
 199 {
 200         int dataSize = sizeof(MSG_OPTION_TYPE_T);
 201
 202         switch (pSetting->type)
 203         {
 204                 case MSG_GENERAL_OPT :
 205                         dataSize += sizeof(MSG_GENERAL_OPT_S);
 206                 break;
 207                 case MSG_SMS_SENDOPT :
 208                         dataSize += sizeof(MSG_SMS_SENDOPT_S);
 209                 break;
 210                 case MSG_SMSC_LIST :
 211                         dataSize += sizeof(MSG_SMSC_LIST_S);
 212                 break;
 213                 case MSG_MMS_SENDOPT :
 214                         dataSize += sizeof(MSG_MMS_SENDOPT_S);
 215                 break;
 216                 case MSG_MMS_RECVOPT :
 217                         dataSize += sizeof(MSG_MMS_RECVOPT_S);
 218                 break;
 219                 case MSG_MMS_STYLEOPT :
 220                         dataSize += sizeof(MSG_MMS_STYLEOPT_S);
 221                 break;
 222                 case MSG_PUSHMSG_OPT :
 223                         dataSize += sizeof(MSG_PUSHMSG_OPT_S);
 224                 break;
 225                 case MSG_CBMSG_OPT :
 226                         dataSize += sizeof(MSG_CBMSG_OPT_S);
 227                 break;
 228                 case MSG_VOICEMAIL_OPT :
 229                         dataSize += sizeof(MSG_VOICEMAIL_OPT_S);
 230                 break;
 231                 case MSG_MSGSIZE_OPT :
 232                         dataSize += sizeof(MSG_MSGSIZE_OPT_S);
 233                 break;
 234         }
 235
 236         *ppDest = (char*)new char[dataSize];
 237
 238         void* p = (void*)*ppDest;
 239
 240         memcpy(p, pSetting, dataSize);
 241
 242         return dataSize;
 243 }
 244
 245
 246 int MsgEncodeMsgType(MSG_MESSAGE_TYPE_S *pMsgType, char **ppDest)
 247 {
 248         int dataSize = 0;
 249
 250         dataSize = (sizeof(MSG_MESSAGE_TYPE_S));
 251
 252         *ppDest = (char*)new char[dataSize];
 253
 254         void* p = (void*)*ppDest;
 255
 256         memcpy(p, pMsgType, dataSize);
 257
 258         return dataSize;
 259 }
 260
 261
 262 int MsgEncodeThreadViewList(MSG_THREAD_VIEW_LIST_S *pThreadViewList, char **ppDest)
 263 {
 264         int count = 0, dataSize = 0;
 265
 266         count = pThreadViewList->nCount;
 267
 268         dataSize = sizeof(int) + (sizeof(MSG_THREAD_VIEW_S)*count);
 269
 270         *ppDest = (char*)new char[dataSize];
 271
 272         void* p = (void*)*ppDest;
 273
 274         memcpy(p, &count, sizeof(int));
 275         p = (void*)((char*)p + sizeof(int));
 276
 277         for (int i = 0; i < count; i++)
 278         {
 279                 memcpy(p, &(pThreadViewList->msgThreadInfo[i]), sizeof(MSG_THREAD_VIEW_S));
 280                 p = (void*)((char*)p + sizeof(MSG_THREAD_VIEW_S));
 281         }
 282
 283         return dataSize;
 284 }
 285
 286
 287 int MsgEncodeConversationViewList(MSG_LIST_S *pConvViewList, char **ppDest)
 288 {
 289         int count = 0, dataSize = 0;
 290
 291         count = pConvViewList->nCount;
 292
 293         dataSize = sizeof(int) + (sizeof(MSG_LIST_S)*count);
 294
 295         *ppDest = (char*)new char[dataSize];
 296
 297         void* p = (void*)*ppDest;
 298
 299         memcpy(p, &count, sizeof(int));
 300         p = (void*)((char*)p + sizeof(int));
 301
 302         for (int i = 0; i < count; i++)
 303         {
 304                 memcpy(p, &(pConvViewList->msgInfo[i]), sizeof(MSG_LIST_S));
 305                 p = (void*)((char*)p + sizeof(MSG_LIST_S));
 306         }
 307
 308         return dataSize;
 309 }
 310
 311
 312 int MsgEncodeMsgGetContactCount(MSG_THREAD_COUNT_INFO_S *threadCountInfo, char **ppDest)
 313 {
 314         int dataSize = sizeof(int) + sizeof(int) + sizeof(int) + sizeof(int);
 315
 316         MSG_DEBUG("datasize = [%d] \n", dataSize);
 317
 318         *ppDest = (char*)new char[dataSize];
 319
 320         void* p = (void*)*ppDest;
 321
 322         memcpy(p, &(threadCountInfo->totalCount), sizeof(int));
 323         p = (void*)((char*)p + sizeof(int));
 324
 325         memcpy(p, &(threadCountInfo->unReadCount), sizeof(int));
 326         p = (void*)((char*)p + sizeof(int));
 327
 328         memcpy(p, &(threadCountInfo->mmsMsgCount), sizeof(int));
 329         p = (void*)((char*)p + sizeof(int));
 330
 331         memcpy(p, &(threadCountInfo->smsMsgCount), sizeof(int));
 332         p = (void*)((char*)p + sizeof(int));
 333
 334         return dataSize;
 335 }
 336
 337 int MsgEncodeMemSize(unsigned int *memsize, char **ppDest)
 338 {
 339         int dataSize = 0;
 340
 341         dataSize = sizeof(unsigned int);
 342
 343         *ppDest = (char*)new char[dataSize];
 344
 345         void* p = (void*)*ppDest;
 346
 347         memcpy(p, memsize, dataSize);
 348
 349         return dataSize;
 350 }
 351
 352
 353 int MsgEncodeSyncMLOperationData(int msgId, int extId, char **ppDest)
 354 {
 355         int dataSize = 0;
 356
 357         dataSize = sizeof(int) + sizeof(int);
 358
 359         *ppDest = (char*)new char[dataSize];
 360
 361         void* p = (void*)*ppDest;
 362
 363         memcpy(p, &msgId, sizeof(int));
 364         p = (void*)((char*)p + sizeof(int));
 365
 366         memcpy(p, &extId, sizeof(int));
 367
 368         return dataSize;
 369 }
 370
 371
 372 int MsgEncodeStorageChangeData(const MSG_STORAGE_CHANGE_TYPE_T storageChangeType, const MSG_MSGID_LIST_S *pMsgIdList, char **ppDest)
 373 {
 374         int dataSize = 0;
 375         int count = 0;
 376
 377         count = pMsgIdList->nCount;
 378
 379         dataSize = sizeof(MSG_STORAGE_CHANGE_TYPE_T) + sizeof(int) + (sizeof(MSG_MESSAGE_ID_T)*count);
 380
 381         *ppDest = (char*)new char[dataSize];
 382
 383         void* p = (void*)*ppDest;
 384
 385         memcpy(p, &storageChangeType, sizeof(MSG_STORAGE_CHANGE_TYPE_T));
 386         p = (void*)((char*)p + sizeof(MSG_STORAGE_CHANGE_TYPE_T));
 387
 388         memcpy(p, &count, sizeof(int));
 389         p = (void*)((char*)p + sizeof(int));
 390
 391         for (int i = 0; i < count; i++) {
 392                 memcpy(p, &(pMsgIdList->msgIdList[i]), sizeof(MSG_MESSAGE_ID_T));
 393                 p = (void*)((char*)p + sizeof(MSG_MESSAGE_ID_T));
 394         }
 395
 396         return dataSize;
 397 }
 398
 399
 400 int MsgEncodeReportStatus(MSG_REPORT_STATUS_INFO_S* pReportStatus, char **ppDest)
 401 {
 402         int dataSize = 0;
 403
 404         dataSize = (sizeof(MSG_REPORT_STATUS_INFO_S));
 405
 406         *ppDest = (char*)new char[dataSize];
 407
 408         void* p = (void*)*ppDest;
 409
 410         memcpy(p, pReportStatus, dataSize);
 411
 412         return dataSize;
 413 }
 414
 415
 416 // Decoders
 417 void MsgDecodeMsgId(char *pSrc, MSG_MESSAGE_ID_T *pMsgId)
 418 {
 419         memcpy(pMsgId, pSrc, sizeof(MSG_MESSAGE_ID_T));
 420 }
 421
 422
 423 void MsgDecodeCountInfo(char *pSrc, MSG_COUNT_INFO_S *pCountInfo)
 424 {
 425         memcpy(pCountInfo, pSrc, sizeof(MSG_COUNT_INFO_S));
 426 }
 427
 428
 429 void MsgDecodeMemSize(char *pSrc, unsigned int *memsize)
 430 {
 431         memcpy(memsize, pSrc, sizeof(unsigned int));
 432 }
 433
 434
 435 void MsgDecodeMsgInfo(char *pSrc, MSG_MESSAGE_INFO_S *pMsgInfo, MSG_SENDINGOPT_INFO_S* pSendOptInfo)
 436 {
 437         memcpy(pMsgInfo, pSrc, sizeof(MSG_MESSAGE_INFO_S));
 438
 439         pSrc = pSrc + sizeof(MSG_MESSAGE_INFO_S);
 440
 441         memcpy(pSendOptInfo, pSrc, sizeof(MSG_SENDINGOPT_INFO_S));
 442 }
 443
 444
 445 void MsgDecodeFolderViewList(char *pSrc, MSG_LIST_S *pFolderViewList)
 446 {
 447         int count = 0;
 448
 449         memcpy(&count, pSrc, sizeof(int));
 450         pSrc = pSrc + sizeof(int);
 451
 452         if( count > 0 )
 453         {
 454                 pFolderViewList->nCount = count;
 455                 pFolderViewList->msgInfo = (msg_message_t*)new char[sizeof(MSG_MESSAGE_S)*count];
 456
 457                 MSG_MESSAGE_S* pInfoTmp = (MSG_MESSAGE_S*)pFolderViewList->msgInfo;
 458
 459                 for (int i = 0; i < count; i++)
 460                 {
 461                         memcpy(pInfoTmp, pSrc, sizeof(MSG_MESSAGE_S));
 462                         pSrc = pSrc + sizeof(MSG_MESSAGE_S);
 463                         pInfoTmp++;
 464                 }
 465         }
 466         else if ( count == 0 )
 467         {
 468                 pFolderViewList->nCount = count;
 469                 pFolderViewList->msgInfo = NULL;
 470         }
 471 }
 472
 473
 474 void MsgDecodeRecipientList(char *pSrc, MSG_RECIPIENTS_LIST_S *pRecipientList)
 475 {
 476         int count = 0;
 477
 478         memcpy(&count, pSrc, sizeof(int));
 479         pSrc = pSrc + sizeof(int);
 480
 481         pRecipientList->recipientCnt= count;
 482         pRecipientList->recipientAddr = (MSG_ADDRESS_INFO_S*)new char[sizeof(MSG_ADDRESS_INFO_S)*count];
 483
 484         MSG_ADDRESS_INFO_S* pInfoTmp = pRecipientList->recipientAddr;
 485
 486         for (int i = 0; i < count; i++)
 487         {
 488                 memcpy(pInfoTmp, pSrc, sizeof(MSG_ADDRESS_INFO_S));
 489                 pSrc = pSrc + sizeof(MSG_ADDRESS_INFO_S);
 490                 pInfoTmp++;
 491         }
 492 }
 493
 494
 495 void MsgDecodeFolderList(char *pSrc, MSG_FOLDER_LIST_S *pFolderList)
 496 {
 497         int count = 0;
 498
 499         memcpy(&count, pSrc, sizeof(int));
 500         pSrc = pSrc + sizeof(int);
 501
 502         pFolderList->nCount = count;
 503         pFolderList->folderInfo = (MSG_FOLDER_INFO_S*)new char[sizeof(MSG_FOLDER_INFO_S)*count];
 504
 505         MSG_FOLDER_INFO_S* pInfoTmp = pFolderList->folderInfo;
 506
 507         for (int i = 0; i < count; i++)
 508         {
 509                 memcpy(pInfoTmp, pSrc, sizeof(MSG_FOLDER_INFO_S));
 510                 pSrc = pSrc + sizeof(MSG_FOLDER_INFO_S);
 511                 pInfoTmp++;
 512         }
 513 }
 514
 515
 516 void MsgDecodeSetting(char *pSrc, MSG_SETTING_S *pSetting)
 517 {
 518         int dataSize = sizeof(MSG_OPTION_TYPE_T);
 519
 520         switch (pSetting->type)
 521         {
 522                 case MSG_GENERAL_OPT :
 523                         dataSize += sizeof(MSG_GENERAL_OPT_S);
 524                 break;
 525                 case MSG_SMS_SENDOPT :
 526                         dataSize += sizeof(MSG_SMS_SENDOPT_S);
 527                 break;
 528                 case MSG_SMSC_LIST :
 529                         dataSize += sizeof(MSG_SMSC_LIST_S);
 530                 break;
 531                 case MSG_MMS_SENDOPT :
 532                         dataSize += sizeof(MSG_MMS_SENDOPT_S);
 533                 break;
 534                 case MSG_MMS_RECVOPT :
 535                         dataSize += sizeof(MSG_MMS_RECVOPT_S);
 536                 break;
 537                 case MSG_MMS_STYLEOPT :
 538                         dataSize += sizeof(MSG_MMS_STYLEOPT_S);
 539                 break;
 540                 case MSG_PUSHMSG_OPT :
 541                         dataSize += sizeof(MSG_PUSHMSG_OPT_S);
 542                 break;
 543                 case MSG_CBMSG_OPT :
 544                         dataSize += sizeof(MSG_CBMSG_OPT_S);
 545                 break;
 546                 case MSG_VOICEMAIL_OPT :
 547                         dataSize += sizeof(MSG_VOICEMAIL_OPT_S);
 548                 break;
 549                 case MSG_MSGSIZE_OPT :
 550                         dataSize += sizeof(MSG_MSGSIZE_OPT_S);
 551                 break;
 552         }
 553
 554         memcpy(pSetting, pSrc, dataSize);
 555 }
 556
 557
 558 void MsgDecodeMsgType(char *pSrc, MSG_MESSAGE_TYPE_S* pMsgType)
 559 {
 560         memcpy(pMsgType, pSrc, sizeof(MSG_MESSAGE_TYPE_S));
 561 }
 562
 563
 564 void MsgDecodeThreadViewList(char *pSrc, MSG_THREAD_VIEW_LIST_S *pThreadViewList)
 565 {
 566         int count = 0;
 567
 568         memcpy(&count, pSrc, sizeof(int));
 569         pSrc = pSrc + sizeof(int);
 570
 571         if (count > 0)
 572         {
 573                 pThreadViewList->nCount = count;
 574                 pThreadViewList->msgThreadInfo = (msg_thread_view_t*)new char[sizeof(MSG_THREAD_VIEW_S)*count];
 575
 576                 MSG_THREAD_VIEW_S* pInfoTmp = (MSG_THREAD_VIEW_S*)pThreadViewList->msgThreadInfo;
 577
 578                 for (int i = 0; i < count; i++)
 579                 {
 580                         memcpy(pInfoTmp, pSrc, sizeof(MSG_THREAD_VIEW_S));
 581                         pSrc = pSrc + sizeof(MSG_THREAD_VIEW_S);
 582                         pInfoTmp++;
 583                 }
 584         }
 585         else if (count == 0)
 586         {
 587                 pThreadViewList->nCount = count;
 588                 pThreadViewList->msgThreadInfo = NULL;
 589         }
 590 }
 591
 592
 593 void MsgDecodeConversationViewList(char *pSrc, MSG_LIST_S *pConvViewList)
 594 {
 595         int count = 0;
 596
 597         memcpy(&count, pSrc, sizeof(int));
 598         pSrc = pSrc + sizeof(int);
 599
 600         if (count > 0)
 601         {
 602                 pConvViewList->nCount = count;
 603                 pConvViewList->msgInfo = (msg_message_t*)new char[sizeof(MSG_MESSAGE_S)*count];
 604
 605                 MSG_MESSAGE_S* pInfoTmp = (MSG_MESSAGE_S*)pConvViewList->msgInfo;
 606
 607                 for (int i = 0; i < count; i++)
 608                 {
 609                         memcpy(pInfoTmp, pSrc, sizeof(MSG_MESSAGE_S));
 610                         pSrc = pSrc + sizeof(MSG_MESSAGE_S);
 611                         pInfoTmp++;
 612                 }
 613         }
 614         else if (count == 0)
 615         {
 616                 pConvViewList->nCount = count;
 617                 pConvViewList->msgInfo = NULL;
 618         }
 619 }
 620
 621
 622 void    MsgDecodeContactCount(char *pSrc,  MSG_THREAD_COUNT_INFO_S *pMsgThreadCountList)
 623 {
 624         int count = 0;
 625
 626         if(pSrc == NULL)
 627                 return;
 628
 629         memcpy(&count, pSrc, sizeof(int));
 630         pSrc = pSrc + sizeof(int);
 631         pMsgThreadCountList->totalCount = count;
 632
 633
 634         memcpy(&count, pSrc, sizeof(int));
 635         pSrc = pSrc + sizeof(int);
 636         pMsgThreadCountList->unReadCount        = count;
 637
 638
 639         memcpy(&count, pSrc, sizeof(int));
 640         pSrc = pSrc + sizeof(int);
 641         pMsgThreadCountList->mmsMsgCount        = count;
 642
 643
 644         memcpy(&count, pSrc, sizeof(int));
 645         pSrc = pSrc + sizeof(int);
 646         pMsgThreadCountList->smsMsgCount        = count;
 647
 648
 649         return;
 650 }
 651
 652
 653 void    MsgDecodeReportStatus(char *pSrc,  MSG_REPORT_STATUS_INFO_S *pReportStatus)
 654 {
 655         int count = 0;
 656
 657         if(pSrc == NULL)
 658                 return;
 659
 660         memcpy(&count, pSrc, sizeof(MSG_DELIVERY_REPORT_STATUS_T));
 661         pSrc = pSrc + sizeof(MSG_DELIVERY_REPORT_STATUS_T);
 662         pReportStatus->deliveryStatus = count;
 663
 664
 665         memcpy(&count, pSrc, sizeof(time_t));
 666         pSrc = pSrc + sizeof(time_t);
 667         pReportStatus->deliveryStatusTime = count;
 668
 669
 670         memcpy(&count, pSrc, sizeof(MSG_READ_REPORT_STATUS_T));
 671         pSrc = pSrc + sizeof(MSG_READ_REPORT_STATUS_T);
 672         pReportStatus->readStatus = count;
 673
 674
 675         memcpy(&count, pSrc, sizeof(time_t));
 676         pSrc = pSrc + sizeof(time_t);
 677         pReportStatus->readStatusTime = count;
 678
 679
 680         return;
 681 }
 682
 683
 684 // Event Encoder
 685 int MsgMakeEvent(const void *pData, int DataSize, MSG_EVENT_TYPE_T MsgEvent, MSG_ERROR_T MsgError, void **ppEvent)
 686 {
 687         MSG_EVENT_S* pMsgEvent = NULL;
 688
 689         *ppEvent = (MSG_EVENT_S*)new char[sizeof(MSG_EVENT_S) + DataSize];
 690
 691         pMsgEvent = (MSG_EVENT_S*)*ppEvent;
 692
 693         pMsgEvent->eventType = MsgEvent;
 694         pMsgEvent->result = MsgError;
 695
 696         MSG_DEBUG("eventType [%d : %s]", pMsgEvent->eventType, MsgDbgEvtStr(pMsgEvent->eventType));
 697         MSG_DEBUG("result [%d]", pMsgEvent->result);
 698
 699         if (DataSize > 0)
 700                 memcpy((void*)pMsgEvent->data, pData, DataSize);
 701
 702         return (sizeof(MSG_EVENT_S) + DataSize);
 703 }