plugin/mms_plugin/MmsPluginInternal.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd. All rights reserved
   3  *
   4  * Licensed under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0
   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 <stdlib.h>
  18 #include <errno.h>
  19 #include <sys/stat.h>
  20
  21 #include "MsgCppTypes.h"
  22 #include "MsgUtilFile.h"
  23 #include "MsgException.h"
  24 #include "MsgSettingTypes.h"
  25 #include "MsgMmsMessage.h"
  26 #include "MsgGconfWrapper.h"
  27 #include "MsgSerialize.h"
  28 #include "MsgSpamFilter.h"
  29 #include "MsgUtilMime.h"
  30 #include "MsgUtilFunction.h"
  31
  32 #include "MmsPluginDebug.h"
  33 #include "MmsPluginTypes.h"
  34 #include "MmsPluginCodec.h"
  35 #include "MmsPluginInternal.h"
  36 #include "MmsPluginStorage.h"
  37 #include "MmsPluginAppBase.h"
  38
  39 /*==================================================================================================
  40                                      IMPLEMENTATION OF MmsPluginInternal - Member Functions
  41 ==================================================================================================*/
  42 MmsPluginInternal *MmsPluginInternal::pInstance = NULL;
  43
  44
  45 MmsPluginInternal::MmsPluginInternal()
  46 {
  47 }
  48
  49 MmsPluginInternal::~MmsPluginInternal()
  50 {
  51 }
  52
  53 MmsPluginInternal *MmsPluginInternal::instance()
  54 {
  55         if (!pInstance)
  56                 pInstance = new MmsPluginInternal();
  57
  58         return pInstance;
  59 }
  60
  61 void MmsPluginInternal::processReceivedInd(MSG_MESSAGE_INFO_S *pMsgInfo, MSG_REQUEST_INFO_S *pRequest, bool *bReject)
  62 {
  63         MSG_BEGIN();
  64
  65         FILE *pFile = NULL;
  66         char fileName[MSG_FILENAME_LEN_MAX] = {0, };
  67
  68         if (pMsgInfo->bTextSms == true) {
  69                 char fullPath[MAX_FULL_PATH_SIZE+1] = {0, };
  70
  71                 if (MsgCreateFileName(fileName) == false)
  72                         THROW(MsgException::FILE_ERROR, "MsgCreateFileName error");
  73
  74                 MSG_SEC_DEBUG("File name = %s", fileName);
  75
  76                 if (MsgWriteIpcFile(fileName, pMsgInfo->msgText, pMsgInfo->dataSize) == false)
  77                         THROW(MsgException::FILE_ERROR, "MsgWriteIpcFile error");
  78
  79                 snprintf(fullPath, MAX_FULL_PATH_SIZE+1, "%s%s", MSG_IPC_DATA_PATH, fileName);
  80
  81                 memset(pMsgInfo->msgData, 0x00, sizeof(pMsgInfo->msgData));
  82                 memcpy(pMsgInfo->msgData, fullPath, strlen(fullPath));
  83                 pMsgInfo->bTextSms = false;
  84         }
  85
  86         MSG_SEC_DEBUG("MMS File Path = %s", pMsgInfo->msgData);
  87
  88         MmsInitHeader();
  89         MmsRegisterDecodeBuffer();
  90
  91         if ((pFile = MsgOpenFile(pMsgInfo->msgData, "rb+")) == NULL) {
  92                 MSG_DEBUG("File Open Error: %s", pMsgInfo->msgData);
  93         } else {
  94                 /* Decode Header */
  95                 if (!MmsBinaryDecodeMsgHeader(pFile, pMsgInfo->dataSize))
  96                         MSG_DEBUG("Decoding Header Failed \r\n");
  97
  98                 MsgCloseFile(pFile);
  99
 100                 if (remove(pMsgInfo->msgData) != 0)
 101                         MSG_DEBUG("Fail remove");
 102
 103                 switch (mmsHeader.type) {
 104                 case MMS_MSGTYPE_NOTIFICATION_IND:
 105                         MSG_DEBUG("process noti.ind\n");
 106                         /* For Set Value pMsgInfo */
 107                         if (processNotiInd(pMsgInfo, pRequest) == false)
 108                                 *bReject = true;
 109                         else
 110                                 *bReject = false;
 111                         break;
 112
 113                 case MMS_MSGTYPE_DELIVERY_IND:
 114                         MSG_DEBUG("process delivery.ind\n");
 115                         /* For Set Value pMsgInfo */
 116                         processDeliveryInd(pMsgInfo);
 117                         break;
 118
 119                 case MMS_MSGTYPE_READORG_IND:
 120                         MSG_DEBUG("process readorig.ind\n");
 121                         processReadOrgInd(pMsgInfo);
 122                         break;
 123                 default:
 124                         break;
 125                 }
 126         }
 127
 128         MSG_END();
 129 }
 130
 131 bool MmsPluginInternal::processNotiInd(MSG_MESSAGE_INFO_S *pMsgInfo, MSG_REQUEST_INFO_S *pRequest)
 132 {
 133         MSG_DEBUG("MmsProcessNotiInd");
 134
 135         MSG_MMS_HOME_RETRIEVE_TYPE_T retrieveType;
 136         bool bReportAllowed;
 137
 138         MmsAttrib attrib;
 139         MsgDbHandler *dbHandle = getDbHandle();
 140
 141         MmsInitMsgAttrib(&attrib);
 142
 143         pMsgInfo->msgType.mainType = MSG_MMS_TYPE;
 144         pMsgInfo->msgType.subType = MSG_NOTIFICATIONIND_MMS;
 145         pMsgInfo->priority = mmsHeader.priority;
 146         strncpy(pMsgInfo->subject, mmsHeader.szSubject, MSG_LOCALE_SUBJ_LEN);
 147
 148         MSG_DEBUG("pMsgInfo->subject [%s]", pMsgInfo->subject);
 149
 150 #if 0   /* we do not need to add empty subject text any more. */
 151         if (strlen(pMsgInfo->subject) < 1)
 152                 snprintf(pMsgInfo->subject, MAX_SUBJECT_LEN, "MMS Notification Message.");
 153 #endif
 154
 155         attrib.expiryTime = mmsHeader.expiryTime;
 156
 157         if (mmsHeader.pFrom) {
 158                 MmsAddrUtilRemovePlmnString(mmsHeader.pFrom->szAddr);
 159                 /* From */
 160                 strncpy(pMsgInfo->addressList[0].addressVal, mmsHeader.pFrom->szAddr, MAX_ADDRESS_VAL_LEN);
 161                 if (MmsAddrUtilCheckEmailAddress(pMsgInfo->addressList[0].addressVal)) {
 162                         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_EMAIL;
 163                 }
 164         }
 165
 166         MMS_DATA_S *mms_data = MsgMmsCreate();
 167         if (mms_data == NULL)
 168                 return false;
 169
 170         mms_data->header = MsgMmsCreateHeader();
 171
 172         if (mms_data->header == NULL) {
 173                 MsgMmsRelease(&mms_data);
 174                 return false;
 175         }
 176
 177         MMS_HEADER_DATA_S *pHeader = mms_data->header;
 178
 179         pHeader->messageType = mmsHeader.type;
 180
 181         snprintf(pHeader->trID, sizeof(pHeader->trID), "%s", mmsHeader.szTrID);
 182
 183         pHeader->mmsVersion = mmsHeader.version;
 184
 185         /* From */
 186         if (mmsHeader.pFrom) {
 187                 MmsAddrUtilRemovePlmnString(mmsHeader.pFrom->szAddr);
 188                 snprintf(pHeader->szFrom, sizeof(pHeader->szFrom), "%s", mmsHeader.pFrom->szAddr);
 189         }
 190
 191         /* Subject */
 192         snprintf(pHeader->szSubject, sizeof(pHeader->szSubject), "%s", mmsHeader.szSubject);
 193         /* Delivery Report */
 194         pHeader->bDeliveryReport = (mmsHeader.deliveryReport != MMS_REPORT_YES);
 195         /* Message Class */
 196         pHeader->messageClass = mmsHeader.msgClass;
 197
 198         /* Priority */
 199         pHeader->mmsPriority = mmsHeader.priority;
 200
 201         /* Message Size : pMmsMsg->mmsAttrib.msgSize = mmsHeader.msgSize; */
 202         /* Expiry */
 203         pHeader->expiry.type = mmsHeader.expiryTime.type;
 204         pHeader->expiry.time = mmsHeader.expiryTime.time;
 205
 206         time_t curTime = time(NULL);
 207
 208         if (pHeader->expiry.type == MMS_TIMETYPE_RELATIVE) {
 209                 pHeader->expiry.type = MMS_TIMETYPE_ABSOLUTE;
 210                 pHeader->expiry.time += curTime;
 211         }
 212
 213         /* Charge */
 214         /* contentclass */
 215         /* int contentClass; */ /*text | image-basic| image-rich | video-basic | video-rich | megapixel | content-basic | content-rich */
 216         strncpy(pHeader->contentLocation, mmsHeader.szContentLocation, MMS_LOCATION_LEN);
 217
 218         pHeader->messageSize = mmsHeader.msgSize;
 219
 220         MSG_DEBUG("Message size = [%d]", pHeader->messageSize);
 221
 222         char *pSerializedMms = NULL;
 223         int serializeDataSize = 0;
 224
 225         char pTempFileName[MSG_FILENAME_LEN_MAX+1] = {0};
 226         char pTempFilePath[MSG_FILEPATH_LEN_MAX+1] = {0};
 227
 228         serializeDataSize = MsgSerializeMms(mms_data, &pSerializedMms);
 229
 230         if (pSerializedMms) {
 231                 if (MsgCreateFileName(pTempFileName) == true) {
 232                         pMsgInfo->bTextSms = false;
 233
 234                         snprintf(pTempFilePath, sizeof(pTempFilePath), "%s%s", MSG_IPC_DATA_PATH, pTempFileName);
 235
 236                         MsgOpenCreateAndOverwriteFile(pTempFilePath, pSerializedMms, serializeDataSize);
 237
 238                         /* set file name */
 239                         snprintf(pMsgInfo->msgData, sizeof(pMsgInfo->msgData), "%s", pTempFileName);
 240                 }
 241
 242                 delete [] pSerializedMms;
 243         }
 244
 245                 MsgMmsRelease(&mms_data);
 246
 247         /* Check contents-location is in noti.ind */
 248         if (mmsHeader.szContentLocation[0] == '\0') {
 249                 THROW(MsgException::INCOMING_MSG_ERROR, "######## Contents-location is empty in MMS-Noti-Ind  #######");
 250                 return false;
 251         }
 252
 253         int roamState = 0;
 254         char pPduFilePath[MAX_FULL_PATH_SIZE] = {0};
 255
 256         if (MsgSettingGetInt(VCONFKEY_TELEPHONY_SVC_ROAM, &roamState) != MSG_SUCCESS)
 257                 MSG_INFO("MsgSettingGetInt() is failed");
 258
 259         if (MsgSettingGetBool(MMS_SEND_REPORT_ALLOWED, &bReportAllowed) != MSG_SUCCESS)
 260                 MSG_INFO("MsgSettingGetBool() is failed");
 261
 262         if (checkRejectNotiInd(roamState, bReportAllowed, pPduFilePath)) {
 263                 MSG_DEBUG("MMS Message Rejected......");
 264
 265                 pMsgInfo->dataSize = strlen(pPduFilePath);
 266                 memcpy(&pRequest->msgInfo, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 267                 snprintf(pRequest->msgInfo.msgData, sizeof(pRequest->msgInfo.msgData), "%s", pPduFilePath);
 268                 pRequest->msgInfo.msgType.subType = MSG_NOTIFYRESPIND_MMS;
 269
 270                 return false;
 271         }
 272
 273         if (MsgCheckFilter(dbHandle, pMsgInfo)) {
 274                 encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_DEFERRED, bReportAllowed, pPduFilePath);
 275
 276                 pMsgInfo->dataSize = strlen(pPduFilePath);
 277
 278                 pRequest->msgInfo.bTextSms = false;
 279
 280                 memcpy(&pRequest->msgInfo, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 281
 282                 snprintf(pRequest->msgInfo.msgData, sizeof(pRequest->msgInfo.msgData), "%s", pPduFilePath);
 283                 MSG_SEC_DEBUG("pRequest->msgInfo.msgData = %s", pRequest->msgInfo.msgData);
 284                 pRequest->msgInfo.msgType.subType = MSG_NOTIFYRESPIND_MMS;
 285                 pRequest->msgInfo.folderId = MSG_SPAMBOX_ID;
 286
 287                 return true;
 288         }
 289
 290         int tmpVal = 0;
 291         if (roamState == VCONFKEY_TELEPHONY_SVC_ROAM_OFF) {
 292                 if (MsgSettingGetInt(MMS_RECV_HOME_NETWORK, &tmpVal) != MSG_SUCCESS) {
 293                         MSG_INFO("MsgSettingGetInt() is failed");
 294                 }
 295                 retrieveType = (MSG_MMS_HOME_RETRIEVE_TYPE_T)tmpVal;
 296                 MSG_DEBUG("$$$$$$$$$$ MMS_RECV_HOME_NETWORK = %d $$$$$$$$$$$$$", retrieveType);
 297         } else {
 298                 if (MsgSettingGetInt(MMS_RECV_ABROAD_NETWORK, &tmpVal) != MSG_SUCCESS) {
 299                         MSG_INFO("MsgSettingGetInt() is failed");
 300                 }
 301                 retrieveType = (MSG_MMS_HOME_RETRIEVE_TYPE_T)tmpVal;
 302                 MSG_DEBUG("$$$$$$$$$$ MMS_RECV_ABROAD_NETWORK = %d $$$$$$$$$$$$$", retrieveType);
 303
 304                 if (retrieveType == MSG_ABROAD_RESTRICTED) {
 305                         MSG_DEBUG("MMS Receiving Setting Restricted was selected.");
 306                         /* m-notify-resp-ind encoding process */
 307                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_DEFERRED, bReportAllowed, pPduFilePath);
 308
 309                         pMsgInfo->dataSize = strlen(pPduFilePath);
 310
 311                         pRequest->msgInfo.bTextSms = false;
 312
 313                         memcpy(&pRequest->msgInfo, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 314
 315                         snprintf(pRequest->msgInfo.msgData, sizeof(pRequest->msgInfo.msgData), "%s", pPduFilePath);
 316
 317                         pRequest->msgInfo.msgType.subType = MSG_NOTIFYRESPIND_MMS;
 318
 319                         return true;
 320                 }
 321         }
 322
 323         /* should send http 'GET' */
 324         if (retrieveType == MSG_HOME_AUTO_DOWNLOAD || retrieveType == MSG_ABROAD_AUTO_DOWNLOAD) {
 325                 /* Check if current request sim index is different from default network SIM */
 326                 /* Convert auto-retrieve to manual retrieve in case sim indexes are different */
 327                 int default_sim = 0;
 328                 if (MsgSettingGetInt(MSG_NETWORK_SIM, &default_sim) != MSG_SUCCESS) {
 329                         MSG_INFO("MsgSettingGetInt() is failed");
 330                 }
 331
 332                 MSG_DEBUG("default_sim = %d, pMsgInfo->sim_idx = %d", default_sim, pMsgInfo->sim_idx);
 333
 334                 if (default_sim == (int)pMsgInfo->sim_idx) {
 335                         MSG_DEBUG("=========== START AUTO RETRIEVE MODE ============");
 336
 337                         pMsgInfo->dataSize = strlen(mmsHeader.szContentLocation);
 338
 339                         pRequest->msgInfo.bTextSms = true;
 340
 341                         memcpy(&pRequest->msgInfo, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 342
 343                         snprintf(pRequest->msgInfo.msgData, sizeof(pRequest->msgInfo.msgData), "%s", mmsHeader.szContentLocation);
 344
 345                         pRequest->msgInfo.msgType.subType = MSG_GET_MMS;
 346
 347                         MSG_SEC_DEBUG("MSG SUBTYPE = %d msg data %s bTextsms %d", pRequest->msgInfo.msgType.subType, pRequest->msgInfo.msgData, pRequest->msgInfo.bTextSms);
 348                 } else {
 349                         /* should send m-notify-resp-ind */
 350                         MSG_DEBUG("=========== START MANUAL RETRIEVE MODE ===========");
 351                         /* m-notify-resp-ind encoding process */
 352                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_DEFERRED, bReportAllowed, pPduFilePath);
 353
 354                         pMsgInfo->dataSize = strlen(pPduFilePath);
 355
 356                         pRequest->msgInfo.bTextSms = false;
 357
 358                         memcpy(&pRequest->msgInfo, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 359
 360                         snprintf(pRequest->msgInfo.msgData, sizeof(pRequest->msgInfo.msgData), "%s", pPduFilePath);
 361                         MSG_SEC_DEBUG("pRequest->msgInfo.msgData = %s", pRequest->msgInfo.msgData);
 362                         snprintf(pRequest->msgInfo.msgURL, sizeof(pRequest->msgInfo.msgURL), "%s", mmsHeader.szContentLocation);
 363                         pRequest->msgInfo.msgType.subType = MSG_NOTIFYRESPIND_MMS;
 364                 }
 365         } else {
 366                 /* should send m-notify-resp-ind */
 367                 MSG_DEBUG("=========== START MANUAL RETRIEVE MODE ===========");
 368                 /* m-notify-resp-ind encoding process */
 369
 370                 if (retrieveType == MSG_HOME_MANUAL || retrieveType == MSG_ABROAD_MANUAL) {
 371                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_DEFERRED, bReportAllowed, pPduFilePath);
 372                 }
 373
 374                 pMsgInfo->dataSize = strlen(pPduFilePath);
 375
 376                 pRequest->msgInfo.bTextSms = false;
 377
 378                 memcpy(&pRequest->msgInfo, pMsgInfo, sizeof(MSG_MESSAGE_INFO_S));
 379
 380                 snprintf(pRequest->msgInfo.msgData, sizeof(pRequest->msgInfo.msgData), "%s", pPduFilePath);
 381                 MSG_SEC_DEBUG("pRequest->msgInfo.msgData = %s", pRequest->msgInfo.msgData);
 382                 snprintf(pRequest->msgInfo.msgURL, sizeof(pRequest->msgInfo.msgURL), "%s", mmsHeader.szContentLocation);
 383                 pRequest->msgInfo.msgType.subType = MSG_NOTIFYRESPIND_MMS;
 384         }
 385
 386         return true;
 387 }
 388
 389 void MmsPluginInternal::processDeliveryInd(MSG_MESSAGE_INFO_S *pMsgInfo)
 390 {
 391         MSG_BEGIN();
 392
 393         MmsMsgMultiStatus status;
 394         memset(&status, 0x00, sizeof(MmsMsgMultiStatus));
 395
 396         status.msgStatus = mmsHeader.msgStatus;
 397         status.handledTime = mmsHeader.date;
 398         status.bDeliveryReportIsRead = false;
 399         status.bDeliveyrReportIsLast = true;
 400
 401         MmsAddrUtilRemovePlmnString(mmsHeader.pTo->szAddr);
 402         MSG_SEC_DEBUG("[INFO] [ADDR: %s, MMSID: %s]", mmsHeader.pTo->szAddr, mmsHeader.szMsgID);
 403
 404         pMsgInfo->msgType.mainType      = MSG_MMS_TYPE;
 405         pMsgInfo->msgType.subType       = MSG_DELIVERYIND_MMS;
 406         pMsgInfo->bTextSms = true;
 407         pMsgInfo->dataSize = 0;
 408         memset(pMsgInfo->msgData, 0x00, MAX_MSG_DATA_LEN + 1);
 409
 410         strncpy(pMsgInfo->msgData, getMmsDeliveryStatus(status.msgStatus), MAX_MSG_DATA_LEN);
 411         pMsgInfo->dataSize  = strlen(pMsgInfo->msgData);
 412         MSG_DEBUG("Delivery Status = %s", pMsgInfo->msgData);
 413
 414         strncpy(pMsgInfo->addressList[0].addressVal, mmsHeader.pTo->szAddr, MAX_ADDRESS_VAL_LEN);
 415
 416         int tmpId = (msg_message_id_t)MmsPluginStorage::instance()->searchMsgId(mmsHeader.pTo->szAddr, mmsHeader.szMsgID);
 417         if (tmpId > 0) {
 418                 MSG_DEBUG("Found MSG_ID = %d", tmpId);
 419
 420                 /* Insert to Delievery DB */
 421                 MmsPluginStorage::instance()->insertDeliveryReport(tmpId, mmsHeader.pTo->szAddr, &status);
 422
 423                 pMsgInfo->msgId = (msg_message_id_t)tmpId;
 424
 425         } else {
 426                 MSG_DEBUG("Can not find MMS message in DB");
 427         }
 428
 429         MSG_END();
 430 }
 431
 432 void MmsPluginInternal::processReadOrgInd(MSG_MESSAGE_INFO_S *pMsgInfo)
 433 {
 434         MSG_BEGIN();
 435
 436         if (pMsgInfo == NULL) {
 437                 MSG_DEBUG("parameter err");
 438                 return;
 439         }
 440
 441         pMsgInfo->msgType.mainType = MSG_MMS_TYPE;
 442         pMsgInfo->msgType.subType = MSG_READORGIND_MMS;
 443         pMsgInfo->bTextSms = true;
 444
 445         MmsAddrUtilRemovePlmnString(mmsHeader.pFrom->szAddr);
 446         MmsAddrUtilRemovePlmnString(mmsHeader.pTo->szAddr);
 447
 448         memset(pMsgInfo->msgData, 0x00, MAX_MSG_DATA_LEN + 1);
 449         pMsgInfo->dataSize = 0;
 450
 451         strncpy(pMsgInfo->msgData, getMmsReadStatus(mmsHeader.readStatus), MAX_MSG_DATA_LEN);
 452         pMsgInfo->dataSize  = strlen(pMsgInfo->msgData);
 453
 454         MSG_SEC_DEBUG("read Status = %s", pMsgInfo->msgData);
 455         strncpy(pMsgInfo->addressList[0].addressVal, mmsHeader.pFrom->szAddr, MAX_ADDRESS_VAL_LEN);
 456
 457         int tmpId = MmsPluginStorage::instance()->searchMsgId(mmsHeader.pFrom->szAddr, mmsHeader.szMsgID);
 458         if (tmpId > 0) {
 459                 pMsgInfo->msgId = (msg_message_id_t)tmpId;
 460
 461                 MmsMsgMultiStatus Status;
 462                 memset(&Status, 0x00, sizeof(MmsMsgMultiStatus));
 463                 Status.readTime = mmsHeader.date;
 464                 Status.readStatus = mmsHeader.readStatus;
 465
 466                 MmsPluginStorage::instance()->insertReadReport(pMsgInfo->msgId, mmsHeader.pFrom->szAddr, &Status);
 467
 468         } else {
 469                 MSG_DEBUG("Can't not find Message!");
 470         }
 471
 472         MSG_END();
 473 }
 474
 475 void MmsPluginInternal::processSendConf(MSG_MESSAGE_INFO_S *pMsgInfo, mmsTranQEntity *pRequest)
 476 {
 477         MSG_BEGIN();
 478
 479         MMS_RECV_DATA_S recvData = {{0}, };
 480
 481         pMsgInfo->msgId = pRequest->msgId;
 482
 483         /* Set only changed members */
 484         pMsgInfo->msgType.mainType = MSG_MMS_TYPE;
 485         pMsgInfo->msgType.subType = MSG_SENDCONF_MMS;
 486
 487         pMsgInfo->folderId = MSG_OUTBOX_ID;
 488
 489         strncpy(pMsgInfo->subject, mmsHeader.szSubject, MSG_LOCALE_SUBJ_LEN);
 490
 491         if (mmsHeader.responseStatus == MMS_RESPSTATUS_OK) {
 492                 pMsgInfo->networkStatus = MSG_NETWORK_SEND_SUCCESS;
 493                 pMsgInfo->dataSize = pRequest->postDataLen;
 494         } else {
 495                 pMsgInfo->networkStatus = MSG_NETWORK_SEND_FAIL;
 496
 497                 char responseText[MMS_LOCALE_RESP_TEXT_LEN];
 498
 499                 memset(responseText, 0x00, MMS_LOCALE_RESP_TEXT_LEN);
 500                 snprintf(responseText, MMS_LOCALE_RESP_TEXT_LEN, " %s [%d]", mmsHeader.szResponseText, mmsHeader.responseStatus);
 501
 502                 memset(pMsgInfo->msgText, 0x00, MAX_MSG_TEXT_LEN + 1);
 503                 strncpy(pMsgInfo->msgText, responseText, MMS_LOCALE_RESP_TEXT_LEN);
 504         }
 505
 506         MSG_ADDRESS_INFO_S addressinfo = {0, };
 507         char keyName[MAX_VCONFKEY_NAME_LEN];
 508         memset(keyName, 0x00, sizeof(keyName));
 509
 510         snprintf(keyName, sizeof(keyName), "%s/%d", MSG_SIM_MSISDN, pMsgInfo->sim_idx);
 511         char *msisdn = NULL;
 512         if (MsgSettingGetString(keyName, &msisdn) != MSG_SUCCESS) {
 513                 MSG_INFO("MsgSettingGetString() is failed");
 514         }
 515
 516         MmsPluginStorage::instance()->getAddressInfo(pMsgInfo->msgId, &addressinfo);
 517
 518         MSG_SEC_DEBUG("%d, MMS Send End %s->%s %s", pMsgInfo->msgId
 519                                                                                                         , (msisdn == NULL)?"ME":msisdn
 520                                                                                                         , addressinfo.addressVal
 521                                                                                                         , (pMsgInfo->networkStatus == MSG_NETWORK_SEND_SUCCESS)?"Success":"Fail");
 522
 523         if (msisdn) {
 524                 free(msisdn);
 525                 msisdn = NULL;
 526         }
 527
 528         /* set message-id from mmsc */
 529         strncpy(recvData.szMsgID, mmsHeader.szMsgID, MMS_MSG_ID_LEN);
 530         strncpy(recvData.szTrID, mmsHeader.szTrID, MMS_TR_ID_LEN);
 531
 532         memset(pMsgInfo->msgData, 0x00, MAX_MSG_DATA_LEN + 1);
 533         memcpy(pMsgInfo->msgData, &recvData, sizeof(MMS_RECV_DATA_S));
 534
 535         time_t curTime;
 536         curTime = time(NULL);
 537
 538         pMsgInfo->displayTime = curTime;
 539
 540         MmsMsg *pMsg = NULL;
 541         MmsPluginStorage::instance()->getMmsMessage(&pMsg);
 542         MmsInitHeader();
 543         MmsReleaseMsgDRMInfo(&pMsg->msgType.drmInfo);
 544         MmsReleaseMsgBody(&pMsg->msgBody, pMsg->msgType.type);
 545
 546         MSG_END();
 547 }
 548
 549 #if 1
 550 void MmsPluginInternal::processRetrieveConf(MSG_MESSAGE_INFO_S *pMsgInfo, mmsTranQEntity *pRequest, char *pRetrievedFilePath)
 551 {
 552         MSG_BEGIN();
 553
 554         msg_error_t err = MSG_SUCCESS;
 555         MMS_RECV_DATA_S recvData = {{0}, };
 556
 557         MmsAttrib attrib;
 558
 559         MmsInitMsgAttrib(&attrib);
 560
 561         attrib.priority = mmsHeader.priority;
 562         attrib.bAskDeliveryReport = getMmsReport(mmsHeader.deliveryReport);
 563         attrib.bAskReadReply = getMmsReport(mmsHeader.readReply);
 564
 565         /* Set only changed members */
 566         pMsgInfo->msgId = pRequest->msgId;
 567         MSG_DEBUG("@@@@@ msgId = %d @@@@@", pMsgInfo->msgId);
 568         pMsgInfo->msgType.mainType = MSG_MMS_TYPE;
 569
 570         if (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)
 571                 pMsgInfo->msgType.subType = MSG_RETRIEVE_AUTOCONF_MMS;
 572         else
 573                 pMsgInfo->msgType.subType = MSG_RETRIEVE_MANUALCONF_MMS;
 574
 575         strncpy(pMsgInfo->subject, mmsHeader.szSubject, MSG_LOCALE_SUBJ_LEN);
 576
 577         strncpy(pRequest->transactionId, mmsHeader.szTrID, MMS_TR_ID_LEN);
 578
 579         time_t curTime;
 580         curTime = time(NULL);
 581
 582         pMsgInfo->displayTime = curTime;
 583
 584         if (mmsHeader.retrieveStatus == MMS_RETRSTATUS_OK) {
 585                 pMsgInfo->networkStatus = MSG_NETWORK_RETRIEVE_SUCCESS;
 586                 pMsgInfo->folderId = MSG_INBOX_ID;
 587         } else {
 588                 pMsgInfo->networkStatus = MSG_NETWORK_RETRIEVE_FAIL;
 589                 pMsgInfo->folderId = MSG_INBOX_ID;
 590                 /* If failed MMS Retrieve, then saved as MMS Noti Ind Message.
 591                  * It will changed in MsgHandleMmsConfIncomingMsg */
 592 /*              pMsgInfo->msgType.subType = MSG_NOTIFICATIONIND_MMS; */
 593         }
 594
 595         char keyName[MAX_VCONFKEY_NAME_LEN];
 596         memset(keyName, 0x00, sizeof(keyName));
 597
 598         snprintf(keyName, sizeof(keyName), "%s/%d", MSG_SIM_MSISDN, pMsgInfo->sim_idx);
 599         char *msisdn = NULL;
 600         if (MsgSettingGetString(keyName, &msisdn) != MSG_SUCCESS) {
 601                 MSG_INFO("MsgSettingGetString() is failed");
 602         }
 603         char *normal_msisdn = NULL;
 604         if (msisdn)
 605                 normal_msisdn = msg_normalize_number(msisdn);
 606
 607         /* get setting value of group message */
 608         bool is_group_on = false;
 609
 610         if (is_group_on) {
 611                 int addr_cnt = 0;
 612                 MsgHeaderAddress *iter = NULL;
 613
 614                 iter = mmsHeader.pFrom;
 615                 while (iter) {
 616                         addr_cnt++;
 617                         iter = iter->pNext;
 618                 }
 619
 620                 iter = mmsHeader.pTo;
 621                 while (iter) {
 622                         if (normal_msisdn == NULL || !g_str_has_suffix(iter->szAddr, normal_msisdn))
 623                                 addr_cnt++;
 624                         iter = iter->pNext;
 625                 }
 626
 627                 iter = mmsHeader.pCc;
 628                 while (iter) {
 629                         if (normal_msisdn == NULL || !g_str_has_suffix(iter->szAddr, normal_msisdn))
 630                                 addr_cnt++;
 631                         iter = iter->pNext;
 632                 }
 633
 634                 MSG_ADDRESS_INFO_S *tmp_addr_info = (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S)*addr_cnt];
 635                 memset(tmp_addr_info, 0x00, sizeof(MSG_ADDRESS_INFO_S)*addr_cnt);
 636                 if (mmsHeader.pFrom == NULL) {
 637                         strncpy(tmp_addr_info[0].addressVal, pMsgInfo->addressList[0].addressVal, MAX_ADDRESS_VAL_LEN);
 638                 }
 639
 640                 pMsgInfo->nAddressCnt = addr_cnt;
 641                 pMsgInfo->addressList = tmp_addr_info;
 642         } else {
 643                 pMsgInfo->addressList = (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S)];
 644                 memset(pMsgInfo->addressList, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 645                 pMsgInfo->nAddressCnt = 1;
 646         }
 647
 648         if (mmsHeader.pFrom) {
 649                 MSG_DEBUG("FROM : [%s]", mmsHeader.pFrom->szAddr);
 650                 MmsAddrUtilRemovePlmnString(mmsHeader.pFrom->szAddr);
 651                 /* From */
 652                 strncpy(pMsgInfo->addressList[0].addressVal, mmsHeader.pFrom->szAddr, MAX_ADDRESS_VAL_LEN);
 653                 if (MmsAddrUtilCheckEmailAddress(pMsgInfo->addressList[0].addressVal)) {
 654                         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_EMAIL;
 655                 }
 656         }
 657
 658         if (is_group_on) {
 659                 int addr_idx = 0;
 660                 if (mmsHeader.pTo) {
 661                         MsgHeaderAddress *iter = mmsHeader.pTo;
 662                         while (iter) {
 663                                 addr_idx++;
 664                                 MSG_DEBUG("TO : [%s]", mmsHeader.pTo->szAddr);
 665                                 MmsAddrUtilRemovePlmnString(iter->szAddr);
 666                                 /* To */
 667                                 if (normal_msisdn == NULL || !g_str_has_suffix(iter->szAddr, normal_msisdn)) {
 668                                         strncpy(pMsgInfo->addressList[addr_idx].addressVal, iter->szAddr, MAX_ADDRESS_VAL_LEN);
 669                                         pMsgInfo->addressList[addr_idx].recipientType = MSG_RECIPIENTS_TYPE_TO;
 670                                         if (MmsAddrUtilCheckEmailAddress(pMsgInfo->addressList[addr_idx].addressVal)) {
 671                                                 pMsgInfo->addressList[addr_idx].addressType = MSG_ADDRESS_TYPE_EMAIL;
 672                                         }
 673                                 } else {
 674                                         addr_idx--;
 675                                 }
 676
 677                                 iter = iter->pNext;
 678                         }
 679                 }
 680
 681                 if (mmsHeader.pCc) {
 682                         MsgHeaderAddress *iter = mmsHeader.pCc;
 683                         while (iter) {
 684                                 addr_idx++;
 685                                 MSG_DEBUG("CC : [%s]", mmsHeader.pCc->szAddr);
 686                                 MmsAddrUtilRemovePlmnString(iter->szAddr);
 687                                 /* Cc */
 688                                 if (normal_msisdn == NULL || !g_str_has_suffix(iter->szAddr, normal_msisdn)) {
 689                                         strncpy(pMsgInfo->addressList[addr_idx].addressVal, iter->szAddr, MAX_ADDRESS_VAL_LEN);
 690                                         pMsgInfo->addressList[addr_idx].recipientType = MSG_RECIPIENTS_TYPE_CC;
 691                                         if (MmsAddrUtilCheckEmailAddress(pMsgInfo->addressList[addr_idx].addressVal)) {
 692                                                 pMsgInfo->addressList[addr_idx].addressType = MSG_ADDRESS_TYPE_EMAIL;
 693                                         }
 694                                 } else {
 695                                         addr_idx--;
 696                                 }
 697
 698                                 iter = iter->pNext;
 699                         }
 700                 }
 701         }
 702
 703         MSG_SEC_DEBUG("%d, MMS Receive %s End %s->%s %s", pMsgInfo->msgId
 704                                                                                                                 , (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)?"Auto":"Manual"
 705                                                                                                                 , (mmsHeader.pFrom)?mmsHeader.pFrom->szAddr:"YOU"
 706                                                                                                                 , (msisdn == NULL)?"ME":msisdn
 707                                                                                                                 , (pMsgInfo->networkStatus == MSG_NETWORK_RETRIEVE_SUCCESS)?"Success":"Fail");
 708
 709         if (msisdn) {
 710                 free(msisdn);
 711                 msisdn = NULL;
 712         }
 713
 714         pMsgInfo->dataSize = pRequest->getDataLen;
 715
 716         /* set message-id & MMS TPDU file path */
 717         snprintf(recvData.szMsgID, sizeof(recvData.szMsgID), "%s", mmsHeader.szMsgID);
 718
 719         if (pRetrievedFilePath)
 720                 strncpy(recvData.retrievedFilePath, pRetrievedFilePath, sizeof(recvData.retrievedFilePath)-1);
 721
 722         char *filename = NULL;
 723
 724 #ifdef FEATURE_JAVA_MMS
 725         if (mmsHeader.msgType.param.szApplicationID || mmsHeader.msgType.param.szReplyToApplicationID) {
 726                 recvData.msgAppId.valid = true;
 727                 if (mmsHeader.msgType.param.szApplicationID)
 728                         strncpy(recvData.msgAppId.appId, mmsHeader.msgType.param.szApplicationID, sizeof(recvData.msgAppId.appId));
 729                 if (mmsHeader.msgType.param.szReplyToApplicationID)
 730                         strncpy(recvData.msgAppId.replyToAppId, mmsHeader.msgType.param.szReplyToApplicationID, sizeof(recvData.msgAppId.replyToAppId));
 731
 732                 char fullPath[MAX_FULL_PATH_SIZE+1] = {0, };
 733
 734                 filename = MsgGetFileName(pRetrievedFilePath);
 735
 736                 snprintf(fullPath, MAX_FULL_PATH_SIZE+1, "%s%s", MSG_IPC_DATA_PATH, filename);
 737
 738                 if (pRetrievedFilePath) {
 739                         int ret  = rename(pRetrievedFilePath, fullPath);
 740                         if (ret != 0) {
 741                                 MSG_DEBUG("File rename Error: %s", g_strerror(errno));
 742                         }
 743                 }
 744         }
 745 #endif
 746         memcpy(pMsgInfo->msgData, &recvData, sizeof(MMS_RECV_DATA_S));
 747
 748         MSG_SEC_DEBUG("@@@@@ MsgData = %s @@@@@", pMsgInfo->msgData);
 749         MSG_SEC_DEBUG("@@@@@ retrievedFilePath = %s @@@@@", recvData.retrievedFilePath);
 750         MSG_DEBUG("@@@@@ szMsgID = %s @@@@@", recvData.szMsgID);
 751         /* update delivery report, read reply */
 752
 753         MmsPluginStorage *pStorage = MmsPluginStorage::instance();
 754
 755         err = pStorage->updateMmsAttrib(pMsgInfo->msgId, &attrib, pMsgInfo->msgType.subType);
 756
 757         MSG_DEBUG("Error value of updateMmsAttrib [%d]", err);
 758
 759         /* make MmsData & insert multipart */
 760         MMSList *multipart_list = NULL;
 761         MMS_MULTIPART_DATA_S *pSmilMultipart = NULL;
 762
 763         MmsMsg *pMmsMsg = NULL;
 764         MmsPluginStorage::instance()->getMmsMessage(&pMmsMsg);
 765
 766         bool bFiltered;
 767         MmsPluginAppBase *appBase;
 768
 769         MMS_DATA_S *pMmsData = MsgMmsCreate();
 770         if (pMmsData == NULL) {
 771                 MSG_SEC_DEBUG("Fail to create mms");
 772                 goto __CATCH;
 773         }
 774
 775         pMmsData->header = MsgMmsCreateHeader();
 776
 777         MmsConvertMmsData(pMmsMsg, pMmsData);
 778         /* CID 41996 : MmsConvertMmsData always returns true */
 779         /*
 780         if (MmsConvertMmsData(pMmsMsg, pMmsData) != true) {
 781                 MSG_DEBUG("Fail to Compose MMS Message");
 782                 goto __CATCH;
 783         } */
 784
 785         bFiltered = checkFilterMmsBody(pMmsData);
 786         if (bFiltered == true) {
 787                 pMsgInfo->folderId = MSG_SPAMBOX_ID;
 788         }
 789
 790         pSmilMultipart = pMmsData->smil;
 791         if (pSmilMultipart) {
 792                 MmsPluginStorage::instance()->insertMultipart(pMsgInfo->msgId, pSmilMultipart);
 793         }
 794
 795         multipart_list = pMmsData->multipartlist;
 796
 797         for (int i = 0; i < (int)g_list_length(multipart_list); i++) {
 798                 MMS_MULTIPART_DATA_S *pMultipart = (MMS_MULTIPART_DATA_S *)g_list_nth_data(multipart_list, i);
 799                 MmsPluginStorage::instance()->insertMultipart(pMsgInfo->msgId, pMultipart);
 800         }
 801
 802         /* make Preview info for APP */
 803         appBase = new MmsPluginAppBase(pMmsData);
 804         appBase->makePreviewInfo(pMsgInfo->msgId, false, pRetrievedFilePath);
 805         appBase->getFirstPageTextFilePath(pMsgInfo->msgText, sizeof(pMsgInfo->msgText));
 806         delete appBase;
 807
 808         MsgMmsRelease(&pMmsData);
 809
 810         if (MsgGetFileSize(pRetrievedFilePath, (int *)&pMsgInfo->dataSize) == false) {
 811                 MSG_SEC_DEBUG("Fail to get mms file size [%s]", pRetrievedFilePath);
 812                 goto __CATCH;
 813         }
 814
 815 __CATCH: {
 816                 MmsMsg *pMsg = NULL;
 817                 pStorage->getMmsMessage(&pMsg);
 818                 MmsInitHeader();
 819                 MmsReleaseMsgDRMInfo(&pMsg->msgType.drmInfo);
 820                 MmsReleaseMsgBody(&pMsg->msgBody, pMsg->msgType.type);
 821                 g_free(filename); filename = NULL;
 822         }
 823         MSG_END();
 824 }
 825 #else /* NEW process RetrieveConf */
 826 void MmsPluginInternal::processRetrieveConf(MSG_MESSAGE_INFO_S *pMsgInfo, mmsTranQEntity *pRequest, char *pRetrievedFilePath)
 827 {
 828         MSG_BEGIN();
 829
 830         msg_error_t err = MSG_SUCCESS;
 831
 832         pMsgInfo->msgId = pRequest->msgId;
 833
 834         pMsgInfo->msgType.mainType = MSG_MMS_TYPE;
 835         if (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)
 836                 pMsgInfo->msgType.subType = MSG_RETRIEVE_AUTOCONF_MMS;
 837         else
 838                 pMsgInfo->msgType.subType = MSG_RETRIEVE_MANUALCONF_MMS;
 839
 840         strncpy(pMsgInfo->subject, mmsHeader.szSubject, MSG_LOCALE_SUBJ_LEN);
 841         strncpy(pRequest->transactionId, mmsHeader.szTrID, MMS_TR_ID_LEN);
 842
 843         time_t curTime;
 844         curTime = time(NULL);
 845
 846         pMsgInfo->displayTime = curTime;
 847
 848         if (mmsHeader.retrieveStatus == MMS_RETRSTATUS_OK) {
 849                 pMsgInfo->networkStatus = MSG_NETWORK_RETRIEVE_SUCCESS;
 850                 pMsgInfo->folderId = MSG_INBOX_ID;
 851         } else {
 852                 pMsgInfo->networkStatus = MSG_NETWORK_RETRIEVE_FAIL;
 853                 pMsgInfo->folderId = MSG_INBOX_ID;
 854                 /* If failed MMS Retrieve, then saved as MMS Noti Ind Message.
 855                  * It will changed in MsgHandleMmsConfIncomingMsg */
 856 /*              pMsgInfo->msgType.subType = MSG_NOTIFICATIONIND_MMS; */
 857         }
 858
 859         char *msisdn = NULL;
 860         if (MsgSettingGetString(MSG_SIM_MSISDN, &msisdn) != MSG_SUCCESS) {
 861                 MSG_INFO("MsgSettingGetString() is failed");
 862         }
 863
 864         if (mmsHeader.pFrom)
 865                 MmsAddrUtilRemovePlmnString(mmsHeader.pFrom->szAddr);
 866
 867         MSG_MMS_VLD_INFO("%d, MMS Receive %s End %s->%s %s", pMsgInfo->msgId
 868                                                                                                                 , (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)?"Auto":"Manual"
 869                                                                                                                 , (mmsHeader.pFrom)?mmsHeader.pFrom->szAddr:"YOU"
 870                                                                                                                 , (msisdn == NULL)?"ME":msisdn
 871                                                                                                                 , (pMsgInfo->networkStatus == MSG_NETWORK_RETRIEVE_SUCCESS)?"Success":"Fail");
 872
 873         if (msisdn) {
 874                 free(msisdn);
 875                 msisdn = NULL;
 876         }
 877
 878         pMsgInfo->dataSize = pRequest->getDataLen;
 879
 880         MmsMsg *pMmsMsg = NULL;
 881         MmsPluginStorage::instance()->getMmsMessage(&pMmsMsg);
 882
 883         MMS_DATA_S *pMmsData = MsgMmsCreate();
 884         pMmsData->header = MsgMmsCreateHeader();
 885
 886         if (MmsConvertMmsData(pMmsMsg, pMmsData) != true) {
 887                 MSG_DEBUG("Fail to Compose MMS Message");
 888                 goto __CATCH;
 889         }
 890
 891         char *pSerializedData = NULL;
 892
 893         MsgSerializeMms(pMmsData, &pSerializedData);
 894
 895         MsgMmsRelease(&pMmsData);
 896
 897
 898         char fileName[MSG_FILENAME_LEN_MAX] = {0};
 899         char fileFilePath[MSG_FILEPATH_LEN_MAX] = {0};
 900
 901         if (MsgCreateFileName(fileName) == false)
 902                 goto __CATCH;
 903
 904         snprintf(fileFilePath, sizeof(fileFilePath), "%s%s", MSG_DATA_PATH, fileName);
 905
 906         if (!MsgOpenCreateAndOverwriteFile(fileFilePath, (char *)pSerializedData, (int)strlen(pSerializedData))) {
 907                 goto __CATCH;
 908         }
 909
 910         snprintf(pMsgInfo->msgData, sizeof(pMsgInfo->msgData), "%s", fileFilePath);
 911
 912         if (MsgGetFileSize(pRetrievedFilePath, (int *)&pMsgInfo->dataSize) == false) {
 913                 MSG_SEC_DEBUG("Fail to get mms file size [%s]", pRetrievedFilePath);
 914                 goto __CATCH;
 915         }
 916
 917 __CATCH: {
 918                 MmsMsg *pMsg = NULL;
 919                 MmsPluginStorage::instance()->getMmsMessage(&pMsg);
 920                 MmsInitHeader();
 921                 MmsReleaseMsgDRMInfo(&pMsg->msgType.drmInfo);
 922                 MmsReleaseMsgBody(&pMsg->msgBody, pMsg->msgType.type);
 923         }
 924         MSG_END();
 925 }
 926 #endif
 927 void MmsPluginInternal::processForwardConf(MSG_MESSAGE_INFO_S *msgInfo, mmsTranQEntity *pRequest)
 928 {
 929 }
 930
 931 /* This function Send NotifyRespInd Msg
 932  *
 933  * @param       pTrID [in] Specifies Transaction ID
 934  * @param       iStatus [in] Specifies Msg Status
 935  * @param       iReportAllowed [in] Specifies whether to send deliveryReport to sender or not
 936  * @return      This function returns true on success, or false on failure.
 937  */
 938 bool MmsPluginInternal::encodeNotifyRespInd(char *szTrID, msg_delivery_report_status_t iStatus, bool bReportAllowed, char *pSendFilePath)
 939 {
 940         MSG_BEGIN();
 941
 942         FILE *pFile = NULL;
 943         char pTempFileName[MSG_FILENAME_LEN_MAX+1] = {0};
 944         char pTempFilePath[MAX_FULL_PATH_SIZE] = {0};
 945
 946         if (MsgCreateFileName(pTempFileName) == false)
 947                 return false;
 948
 949         snprintf(pTempFilePath, MAX_FULL_PATH_SIZE, "%s%s.noti.ind", MSG_DATA_PATH, pTempFileName);
 950
 951         pFile = MsgOpenMMSFile(pTempFilePath);
 952
 953         if (!pFile) {
 954                 MSG_DEBUG("[ERROR] MsgOpenMMSFile fail");
 955                 return false;
 956         }
 957
 958         if (MmsEncodeNotiRespInd(pFile, szTrID, iStatus, bReportAllowed) == false) {
 959                 MSG_DEBUG("MmsEncodeNotifyRespInd: MmsEncodeNotiRespInd fail");
 960                 MsgCloseFile(pFile);
 961                 return false;
 962         }
 963
 964         MsgCloseFile(pFile);
 965
 966         if (pSendFilePath) {
 967                 /* CID 41993: replaced size 'MAX_MSG_DATA_LEN+1' with MAX_FULL_PATH_SIZE */
 968                 snprintf(pSendFilePath, MAX_FULL_PATH_SIZE, "%s.mms", pTempFilePath);
 969         } else {
 970                 MSG_DEBUG("[ERROR] pSendFilePath is NULL");
 971                 return false;
 972         }
 973
 974         MSG_END();
 975
 976         return true;
 977 }
 978
 979 /* This function Send AcknowledgeInd Msg
 980  *
 981  * @param       pTrID [in] Specifies Transaction ID
 982  * @param       iReportAllowed [in] Specifies whether to send deliveryReport to sender or not
 983  * @return      This function returns true on success, or false on failure.
 984  */
 985 bool MmsPluginInternal::encodeAckInd(char *szTrID, bool bReportAllowed, char *pSendFilePath)
 986 {
 987         MSG_BEGIN();
 988         FILE *pFile = NULL;
 989         char pTempFileName[MSG_FILENAME_LEN_MAX+1] = {0};
 990         char pTempFilePath[MAX_FULL_PATH_SIZE] = {0};
 991
 992         if (MsgCreateFileName(pTempFileName) == false)
 993                 return false;
 994
 995         snprintf(pTempFilePath, MAX_FULL_PATH_SIZE, "%s%s.ack.ind", MSG_DATA_PATH, pTempFileName);
 996
 997         pFile = MsgOpenMMSFile(pTempFilePath);
 998         if (!pFile) {
 999                 MSG_ERR("MsgOpenMMSFile fail \n");
1000                 return false;
1001         }
1002
1003         if (MmsEncodeAckInd(pFile, szTrID, bReportAllowed) == false) {
1004                 MSG_ERR("MmsEncodeAckInd: MmsEncodeAckInd fail \n");
1005                 MsgCloseFile(pFile);
1006                 return false;
1007         }
1008
1009         MsgCloseFile(pFile);
1010
1011         if (pSendFilePath) {
1012                 snprintf(pSendFilePath, MAX_MSG_DATA_LEN+1, "%s.mms", pTempFilePath);
1013         } else {
1014                 MSG_ERR("pSendFilePath is NULL");
1015                 return false;
1016         }
1017
1018         MSG_END();
1019
1020         return true;
1021 }
1022
1023 bool MmsPluginInternal::checkRejectNotiInd(int roamState, bool bReportAllowed, char *pSendFilePath)
1024 {
1025         MSG_BEGIN();
1026         MSG_MMS_HOME_RETRIEVE_TYPE_T retrieveType;
1027         bool bRejectAnonymous;
1028         bool bRejectAdvertisement;
1029
1030         if (MsgSettingGetBool(MMS_RECV_REJECT_UNKNOWN, &bRejectAnonymous) != MSG_SUCCESS)
1031                 MSG_INFO("MsgSettingGetBool() is failed");
1032
1033         if (MsgSettingGetBool(MMS_RECV_REJECT_ADVERTISE, &bRejectAdvertisement) != MSG_SUCCESS)
1034                 MSG_INFO("MsgSettingGetBool() is failed");
1035
1036         /* Anonymous Reject */
1037         if (bRejectAnonymous &&
1038                 (mmsHeader.pFrom == NULL || mmsHeader.pFrom->szAddr[0] == '\0')) {
1039                 MSG_DEBUG("Anonymous Reject... ");
1040                 encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1041
1042                 return true;
1043         }
1044
1045         /* Advertisement Reject */
1046         if (bRejectAdvertisement && mmsHeader.msgClass == MMS_MSGCLASS_ADVERTISEMENT) {
1047                 MSG_DEBUG("Advertisement Reject... ");
1048                 encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1049
1050                 return true;
1051         }
1052
1053         /* Message Reject - Roaming Case */
1054         int tmpVal = 0;
1055         if (roamState == VCONFKEY_TELEPHONY_SVC_ROAM_ON) {
1056                 if (MsgSettingGetInt(MMS_RECV_ABROAD_NETWORK, &tmpVal) != MSG_SUCCESS) {
1057                         MSG_INFO("MsgSettingGetInt() is failed");
1058                 }
1059                 retrieveType = (MSG_MMS_HOME_RETRIEVE_TYPE_T)tmpVal;
1060                 if (retrieveType == MSG_ABROAD_REJECT) {
1061                         MSG_DEBUG("Abroad_Network : Notification Reject... ");
1062                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1063
1064                         return true;
1065                 }
1066         } else {
1067                 if (MsgSettingGetInt(MMS_RECV_HOME_NETWORK, &tmpVal) != MSG_SUCCESS) {
1068                         MSG_INFO("MsgSettingGetInt() is failed");
1069                 }
1070                 retrieveType = (MSG_MMS_HOME_RETRIEVE_TYPE_T)tmpVal;
1071                 if (retrieveType == MSG_HOME_REJECT) {
1072                         MSG_DEBUG("Home_Network : Notification Reject... ");
1073                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1074
1075                         return true;
1076                 }
1077         }
1078
1079         /* Duplicate MMS notification */
1080         int msgId = 0;
1081
1082         msgId = MmsPluginStorage::instance()->checkDuplicateNotification(mmsHeader.szTrID, mmsHeader.szContentLocation);
1083
1084         MSG_DEBUG("Msg Id = %d", msgId);
1085         if (msgId > 0)
1086                 return true;
1087
1088         /* Not Rejected */
1089         MSG_END();
1090         return false;
1091 }
1092
1093
1094 bool MmsPluginInternal::checkFilterMmsBody(MMS_DATA_S *pMmsData)
1095 {
1096         if (pMmsData == NULL)
1097                 return false;
1098
1099         bool bFiltered = false;
1100         MMS_PAGE_S *pPage = NULL;
1101         MMS_MEDIA_S *pMedia = NULL;
1102         char filePath[MSG_FILEPATH_LEN_MAX + 1];
1103         gchar *fileContent = NULL;
1104         MsgDbHandler *dbHandle = getDbHandle();
1105         MimeType mimeType = MIME_UNKNOWN;
1106
1107         MMS_MESSAGE_DATA_S *mmsMsg = NULL;
1108         unique_ptr<MMS_MESSAGE_DATA_S*, void(*)(MMS_MESSAGE_DATA_S**)> buf(&mmsMsg, unique_ptr_deleter);
1109         mmsMsg = (MMS_MESSAGE_DATA_S *)new char[sizeof(MMS_MESSAGE_DATA_S)];
1110         memset(mmsMsg, 0x00, sizeof(MMS_MESSAGE_DATA_S));
1111
1112         MsgMmsConvertMmsDataToMmsMessageData(pMmsData, mmsMsg);
1113
1114         /* Get the text data from the 1st slide. */
1115         if (mmsMsg->pageCnt <= 0) {
1116                 MSG_WARN("pageCnt : %d", mmsMsg->pageCnt);
1117                 MsgMmsReleaseMmsLists(mmsMsg);
1118                 return false;
1119         }
1120
1121         pPage = _MsgMmsGetPage(mmsMsg, 0);
1122
1123         if (!pPage) {
1124                 MSG_WARN("page is NULL");
1125                 MsgMmsReleaseMmsLists(mmsMsg);
1126                 return false;
1127         }
1128
1129         for (int j = 0; j < pPage->mediaCnt; ++j) {
1130                 pMedia = _MsgMmsGetMedia(pPage, j);
1131
1132                 if (pMedia && pMedia->mediatype == MMS_SMIL_MEDIA_TEXT) {
1133                         MsgGetMimeTypeFromFileName(MIME_MAINTYPE_UNKNOWN, pMedia->szFilePath, &mimeType, NULL);
1134
1135                         if (mimeType == MIME_TEXT_X_VCALENDAR || mimeType == MIME_TEXT_X_VCARD || mimeType == MIME_TEXT_X_VTODO || mimeType == MIME_TEXT_X_VNOTE) {
1136                                 MSG_SEC_DEBUG("Media Type is Text, but Vobject file [%s]", pMedia->szFilePath);
1137                         } else {
1138                                 strncpy(filePath, pMedia->szFilePath, MSG_FILEPATH_LEN_MAX);
1139
1140                                 g_file_get_contents((const gchar*)filePath, (gchar**)&fileContent, NULL, NULL);
1141
1142                                 bFiltered = MsgCheckFilterByWord(dbHandle, (const char *)fileContent);
1143
1144                                 g_free(fileContent);
1145                                 fileContent = NULL;
1146
1147                                 if (bFiltered == true)
1148                                         break;
1149                         }
1150                 }
1151         }
1152
1153         MsgMmsReleaseMmsLists(mmsMsg);
1154
1155         return bFiltered;
1156 }
1157
1158 bool MmsPluginInternal::getMmsReport(MmsReport mmsReport)
1159 {
1160         bool result = false;
1161
1162         if (mmsReport == MMS_REPORT_YES)
1163                 result = true;
1164         else if (mmsReport == MMS_REPORT_NO)
1165                 result = false;
1166
1167         return result;
1168 }
1169
1170 const char *MmsPluginInternal::getMmsDeliveryStatus(msg_delivery_report_status_t deliveryStatus)
1171 {
1172         MSG_DEBUG("msgStatus= %d", deliveryStatus);
1173
1174         switch (deliveryStatus) {
1175         case MSG_DELIVERY_REPORT_EXPIRED:
1176                 return "expired.";
1177         case MSG_DELIVERY_REPORT_REJECTED:
1178                 return "rejected.";
1179         case MSG_DELIVERY_REPORT_UNREACHABLE:
1180                 return "unreachable.";
1181         case MSG_DELIVERY_REPORT_UNRECOGNISED:
1182                 return "unrecognised.";
1183         case MSG_DELIVERY_REPORT_SUCCESS:
1184                 return "delivered.";
1185         default:
1186                 return "delivery failed.";
1187         }
1188 }
1189
1190 const char *MmsPluginInternal::getMmsReadStatus(msg_read_report_status_t readStatus)
1191 {
1192         switch (readStatus) {
1193         case MSG_READ_REPORT_IS_READ:
1194                 return "message is read.";
1195         case MSG_READ_REPORT_IS_DELETED:
1196                 return "message is deleted.";
1197         default:
1198                 return "read status is none.";
1199         }
1200 }
1201