utils/MsgUtilFunction.cpp

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