plugin/mms_plugin/MmsPluginUserAgent.cpp

   1 /*
   2 * Copyright 2012  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 *    http://www.tizenopensource.org/license
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17 #include <glib.h>
  18 #include <curl/curl.h>
  19 #include "MmsPluginUserAgent.h"
  20 #include "MmsPluginEventHandler.h"
  21 #include "MsgGconfWrapper.h"
  22 #include "MmsPluginInternal.h"
  23 #include "MsgUtilFile.h"
  24 #include "MmsPluginCodec.h"
  25 #include "MsgException.h"
  26 #include "MmsPluginDrm.h"
  27 #include "MmsPluginStorage.h"
  28
  29
  30 extern MmsHeader mmsHeader;
  31
  32 void PRINT_PDU_TYPE(MMS_PDU_TYPE_T pduType)
  33 {
  34         switch (pduType) {
  35         case eMMS_SEND_REQ:
  36                 MSG_DEBUG("[SEND_REQ]");
  37                 break;
  38         case eMMS_SEND_CONF:
  39                 MSG_DEBUG("[MMS_SEND_CONF]");
  40                 break;
  41         case eMMS_RETRIEVE_AUTO:
  42                 MSG_DEBUG("[MMS_RETRIEVE_AUTO]");
  43                 break;
  44         case eMMS_RETRIEVE_MANUAL:
  45                 MSG_DEBUG("[MMS_RETRIEVE_MANUAL]");
  46                 break;
  47         case eMMS_RETRIEVE_AUTO_CONF:
  48                 MSG_DEBUG("[MMS_RETRIEVE_AUTO_CONF]");
  49                 break;
  50         case eMMS_RETRIEVE_MANUAL_CONF:
  51                 MSG_DEBUG("[MMS_RETRIEVE_MANUAL_CONF]");
  52                 break;
  53         case eMMS_DELIVERY_IND:
  54                 MSG_DEBUG("[MMS_DELIVERY_IND]");
  55                 break;
  56         case eMMS_NOTIFICATION_IND:
  57                 MSG_DEBUG("[MMS_NOTIFICATION_IND]");
  58                 break;
  59         case eMMS_NOTIFYRESP_IND:
  60                 MSG_DEBUG("[MMS_NOTIFYRESP_IND]");
  61                 break;
  62         case eMMS_ACKNOWLEDGE_IND:
  63                 MSG_DEBUG("[MMS_ACKNOWLEDGE_IND]");
  64                 break;
  65         case eMMS_FORWARD_REQ:
  66                 MSG_DEBUG("[MMS_FORWARD_REQ]");
  67                 break;
  68         case eMMS_FORWARD_CONF:
  69                 MSG_DEBUG("[MMS_FORWARD_CONF]");
  70                 break;
  71         case eMMS_CANCEL_REQ:
  72                 MSG_DEBUG("[MMS_CANCEL_REQ]");
  73                 break;
  74         case eMMS_CANCEL_CONF:
  75                 MSG_DEBUG("[MMS_CANCEL_CONF]");
  76                 break;
  77         case eMMS_DELETE_REQ:
  78                 MSG_DEBUG("[MMS_DELETE_REQ]");
  79                 break;
  80         case eMMS_DELETE_CONF:
  81                 MSG_DEBUG("[MMS_DELETE_CONF]");
  82                 break;
  83         case eMMS_READREC_IND:
  84                 MSG_DEBUG("[MMS_READREC_IND]");
  85                 break;
  86         case eMMS_READORIG_IND:
  87                 MSG_DEBUG("[MMS_READORIG_IND]");
  88                 break;
  89         case eMMS_MBOX_STORE_REQ:
  90                 MSG_DEBUG("[MMS_MBOX_STORE_REQ]");
  91                 break;
  92         case eMMS_MBOX_STORE_CONF:
  93                 MSG_DEBUG("[MMS_MBOX_STORE_CONF]");
  94                 break;
  95         case eMMS_MBOX_VIEW_REQ:
  96                 MSG_DEBUG("[MMS_MBOX_VIEW_REQ]");
  97                 break;
  98         case eMMS_MBOX_VIEW_CONF:
  99                 MSG_DEBUG("[MMS_MBOX_VIEW_CONF]");
 100                 break;
 101         case eMMS_MBOX_UPLOAD_REQ:
 102                 MSG_DEBUG("[MMS_MBOX_UPLOAD_REQ]");
 103                 break;
 104         case eMMS_MBOX_UPLOAD_CONF:
 105                 MSG_DEBUG("[MMS_MBOX_UPLOAD_CONF]");
 106                 break;
 107         case eMMS_MBOX_DELETE_REQ:
 108                 MSG_DEBUG("[MMS_MBOX_DELETE_REQ]");
 109                 break;
 110         case eMMS_MBOX_DELETE_CONF:
 111                 MSG_DEBUG("[MMS_MBOX_DELETE_CONF]");
 112                 break;
 113         default:
 114                 MSG_DEBUG("[Unknown PDU Type]");
 115                 break;
 116         }
 117 }
 118
 119
 120 void PRINT_QUEUE_ENTITY(mmsTranQEntity *entity)
 121 {
 122         MSG_DEBUG("Entity: msgId: %d", entity->msgId);
 123         MSG_DEBUG("Entity: completed: %d", entity->isCompleted);
 124         MSG_DEBUG("Entity: eMmsPduType: %d", entity->eMmsPduType);
 125         MSG_DEBUG("Entity: eHttpCmdType: %d", entity->eHttpCmdType);
 126         MSG_DEBUG("Entity: GetLen: %d", entity->getDataLen);
 127         MSG_DEBUG("Entity: GetData: (%s)", entity->pGetData);
 128         MSG_DEBUG("Entity: postLen: %d", entity->postDataLen);
 129         MSG_DEBUG("Entity: pPostData: (%s)", entity->pPostData);
 130 }
 131
 132 void updatePduType(mmsTranQEntity *qEntity)
 133 {
 134         switch(qEntity->eMmsPduType) {
 135         case eMMS_SEND_REQ:
 136                 qEntity->eMmsPduType = eMMS_SEND_CONF;
 137                 break;
 138         case eMMS_RETRIEVE_AUTO:
 139                 qEntity->eMmsPduType = eMMS_RETRIEVE_AUTO_CONF;
 140                 break;
 141         case eMMS_RETRIEVE_MANUAL:
 142                 qEntity->eMmsPduType = eMMS_RETRIEVE_MANUAL_CONF;
 143                 break;
 144         case eMMS_RETRIEVE_AUTO_CONF:
 145                 qEntity->eMmsPduType = eMMS_NOTIFYRESP_IND;
 146                 break;
 147         case eMMS_READREC_IND:
 148                 qEntity->eMmsPduType = eMMS_SEND_CONF;
 149                 break;
 150         case eMMS_READREPORT_REQ:
 151                 qEntity->eMmsPduType = eMMS_READREPORT_CONF;
 152                 break;
 153         case eMMS_RETRIEVE_MANUAL_CONF:
 154                 qEntity->eMmsPduType = eMMS_ACKNOWLEDGE_IND;
 155                 break;
 156         case eMMS_DELETE_REQ:
 157                 qEntity->eMmsPduType = eMMS_DELETE_CONF;
 158                 break;
 159         case eMMS_FORWARD_REQ:
 160                 qEntity->eMmsPduType = eMMS_FORWARD_CONF;
 161                 break;
 162         case eMMS_MBOX_STORE_REQ:
 163                 qEntity->eMmsPduType = eMMS_MBOX_STORE_CONF;
 164                 break;
 165         case eMMS_MBOX_VIEW_REQ:
 166                 qEntity->eMmsPduType = eMMS_MBOX_VIEW_CONF;
 167                 break;
 168         case eMMS_MBOX_UPLOAD_REQ:
 169                 qEntity->eMmsPduType = eMMS_MBOX_UPLOAD_CONF;
 170                 break;
 171         case eMMS_MBOX_DELETE_REQ:
 172                 qEntity->eMmsPduType = eMMS_MBOX_DELETE_CONF;
 173                 break;
 174         default:
 175                 break;
 176         }
 177
 178         MSG_DEBUG("Update PDU Type:");
 179         PRINT_PDU_TYPE(qEntity->eMmsPduType);
 180 }
 181
 182 MmsPluginUaManager *MmsPluginUaManager::pInstance = NULL;
 183
 184 MmsPluginUaManager::MmsPluginUaManager()
 185 {
 186         running = false;
 187         mmsTranQ.clear();
 188 }
 189
 190 MmsPluginUaManager::~MmsPluginUaManager()
 191 {
 192         if (pInstance) {
 193                 delete pInstance;
 194                 pInstance = NULL;
 195         }
 196 }
 197
 198 MmsPluginUaManager *MmsPluginUaManager::instance()
 199 {
 200         if (!pInstance)
 201                 pInstance = new MmsPluginUaManager();
 202
 203         return pInstance;
 204 }
 205
 206 void MmsPluginUaManager::start()
 207 {
 208 //      bool bStart = true;
 209
 210         MutexLocker lock(mx);
 211
 212         if (!running) {
 213
 214                 running = true;
 215                 MsgThread::start();
 216         }
 217 }
 218
 219 MMS_NET_ERROR_T MmsPluginUaManager::submitHandler(mmsTranQEntity *qEntity)
 220 {
 221         MMS_NET_ERROR_T ret = eMMS_UNKNOWN;
 222         int retryCount = 0;
 223
 224         MSG_DEBUG("request Submit:");
 225         PRINT_PDU_TYPE(qEntity->eMmsPduType);
 226         PRINT_QUEUE_ENTITY(qEntity);
 227
 228         MmsPluginHttpAgent*     httpAgent = MmsPluginHttpAgent::instance();
 229
 230         while (retryCount < RETRY_MAX) {
 231                 ret = httpAgent->cmdRequest(qEntity->eHttpCmdType);
 232
 233                 // Process result
 234                 if (ret == eMMS_HTTP_SENT_SUCCESS) {
 235                         MSG_DEBUG("Submit request sent");
 236                         break;
 237                 } else if (ret == eMMS_HTTP_ERROR_NETWORK) {
 238                         retryCount++;
 239                         MSG_DEBUG("HTTP sent timeout and try again: %d", retryCount);
 240                         continue;
 241                 } else {
 242                         MSG_DEBUG("Unexpected Error %d", ret);
 243                         break;
 244                 }
 245         }
 246
 247         return ret;
 248 }
 249
 250 MMS_NET_ERROR_T MmsPluginUaManager::waitingConf(mmsTranQEntity *qEntity)
 251 {
 252         MMS_NET_ERROR_T ret = eMMS_HTTP_ERROR_UNKNOWN;
 253         MmsPluginHttpAgent *pHttpAgent = MmsPluginHttpAgent::instance();
 254         MMS_PLUGIN_HTTP_CONTEXT_S *pMmsPldCd = NULL;
 255
 256         pMmsPldCd = pHttpAgent->getMmsPldCd();
 257
 258         if (qEntity->pGetData) {
 259                 free(qEntity->pGetData);
 260                 qEntity->pGetData = NULL;
 261         }
 262         qEntity->getDataLen = pMmsPldCd->bufOffset;
 263         qEntity->pGetData = (char *)calloc(1, pMmsPldCd->bufOffset + 1);
 264
 265         memcpy(qEntity->pGetData, pMmsPldCd->final_content_buf, pMmsPldCd->bufOffset);
 266         free(pMmsPldCd->final_content_buf);
 267         pMmsPldCd->final_content_buf = NULL;
 268         pMmsPldCd->bufOffset = 0;
 269
 270         MSG_DEBUG("dataLen:%d  pData:(%s)", qEntity->getDataLen, qEntity->pGetData);
 271
 272         ret = eMMS_HTTP_CONF_SUCCESS;
 273
 274         return ret;
 275 }
 276
 277 void MmsPluginUaManager::run()
 278 {
 279         MSG_BEGIN();
 280
 281         MmsPluginCmAgent *cmAgent = MmsPluginCmAgent::instance();
 282         MmsPluginHttpAgent *httpAgent = MmsPluginHttpAgent::instance();
 283
 284         int trId;
 285 //      CURL *session = NULL;
 286
 287         int msgId;
 288
 289         while (1) {
 290                 if (mmsTranQ.empty()) {
 291                         lock();
 292                         wait();
 293                         unlock();
 294                 }
 295
 296                 // Request CM Open
 297                 if (!(cmAgent->open())) {
 298                         MSG_DEBUG("Cm Open Failed");
 299
 300                         // delete all request from reqQEntities
 301                         goto CLEANUP;
 302                 }
 303
 304                 httpAgent->SetMMSProfile();
 305
 306                 while (!mmsTranQ.empty()) {
 307
 308                         MSG_DEBUG("###### mmsTranQ.size [%d]", mmsTranQ.size());
 309
 310                         mmsTranQEntity reqEntity;
 311                         memset(&reqEntity, 0, sizeof(mmsTranQEntity));
 312
 313                         mmsTranQ.front(&reqEntity);
 314
 315                         reqEntity.isCompleted = false;
 316
 317                         PRINT_QUEUE_ENTITY(&reqEntity);
 318
 319                         if (reqEntity.eMmsPduType == eMMS_RETRIEVE_AUTO) {
 320                                 msgId = reqEntity.msgId;
 321                                 MmsPluginStorage::instance()->updateNetStatus(msgId, MSG_NETWORK_RETRIEVING);
 322                         }
 323
 324                         if (httpAgent->cmdRequest(eHTTP_CMD_INIT_SESSION) == eMMS_HTTP_SESSION_OPEN_FAILED) {
 325                                 MSG_DEBUG("HTTP session open failed");
 326                                 // cm close
 327                                 cmAgent->close();
 328                                 // delete all request from reqQEntities
 329                                 goto CLEANUP;
 330                         }
 331
 332                         // MMS Transaction
 333                         MSG_DEBUG("\n\n ===================  MMS Transaction Start ========================");
 334
 335                         do {
 336                                 httpAgent->setSession(&reqEntity);
 337
 338                                 if (submitHandler(&reqEntity) != eMMS_HTTP_SENT_SUCCESS) {
 339                                         MSG_DEBUG("Transaction Error: submit failed");
 340
 341                                         MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 342                                         mmsTranQ.pop_front();
 343                                         //try to next mmsTranQ
 344                                         break;
 345                                 }
 346
 347                                 MSG_DEBUG("submitHandler(&reqEntity) success.");
 348                                 trId = httpAgent->getHttpConfigData()->transactionId;
 349
 350                                 MSG_DEBUG("#### MMS PDU TYPE = %d ####", reqEntity.eMmsPduType);
 351
 352                                 if (reqEntity.eMmsPduType == eMMS_NOTIFYRESP_IND ||
 353                                         reqEntity.eMmsPduType == eMMS_ACKNOWLEDGE_IND ||
 354                                         reqEntity.eMmsPduType == eMMS_READREC_IND ||
 355                                         reqEntity.eMmsPduType == eMMS_CANCEL_CONF) {
 356                                         reqEntity.isCompleted = true;
 357
 358                                         mmsTranQ.pop_front();
 359
 360                                         MSG_DEBUG("Transaction Completed");
 361                                         break;
 362                                 } else {
 363                                         // change MmsPduType from XXX.req to XXX.conf for waiting
 364                                         MSG_DEBUG("Update Pdutype");
 365                                         updatePduType(&reqEntity);
 366                                         MSG_DEBUG("Waiting Conf");
 367                                 }
 368
 369                                 mmsTranQ.pop_front();
 370
 371                                 //////// Waiting Conf //////////////////////
 372                                 MMS_NET_ERROR_T networkErr;
 373
 374                                 if ((networkErr = waitingConf(&reqEntity)) == eMMS_HTTP_CONF_SUCCESS) {
 375                                         bool bReportAllowed;
 376                                         char retrievedFilePath[MAX_FULL_PATH_SIZE+1] = {0,};
 377
 378                                         // process Http data
 379                                         try {
 380                                                 if (processReceivedData(reqEntity.msgId, reqEntity.pGetData, reqEntity.getDataLen, retrievedFilePath) == false) {
 381                                                         MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 382                                                         break;
 383                                                 }
 384                                         } catch (MsgException& e) {
 385                                                 MSG_FATAL("%s", e.what());
 386                                                 MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 387                                                 break;
 388
 389                                         } catch (exception& e) {
 390                                                 MSG_FATAL("%s", e.what());
 391                                                 MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 392                                                 break;
 393                                         }
 394
 395                                         if (reqEntity.eMmsPduType != (MMS_PDU_TYPE_T)mmsHeader.type) {
 396                                                 if (!(reqEntity.eMmsPduType == eMMS_RETRIEVE_MANUAL_CONF && mmsHeader.type == MMS_MSGTYPE_RETRIEVE_CONF)) {
 397                                                         MSG_DEBUG("FAIL::type mismatched req:%d received:%d", reqEntity.eMmsPduType, mmsHeader.type);
 398
 399                                                         MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 400                                                         break;
 401                                                 }
 402                                         }
 403
 404                                         MSG_DEBUG("conf received successfully");
 405
 406                                         try {
 407                                                 MmsPluginEventHandler::instance()->handleMmsReceivedData(&reqEntity, retrievedFilePath);
 408                                         } catch (MsgException& e) {
 409                                                 MSG_FATAL("%s", e.what());
 410                                                 break;
 411                                         } catch (exception& e) {
 412                                                 MSG_FATAL("%s", e.what());
 413                                                 break;
 414                                         }
 415
 416                                         MsgSettingGetBool(MMS_RECV_DELIVERY_RECEIPT, &bReportAllowed);
 417
 418                                         MSG_DEBUG("conf received successfully -2");
 419                                         MSG_DEBUG("reqEntity.eMmsPduType [%d]", reqEntity.eMmsPduType);
 420
 421                                         // send NotifyResponseInd
 422                                         if (reqEntity.eMmsPduType == eMMS_RETRIEVE_AUTO_CONF) {
 423                                                 char filepath[MAX_FULL_PATH_SIZE] = {0};
 424                                                 // change MmsPduType for ind or ack
 425                                                 // make the PDU and then attach to reqEntity also.
 426                                                 updatePduType(&reqEntity);
 427
 428                                                 MSG_DEBUG("#### eMmsPduType:%d ####", reqEntity.eMmsPduType);
 429
 430                                                 //update http command type & encode m-notify-response-ind
 431                                                 reqEntity.eHttpCmdType = eHTTP_CMD_POST_TRANSACTION;
 432
 433                                                 try {
 434                                                         MmsPluginInternal::instance()->encodeNotifyRespInd(reqEntity.transactionId, MMS_MSGSTATUS_RETRIEVED, bReportAllowed, filepath);
 435                                                         //m-notification-resp-ind encoding      if err is not MSG_SUCCESS then should set x-mms-status to deferred
 436                                                         if (MsgGetFileSize(filepath, &reqEntity.postDataLen) == false) {
 437                                                                 MSG_DEBUG("MsgGetFileSize: failed");
 438                                                                 break;
 439                                                         }
 440                                                 } catch (MsgException& e) {
 441                                                         MSG_FATAL("%s", e.what());
 442                                                         break;
 443                                                 } catch (exception& e) {
 444                                                         MSG_FATAL("%s", e.what());
 445                                                         break;
 446                                                 }
 447
 448                                                 if (reqEntity.pPostData) {
 449                                                         free(reqEntity.pPostData);
 450                                                         reqEntity.pPostData = NULL;
 451                                                 }
 452
 453                                                 reqEntity.pPostData = MsgOpenAndReadMmsFile(filepath, 0, -1, &reqEntity.postDataLen);
 454
 455                                                 mmsTranQ.push_front(reqEntity);
 456
 457                                                 remove(filepath);
 458
 459                                                 MSG_DEBUG("Submit Ind");
 460                                         } else if (reqEntity.eMmsPduType == eMMS_RETRIEVE_MANUAL_CONF) {
 461                                                 /* saved msg trId should be checked  */
 462                                                 // Send Acknowledge Ind
 463                                                 char filepath[MAX_FULL_PATH_SIZE] = {0};
 464                                                 // change MmsPduType for ind or ack
 465                                                 // make the PDU and then attach to reqEntity also.
 466                                                 updatePduType(&reqEntity);
 467
 468                                                 MSG_DEBUG("#### eMmsPduType:%d ####", reqEntity.eMmsPduType);
 469
 470                                                 //update http command type & encode m-notify-response-ind
 471                                                 reqEntity.eHttpCmdType = eHTTP_CMD_POST_TRANSACTION;
 472
 473                                                 try {
 474                                                         MmsPluginInternal::instance()->encodeAckInd(reqEntity.transactionId, bReportAllowed, filepath);
 475                                                         if (MsgGetFileSize(filepath, &reqEntity.postDataLen) == false) {
 476                                                                 MSG_DEBUG("MsgGetFileSize: failed");
 477                                                                 break;
 478                                                         }
 479                                                 } catch (MsgException& e) {
 480                                                         MSG_FATAL("%s", e.what());
 481                                                         break;
 482                                                 } catch (exception& e) {
 483                                                         MSG_FATAL("%s", e.what());
 484                                                         break;
 485                                                 }
 486
 487                                                 if (reqEntity.pPostData) {
 488                                                         free(reqEntity.pPostData);
 489                                                         reqEntity.pPostData = NULL;
 490                                                 }
 491
 492                                                 reqEntity.pPostData = MsgOpenAndReadMmsFile(filepath, 0, -1, &reqEntity.postDataLen);
 493
 494                                                 mmsTranQ.push_front(reqEntity);
 495
 496                                                 remove(filepath); // not ipc
 497
 498                                                 MSG_DEBUG("Submit Ack");
 499                                         } else {
 500                                                 reqEntity.isCompleted = true;
 501
 502                                                 MSG_DEBUG("Transaction complete");
 503                                         }
 504                                 } else {
 505                                         MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 506                                         break;
 507                                 }
 508                         } while (reqEntity.isCompleted == false);
 509
 510                         MSG_DEBUG("==== MMS Transaction Completed ====\n\n");
 511
 512                         if (reqEntity.pPostData) {
 513                                 free(reqEntity.pPostData);
 514                                 reqEntity.pPostData = NULL;
 515                         }
 516
 517                         if (reqEntity.pGetData) {
 518                                 free(reqEntity.pGetData);
 519                                 reqEntity.pGetData = NULL;
 520                         }
 521
 522                         // Http Session Close
 523                         httpAgent->clearSession();
 524                 }
 525
 526                 // Request CM Close
 527                 cmAgent->close();
 528
 529         }
 530
 531 CLEANUP:
 532         MSG_DEBUG("CLEANUP");
 533
 534         while (!mmsTranQ.empty()) {
 535                 MSG_DEBUG("clear mmsTranQ");
 536
 537                 mmsTranQEntity reqEntity;
 538                 memset(&reqEntity, 0, sizeof(mmsTranQEntity));
 539
 540                 mmsTranQ.front(&reqEntity);
 541
 542                 // notify send fail to APP
 543                 MmsPluginEventHandler::instance()->handleMmsError(&reqEntity);
 544
 545                 if (reqEntity.pGetData) {
 546                         MSG_DEBUG("free pGetData");
 547                         free(reqEntity.pGetData);
 548                         reqEntity.pGetData = NULL;
 549                 }
 550
 551                 if (reqEntity.pPostData) {
 552                         MSG_DEBUG("free pPostData");
 553                         free(reqEntity.pPostData);
 554                         reqEntity.pPostData = NULL;
 555                 }
 556
 557                 mmsTranQ.pop_front();
 558         }
 559
 560         mmsTranQ.clear();
 561         MutexLocker locker(mx);
 562         running = false;
 563
 564         MSG_END();
 565
 566         return;
 567 }
 568
 569 void MmsPluginUaManager::getMmsPduData(mmsTranQEntity *qEntity)
 570 {
 571         mmsTranQ.front(qEntity);
 572 }
 573
 574 void MmsPluginUaManager::addMmsReqEntity(mmsTranQEntity req)
 575 {
 576         MSG_DEBUG("New MMS Tran Added");
 577         mmsTranQ.push_back(req);
 578         lock();
 579         signal();
 580         unlock();
 581 }
 582
 583 bool MmsPluginUaManager::processReceivedData(int msgId, char *pRcvdBody, int rcvdBodyLen, char *retrievedFilePath)
 584 {
 585         MSG_BEGIN();
 586
 587         char fileName[MSG_FILENAME_LEN_MAX] = {0};
 588
 589         MSG_DEBUG(":::%d :%s ", rcvdBodyLen, pRcvdBody);
 590
 591         _MmsInitHeader();
 592         _MmsRegisterDecodeBuffer(gszMmsLoadBuf1,  gszMmsLoadBuf2, MSG_MMS_DECODE_BUFFER_MAX);
 593
 594         if (MsgCreateFileName(fileName) == false)
 595                 return false;
 596
 597         snprintf(retrievedFilePath, MSG_FILEPATH_LEN_MAX, MSG_DATA_PATH"%s", fileName);
 598
 599         MSG_DEBUG("retrievedFilePaths [%s]", retrievedFilePath);
 600
 601         // create temp file
 602         if (!MsgOpenCreateAndOverwriteFile(retrievedFilePath, (char *)pRcvdBody, rcvdBodyLen)) {
 603                 MSG_DEBUG( "_MmsUaInitMsgDecoder: creating temporary file failed(msgID=%d)\n", msgId);
 604                 return false;
 605         }
 606
 607         if (_MmsReadMsgBody(msgId, true, true, retrievedFilePath) == false) {
 608                 MSG_DEBUG("The MMS Message might include drm contents!!!");
 609
 610 #ifdef __SUPPORT_DRM__
 611                 if (MmsDrm2GetConvertState() == MMS_DRM2_CONVERT_REQUIRED) {
 612                         bool bRetToConvert = true;
 613                         MSG_MESSAGE_INFO_S pMsg = {0, };
 614
 615                         pMsg.msgId = msgId;
 616
 617                         bRetToConvert = MmsDrm2ConvertMsgBody(mmsHeader.msgType.szOrgFilePath);
 618
 619                         MmsDrm2SetConvertState(MMS_DRM2_CONVERT_FINISH);
 620
 621                         if (bRetToConvert) {
 622                                 int ret;
 623                                 ret = remove(mmsHeader.msgType.szOrgFilePath);
 624                                 if (ret != 0) {
 625                                         MSG_DEBUG("remove fail\n");
 626                                         goto ERR_MMS_UA_PROCESS_CONF;
 627                                 }
 628
 629                                 ret = rename(MMS_DECODE_DRM_CONVERTED_TEMP_FILE, mmsHeader.msgType.szOrgFilePath);
 630                                 if (ret != 0) {
 631                                         MSG_DEBUG("rename fail\n");
 632                                         goto ERR_MMS_UA_PROCESS_CONF;
 633                                 }
 634
 635                                 if (MmsDrm2ReadMsgConvertedBody(&pMsg, true, true, retrievedFilePath) == false) {
 636                                         MSG_DEBUG("MmsLoadMsg:MmsDrm2ReadMsgConvertedBody() returns false\n");
 637                                         goto ERR_MMS_UA_PROCESS_CONF;
 638                                 }
 639                         }
 640                 }
 641 #endif
 642         }
 643
 644         MSG_END();
 645
 646         return true;
 647
 648 ERR_MMS_UA_PROCESS_CONF:
 649         {
 650                 MmsMsg *pMsg;
 651                 MmsPluginStorage::instance()->getMmsMessage(&pMsg);
 652
 653
 654                 _MmsInitHeader();
 655                 _MmsUnregisterDecodeBuffer();
 656
 657 #ifdef __SUPPORT_DRM__
 658                 _MsgFreeDRMInfo(&pMsg->msgType.drmInfo);
 659 #endif
 660                 _MsgFreeBody(&pMsg->msgBody, pMsg->msgType.type);
 661
 662                 return false;
 663         }
 664 }
 665