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                 } else {
 656                         pMsgInfo->addressList[0].addressType = MSG_ADDRESS_TYPE_PLMN;
 657                 }
 658         }
 659
 660         if (is_group_on) {
 661                 int addr_idx = 0;
 662                 if (mmsHeader.pTo) {
 663                         MsgHeaderAddress *iter = mmsHeader.pTo;
 664                         while (iter) {
 665                                 addr_idx++;
 666                                 MSG_DEBUG("TO : [%s]", mmsHeader.pTo->szAddr);
 667                                 MmsAddrUtilRemovePlmnString(iter->szAddr);
 668                                 /* To */
 669                                 if (normal_msisdn == NULL || !g_str_has_suffix(iter->szAddr, normal_msisdn)) {
 670                                         strncpy(pMsgInfo->addressList[addr_idx].addressVal, iter->szAddr, MAX_ADDRESS_VAL_LEN);
 671                                         pMsgInfo->addressList[addr_idx].recipientType = MSG_RECIPIENTS_TYPE_TO;
 672                                         if (MmsAddrUtilCheckEmailAddress(pMsgInfo->addressList[addr_idx].addressVal)) {
 673                                                 pMsgInfo->addressList[addr_idx].addressType = MSG_ADDRESS_TYPE_EMAIL;
 674                                         } else {
 675                                                 pMsgInfo->addressList[addr_idx].addressType = MSG_ADDRESS_TYPE_PLMN;
 676                                         }
 677                                 } else {
 678                                         addr_idx--;
 679                                 }
 680
 681                                 iter = iter->pNext;
 682                         }
 683                 }
 684
 685                 if (mmsHeader.pCc) {
 686                         MsgHeaderAddress *iter = mmsHeader.pCc;
 687                         while (iter) {
 688                                 addr_idx++;
 689                                 MSG_DEBUG("CC : [%s]", mmsHeader.pCc->szAddr);
 690                                 MmsAddrUtilRemovePlmnString(iter->szAddr);
 691                                 /* Cc */
 692                                 if (normal_msisdn == NULL || !g_str_has_suffix(iter->szAddr, normal_msisdn)) {
 693                                         strncpy(pMsgInfo->addressList[addr_idx].addressVal, iter->szAddr, MAX_ADDRESS_VAL_LEN);
 694                                         pMsgInfo->addressList[addr_idx].recipientType = MSG_RECIPIENTS_TYPE_CC;
 695                                         if (MmsAddrUtilCheckEmailAddress(pMsgInfo->addressList[addr_idx].addressVal)) {
 696                                                 pMsgInfo->addressList[addr_idx].addressType = MSG_ADDRESS_TYPE_EMAIL;
 697                                         } else {
 698                                                 pMsgInfo->addressList[addr_idx].addressType = MSG_ADDRESS_TYPE_PLMN;
 699                                         }
 700                                 } else {
 701                                         addr_idx--;
 702                                 }
 703
 704                                 iter = iter->pNext;
 705                         }
 706                 }
 707         }
 708
 709         MSG_SEC_DEBUG("%d, MMS Receive %s End %s->%s %s", pMsgInfo->msgId
 710                                                                                                                 , (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)?"Auto":"Manual"
 711                                                                                                                 , (mmsHeader.pFrom)?mmsHeader.pFrom->szAddr:"YOU"
 712                                                                                                                 , (msisdn == NULL)?"ME":msisdn
 713                                                                                                                 , (pMsgInfo->networkStatus == MSG_NETWORK_RETRIEVE_SUCCESS)?"Success":"Fail");
 714
 715         if (msisdn) {
 716                 free(msisdn);
 717                 msisdn = NULL;
 718         }
 719
 720         pMsgInfo->dataSize = pRequest->getDataLen;
 721
 722         /* set message-id & MMS TPDU file path */
 723         snprintf(recvData.szMsgID, sizeof(recvData.szMsgID), "%s", mmsHeader.szMsgID);
 724
 725         if (pRetrievedFilePath)
 726                 strncpy(recvData.retrievedFilePath, pRetrievedFilePath, sizeof(recvData.retrievedFilePath)-1);
 727
 728         char *filename = NULL;
 729
 730 #ifdef FEATURE_JAVA_MMS
 731         if (mmsHeader.msgType.param.szApplicationID || mmsHeader.msgType.param.szReplyToApplicationID) {
 732                 recvData.msgAppId.valid = true;
 733                 if (mmsHeader.msgType.param.szApplicationID)
 734                         strncpy(recvData.msgAppId.appId, mmsHeader.msgType.param.szApplicationID, sizeof(recvData.msgAppId.appId));
 735                 if (mmsHeader.msgType.param.szReplyToApplicationID)
 736                         strncpy(recvData.msgAppId.replyToAppId, mmsHeader.msgType.param.szReplyToApplicationID, sizeof(recvData.msgAppId.replyToAppId));
 737
 738                 char fullPath[MAX_FULL_PATH_SIZE+1] = {0, };
 739
 740                 filename = MsgGetFileName(pRetrievedFilePath);
 741
 742                 snprintf(fullPath, MAX_FULL_PATH_SIZE+1, "%s%s", MSG_IPC_DATA_PATH, filename);
 743
 744                 if (pRetrievedFilePath) {
 745                         int ret  = rename(pRetrievedFilePath, fullPath);
 746                         if (ret != 0) {
 747                                 MSG_DEBUG("File rename Error: %s", g_strerror(errno));
 748                         }
 749                 }
 750         }
 751 #endif
 752         memcpy(pMsgInfo->msgData, &recvData, sizeof(MMS_RECV_DATA_S));
 753
 754         MSG_SEC_DEBUG("@@@@@ MsgData = %s @@@@@", pMsgInfo->msgData);
 755         MSG_SEC_DEBUG("@@@@@ retrievedFilePath = %s @@@@@", recvData.retrievedFilePath);
 756         MSG_DEBUG("@@@@@ szMsgID = %s @@@@@", recvData.szMsgID);
 757         /* update delivery report, read reply */
 758
 759         MmsPluginStorage *pStorage = MmsPluginStorage::instance();
 760
 761         err = pStorage->updateMmsAttrib(pMsgInfo->msgId, &attrib, pMsgInfo->msgType.subType);
 762
 763         MSG_DEBUG("Error value of updateMmsAttrib [%d]", err);
 764
 765         /* make MmsData & insert multipart */
 766         MMSList *multipart_list = NULL;
 767         MMS_MULTIPART_DATA_S *pSmilMultipart = NULL;
 768
 769         MmsMsg *pMmsMsg = NULL;
 770         MmsPluginStorage::instance()->getMmsMessage(&pMmsMsg);
 771
 772         bool bFiltered;
 773         MmsPluginAppBase *appBase;
 774
 775         MMS_DATA_S *pMmsData = MsgMmsCreate();
 776         if (pMmsData == NULL) {
 777                 MSG_SEC_DEBUG("Fail to create mms");
 778                 goto __CATCH;
 779         }
 780
 781         pMmsData->header = MsgMmsCreateHeader();
 782
 783         MmsConvertMmsData(pMmsMsg, pMmsData);
 784         /* CID 41996 : MmsConvertMmsData always returns true */
 785         /*
 786         if (MmsConvertMmsData(pMmsMsg, pMmsData) != true) {
 787                 MSG_DEBUG("Fail to Compose MMS Message");
 788                 goto __CATCH;
 789         } */
 790
 791         bFiltered = checkFilterMmsBody(pMmsData);
 792         if (bFiltered == true) {
 793                 pMsgInfo->folderId = MSG_SPAMBOX_ID;
 794         }
 795
 796         pSmilMultipart = pMmsData->smil;
 797         if (pSmilMultipart) {
 798                 MmsPluginStorage::instance()->insertMultipart(pMsgInfo->msgId, pSmilMultipart);
 799         }
 800
 801         multipart_list = pMmsData->multipartlist;
 802
 803         for (int i = 0; i < (int)g_list_length(multipart_list); i++) {
 804                 MMS_MULTIPART_DATA_S *pMultipart = (MMS_MULTIPART_DATA_S *)g_list_nth_data(multipart_list, i);
 805                 MmsPluginStorage::instance()->insertMultipart(pMsgInfo->msgId, pMultipart);
 806         }
 807
 808         /* make Preview info for APP */
 809         appBase = new MmsPluginAppBase(pMmsData);
 810         appBase->makePreviewInfo(pMsgInfo->msgId, false, pRetrievedFilePath);
 811         appBase->getFirstPageTextFilePath(pMsgInfo->msgText, sizeof(pMsgInfo->msgText));
 812         delete appBase;
 813
 814         MsgMmsRelease(&pMmsData);
 815
 816         if (MsgGetFileSize(pRetrievedFilePath, (int *)&pMsgInfo->dataSize) == false) {
 817                 MSG_SEC_DEBUG("Fail to get mms file size [%s]", pRetrievedFilePath);
 818                 goto __CATCH;
 819         }
 820
 821 __CATCH: {
 822                 MmsMsg *pMsg = NULL;
 823                 pStorage->getMmsMessage(&pMsg);
 824                 MmsInitHeader();
 825                 MmsReleaseMsgDRMInfo(&pMsg->msgType.drmInfo);
 826                 MmsReleaseMsgBody(&pMsg->msgBody, pMsg->msgType.type);
 827                 g_free(filename); filename = NULL;
 828         }
 829         MSG_END();
 830 }
 831 #else /* NEW process RetrieveConf */
 832 void MmsPluginInternal::processRetrieveConf(MSG_MESSAGE_INFO_S *pMsgInfo, mmsTranQEntity *pRequest, char *pRetrievedFilePath)
 833 {
 834         MSG_BEGIN();
 835
 836         msg_error_t err = MSG_SUCCESS;
 837
 838         pMsgInfo->msgId = pRequest->msgId;
 839
 840         pMsgInfo->msgType.mainType = MSG_MMS_TYPE;
 841         if (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)
 842                 pMsgInfo->msgType.subType = MSG_RETRIEVE_AUTOCONF_MMS;
 843         else
 844                 pMsgInfo->msgType.subType = MSG_RETRIEVE_MANUALCONF_MMS;
 845
 846         strncpy(pMsgInfo->subject, mmsHeader.szSubject, MSG_LOCALE_SUBJ_LEN);
 847         strncpy(pRequest->transactionId, mmsHeader.szTrID, MMS_TR_ID_LEN);
 848
 849         time_t curTime;
 850         curTime = time(NULL);
 851
 852         pMsgInfo->displayTime = curTime;
 853
 854         if (mmsHeader.retrieveStatus == MMS_RETRSTATUS_OK) {
 855                 pMsgInfo->networkStatus = MSG_NETWORK_RETRIEVE_SUCCESS;
 856                 pMsgInfo->folderId = MSG_INBOX_ID;
 857         } else {
 858                 pMsgInfo->networkStatus = MSG_NETWORK_RETRIEVE_FAIL;
 859                 pMsgInfo->folderId = MSG_INBOX_ID;
 860                 /* If failed MMS Retrieve, then saved as MMS Noti Ind Message.
 861                  * It will changed in MsgHandleMmsConfIncomingMsg */
 862 /*              pMsgInfo->msgType.subType = MSG_NOTIFICATIONIND_MMS; */
 863         }
 864
 865         char *msisdn = NULL;
 866         if (MsgSettingGetString(MSG_SIM_MSISDN, &msisdn) != MSG_SUCCESS) {
 867                 MSG_INFO("MsgSettingGetString() is failed");
 868         }
 869
 870         if (mmsHeader.pFrom)
 871                 MmsAddrUtilRemovePlmnString(mmsHeader.pFrom->szAddr);
 872
 873         MSG_MMS_VLD_INFO("%d, MMS Receive %s End %s->%s %s", pMsgInfo->msgId
 874                                                                                                                 , (pRequest->eMmsPduType == eMMS_RETRIEVE_AUTO_CONF)?"Auto":"Manual"
 875                                                                                                                 , (mmsHeader.pFrom)?mmsHeader.pFrom->szAddr:"YOU"
 876                                                                                                                 , (msisdn == NULL)?"ME":msisdn
 877                                                                                                                 , (pMsgInfo->networkStatus == MSG_NETWORK_RETRIEVE_SUCCESS)?"Success":"Fail");
 878
 879         if (msisdn) {
 880                 free(msisdn);
 881                 msisdn = NULL;
 882         }
 883
 884         pMsgInfo->dataSize = pRequest->getDataLen;
 885
 886         MmsMsg *pMmsMsg = NULL;
 887         MmsPluginStorage::instance()->getMmsMessage(&pMmsMsg);
 888
 889         MMS_DATA_S *pMmsData = MsgMmsCreate();
 890         pMmsData->header = MsgMmsCreateHeader();
 891
 892         if (MmsConvertMmsData(pMmsMsg, pMmsData) != true) {
 893                 MSG_DEBUG("Fail to Compose MMS Message");
 894                 goto __CATCH;
 895         }
 896
 897         char *pSerializedData = NULL;
 898
 899         MsgSerializeMms(pMmsData, &pSerializedData);
 900
 901         MsgMmsRelease(&pMmsData);
 902
 903
 904         char fileName[MSG_FILENAME_LEN_MAX] = {0};
 905         char fileFilePath[MSG_FILEPATH_LEN_MAX] = {0};
 906
 907         if (MsgCreateFileName(fileName) == false)
 908                 goto __CATCH;
 909
 910         snprintf(fileFilePath, sizeof(fileFilePath), "%s%s", MSG_DATA_PATH, fileName);
 911
 912         if (!MsgOpenCreateAndOverwriteFile(fileFilePath, (char *)pSerializedData, (int)strlen(pSerializedData))) {
 913                 goto __CATCH;
 914         }
 915
 916         snprintf(pMsgInfo->msgData, sizeof(pMsgInfo->msgData), "%s", fileFilePath);
 917
 918         if (MsgGetFileSize(pRetrievedFilePath, (int *)&pMsgInfo->dataSize) == false) {
 919                 MSG_SEC_DEBUG("Fail to get mms file size [%s]", pRetrievedFilePath);
 920                 goto __CATCH;
 921         }
 922
 923 __CATCH: {
 924                 MmsMsg *pMsg = NULL;
 925                 MmsPluginStorage::instance()->getMmsMessage(&pMsg);
 926                 MmsInitHeader();
 927                 MmsReleaseMsgDRMInfo(&pMsg->msgType.drmInfo);
 928                 MmsReleaseMsgBody(&pMsg->msgBody, pMsg->msgType.type);
 929         }
 930         MSG_END();
 931 }
 932 #endif
 933 void MmsPluginInternal::processForwardConf(MSG_MESSAGE_INFO_S *msgInfo, mmsTranQEntity *pRequest)
 934 {
 935 }
 936
 937 /* This function Send NotifyRespInd Msg
 938  *
 939  * @param       pTrID [in] Specifies Transaction ID
 940  * @param       iStatus [in] Specifies Msg Status
 941  * @param       iReportAllowed [in] Specifies whether to send deliveryReport to sender or not
 942  * @return      This function returns true on success, or false on failure.
 943  */
 944 bool MmsPluginInternal::encodeNotifyRespInd(char *szTrID, msg_delivery_report_status_t iStatus, bool bReportAllowed, char *pSendFilePath)
 945 {
 946         MSG_BEGIN();
 947
 948         FILE *pFile = NULL;
 949         char pTempFileName[MSG_FILENAME_LEN_MAX+1] = {0};
 950         char pTempFilePath[MAX_FULL_PATH_SIZE] = {0};
 951
 952         if (MsgCreateFileName(pTempFileName) == false)
 953                 return false;
 954
 955         snprintf(pTempFilePath, MAX_FULL_PATH_SIZE, "%s%s.noti.ind", MSG_DATA_PATH, pTempFileName);
 956
 957         pFile = MsgOpenMMSFile(pTempFilePath);
 958
 959         if (!pFile) {
 960                 MSG_DEBUG("[ERROR] MsgOpenMMSFile fail");
 961                 return false;
 962         }
 963
 964         if (MmsEncodeNotiRespInd(pFile, szTrID, iStatus, bReportAllowed) == false) {
 965                 MSG_DEBUG("MmsEncodeNotifyRespInd: MmsEncodeNotiRespInd fail");
 966                 MsgCloseFile(pFile);
 967                 return false;
 968         }
 969
 970         MsgCloseFile(pFile);
 971
 972         if (pSendFilePath) {
 973                 /* CID 41993: replaced size 'MAX_MSG_DATA_LEN+1' with MAX_FULL_PATH_SIZE */
 974                 snprintf(pSendFilePath, MAX_FULL_PATH_SIZE, "%s.mms", pTempFilePath);
 975         } else {
 976                 MSG_DEBUG("[ERROR] pSendFilePath is NULL");
 977                 return false;
 978         }
 979
 980         MSG_END();
 981
 982         return true;
 983 }
 984
 985 /* This function Send AcknowledgeInd Msg
 986  *
 987  * @param       pTrID [in] Specifies Transaction ID
 988  * @param       iReportAllowed [in] Specifies whether to send deliveryReport to sender or not
 989  * @return      This function returns true on success, or false on failure.
 990  */
 991 bool MmsPluginInternal::encodeAckInd(char *szTrID, bool bReportAllowed, char *pSendFilePath)
 992 {
 993         MSG_BEGIN();
 994         FILE *pFile = NULL;
 995         char pTempFileName[MSG_FILENAME_LEN_MAX+1] = {0};
 996         char pTempFilePath[MAX_FULL_PATH_SIZE] = {0};
 997
 998         if (MsgCreateFileName(pTempFileName) == false)
 999                 return false;
1000
1001         snprintf(pTempFilePath, MAX_FULL_PATH_SIZE, "%s%s.ack.ind", MSG_DATA_PATH, pTempFileName);
1002
1003         pFile = MsgOpenMMSFile(pTempFilePath);
1004         if (!pFile) {
1005                 MSG_ERR("MsgOpenMMSFile fail \n");
1006                 return false;
1007         }
1008
1009         if (MmsEncodeAckInd(pFile, szTrID, bReportAllowed) == false) {
1010                 MSG_ERR("MmsEncodeAckInd: MmsEncodeAckInd fail \n");
1011                 MsgCloseFile(pFile);
1012                 return false;
1013         }
1014
1015         MsgCloseFile(pFile);
1016
1017         if (pSendFilePath) {
1018                 snprintf(pSendFilePath, MAX_MSG_DATA_LEN+1, "%s.mms", pTempFilePath);
1019         } else {
1020                 MSG_ERR("pSendFilePath is NULL");
1021                 return false;
1022         }
1023
1024         MSG_END();
1025
1026         return true;
1027 }
1028
1029 bool MmsPluginInternal::checkRejectNotiInd(int roamState, bool bReportAllowed, char *pSendFilePath)
1030 {
1031         MSG_BEGIN();
1032         MSG_MMS_HOME_RETRIEVE_TYPE_T retrieveType;
1033         bool bRejectAnonymous;
1034         bool bRejectAdvertisement;
1035
1036         if (MsgSettingGetBool(MMS_RECV_REJECT_UNKNOWN, &bRejectAnonymous) != MSG_SUCCESS)
1037                 MSG_INFO("MsgSettingGetBool() is failed");
1038
1039         if (MsgSettingGetBool(MMS_RECV_REJECT_ADVERTISE, &bRejectAdvertisement) != MSG_SUCCESS)
1040                 MSG_INFO("MsgSettingGetBool() is failed");
1041
1042         /* Anonymous Reject */
1043         if (bRejectAnonymous &&
1044                 (mmsHeader.pFrom == NULL || mmsHeader.pFrom->szAddr[0] == '\0')) {
1045                 MSG_DEBUG("Anonymous Reject... ");
1046                 encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1047
1048                 return true;
1049         }
1050
1051         /* Advertisement Reject */
1052         if (bRejectAdvertisement && mmsHeader.msgClass == MMS_MSGCLASS_ADVERTISEMENT) {
1053                 MSG_DEBUG("Advertisement Reject... ");
1054                 encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1055
1056                 return true;
1057         }
1058
1059         /* Message Reject - Roaming Case */
1060         int tmpVal = 0;
1061         if (roamState == VCONFKEY_TELEPHONY_SVC_ROAM_ON) {
1062                 if (MsgSettingGetInt(MMS_RECV_ABROAD_NETWORK, &tmpVal) != MSG_SUCCESS) {
1063                         MSG_INFO("MsgSettingGetInt() is failed");
1064                 }
1065                 retrieveType = (MSG_MMS_HOME_RETRIEVE_TYPE_T)tmpVal;
1066                 if (retrieveType == MSG_ABROAD_REJECT) {
1067                         MSG_DEBUG("Abroad_Network : Notification Reject... ");
1068                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1069
1070                         return true;
1071                 }
1072         } else {
1073                 if (MsgSettingGetInt(MMS_RECV_HOME_NETWORK, &tmpVal) != MSG_SUCCESS) {
1074                         MSG_INFO("MsgSettingGetInt() is failed");
1075                 }
1076                 retrieveType = (MSG_MMS_HOME_RETRIEVE_TYPE_T)tmpVal;
1077                 if (retrieveType == MSG_HOME_REJECT) {
1078                         MSG_DEBUG("Home_Network : Notification Reject... ");
1079                         encodeNotifyRespInd(mmsHeader.szTrID, MSG_DELIVERY_REPORT_REJECTED, bReportAllowed, pSendFilePath);
1080
1081                         return true;
1082                 }
1083         }
1084
1085         /* Duplicate MMS notification */
1086         int msgId = 0;
1087
1088         msgId = MmsPluginStorage::instance()->checkDuplicateNotification(mmsHeader.szTrID, mmsHeader.szContentLocation);
1089
1090         MSG_DEBUG("Msg Id = %d", msgId);
1091         if (msgId > 0)
1092                 return true;
1093
1094         /* Not Rejected */
1095         MSG_END();
1096         return false;
1097 }
1098
1099
1100 bool MmsPluginInternal::checkFilterMmsBody(MMS_DATA_S *pMmsData)
1101 {
1102         if (pMmsData == NULL)
1103                 return false;
1104
1105         bool bFiltered = false;
1106         MMS_PAGE_S *pPage = NULL;
1107         MMS_MEDIA_S *pMedia = NULL;
1108         char filePath[MSG_FILEPATH_LEN_MAX + 1];
1109         gchar *fileContent = NULL;
1110         MsgDbHandler *dbHandle = getDbHandle();
1111         MimeType mimeType = MIME_UNKNOWN;
1112
1113         MMS_MESSAGE_DATA_S *mmsMsg = NULL;
1114         unique_ptr<MMS_MESSAGE_DATA_S*, void(*)(MMS_MESSAGE_DATA_S**)> buf(&mmsMsg, unique_ptr_deleter);
1115         mmsMsg = (MMS_MESSAGE_DATA_S *)new char[sizeof(MMS_MESSAGE_DATA_S)];
1116         memset(mmsMsg, 0x00, sizeof(MMS_MESSAGE_DATA_S));
1117
1118         MsgMmsConvertMmsDataToMmsMessageData(pMmsData, mmsMsg);
1119
1120         /* Get the text data from the 1st slide. */
1121         if (mmsMsg->pageCnt <= 0) {
1122                 MSG_WARN("pageCnt : %d", mmsMsg->pageCnt);
1123                 MsgMmsReleaseMmsLists(mmsMsg);
1124                 return false;
1125         }
1126
1127         pPage = _MsgMmsGetPage(mmsMsg, 0);
1128
1129         if (!pPage) {
1130                 MSG_WARN("page is NULL");
1131                 MsgMmsReleaseMmsLists(mmsMsg);
1132                 return false;
1133         }
1134
1135         for (int j = 0; j < pPage->mediaCnt; ++j) {
1136                 pMedia = _MsgMmsGetMedia(pPage, j);
1137
1138                 if (pMedia && pMedia->mediatype == MMS_SMIL_MEDIA_TEXT) {
1139                         MsgGetMimeTypeFromFileName(MIME_MAINTYPE_UNKNOWN, pMedia->szFilePath, &mimeType, NULL);
1140
1141                         if (mimeType == MIME_TEXT_X_VCALENDAR || mimeType == MIME_TEXT_X_VCARD || mimeType == MIME_TEXT_X_VTODO || mimeType == MIME_TEXT_X_VNOTE) {
1142                                 MSG_SEC_DEBUG("Media Type is Text, but Vobject file [%s]", pMedia->szFilePath);
1143                         } else {
1144                                 strncpy(filePath, pMedia->szFilePath, MSG_FILEPATH_LEN_MAX);
1145
1146                                 g_file_get_contents((const gchar*)filePath, (gchar**)&fileContent, NULL, NULL);
1147
1148                                 bFiltered = MsgCheckFilterByWord(dbHandle, (const char *)fileContent);
1149
1150                                 g_free(fileContent);
1151                                 fileContent = NULL;
1152
1153                                 if (bFiltered == true)
1154                                         break;
1155                         }
1156                 }
1157         }
1158
1159         MsgMmsReleaseMmsLists(mmsMsg);
1160
1161         return bFiltered;
1162 }
1163
1164 bool MmsPluginInternal::getMmsReport(MmsReport mmsReport)
1165 {
1166         bool result = false;
1167
1168         if (mmsReport == MMS_REPORT_YES)
1169                 result = true;
1170         else if (mmsReport == MMS_REPORT_NO)
1171                 result = false;
1172
1173         return result;
1174 }
1175
1176 const char *MmsPluginInternal::getMmsDeliveryStatus(msg_delivery_report_status_t deliveryStatus)
1177 {
1178         MSG_DEBUG("msgStatus= %d", deliveryStatus);
1179
1180         switch (deliveryStatus) {
1181         case MSG_DELIVERY_REPORT_EXPIRED:
1182                 return "expired.";
1183         case MSG_DELIVERY_REPORT_REJECTED:
1184                 return "rejected.";
1185         case MSG_DELIVERY_REPORT_UNREACHABLE:
1186                 return "unreachable.";
1187         case MSG_DELIVERY_REPORT_UNRECOGNISED:
1188                 return "unrecognised.";
1189         case MSG_DELIVERY_REPORT_SUCCESS:
1190                 return "delivered.";
1191         default:
1192                 return "delivery failed.";
1193         }
1194 }
1195
1196 const char *MmsPluginInternal::getMmsReadStatus(msg_read_report_status_t readStatus)
1197 {
1198         switch (readStatus) {
1199         case MSG_READ_REPORT_IS_READ:
1200                 return "message is read.";
1201         case MSG_READ_REPORT_IS_DELETED:
1202                 return "message is deleted.";
1203         default:
1204                 return "read status is none.";
1205         }
1206 }
1207