utils/MsgUtilStorage.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 <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <tr1/unordered_set>
  21 #include <queue>
  22 #include <glib.h>
  23
  24 #include <boost/filesystem.hpp>
  25 #include <boost/chrono/detail/system.hpp>
  26
  27 #include "MsgDebug.h"
  28 #include "MsgUtilFile.h"
  29 #include "MsgContact.h"
  30 #include "MsgCppTypes.h"
  31 #include "MsgGconfWrapper.h"
  32 #include "MsgUtilFunction.h"
  33 #include "MsgUtilStorage.h"
  34 #include "MsgException.h"
  35
  36 static int msgCntLimit[MSG_COUNT_LIMIT_MAILBOX_TYPE_MAX][MSG_COUNT_LIMIT_MSG_TYPE_MAX] = {{10, 10, 0, 10, 10}, {5, 10, 0, 0, 0}, {10, 10, 0, 0, 0}, {10, 10, 0, 0, 0}, {0, 0, 10, 0, 0}};
  37
  38 using namespace std;
  39
  40 #define CHECK_SIZE 1 * 1024 * 1024 * 1024
  41 #define RESERVE 100 * 1024 * 1024
  42 #define RESERVE_LITE 5 * 1024 * 1024
  43
  44 /*==================================================================================================
  45                                      FUNCTION IMPLEMENTATION
  46 ==================================================================================================*/
  47
  48 unsigned int MsgStoAddMessageTable(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo)
  49 {
  50         MSG_BEGIN();
  51
  52         msg_error_t err = MSG_SUCCESS;
  53
  54         msg_message_id_t msgId = 0;
  55
  56         err = pDbHandle->getRowId(MSGFW_MESSAGE_TABLE_NAME, &msgId);
  57
  58         if (err != MSG_SUCCESS)
  59                 return 0;
  60
  61         int fileSize = 0;
  62
  63         char* pFileData = NULL;
  64         unique_ptr<char*, void(*)(char**)> buf(&pFileData, unique_ptr_deleter);
  65
  66         /* Get File Data */
  67         if (pMsgInfo->bTextSms == false) {
  68                 if (MsgOpenAndReadFile(pMsgInfo->msgData, &pFileData, &fileSize) == false)
  69                         return 0;
  70
  71                 MSG_DEBUG("file size [%d]", fileSize);
  72         }
  73
  74         char keyName[MAX_VCONFKEY_NAME_LEN];
  75         memset(keyName, 0x00, sizeof(keyName));
  76         snprintf(keyName, sizeof(keyName), "%s/%d", MSG_SIM_SUBS_ID, pMsgInfo->sim_idx);
  77
  78         char *imsi = NULL;
  79         if (MsgSettingGetString(keyName, &imsi) != MSG_SUCCESS) {
  80                 MSG_INFO("MsgSettingGetString() is failed");
  81         }
  82
  83         /* Add Message */
  84         char sqlQuery[MAX_QUERY_LEN+1];
  85
  86         memset(sqlQuery, 0x00, sizeof(sqlQuery));
  87         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, %d, %d, %lu, %zu, %d, %d, %d, %d, %d, %d, %d, ?, '', '', ?, 0, %d, '%s', %d);",
  88                         MSGFW_MESSAGE_TABLE_NAME, msgId, pMsgInfo->threadId, pMsgInfo->folderId, pMsgInfo->storageId, pMsgInfo->msgType.mainType,
  89                         pMsgInfo->msgType.subType, pMsgInfo->displayTime, pMsgInfo->dataSize, pMsgInfo->networkStatus, pMsgInfo->bRead, pMsgInfo->bProtected,
  90                         pMsgInfo->priority, pMsgInfo->direction, 0, pMsgInfo->bBackup, pMsgInfo->sim_idx, imsi, pMsgInfo->bRestricted);
  91
  92         MSG_DEBUG("QUERY : %s", sqlQuery);
  93
  94         g_free(imsi);
  95         imsi = NULL;
  96
  97         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
  98                 return 0;
  99
 100         pDbHandle->bindText(pMsgInfo->subject, 1);
 101
 102         if (pMsgInfo->msgType.subType == MSG_NOTIFICATIONIND_MMS) {
 103                 pDbHandle->bindText("", 2);
 104         } else {
 105                 if (pMsgInfo->bTextSms == false)
 106                         pDbHandle->bindText(pFileData, 2);
 107                 else
 108                         pDbHandle->bindText(pMsgInfo->msgText, 2);
 109         }
 110
 111         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 112                 pDbHandle->finalizeQuery();
 113                 return 0;
 114         }
 115
 116         pDbHandle->finalizeQuery();
 117
 118         return msgId;
 119 }
 120
 121
 122 msg_error_t MsgStoSetReadStatus(MsgDbHandler *pDbHandle, msg_message_id_t msgId, bool bRead)
 123 {
 124         char sqlQuery[MAX_QUERY_LEN+1];
 125
 126         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 127         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET READ_STATUS = %d WHERE MSG_ID = %d;",
 128                         MSGFW_MESSAGE_TABLE_NAME, (int)bRead, msgId);
 129
 130         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
 131                 return MSG_ERR_DB_EXEC;
 132
 133         /* Get MAIN_TYPE, SUB_TYPE, STORAGE_ID */
 134         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 135         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.MAIN_TYPE, A.SUB_TYPE, B.CONV_ID \
 136                         FROM %s A, %s B WHERE A.MSG_ID = %d AND A.CONV_ID = B.CONV_ID;",
 137                         MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME, msgId);
 138
 139         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 140                 return MSG_ERR_DB_PREPARE;
 141
 142         MSG_MESSAGE_TYPE_S msgType;
 143         msg_thread_id_t convId;
 144
 145         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 146                 msgType.mainType = pDbHandle->columnInt(0);
 147                 msgType.subType = pDbHandle->columnInt(1);
 148                 convId = pDbHandle->columnInt(2);
 149         } else {
 150                 pDbHandle->finalizeQuery();
 151                 return MSG_ERR_DB_STEP;
 152         }
 153
 154         pDbHandle->finalizeQuery();
 155
 156         MSG_DEBUG("Main Type:[%d] SubType:[%d] ConvId:[%d]", msgType.mainType, msgType.subType, convId);
 157
 158         if (MsgStoUpdateConversation(pDbHandle, convId) != MSG_SUCCESS) {
 159                 MSG_DEBUG("MsgStoUpdateConversation() Error");
 160                 return MSG_ERR_STORAGE_ERROR;
 161         }
 162
 163         return MSG_SUCCESS;
 164 }
 165
 166
 167 msg_error_t MsgStoGetOldestMessage(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo, msg_message_id_t *pMsgId)
 168 {
 169         char sqlQuery[MAX_QUERY_LEN+1];
 170
 171         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 172
 173         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s \
 174                         WHERE SUB_TYPE = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND PROTECTED = 0 \
 175                         ORDER BY DISPLAY_TIME ASC",
 176                         MSGFW_MESSAGE_TABLE_NAME, pMsgInfo->msgType.subType, pMsgInfo->folderId, MSG_STORAGE_PHONE);
 177
 178         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 179                 return MSG_ERR_DB_PREPARE;
 180
 181         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 182                 *pMsgId = pDbHandle->columnInt(0);
 183         } else {
 184                 pDbHandle->finalizeQuery();
 185                 return MSG_ERR_DB_STEP;
 186         }
 187
 188         pDbHandle->finalizeQuery();
 189
 190         return MSG_SUCCESS;
 191 }
 192
 193
 194 msg_error_t MsgStoCheckMsgCntFull(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
 195 {
 196         MSG_BEGIN();
 197
 198         msg_error_t err = MSG_SUCCESS;
 199
 200         boost::system::error_code ec;
 201         boost::filesystem::space_info si = boost::filesystem::space(TZ_SYS_HOME_PATH, ec);
 202         long long int available = 0;
 203
 204         if (ec) {
 205                 MSG_ERR("Failed to get space info [%s]", ec.message().c_str());
 206                 return MSG_ERR_STORAGE_ERROR;
 207         } else {
 208                 if (si.capacity < CHECK_SIZE)
 209                         available = si.available - RESERVE_LITE;
 210                 else
 211                         available = si.available - RESERVE;
 212
 213                 if (available < 0)
 214                         available = 0;
 215
 216                 MSG_DEBUG("Free space of storage is [%llu] Bytes.", available);
 217
 218                 if (available < SMS_MINIMUM_SPACE && pMsgType->mainType == MSG_SMS_TYPE)
 219                         err = MSG_ERR_MESSAGE_COUNT_FULL;
 220                 else if (available < MMS_MINIMUM_SPACE && pMsgType->mainType == MSG_MMS_TYPE)
 221                         err = MSG_ERR_MESSAGE_COUNT_FULL;
 222         }
 223
 224         MSG_END();
 225
 226         return err;
 227 }
 228
 229
 230 msg_error_t MsgStoCountMsgByLimitCategory(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S *pMsgType, int *pMsgCount, msg_folder_id_t folderId)
 231 {
 232         if (pMsgType == NULL) {
 233                 MSG_DEBUG("pMsgType is NULL");
 234                 return MSG_ERR_NULL_POINTER;
 235         }
 236
 237         *pMsgCount = 0;
 238
 239         char sqlQuery[MAX_QUERY_LEN+1];
 240         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 241
 242         if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_WAP_SI_SMS ||pMsgType->subType == MSG_WAP_SL_SMS)) { /* PUSH */
 243                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d) AND FOLDER_ID = %d;",
 244                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_INBOX_ID);
 245         } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_CB_SMS)) { /* CB */
 246                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
 247                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_CB_SMS, MSG_CBMSGBOX_ID);
 248         } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_SYNCML_CP)) { /* Provision */
 249                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
 250                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SYNCML_CP, MSG_INBOX_ID);
 251         } else if ((pMsgType->mainType == MSG_SMS_TYPE)) { /* SMS */
 252                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE NOT IN (%d, %d, %d, %d) AND FOLDER_ID = %d;",
 253                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_CB_SMS, MSG_SYNCML_CP, MSG_INBOX_ID); /* etc SMS */
 254         } else if ((pMsgType->mainType == MSG_MMS_TYPE) &&
 255                         (pMsgType->subType == MSG_SENDREQ_MMS || pMsgType->subType == MSG_SENDCONF_MMS || pMsgType->subType == MSG_RETRIEVE_AUTOCONF_MMS ||
 256                                         pMsgType->subType == MSG_RETRIEVE_MANUALCONF_MMS || pMsgType->subType == MSG_NOTIFICATIONIND_MMS)) { /* MMS */
 257                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d, %d, %d) AND FOLDER_ID = %d;",
 258                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SENDREQ_MMS, MSG_SENDCONF_MMS, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS, folderId);
 259         } else {
 260                 return MSG_ERR_INVALID_PARAMETER;
 261         }
 262
 263         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 264                 return MSG_ERR_DB_PREPARE;
 265
 266         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 267                 *pMsgCount = pDbHandle->columnInt(0);
 268         } else {
 269                 pDbHandle->finalizeQuery();
 270                 return MSG_ERR_DB_STEP;
 271         }
 272
 273         pDbHandle->finalizeQuery();
 274
 275         return MSG_SUCCESS;
 276 }
 277
 278
 279 int MsgStoCheckMsgCntLimit(const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
 280 {
 281         int msgboxType = -1;
 282         int msgType = -1;
 283
 284         switch (folderId) {
 285                 case MSG_INBOX_ID :
 286                         msgboxType = MSG_COUNT_LIMIT_INBOX_TYPE;
 287                 break;
 288
 289                 case MSG_OUTBOX_ID :
 290                         msgboxType = MSG_COUNT_LIMIT_OUTBOX_TYPE;
 291                 break;
 292
 293                 case MSG_SENTBOX_ID :
 294                         msgboxType = MSG_COUNT_LIMIT_SENTBOX_TYPE;
 295                 break;
 296
 297                 case MSG_DRAFT_ID :
 298                         msgboxType = MSG_COUNT_LIMIT_DRAFTBOX_TYPE;
 299                 break;
 300
 301                 case MSG_CBMSGBOX_ID :
 302                         msgboxType = MSG_COUNT_LIMIT_CBMSGBOX_TYPE;
 303                 break;
 304
 305                 default:
 306                         MSG_DEBUG("Unknown mailbox Type [%d]", folderId);
 307                 return -1;
 308         }
 309
 310         switch (pMsgType->subType) {
 311                 case MSG_NORMAL_SMS:
 312                 case MSG_REPLACE_TYPE1_SMS:
 313                 case MSG_REPLACE_TYPE2_SMS:
 314                 case MSG_REPLACE_TYPE3_SMS:
 315                 case MSG_REPLACE_TYPE4_SMS:
 316                 case MSG_REPLACE_TYPE5_SMS:
 317                 case MSG_REPLACE_TYPE6_SMS:
 318                 case MSG_REPLACE_TYPE7_SMS:
 319                 case MSG_MWI_VOICE_SMS:
 320                 case MSG_MWI_FAX_SMS:
 321                 case MSG_MWI_EMAIL_SMS:
 322                 case MSG_MWI_OTHER_SMS:
 323                 case MSG_STATUS_REPORT_SMS:
 324                         msgType = MSG_COUNT_LIMIT_SMS_TYPE;
 325                 break;
 326
 327                 case MSG_CB_SMS:
 328                         msgType = MSG_COUNT_LIMIT_CB_TYPE;
 329                 break;
 330
 331                 case MSG_WAP_SI_SMS:
 332                 case MSG_WAP_SL_SMS:
 333                         msgType = MSG_COUNT_LIMIT_WAPPUSH_TYPE;
 334                 break;
 335
 336                 case MSG_SYNCML_CP:
 337                         msgType = MSG_COUNT_LIMIT_PROVISION_TYPE;
 338                 break;
 339
 340                 case MSG_SENDREQ_MMS:
 341                 case MSG_SENDCONF_MMS:
 342                 case MSG_NOTIFICATIONIND_MMS:
 343                 case MSG_RETRIEVE_AUTOCONF_MMS:
 344                 case MSG_RETRIEVE_MANUALCONF_MMS:
 345                         msgType = MSG_COUNT_LIMIT_MMS_TYPE;
 346                 break;
 347
 348                 default:
 349                         MSG_DEBUG("Unknown Message Type [%d]", pMsgType->subType);
 350                 return -1;
 351         }
 352
 353         return msgCntLimit[msgboxType][msgType];
 354 }
 355
 356
 357 msg_error_t MsgStocheckMemoryStatus()
 358 {
 359         msg_error_t err = MSG_SUCCESS;
 360         boost::system::error_code ec;
 361         boost::filesystem::space_info si = boost::filesystem::space(TZ_SYS_HOME_PATH, ec);
 362         long long int available = 0;
 363
 364         if (ec) {
 365                 MSG_ERR("Failed to get space info [%s]", ec.message().c_str());
 366                 return MSG_ERR_STORAGE_ERROR;
 367         }
 368
 369         if (si.capacity < CHECK_SIZE)
 370                 available = si.available - RESERVE_LITE;
 371         else
 372                 available = si.available - RESERVE;
 373
 374         if (available < 0)
 375                 available = 0;
 376
 377         MSG_DEBUG("Free space of storage is [%llu] Bytes.", available);
 378
 379         if (available < SMS_MINIMUM_SPACE)
 380                 err = MSG_ERR_MESSAGE_COUNT_FULL;
 381
 382         MSG_DEBUG("Memory status =[%d]", err);
 383
 384         return err;
 385 }
 386
 387
 388 msg_error_t MsgStoAddAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
 389 {
 390         msg_error_t err = MSG_SUCCESS;
 391
 392         char sqlQuery[MAX_QUERY_LEN+1];
 393
 394         /* Check if new address or not */
 395         if (MsgExistAddress(pDbHandle, pMsg, pConvId) == true) {
 396                 MSG_DEBUG("The address already exists. Conversation ID : [%d]", *pConvId);
 397                 MsgStoUpdateAddress(pDbHandle, pMsg, *pConvId);
 398         } else {
 399                 *pConvId = 0;
 400
 401                 if (pMsg->threadId)
 402                         *pConvId = pMsg->threadId;
 403
 404                 /* conversation insert */
 405                 err = MsgStoAddConversation(pDbHandle, pConvId);
 406                 if (err != MSG_SUCCESS) {
 407                         MSG_DEBUG("MsgStoAddConversation() fail [%d]", err);
 408                         return err;
 409                 }
 410
 411                 /* insert address in loop */
 412                 for (int i = 0; i < pMsg->nAddressCnt; i++) {
 413                         unsigned int addrId;
 414                         MSG_CONTACT_INFO_S contactInfo;
 415                         memset(&contactInfo, 0x00, sizeof(MSG_CONTACT_INFO_S));
 416
 417                         /* Get Contact Info */
 418 #if 0
 419                         if (MsgGetContactInfo(&(pMsg->addressList[i]), &contactInfo) != MSG_SUCCESS) {
 420                                 MSG_DEBUG("MsgGetContactInfo() fail.");
 421                         }
 422 #endif
 423
 424                         err = pDbHandle->getRowId(MSGFW_ADDRESS_TABLE_NAME, &addrId);
 425                         if (err != MSG_SUCCESS) {
 426                                 MSG_DEBUG("pDbHandle->getRowId fail. [%d]", err);
 427                                 return err;
 428                         }
 429
 430                         /* Add Address */
 431                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 432                         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, '%s', %d, %d, ?, ?, ?, ?, ?, '%s', 0);",
 433                                                 MSGFW_ADDRESS_TABLE_NAME, addrId, *pConvId, pMsg->addressList[i].addressType, pMsg->addressList[i].recipientType, pMsg->addressList[i].addressVal,
 434                                                 contactInfo.contactId, contactInfo.addrbookId, contactInfo.imagePath);
 435
 436                         MSG_SEC_DEBUG("Add Address Info. [%s]", sqlQuery);
 437
 438                         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 439                                 return MSG_ERR_DB_PREPARE;
 440
 441                         pDbHandle->bindText(contactInfo.firstName, 1);
 442                         pDbHandle->bindText(contactInfo.lastName, 2);
 443                         pDbHandle->bindText(contactInfo.middleName, 3);
 444                         pDbHandle->bindText(contactInfo.prefix, 4);
 445                         pDbHandle->bindText(contactInfo.suffix, 5);
 446
 447                         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 448                                 pDbHandle->finalizeQuery();
 449                                 return MSG_ERR_DB_STEP;
 450                         }
 451
 452                         pDbHandle->finalizeQuery();
 453                 }
 454         }
 455
 456         /* set conversation display name by conv id */
 457         MsgStoSetConversationDisplayName(pDbHandle, *pConvId);
 458
 459         return err;
 460 }
 461
 462 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int *nAddressCnt, MSG_ADDRESS_INFO_S **pAddress)
 463 {
 464         char sqlQuery[MAX_QUERY_LEN+1];
 465         int rowCnt = 0, index = 0;
 466
 467         *nAddressCnt = 0;
 468
 469         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 470         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
 471                         "A.ADDRESS_TYPE, "
 472                         "A.RECIPIENT_TYPE, "
 473                         "A.ADDRESS_VAL "
 474                         "FROM %s A, %s B "
 475                         "WHERE A.CONV_ID = B.CONV_ID "
 476                         "AND B.MSG_ID = %d;",
 477                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
 478                         msgId);
 479
 480         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
 481
 482         if (err == MSG_ERR_DB_NORECORD) {
 483                 pDbHandle->freeTable();
 484                 return MSG_SUCCESS;
 485         } else if (err != MSG_SUCCESS) {
 486                 MSG_DEBUG("Fail to getTable().");
 487                 pDbHandle->freeTable();
 488                 return err;
 489         }
 490
 491         *nAddressCnt = rowCnt;
 492
 493         MSG_DEBUG("*nAddressCnt [%d]", *nAddressCnt);
 494
 495         MSG_ADDRESS_INFO_S *tmpAddressList = (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S) * rowCnt];
 496         memset(tmpAddressList, 0x00, sizeof(MSG_ADDRESS_INFO_S) * rowCnt);
 497         *pAddress = tmpAddressList;
 498
 499         for (int i = 0; i < rowCnt; i++) {
 500                 tmpAddressList[i].addressType = pDbHandle->getColumnToInt(index++);
 501                 tmpAddressList[i].recipientType = pDbHandle->getColumnToInt(index++);
 502                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, tmpAddressList[i].addressVal);
 503
 504                 strncpy(tmpAddressList[i].displayName, tmpAddressList[i].addressVal, MAX_DISPLAY_NAME_LEN);
 505         }
 506         pDbHandle->freeTable();
 507
 508         return MSG_SUCCESS;
 509 }
 510
 511 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, msg_struct_list_s *pAddress)
 512 {
 513         char sqlQuery[MAX_QUERY_LEN+1];
 514
 515         int rowCnt = 0, index = 0;
 516
 517         pAddress->nCount = 0;
 518         pAddress->msg_struct_info = NULL;
 519
 520         msg_struct_s *pTmp = NULL;
 521         MSG_ADDRESS_INFO_S *pAddr = NULL;
 522
 523         pAddress->msg_struct_info = (msg_struct_t *)calloc(MAX_TO_ADDRESS_CNT, sizeof(msg_struct_t));
 524         if (pAddress->msg_struct_info == NULL)
 525                 return MSG_ERR_MEMORY_ERROR;
 526
 527         for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
 528                 pAddress->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
 529                 pTmp = (msg_struct_s *)pAddress->msg_struct_info[i];
 530                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
 531                 pTmp->data = new MSG_ADDRESS_INFO_S;
 532                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 533         }
 534
 535         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 536         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
 537                         "A.ADDRESS_TYPE, "
 538                         "A.RECIPIENT_TYPE, "
 539                         "A.ADDRESS_VAL "
 540                         "FROM %s A, %s B "
 541                         "WHERE A.CONV_ID = B.CONV_ID "
 542                         "AND B.MSG_ID = %d;",
 543                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
 544                         msgId);
 545
 546         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
 547
 548         if (err == MSG_ERR_DB_NORECORD) {
 549                 pDbHandle->freeTable();
 550                 return MSG_SUCCESS;
 551         } else if (err != MSG_SUCCESS) {
 552                 MSG_DEBUG("Fail to getTable().");
 553                 pDbHandle->freeTable();
 554                 return err;
 555         }
 556
 557         rowCnt = (rowCnt > 10)? MAX_TO_ADDRESS_CNT: rowCnt;
 558         pAddress->nCount = rowCnt;
 559
 560         for (int i = 0; i < rowCnt; i++) {
 561                 pTmp = (msg_struct_s *)pAddress->msg_struct_info[i];
 562                 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
 563
 564                 pAddr->addressType = pDbHandle->getColumnToInt(index++);
 565                 pAddr->recipientType = pDbHandle->getColumnToInt(index++);
 566
 567                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, pAddr->addressVal);
 568
 569                 strncpy(pAddr->displayName, pAddr->addressVal, MAX_DISPLAY_NAME_LEN);
 570         }
 571
 572         pDbHandle->freeTable();
 573
 574         return MSG_SUCCESS;
 575 }
 576
 577
 578 msg_error_t MsgStoGetRecipientsByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int *nAddressCnt, MSG_ADDRESS_INFO_S **pAddress)
 579 {
 580         char sqlQuery[MAX_QUERY_LEN+1];
 581         int rowCnt = 0, index = 0;
 582
 583         *nAddressCnt = 0;
 584
 585         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 586         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT ADDRESS_TYPE, RECIPIENT_TYPE, ADDRESS_VAL FROM %s WHERE MSG_ID = %d;",
 587                         MSGFW_MMS_RECIPIENTS_TABLE_NAME, msgId);
 588
 589         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
 590
 591         if (err == MSG_ERR_DB_NORECORD) {
 592                 pDbHandle->freeTable();
 593                 return MSG_SUCCESS;
 594         } else if (err != MSG_SUCCESS) {
 595                 MSG_DEBUG("Fail to getTable().");
 596                 pDbHandle->freeTable();
 597                 return err;
 598         }
 599
 600         *nAddressCnt = rowCnt;
 601
 602         MSG_DEBUG("*nAddressCnt [%d]", *nAddressCnt);
 603
 604         MSG_ADDRESS_INFO_S *tmpAddressList = (MSG_ADDRESS_INFO_S *)new char[sizeof(MSG_ADDRESS_INFO_S) * rowCnt];
 605         memset(tmpAddressList, 0x00, sizeof(MSG_ADDRESS_INFO_S) * rowCnt);
 606         *pAddress = tmpAddressList;
 607
 608         for (int i = 0; i < rowCnt; i++) {
 609                 tmpAddressList[i].addressType = pDbHandle->getColumnToInt(index++);
 610                 tmpAddressList[i].recipientType = pDbHandle->getColumnToInt(index++);
 611                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, tmpAddressList[i].addressVal);
 612                 strncpy(tmpAddressList[i].displayName, tmpAddressList[i].addressVal, MAX_DISPLAY_NAME_LEN);
 613         }
 614         pDbHandle->freeTable();
 615
 616         return MSG_SUCCESS;
 617 }
 618
 619
 620 msg_error_t MsgStoGetAddressByConvId(MsgDbHandler *pDbHandle, msg_thread_id_t convId, msg_struct_list_s *pAddrlist)
 621 {
 622         char sqlQuery[MAX_QUERY_LEN+1];
 623
 624         int rowCnt = 0, index = 0;
 625
 626         pAddrlist->nCount = 0;
 627         pAddrlist->msg_struct_info = NULL;
 628
 629         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 630         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
 631                         "ADDRESS_TYPE, "
 632                         "RECIPIENT_TYPE, "
 633                         "ADDRESS_VAL "
 634                         "FROM %s WHERE CONV_ID  = %d;",
 635                         MSGFW_ADDRESS_TABLE_NAME, convId);
 636
 637         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
 638
 639         if (err == MSG_ERR_DB_NORECORD) {
 640                 pDbHandle->freeTable();
 641                 return MSG_SUCCESS;
 642         } else if (err != MSG_SUCCESS) {
 643                 MSG_DEBUG("Fail to getTable().");
 644                 pDbHandle->freeTable();
 645                 return err;
 646         }
 647
 648         pAddrlist->nCount = rowCnt;
 649
 650         MSG_DEBUG("pAddrlist->nCount [%d]", pAddrlist->nCount);
 651
 652         msg_struct_s *pTmp = NULL;
 653         MSG_ADDRESS_INFO_S *pAddr = NULL;
 654
 655         pAddrlist->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
 656
 657         for (int i = 0; i < rowCnt; i++) {
 658                 pAddrlist->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
 659                 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
 660                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
 661                 pTmp->data = new MSG_ADDRESS_INFO_S;
 662                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 663         }
 664
 665 /*      rowCnt = (rowCnt > 10)? MAX_TO_ADDRESS_CNT: rowCnt; */
 666
 667         for (int i = 0; i < rowCnt; i++) {
 668                 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
 669                 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
 670
 671                 pAddr->addressType = pDbHandle->getColumnToInt(index++);
 672                 pAddr->recipientType = pDbHandle->getColumnToInt(index++);
 673                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, pAddr->addressVal);
 674
 675                 strncpy(pAddr->displayName, pAddr->addressVal, MAX_DISPLAY_NAME_LEN);
 676         }
 677         pDbHandle->freeTable();
 678
 679         return MSG_SUCCESS;
 680 }
 681
 682 /* Have to use trigger for this function. */
 683 msg_error_t MsgStoUpdateConversation(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
 684 {
 685         MSG_BEGIN();
 686
 687         char sqlQuery[MAX_QUERY_LEN];
 688         unsigned int tmpSize = 0;
 689
 690 #ifdef MSG_NOTI_INTEGRATION
 691         memset(sqlQuery, 0x00, MAX_QUERY_LEN);
 692         snprintf(sqlQuery, sizeof(sqlQuery),
 693                         "SELECT * "
 694                         "FROM %s "
 695                         "WHERE CONV_ID = %d "
 696                         "AND FOLDER_ID > %d AND FOLDER_ID < %d "
 697                         "AND STORAGE_ID = %d;",
 698                         MSGFW_MESSAGE_TABLE_NAME,
 699                         convId,
 700                         MSG_ALLBOX_ID, MSG_SPAMBOX_ID,
 701                         MSG_STORAGE_PHONE);
 702 #else
 703         memset(sqlQuery, 0x00, MAX_QUERY_LEN);
 704         snprintf(sqlQuery, sizeof(sqlQuery),
 705                         "SELECT * "
 706                         "FROM %s "
 707                         "WHERE CONV_ID = %d "
 708                         "AND FOLDER_ID > %d AND FOLDER_ID < %d "
 709                         "AND STORAGE_ID = %d;",
 710                         MSGFW_MESSAGE_TABLE_NAME,
 711                         convId,
 712                         MSG_ALLBOX_ID, MSG_CBMSGBOX_ID,
 713                         MSG_STORAGE_PHONE);
 714 #endif
 715
 716         msg_error_t err = pDbHandle->prepareQuery(sqlQuery);
 717         if (err != MSG_SUCCESS) {
 718                         MSG_DEBUG("Fail to prepareQuery().");
 719                         pDbHandle->finalizeQuery();
 720                         return err;
 721         }
 722
 723         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 724                 pDbHandle->finalizeQuery();
 725
 726                 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
 727                 snprintf(sqlQuery, sizeof(sqlQuery),
 728                                 "SELECT MAIN_TYPE, SUB_TYPE, MSG_DIRECTION, MSG_ID, DISPLAY_TIME, LENGTH(SUBJECT), SUBJECT, MSG_TEXT, DPM_RESTRICTED "
 729                                 "FROM %s "
 730                                 "WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC;",
 731                                 MSGFW_MESSAGE_TABLE_NAME,
 732                                 convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 733
 734                 err = pDbHandle->prepareQuery(sqlQuery);
 735                 if (err != MSG_SUCCESS) {
 736                         MSG_DEBUG("Fail to prepareQuery().");
 737                         return err;
 738                 }
 739
 740                 err = pDbHandle->stepQuery();
 741                 if (err != MSG_ERR_DB_ROW) {
 742                         MSG_DEBUG("Fail to stepQuery().");
 743                         pDbHandle->finalizeQuery();
 744                         return err;
 745                 }
 746
 747                 int main_type = pDbHandle->columnInt(0);
 748                 int sub_type = pDbHandle->columnInt(1);
 749                 int msg_direction = pDbHandle->columnInt(2);
 750                 int last_msg_id = pDbHandle->columnInt(3);
 751                 time_t disp_time = (time_t)pDbHandle->columnInt(4);
 752                 int subject_length = pDbHandle->columnInt(5);
 753                 bool dpm_restricted = pDbHandle->columnInt(8);
 754                 char subject[MAX_SUBJECT_LEN+1] = {0, };
 755                 char msg_text[MAX_MSG_TEXT_LEN+1] = {0, };
 756                 if (!dpm_restricted) {
 757                         snprintf(subject, sizeof(subject), "%s", pDbHandle->columnText(6));
 758                         snprintf(msg_text, sizeof(msg_text), "%s", pDbHandle->columnText(7));
 759                 } else {
 760                         snprintf(subject, sizeof(subject), "restricted message");
 761                         snprintf(msg_text, sizeof(msg_text), "restricted message");
 762                 }
 763
 764                 pDbHandle->finalizeQuery();
 765                 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
 766                 snprintf(sqlQuery, sizeof(sqlQuery),
 767                                 "UPDATE %s SET ",
 768                                 MSGFW_CONVERSATION_TABLE_NAME);
 769
 770                 tmpSize = strlen(sqlQuery);
 771 #ifdef MSG_NOTI_INTEGRATION
 772                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 773                                 "UNREAD_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND (FOLDER_ID = %d OR FOLDER_ID = %d) AND STORAGE_ID = %d AND READ_STATUS = 0), ",
 774                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 775 #else
 776                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 777                                 "UNREAD_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0), ",
 778                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE);
 779 #endif
 780
 781                 tmpSize = strlen(sqlQuery);
 782 #ifdef MSG_NOTI_INTEGRATION
 783                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 784                                 "SMS_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND MAIN_TYPE = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d), ",
 785                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_SMS_TYPE, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 786 #else
 787                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 788                                 "SMS_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND MAIN_TYPE = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d), ",
 789                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_SMS_TYPE, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 790 #endif
 791
 792                 tmpSize = strlen(sqlQuery);
 793                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 794                                 "MMS_CNT = (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND MAIN_TYPE = %d AND SUB_TYPE NOT IN (%d, %d, %d) AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d), ",
 795                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_MMS_TYPE, MSG_DELIVERYIND_MMS, MSG_READRECIND_MMS, MSG_READORGIND_MMS, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 796
 797 #if 0
 798                 tmpSize = strlen(sqlQuery);
 799                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 800                                 "MAIN_TYPE = (SELECT MAIN_TYPE FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC), ",
 801                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 802
 803                 tmpSize = strlen(sqlQuery);
 804                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 805                                 "SUB_TYPE = (SELECT SUB_TYPE FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC), ",
 806                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 807
 808                 tmpSize = strlen(sqlQuery);
 809                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 810                                 "MSG_DIRECTION = (SELECT MSG_DIRECTION FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC), ",
 811                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 812
 813                 tmpSize = strlen(sqlQuery);
 814 #if 1
 815                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 816                                 "DISPLAY_TIME = CASE "
 817                                 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) > 0 "
 818                                 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) "
 819                                 "ELSE 0 "
 820                                 "END, ",
 821                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
 822                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 823 #else
 824                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 825                                 "DISPLAY_TIME = CASE "
 826                                 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0) > 0 "
 827                                 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0 ORDER BY DISPLAY_TIME DESC) "
 828                                 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d) > 0 "
 829                                 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC) "
 830                                 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND NETWORK_STATUS = %d) > 0 "
 831                                 "THEN (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND NETWORK_STATUS = %d ORDER BY DISPLAY_TIME DESC) "
 832                                 "ELSE (SELECT DISPLAY_TIME FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC) "
 833                                 "END, ",
 834                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE,
 835                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE,
 836                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_DRAFT_ID, MSG_STORAGE_PHONE,
 837                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_DRAFT_ID, MSG_STORAGE_PHONE,
 838                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_OUTBOX_ID, MSG_STORAGE_PHONE, MSG_NETWORK_SEND_FAIL,
 839                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_OUTBOX_ID, MSG_STORAGE_PHONE, MSG_NETWORK_SEND_FAIL,
 840                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 841 #endif
 842
 843 #endif
 844                 tmpSize = strlen(sqlQuery);
 845                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 846                                 "MSG_TEXT = CASE "
 847                                 "WHEN %d > 0 THEN ? ELSE ? "
 848                                 "END, ",
 849                                 subject_length);
 850 #if 0
 851                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 852                                 "MSG_TEXT = CASE "
 853                                 "WHEN (SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) > 0 "
 854                                 "THEN CASE "
 855                                 "WHEN (SELECT LENGTH(SUBJECT) FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) > 0 "
 856                                 "THEN (SELECT SUBJECT FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) "
 857                                 "ELSE (SELECT MSG_TEXT FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d AND SCHEDULED_TIME = 0 ORDER BY DISPLAY_TIME DESC) "
 858                                 "END ELSE '' "
 859                                 "END ",
 860                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
 861                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
 862                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE,
 863                                 MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 864 #endif
 865                 tmpSize = strlen(sqlQuery);
 866                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 867                                 "MAIN_TYPE = %d, SUB_TYPE = %d, MSG_DIRECTION = %d, DISPLAY_TIME = %lu, LAST_MSG_ID = %d ",
 868                                 main_type, sub_type, msg_direction, disp_time, last_msg_id);
 869
 870                 tmpSize = strlen(sqlQuery);
 871                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 872                                 "WHERE CONV_ID = %d;",
 873                                 convId);
 874                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 875                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
 876                         return MSG_ERR_DB_PREPARE;
 877                 }
 878
 879                 pDbHandle->bindText(subject, 1);
 880                 pDbHandle->bindText(msg_text, 2);
 881
 882                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 883                         MSG_DEBUG("stepQuery() Failed");
 884                         pDbHandle->finalizeQuery();
 885                         return MSG_ERR_DB_STEP;
 886                 }
 887
 888                 pDbHandle->finalizeQuery();
 889         } else {
 890                 pDbHandle->finalizeQuery();
 891
 892                 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
 893                 snprintf(sqlQuery, sizeof(sqlQuery),
 894                                 "UPDATE %s SET UNREAD_CNT = 0, SMS_CNT = 0, MMS_CNT = 0, MAIN_TYPE = 0, SUB_TYPE = 0, MSG_DIRECTION = 0, DISPLAY_TIME = 0, MSG_TEXT = '' "
 895                                 "WHERE CONV_ID = %d;",
 896                                 MSGFW_CONVERSATION_TABLE_NAME, convId);
 897
 898                 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
 899                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
 900                         return MSG_ERR_DB_EXEC;
 901                 }
 902         }
 903
 904         MSG_END();
 905
 906         return MSG_SUCCESS;
 907 }
 908
 909
 910 /* consider to replcae this function to trigger. */
 911 msg_error_t MsgStoClearConversationTable(MsgDbHandler *pDbHandle)
 912 {
 913         msg_error_t err = MSG_SUCCESS;
 914
 915         char sqlQuery[MAX_QUERY_LEN+1];
 916
 917         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 918
 919         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s "
 920                         "WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s) AND CONV_ID <> 0;",
 921                         MSGFW_CONVERSATION_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 922
 923         err = pDbHandle->execQuery(sqlQuery);
 924
 925         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s);",
 926                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME);
 927
 928         err = pDbHandle->execQuery(sqlQuery);
 929
 930         return err;
 931 }
 932
 933
 934 msg_thread_id_t MsgGetThreadId(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
 935 {
 936         msg_thread_id_t conv_id = 0;
 937
 938         char sqlQuery[MAX_QUERY_LEN+1];
 939         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 940         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CONV_ID FROM %s WHERE MSG_ID = %d;",
 941                         MSGFW_MESSAGE_TABLE_NAME, msgId);
 942
 943         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 944                 return 0;
 945
 946         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 947                 conv_id = pDbHandle->columnInt(0);
 948         }
 949
 950         pDbHandle->finalizeQuery();
 951
 952         return conv_id;
 953 }
 954
 955 /* Change the function name to conversation related. */
 956 bool MsgExistAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
 957 {
 958         msg_error_t err = MSG_SUCCESS;
 959
 960         char sqlQuery[MAX_QUERY_LEN+1];
 961         unsigned int tmpSize = 0;
 962
 963         *pConvId = 0;
 964
 965         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 966         snprintf(sqlQuery, sizeof(sqlQuery),
 967                         "SELECT CONV_ID FROM ( SELECT CONV_ID FROM %s WHERE ( ",
 968                         MSGFW_ADDRESS_TABLE_NAME);
 969
 970         for (int i = 0; i < pMsg->nAddressCnt; i++) {
 971                 if (strlen(pMsg->addressList[i].addressVal) >= (unsigned int)MsgContactGetMinMatchDigit()
 972                                 && pMsg->addressList[i].addressType != MSG_ADDRESS_TYPE_EMAIL
 973                                 && MsgIsNumber(pMsg->addressList[i].addressVal)) {
 974                         int addrSize = strlen(pMsg->addressList[i].addressVal);
 975                         char newPhoneNum[addrSize+1];
 976                         memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
 977                         MsgConvertNumber(pMsg->addressList[i].addressVal, newPhoneNum, addrSize);
 978
 979                         tmpSize = strlen(sqlQuery);
 980                         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 981                                         "ADDRESS_VAL LIKE '%%%%%s' ",
 982                                         newPhoneNum);
 983
 984                         if ((pMsg->nAddressCnt-1) == i) break;
 985
 986                         tmpSize = strlen(sqlQuery);
 987                         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize, " OR ");
 988
 989                 } else {
 990                         tmpSize = strlen(sqlQuery);
 991                         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
 992                                         "ADDRESS_VAL LIKE '%s' ",
 993                                         pMsg->addressList[i].addressVal);
 994
 995                         if ((pMsg->nAddressCnt-1) == i) break;
 996
 997                         tmpSize = strlen(sqlQuery);
 998                         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize, " OR ");
 999                 }
1000         }
1001
1002         tmpSize = strlen(sqlQuery);
1003         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
1004                         ") AND CONV_ID IN (SELECT CONV_ID FROM %s GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d) ",
1005                         MSGFW_ADDRESS_TABLE_NAME, pMsg->nAddressCnt);
1006
1007
1008         tmpSize = strlen(sqlQuery);
1009         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
1010                         ") GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d;",
1011                         pMsg->nAddressCnt);
1012
1013         int rowCnt = 0;
1014         int convId = 0;
1015
1016         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1017
1018         /* No record or other error */
1019         if (err != MSG_SUCCESS) {
1020                 MSG_DEBUG("Fail to getTable().");
1021                 pDbHandle->freeTable();
1022                 return false;
1023         }
1024
1025         convId = pDbHandle->getColumnToInt(1);
1026
1027         if (convId > 0) {
1028                 MSG_DEBUG("Success  to get convId [%d]", convId);
1029                 *pConvId = convId;
1030                 pDbHandle->freeTable();
1031                 return true;
1032         }
1033
1034         pDbHandle->freeTable();
1035
1036         return false;
1037 }
1038
1039
1040 int MsgStoGetUnreadCnt(MsgDbHandler *pDbHandle, MSG_MAIN_TYPE_T msgType)
1041 {
1042         int msgCnt = 0;
1043
1044         char sqlQuery[MAX_QUERY_LEN+1];
1045
1046         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1047
1048         if (msgType == MSG_SMS_TYPE) {
1049                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s "
1050                                 "WHERE MAIN_TYPE = %d "
1051                                 "AND (SUB_TYPE IN (%d, %d, %d, %d, %d, %d, %d) OR (SUB_TYPE >= %d AND SUB_TYPE <= %d)) "
1052                                 "AND FOLDER_ID = %d AND READ_STATUS = 0 AND STORAGE_ID = %d;",
1053                                 MSGFW_MESSAGE_TABLE_NAME,
1054                                 MSG_SMS_TYPE,
1055                                 MSG_NORMAL_SMS, MSG_STATUS_REPORT_SMS, MSG_CONCAT_SIM_SMS, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_MWI_VOICE_SMS, MSG_SYNCML_CP,
1056                                 MSG_REPLACE_TYPE1_SMS, MSG_REPLACE_TYPE7_SMS,
1057                                 MSG_INBOX_ID, MSG_STORAGE_PHONE);
1058         } else if (msgType == MSG_MMS_TYPE) {
1059                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s "
1060                                 "WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d) "
1061                                 "AND FOLDER_ID = %d AND READ_STATUS = 0 AND STORAGE_ID = %d;",
1062                                 MSGFW_MESSAGE_TABLE_NAME,
1063                                 MSG_MMS_TYPE,
1064                                 MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS,
1065                                 MSG_INBOX_ID, MSG_STORAGE_PHONE);
1066         }
1067
1068         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1069                 return 0;
1070
1071         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1072                 msgCnt = pDbHandle->columnInt(0);
1073         } else {
1074                 pDbHandle->finalizeQuery();
1075                 return 0;
1076         }
1077
1078         pDbHandle->finalizeQuery();
1079
1080         return msgCnt;
1081 }
1082
1083
1084 msg_error_t MsgStoGetMmsRawFilePath(MsgDbHandler *pDbHandle, msg_message_id_t msgId, char *pFilePath)
1085 {
1086         char sqlQuery[MAX_QUERY_LEN+1];
1087
1088         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1089
1090         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.FILE_PATH FROM %s A, %s B \
1091                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1092                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1093
1094         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1095                 return MSG_ERR_DB_PREPARE;
1096
1097         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1098                 if (pDbHandle->columnText(0) != NULL)
1099                         strncpy(pFilePath, (char*)pDbHandle->columnText(0), MSG_FILEPATH_LEN_MAX);
1100         } else {
1101                 pDbHandle->finalizeQuery();
1102                 return MSG_ERR_DB_STEP;
1103         }
1104
1105         pDbHandle->finalizeQuery();
1106
1107         return MSG_SUCCESS;
1108 }
1109
1110
1111 bool MsgStoCheckReadReportRequested(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1112 {
1113         msg_error_t err = MSG_SUCCESS;
1114
1115         char sqlQuery[MAX_QUERY_LEN+1];
1116         int rowCnt = 0;
1117         bool bReadReportRequested = false;
1118
1119         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1120
1121         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ASK_READ_REPLY FROM %s A, %s B \
1122                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1123                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1124
1125         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1126
1127         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1128                 pDbHandle->freeTable();
1129                 MSG_DEBUG("[Error]Failed to Get Table");
1130                 return bReadReportRequested;
1131         }
1132
1133         if (rowCnt != 1) {
1134                 pDbHandle->freeTable();
1135                 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1136                 return bReadReportRequested;
1137         }
1138
1139         bReadReportRequested = pDbHandle->getColumnToInt(1);
1140
1141         pDbHandle->freeTable();
1142
1143         return bReadReportRequested;
1144 }
1145
1146
1147 bool MsgStoCheckReadReportIsSent(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1148 {
1149         msg_error_t err = MSG_SUCCESS;
1150
1151         char sqlQuery[MAX_QUERY_LEN+1];
1152
1153         int rowCnt = 0;
1154         bool bReadReportIsSent = true;
1155
1156         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1157
1158         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.READ_REPORT_SENT FROM %s A, %s B \
1159                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1160                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1161
1162         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1163
1164         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1165                 pDbHandle->freeTable();
1166                 MSG_DEBUG("[Error]Failed to Get Table");
1167                 return bReadReportIsSent;
1168         }
1169
1170         if (rowCnt != 1) {
1171                 pDbHandle->freeTable();
1172                 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1173                 return bReadReportIsSent;
1174         }
1175
1176         bReadReportIsSent = (bool)pDbHandle->getColumnToInt(1);
1177
1178         pDbHandle->freeTable();
1179
1180         return bReadReportIsSent;
1181 }
1182
1183
1184 msg_error_t MsgStoAddConversation(MsgDbHandler *pDbHandle, msg_thread_id_t *pConvId)
1185 {
1186         char sqlQuery[MAX_QUERY_LEN+1];
1187
1188         if(*pConvId == 0) {
1189                 if (pDbHandle->getRowId(MSGFW_CONVERSATION_TABLE_NAME, pConvId) != MSG_SUCCESS) {
1190                         return MSG_ERR_DB_EXEC;
1191                 }
1192         }
1193         /* Add Conversation */
1194         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1195         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 0, 0, 0, 0, 0, 0, 0, '', '', 0);",
1196                         MSGFW_CONVERSATION_TABLE_NAME, *pConvId);
1197
1198         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1199                 MSG_DEBUG("Query Failed. [%s]", sqlQuery);
1200                 return MSG_ERR_DB_EXEC;
1201         }
1202
1203         return MSG_SUCCESS;
1204 }
1205
1206
1207 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, int contactId)
1208 {
1209         msg_error_t err = MSG_SUCCESS;
1210         int rowCnt = 0;
1211         char displayName[MAX_DISPLAY_NAME_LEN+1];
1212         char sqlQuery[MAX_QUERY_LEN+1];
1213
1214         MSG_DEBUG("contactId [%d]", contactId);
1215
1216         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1217         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE CONTACT_ID = %d;",
1218                         MSGFW_ADDRESS_TABLE_NAME, contactId);
1219
1220         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1221
1222         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1223                 pDbHandle->freeTable();
1224                 MSG_DEBUG("Fail to getTable().");
1225                 return err;
1226         }
1227
1228         msg_struct_s *pAddrInfo = NULL;
1229         MSG_ADDRESS_INFO_S *address = NULL;
1230
1231         for (int i = 1; i <= rowCnt; i++) {
1232                 memset(displayName, 0x00, sizeof(displayName));
1233                 MsgDbHandler tmpDbHandle;
1234                 msg_struct_list_s addressList = {0, };
1235                 MsgStoGetAddressByConvId(&tmpDbHandle, (msg_thread_id_t)pDbHandle->getColumnToInt(i), &addressList);
1236
1237                 for (int j = 0; j < addressList.nCount; j++) {
1238                         if (j >0)
1239                                 strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1240
1241                         pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1242                         address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1243
1244                         if (address->displayName[0] == '\0')
1245                                 strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1246                         else
1247                                 strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1248                 }
1249
1250                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1251                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1252                                 MSGFW_CONVERSATION_TABLE_NAME, pDbHandle->getColumnToInt(i));
1253
1254                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1255                         pDbHandle->freeTable();
1256                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
1257                         return MSG_ERR_DB_PREPARE;
1258                 }
1259
1260                 pDbHandle->bindText(displayName, 1);
1261
1262                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1263                         pDbHandle->freeTable();
1264                         pDbHandle->finalizeQuery();
1265                         MSG_SEC_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1266                         return MSG_ERR_DB_STEP;
1267                 }
1268
1269                 pDbHandle->finalizeQuery();
1270
1271                 /* free address list */
1272                 for (int j = 0; j < addressList.nCount; j++) {
1273                         msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1274                         delete (MSG_ADDRESS_INFO_S *)pStruct->data;
1275                         delete (msg_struct_s *)pStruct;
1276                 }
1277
1278                 if (addressList.msg_struct_info != NULL) {
1279                         g_free((msg_struct_t *)addressList.msg_struct_info);
1280                 }
1281         }
1282
1283         pDbHandle->freeTable();
1284
1285         return err;
1286 }
1287
1288
1289 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1290 {
1291         msg_error_t err = MSG_SUCCESS;
1292
1293         char displayName[MAX_DISPLAY_NAME_LEN+1];
1294         char sqlQuery[MAX_QUERY_LEN+1];
1295
1296         msg_struct_list_s addressList = {0, };
1297
1298         msg_struct_s *pAddrInfo = NULL;
1299         MSG_ADDRESS_INFO_S *address = NULL;
1300
1301         memset(displayName, 0x00, sizeof(displayName));
1302
1303         MsgStoGetAddressByConvId(pDbHandle, convId, &addressList);
1304
1305         for (int j = 0; j < addressList.nCount; j++) {
1306                 if (j >0)
1307                         strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1308
1309                 pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1310                 address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1311
1312                 if (address->displayName[0] == '\0')
1313                         strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1314                 else
1315                         strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1316         }
1317
1318         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1319         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1320                         MSGFW_CONVERSATION_TABLE_NAME, convId);
1321
1322         for (int j = 0; j < addressList.nCount; j++) {
1323                 msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1324                 delete (MSG_ADDRESS_INFO_S *)pStruct->data;
1325                 delete (msg_struct_s *)pStruct;
1326         }
1327
1328         if (addressList.msg_struct_info != NULL) {
1329                 g_free((msg_struct_t *)addressList.msg_struct_info);
1330         }
1331
1332         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1333                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1334                 return MSG_ERR_DB_PREPARE;
1335         }
1336
1337         pDbHandle->bindText(displayName, 1);
1338
1339         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1340                 pDbHandle->finalizeQuery();
1341                 MSG_SEC_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1342                 return MSG_ERR_DB_STEP;
1343         }
1344
1345         pDbHandle->finalizeQuery();
1346
1347         return err;
1348 }
1349
1350 msg_error_t MsgStoUpdateNetworkStatus(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsgInfo, msg_network_status_t status)
1351 {
1352         msg_error_t err = MSG_SUCCESS;
1353
1354         char sqlQuery[MAX_QUERY_LEN+1];
1355
1356         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1357
1358         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET NETWORK_STATUS = %d WHERE MSG_ID = %d;",
1359                         MSGFW_MESSAGE_TABLE_NAME, status, pMsgInfo->msgId);
1360
1361         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
1362                 err = MSG_ERR_DB_EXEC;
1363
1364         pDbHandle->finalizeQuery();
1365
1366         return err;
1367 }
1368
1369 bool MsgExistConversation(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1370 {
1371         msg_error_t err = MSG_SUCCESS;
1372
1373         char sqlQuery[MAX_QUERY_LEN+1];
1374
1375         int rowCnt = 0;
1376
1377         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1378
1379         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CONV_ID FROM %s WHERE CONV_ID = %d;",
1380                         MSGFW_CONVERSATION_TABLE_NAME, convId);
1381
1382         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1383
1384         if (err == MSG_ERR_DB_NORECORD) {
1385                 pDbHandle->freeTable();
1386                 return false;
1387         } else if (err != MSG_SUCCESS) {
1388                 pDbHandle->freeTable();
1389                 return false;
1390         }
1391         pDbHandle->freeTable();
1392
1393         return true;
1394 }
1395
1396 bool MsgExistInThreadViewList(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1397 {
1398         msg_error_t err = MSG_SUCCESS;
1399
1400         char sqlQuery[MAX_QUERY_LEN+1];
1401
1402         int rowCnt = 0;
1403
1404         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1405
1406         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d;",
1407                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
1408
1409         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1410
1411         if (err == MSG_ERR_DB_NORECORD) {
1412                 pDbHandle->freeTable();
1413                 return false;
1414         } else if (err != MSG_SUCCESS) {
1415                 pDbHandle->freeTable();
1416                 return false;
1417         }
1418         pDbHandle->freeTable();
1419
1420         return true;
1421 }
1422
1423 bool MsgExistMessage(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsg)
1424 {
1425         msg_error_t err = MSG_SUCCESS;
1426
1427         char sqlQuery[MAX_QUERY_LEN+1];
1428
1429
1430         int rowCnt = 0;
1431
1432         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1433
1434         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE CONV_ID = %ud AND DISPLAY_TIME = %ud;",
1435                         MSGFW_MESSAGE_TABLE_NAME, pMsg->threadId, (int)pMsg->displayTime);
1436
1437         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1438
1439
1440         if (err != MSG_SUCCESS) {
1441                 pDbHandle->freeTable();
1442                 return false;
1443         }
1444
1445         if(rowCnt > 0) {
1446                 pMsg->msgId = pDbHandle->getColumnToInt(1);
1447         }
1448         pDbHandle->freeTable();
1449
1450         return true;
1451 }
1452
1453
1454 bool MsgExistAddress(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsg,  msg_thread_id_t convId, int index)
1455 {
1456         msg_error_t err = MSG_SUCCESS;
1457
1458         char sqlQuery[MAX_QUERY_LEN+1];
1459
1460
1461         int rowCnt = 0;
1462
1463         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1464
1465         if (strlen(pMsg->addressList[index].addressVal) > (unsigned int)MsgContactGetMinMatchDigit()) {
1466                 int addrSize = strlen(pMsg->addressList[index].addressVal);
1467                 char newPhoneNum[addrSize+1];
1468                 memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1469                 MsgConvertNumber(pMsg->addressList[index].addressVal, newPhoneNum, addrSize);
1470
1471                 snprintf(sqlQuery, sizeof(sqlQuery),
1472                                 "SELECT ADDRESS_ID FROM %s WHERE ADDRESS_VAL LIKE '%%%%%s' AND CONV_ID= %d;",
1473                                 MSGFW_ADDRESS_TABLE_NAME, newPhoneNum, convId);
1474         } else {
1475                 snprintf(sqlQuery, sizeof(sqlQuery),
1476                                 "SELECT ADDRESS_ID FROM %s WHERE ADDRESS_VAL = '%s' AND CONV_ID= %d;",
1477                                 MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[index].addressVal, convId);
1478         }
1479
1480         err = pDbHandle->getTable(sqlQuery, &rowCnt, NULL);
1481
1482         if (err == MSG_ERR_DB_NORECORD) {
1483                 pDbHandle->freeTable();
1484                 return false;
1485         } else if (err != MSG_SUCCESS) {
1486                 pDbHandle->freeTable();
1487                 return false;
1488         }
1489         pDbHandle->freeTable();
1490
1491         return true;
1492 }
1493
1494
1495 void MsgStoUpdateAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t convId)
1496 {
1497         MSG_BEGIN();
1498         msg_error_t err = MSG_SUCCESS;
1499
1500         char sqlQuery[MAX_QUERY_LEN+1];
1501
1502         for (int i = 0; i < pMsg->nAddressCnt; i++) {
1503                         if (strlen(pMsg->addressList[i].addressVal) > (unsigned int)MsgContactGetMinMatchDigit() && pMsg->addressList[i].addressType == MSG_ADDRESS_TYPE_PLMN) {
1504                                 int addrSize = strlen(pMsg->addressList[i].addressVal);
1505                                 char newPhoneNum[addrSize+1];
1506                                 memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1507                                 MsgConvertNumber(pMsg->addressList[i].addressVal, newPhoneNum, addrSize);
1508
1509                                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1510                                 snprintf(sqlQuery, sizeof(sqlQuery),
1511                                                 "UPDATE %s SET "
1512                                                 "ADDRESS_VAL = '%s', "
1513                                                 "ADDRESS_TYPE = %d, "
1514                                                 "RECIPIENT_TYPE = %d "
1515                                                 "WHERE CONV_ID = %d "
1516                                                 "AND ADDRESS_VAL LIKE '%%%%%s';",
1517                                                 MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[i].addressVal,
1518                                                 pMsg->addressList[i].addressType, pMsg->addressList[i].recipientType, convId, newPhoneNum);
1519
1520                                 err = pDbHandle->execQuery(sqlQuery);
1521                                 if (err != MSG_SUCCESS) MSG_DEBUG("Fail to execQuery(). [%s]", sqlQuery);
1522
1523                                 pDbHandle->finalizeQuery();
1524                         }
1525         }
1526
1527         MSG_END();
1528 }
1529
1530 msg_error_t MsgStoAddCBChannelInfo(MsgDbHandler *pDbHandle, MSG_CB_CHANNEL_S *pCBChannel, msg_sim_slot_id_t simIndex)
1531 {
1532         MSG_BEGIN();
1533
1534         char sqlQuery[MAX_QUERY_LEN] = {0, };
1535
1536         pDbHandle->beginTrans();
1537
1538         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1539         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE SIM_INDEX = %d;", MSGFW_CB_CHANNEL_INFO_TABLE_NAME, simIndex);
1540
1541         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1542                 pDbHandle->endTrans(false);
1543                 return MSG_ERR_DB_EXEC;
1544         }
1545
1546         for (int i = 0; i < pCBChannel->channelCnt; i++) {
1547                 int index = 1;
1548                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1549                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s(CHANNEL_ACTIVATION, CHANNEL_FROM, CHANNEL_TO, CHANNEL_NAME, SIM_INDEX) VALUES (?, ?, ?, ?, ?);",
1550                                 MSGFW_CB_CHANNEL_INFO_TABLE_NAME);
1551
1552                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1553                         pDbHandle->endTrans(false);
1554                         return MSG_ERR_DB_PREPARE;
1555                 }
1556                 pDbHandle->bindInt(pCBChannel->channelInfo[i].bActivate, index++);
1557                 pDbHandle->bindInt(pCBChannel->channelInfo[i].from, index++);
1558                 pDbHandle->bindInt(pCBChannel->channelInfo[i].to, index++);
1559                 pDbHandle->bindText(pCBChannel->channelInfo[i].name, index++);
1560                 pDbHandle->bindInt(simIndex, index++);
1561
1562                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1563                         pDbHandle->finalizeQuery();
1564                         pDbHandle->endTrans(false);
1565                         return MSG_ERR_DB_STEP;
1566                 }
1567
1568                 pDbHandle->finalizeQuery();
1569         }
1570
1571         pDbHandle->endTrans(true);
1572
1573         MSG_END();
1574
1575         return MSG_SUCCESS;
1576 }
1577
1578
1579 msg_error_t MsgStoGetCBChannelInfo(MsgDbHandler *pDbHandle, MSG_CB_CHANNEL_S *pCBChannel, msg_sim_slot_id_t simIndex)
1580 {
1581         MSG_BEGIN();
1582
1583         int rowCnt = 0, index = 0;
1584
1585         char sqlQuery[MAX_QUERY_LEN] = {0, };
1586
1587         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1588         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CHANNEL_ACTIVATION, CHANNEL_FROM, CHANNEL_TO, CHANNEL_NAME FROM %s WHERE SIM_INDEX = %d;", MSGFW_CB_CHANNEL_INFO_TABLE_NAME, simIndex);
1589
1590         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1591
1592         pCBChannel->channelCnt = rowCnt;
1593
1594         if (err == MSG_ERR_DB_NORECORD) {
1595                 pDbHandle->freeTable();
1596                 return MSG_ERR_DB_NORECORD;
1597         } else if (err != MSG_SUCCESS) {
1598                 MSG_DEBUG("Fail to getTable().");
1599                 pDbHandle->freeTable();
1600                 return MSG_ERR_DB_GETTABLE;
1601         }
1602
1603         for (int i = 0; i < rowCnt; i++) {
1604                 pCBChannel->channelInfo[i].bActivate = pDbHandle->getColumnToInt(index++);
1605                 pCBChannel->channelInfo[i].from  = pDbHandle->getColumnToInt(index++);
1606                 pCBChannel->channelInfo[i].to = pDbHandle->getColumnToInt(index++);
1607                 pDbHandle->getColumnToString(index++, CB_CHANNEL_NAME_MAX, pCBChannel->channelInfo[i].name);
1608
1609                 MSG_DEBUG("CH_ACT = %d", pCBChannel->channelInfo[i].bActivate);
1610                 MSG_DEBUG("CH_FROM = %d", pCBChannel->channelInfo[i].from);
1611                 MSG_DEBUG("CH_TO = %d", pCBChannel->channelInfo[i].to);
1612                 MSG_DEBUG("CH_NAME = %s", pCBChannel->channelInfo[i].name);
1613         }
1614
1615         pDbHandle->freeTable();
1616
1617         MSG_END();
1618
1619         return MSG_SUCCESS;
1620 }
1621
1622
1623 msg_error_t MsgStoAddCBChannelInfo(MsgDbHandler *pDbHandle, MSG_CB_CHANNEL_S *pCBChannel)
1624 {
1625         MSG_BEGIN();
1626
1627         char sqlQuery[MAX_QUERY_LEN] = {0,};
1628
1629         pDbHandle->beginTrans();
1630
1631         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1632         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s;", MSGFW_CDMA_CB_CHANNEL_INFO_TABLE_NAME);
1633
1634         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1635                 pDbHandle->endTrans(false);
1636                 return MSG_ERR_DB_EXEC;
1637         }
1638
1639         for (int i = 0; i < pCBChannel->channelCnt; i++) {
1640                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1641                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, '%s');", MSGFW_CDMA_CB_CHANNEL_INFO_TABLE_NAME,
1642                                 i, pCBChannel->channelInfo[i].bActivate, pCBChannel->channelInfo[i].ctg,
1643                                 pCBChannel->channelInfo[i].lang, pCBChannel->channelInfo[i].name);
1644
1645                 if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1646                         pDbHandle->endTrans(false);
1647                         return MSG_ERR_DB_EXEC;
1648                 }
1649         }
1650
1651         pDbHandle->endTrans(true);
1652
1653         MSG_END();
1654
1655         return MSG_SUCCESS;
1656 }
1657
1658
1659 msg_error_t MsgStoGetCBChannelInfo(MsgDbHandler *pDbHandle, MSG_CB_CHANNEL_S *pCBChannel)
1660 {
1661         MSG_BEGIN();
1662
1663         int rowCnt = 0, index = 0;
1664
1665         char sqlQuery[MAX_QUERY_LEN] = {0, };
1666
1667         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1668         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT CHANNEL_ACTIVATION, CHANNEL_CATEGORY, CHANNEL_LANGUAGE, CHANNEL_NAME FROM %s;", MSGFW_CDMA_CB_CHANNEL_INFO_TABLE_NAME);
1669
1670         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1671
1672         pCBChannel->channelCnt = rowCnt;
1673
1674         if (err == MSG_ERR_DB_NORECORD) {
1675                 pDbHandle->freeTable();
1676                 return MSG_ERR_DB_NORECORD;
1677         } else if (err != MSG_SUCCESS) {
1678                 MSG_ERR("Fail to getTable().");
1679                 pDbHandle->freeTable();
1680                 return MSG_ERR_DB_GETTABLE;
1681         }
1682
1683         for (int i = 0; i < rowCnt; i++) {
1684                 pCBChannel->channelInfo[i].bActivate = pDbHandle->getColumnToInt(index++);
1685                 pCBChannel->channelInfo[i].ctg  = pDbHandle->getColumnToInt(index++);
1686                 pCBChannel->channelInfo[i].lang = pDbHandle->getColumnToInt(index++);
1687                 pDbHandle->getColumnToString(index++, CB_CHANNEL_NAME_MAX, pCBChannel->channelInfo[i].name);
1688
1689                 MSG_DEBUG("CH_ACT: [%d], CH_CTG: [%d], CH_LANG: [%d], CH_NAME: [%s]",
1690                         pCBChannel->channelInfo[i].bActivate, pCBChannel->channelInfo[i].ctg, pCBChannel->channelInfo[i].lang, pCBChannel->channelInfo[i].name);
1691         }
1692
1693         pDbHandle->freeTable();
1694
1695         MSG_END();
1696
1697         return MSG_SUCCESS;
1698 }
1699
1700
1701
1702 msg_error_t MsgStoGetThreadViewList(const MSG_SORT_RULE_S *pSortRule, msg_struct_list_s *pThreadViewList)
1703 {
1704         MsgDbHandler *dbHandle = getDbHandle();
1705         dbHandle->connectReadOnly();
1706
1707         pThreadViewList->nCount = 0;
1708         pThreadViewList->msg_struct_info = NULL;
1709
1710         int rowCnt = 0, index = 0;
1711
1712         char sqlQuery[MAX_QUERY_LEN+1];
1713         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1714
1715         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.CONV_ID, A.UNREAD_CNT, A.SMS_CNT, A.MMS_CNT, A.MAIN_TYPE, A.SUB_TYPE, "
1716                         "A.MSG_DIRECTION, A.DISPLAY_TIME, A.DISPLAY_NAME, A.MSG_TEXT, "
1717                         "(COUNT(CASE WHEN M.PROTECTED = 1 THEN 1 END)) AS PROTECTED, "
1718                         "(CASE WHEN B.FOLDER_ID = %d THEN 1 END) AS DRAFT, "
1719                         "(CASE WHEN B.NETWORK_STATUS = %d THEN 1 END) AS FAILED, "
1720                         "(CASE WHEN B.NETWORK_STATUS = %d THEN 1 END) AS SENDING "
1721                         "FROM %s A "
1722                         "LEFT OUTER JOIN %s B ON A.LAST_MSG_ID = B.MSG_ID "
1723                         "LEFT OUTER JOIN %s M ON A.CONV_ID = M.CONV_ID "
1724                         "WHERE A.SMS_CNT + A.MMS_CNT > 0 "
1725                         "GROUP BY A.CONV_ID ORDER BY A.DISPLAY_TIME DESC;",
1726                         MSG_DRAFT_ID,
1727                         MSG_NETWORK_SEND_FAIL,
1728                         MSG_NETWORK_SENDING,
1729                         MSGFW_CONVERSATION_TABLE_NAME,
1730                         MSGFW_MESSAGE_TABLE_NAME,
1731                         MSGFW_MESSAGE_TABLE_NAME);
1732
1733         msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
1734
1735         if (err == MSG_ERR_DB_NORECORD) {
1736                 dbHandle->freeTable();
1737                 return MSG_SUCCESS;
1738         } else if (err != MSG_SUCCESS) {
1739                 MSG_DEBUG("Fail to getTable().");
1740                 dbHandle->freeTable();
1741                 return err;
1742         }
1743
1744         if (rowCnt < 1) {
1745                 MSG_DEBUG("rowCnt is %d", rowCnt);
1746                 dbHandle->freeTable();
1747                 return err;
1748         }
1749
1750         pThreadViewList->nCount = rowCnt;
1751
1752         MSG_DEBUG("pThreadViewList->nCount [%d]", pThreadViewList->nCount);
1753
1754         pThreadViewList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
1755
1756         MSG_THREAD_VIEW_S *pTmp = NULL;
1757         msg_struct_s *thread_t = NULL;
1758
1759         for (int i = 0; i < rowCnt; i++) {
1760                 thread_t = (msg_struct_s *)new msg_struct_s;
1761                 pThreadViewList->msg_struct_info[i] = (msg_struct_t)thread_t;
1762
1763                 thread_t->type = MSG_STRUCT_THREAD_INFO;
1764                 thread_t->data = new MSG_THREAD_VIEW_S;
1765
1766                 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
1767                 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
1768
1769                 pTmp->threadId = dbHandle->getColumnToInt(index++);
1770
1771                 pTmp->unreadCnt = dbHandle->getColumnToInt(index++);
1772                 pTmp->smsCnt = dbHandle->getColumnToInt(index++);
1773                 pTmp->mmsCnt = dbHandle->getColumnToInt(index++);
1774
1775                 pTmp->mainType = dbHandle->getColumnToInt(index++);
1776                 pTmp->subType = dbHandle->getColumnToInt(index++);
1777
1778                 pTmp->direction = dbHandle->getColumnToInt(index++);
1779                 pTmp->threadTime = (time_t)dbHandle->getColumnToInt(index++);
1780
1781                 memset(pTmp->threadName, 0x00, sizeof(pTmp->threadName));
1782                 dbHandle->getColumnToString(index++, MAX_THREAD_NAME_LEN, pTmp->threadName);
1783
1784                 char tmpData[MAX_THREAD_DATA_LEN + 1] = {0};
1785                 dbHandle->getColumnToString(index++, MAX_THREAD_DATA_LEN, tmpData);
1786                 memset(pTmp->threadData, 0x00, sizeof(pTmp->threadData));
1787                 char *end = NULL;
1788                 if (g_utf8_validate(tmpData, -1, (const gchar **)&end) == true) {
1789                         g_utf8_strncpy(pTmp->threadData, tmpData, g_utf8_strlen(tmpData, -1));
1790                 } else {
1791                         g_utf8_strncpy(pTmp->threadData, tmpData, g_utf8_strlen(tmpData, end - tmpData));
1792                 }
1793
1794                 pTmp->bProtected = (dbHandle->getColumnToInt(index++) > 0) ? true : false;
1795                 pTmp->bDraft = dbHandle->getColumnToInt(index++);
1796                 pTmp->bSendFailed = dbHandle->getColumnToInt(index++);
1797                 pTmp->bSending = dbHandle->getColumnToInt(index++);
1798         }
1799
1800         dbHandle->freeTable();
1801
1802         return MSG_SUCCESS;
1803 }
1804
1805
1806 msg_error_t MsgStoGetThreadViewListWithCondition(const MSG_SORT_RULE_S *pSortRule, const MSG_LIST_CONDITION_S *pListCond, msg_struct_list_s *pThreadViewList)
1807 {
1808         msg_error_t err = MSG_SUCCESS;
1809
1810         if (!pListCond) {
1811                 err = MsgStoGetThreadViewList(pSortRule, pThreadViewList);
1812                 if (err != MSG_SUCCESS) {
1813                         MSG_ERR("MsgStoGetThreadViewList() Error!!");
1814                 }
1815
1816                 return err;
1817         }
1818
1819         MsgDbHandler *dbHandle = getDbHandle();
1820         dbHandle->connectReadOnly();
1821
1822         pThreadViewList->nCount = 0;
1823         pThreadViewList->msg_struct_info = NULL;
1824
1825         int rowCnt = 0, index = 0;
1826
1827         char sqlQuery[MAX_QUERY_LEN+1];
1828         char sqlQuerySubset[MAX_QUERY_LEN+1];
1829         char conditionQuery[MAX_QUERY_LEN+1] = {0};
1830
1831         if (pListCond->bProtected == true) {
1832                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
1833                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "PROTECTED = 1 AND ");
1834                 strncat(conditionQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(conditionQuery));
1835         }
1836
1837         if (pListCond->folderId > MSG_ALLBOX_ID) {
1838                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
1839                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FOLDER_ID = %d ", pListCond->folderId);
1840                 strncat(conditionQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(conditionQuery));
1841         } else {
1842                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
1843                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FOLDER_ID > %d AND FOLDER_ID < %d ", MSG_ALLBOX_ID, MSG_SPAMBOX_ID);
1844                 strncat(conditionQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(conditionQuery));
1845         }
1846
1847         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1848         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE ", MSGFW_MESSAGE_TABLE_NAME);
1849
1850         strncat(sqlQuery, conditionQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1851
1852         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
1853         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY DISPLAY_TIME DESC;");
1854         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
1855
1856
1857         err = dbHandle->getTable(sqlQuery, &rowCnt, NULL);
1858         if (err == MSG_ERR_DB_NORECORD) {
1859                 return MSG_SUCCESS;
1860         } else if (err != MSG_SUCCESS) {
1861                 MSG_ERR("Fail to getTable(). [%d]", err);
1862                 dbHandle->freeTable();
1863                 return err;
1864         }
1865
1866         msg_thread_id_t conv_ids[rowCnt];
1867         for (int i = 1; i <= rowCnt; i++) {
1868                 conv_ids[i - 1] = dbHandle->getColumnToInt(i);
1869         }
1870
1871         dbHandle->freeTable();
1872
1873         pThreadViewList->nCount = rowCnt;
1874         MSG_DEBUG("pThreadViewList->nCount [%d]", pThreadViewList->nCount);
1875
1876         pThreadViewList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
1877         if (pThreadViewList->msg_struct_info == NULL) {
1878                 MSG_ERR("calloc failed");
1879                 return MSG_ERR_MEMORY_ERROR;
1880         }
1881
1882         MSG_THREAD_VIEW_S *pTmp = NULL;
1883         msg_struct_s *thread_t = NULL;
1884
1885         for (int i = 0; i < pThreadViewList->nCount; i++) {
1886                 thread_t = (msg_struct_s *)new msg_struct_s;
1887                 pThreadViewList->msg_struct_info[i] = (msg_struct_t)thread_t;
1888                 thread_t->type = MSG_STRUCT_THREAD_INFO;
1889                 thread_t->data = new MSG_THREAD_VIEW_S;
1890
1891                 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
1892                 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
1893
1894                 pTmp->threadId = conv_ids[i];
1895
1896                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1897                 snprintf(sqlQuery, MAX_QUERY_LEN, "SELECT DISPLAY_NAME FROM %s WHERE CONV_ID = %d;",
1898                                 MSGFW_CONVERSATION_TABLE_NAME, conv_ids[i]);
1899
1900                 err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
1901                 if (err != MSG_SUCCESS) {
1902                         MSG_ERR("Fail to getTable(). [%d]", err);
1903                         dbHandle->freeTable();
1904                         return err;
1905                 }
1906
1907                 dbHandle->getColumnToString(index++, MAX_THREAD_NAME_LEN, pTmp->threadName);
1908
1909                 dbHandle->freeTable();
1910
1911                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1912                 snprintf(sqlQuery, MAX_QUERY_LEN, "SELECT "
1913                                 "(COUNT(DISTINCT(CASE WHEN READ_STATUS = 0 THEN MSG_ID END))) AS UNREAD_CNT, "
1914                                 "(COUNT(DISTINCT(CASE WHEN MAIN_TYPE = %d THEN MSG_ID END))) AS SMS_CNT, "
1915                                 "(COUNT(DISTINCT(CASE WHEN MAIN_TYPE = %d THEN MSG_ID END))) AS MMS_CNT "
1916                                 "FROM %s WHERE CONV_ID = %d AND ",
1917                                 MSG_SMS_TYPE,
1918                                 MSG_MMS_TYPE,
1919                                 MSGFW_MESSAGE_TABLE_NAME, conv_ids[i]);
1920
1921                 strncat(sqlQuery, conditionQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1922                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ";");
1923                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
1924
1925                 err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
1926                 if (err != MSG_SUCCESS) {
1927                         MSG_ERR("Fail to getTable(). [%d]", err);
1928                         dbHandle->freeTable();
1929                         return err;
1930                 }
1931
1932                 pTmp->unreadCnt = dbHandle->getColumnToInt(index++);
1933                 pTmp->smsCnt = dbHandle->getColumnToInt(index++);
1934                 pTmp->mmsCnt = dbHandle->getColumnToInt(index++);
1935
1936                 dbHandle->freeTable();
1937
1938                 memset(sqlQuery, 0x00, MAX_QUERY_LEN);
1939                 snprintf(sqlQuery, sizeof(sqlQuery),
1940                                 "SELECT MAIN_TYPE, SUB_TYPE, MSG_DIRECTION, DISPLAY_TIME, DPM_RESTRICTED, (CASE WHEN LENGTH(SUBJECT) > 0 THEN SUBJECT ELSE MSG_TEXT END) "
1941                                 "FROM %s WHERE CONV_ID = %d AND ",
1942                                 MSGFW_MESSAGE_TABLE_NAME, conv_ids[i]);
1943
1944                 strncat(sqlQuery, conditionQuery, MAX_QUERY_LEN-strlen(sqlQuery));
1945                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY DISPLAY_TIME DESC LIMIT 1;");
1946                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
1947
1948                 err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
1949                 if (err != MSG_SUCCESS) {
1950                         MSG_ERR("Fail to getTable(). [%d]", err);
1951                         dbHandle->freeTable();
1952                         return err;
1953                 }
1954
1955                 pTmp->mainType = (MSG_MAIN_TYPE_T)dbHandle->getColumnToInt(index++);
1956                 pTmp->subType = (MSG_SUB_TYPE_T)dbHandle->getColumnToInt(index++);
1957                 pTmp->direction = (msg_direction_type_t)dbHandle->getColumnToInt(index++);
1958                 pTmp->threadTime = (time_t)dbHandle->getColumnToInt(index++);
1959                 bool dpm_restricted = dbHandle->getColumnToInt(index++);
1960                 char tmpData[MAX_THREAD_DATA_LEN + 1] = {0};
1961                 if (!dpm_restricted) {
1962                         dbHandle->getColumnToString(index++, MAX_THREAD_DATA_LEN, tmpData);
1963                 } else {
1964                         snprintf(tmpData, sizeof(tmpData), "restricted message");
1965                 }
1966
1967                 char *end = NULL;
1968                 if (g_utf8_validate(tmpData, -1, (const gchar **)&end) == true) {
1969                         g_utf8_strncpy(pTmp->threadData, tmpData, g_utf8_strlen(tmpData, -1));
1970                 } else {
1971                         g_utf8_strncpy(pTmp->threadData, tmpData, g_utf8_strlen(tmpData, end - tmpData));
1972                 }
1973
1974                 dbHandle->freeTable();
1975         }
1976
1977         return MSG_SUCCESS;
1978 }
1979
1980
1981 msg_error_t MsgStoGetConversationPreview(MsgDbHandler *pDbHandle, MSG_CONVERSATION_VIEW_S *pConv)
1982 {
1983         char sqlQuery[MAX_QUERY_LEN + 1];
1984         int rowCnt = 0, index = 0;
1985         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1986
1987         if (pConv == NULL)
1988                 return MSG_ERR_NULL_POINTER;
1989
1990         pConv->tcs_bc_level = -1; /* init */
1991
1992         /*(MSG_ID INTEGER, TYPE INTEGER, VALUE TEXT, COUNT INTEGER) */
1993         snprintf(sqlQuery, sizeof(sqlQuery),
1994                         "SELECT TYPE, VALUE, COUNT "
1995                         "FROM %s WHERE MSG_ID=%d;",
1996                         MSGFW_MMS_PREVIEW_TABLE_NAME, pConv->msgId);
1997
1998         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
1999         if (err == MSG_SUCCESS) {
2000                 for (int i = 0; i < rowCnt; i++) {
2001                         int type = pDbHandle->getColumnToInt(index++);
2002                         if (type == MSG_MMS_ITEM_TYPE_IMG) {
2003                                 pDbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->imageThumbPath);
2004                                 pDbHandle->getColumnToInt(index++);
2005                         } else if (type == MSG_MMS_ITEM_TYPE_VIDEO) {
2006                                 pDbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->videoThumbPath);
2007                                 pDbHandle->getColumnToInt(index++);
2008                         } else if (type == MSG_MMS_ITEM_TYPE_AUDIO) {
2009                                 pDbHandle->getColumnToString(index++, MSG_FILENAME_LEN_MAX, pConv->audioFileName);
2010                                 pDbHandle->getColumnToInt(index++);
2011                         } else if (type == MSG_MMS_ITEM_TYPE_ATTACH) {
2012                                 pDbHandle->getColumnToString(index++, MSG_FILENAME_LEN_MAX, pConv->attachFileName);
2013                                 pConv->attachCount = pDbHandle->getColumnToInt(index++);
2014                         } else if (type == MSG_MMS_ITEM_TYPE_PAGE) {
2015                                 index++;
2016                                 pConv->pageCount = pDbHandle->getColumnToInt(index++);
2017                         } else if (type == MSG_MMS_ITEM_TYPE_MALWARE) {
2018                                 index++;
2019                                 pConv->tcs_bc_level = pDbHandle->getColumnToInt(index++);
2020                         } else if (type == MSG_MMS_ITEM_TYPE_1ST_MEDIA) {
2021                                 pDbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, pConv->firstMediaPath);
2022                                 pDbHandle->getColumnToInt(index++);
2023                         } else {
2024                                 MSG_DEBUG("Unknown item type [%d]", type);
2025                                 index+=2;
2026                         }
2027                 }
2028         }
2029
2030         pDbHandle->freeTable();
2031         return MSG_SUCCESS;
2032 }
2033
2034 msg_error_t MsgStoGetConversationMultipart(MsgDbHandler *pDbHandle, MSG_CONVERSATION_VIEW_S *pConv)
2035 {
2036         char sqlQuery[MAX_QUERY_LEN + 1];
2037         int rowCnt = 0, index = 0;
2038         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2039
2040         if (pConv == NULL)
2041                 return MSG_ERR_NULL_POINTER;
2042
2043         snprintf(sqlQuery, sizeof(sqlQuery),
2044                         "SELECT CONTENT_TYPE, NAME, FILE_PATH, CONTENT_ID, CONTENT_LOCATION, TCS_LEVEL, MALWARE_ALLOW, THUMB_FILE_PATH "
2045                         "FROM %s WHERE MSG_ID=%d;",
2046                         MSGFW_MMS_MULTIPART_TABLE_NAME, pConv->msgId);
2047
2048         msg_error_t err = pDbHandle->getTable(sqlQuery, &rowCnt, &index);
2049         if (err == MSG_SUCCESS) {
2050                 GList *multipart_list = NULL;
2051                 for (int i = 0; i < rowCnt; i++) {
2052                         msg_struct_s *multipart_struct_s = new msg_struct_s;
2053                         multipart_struct_s->type = MSG_STRUCT_MULTIPART_INFO;
2054                         multipart_struct_s->data = new MMS_MULTIPART_DATA_S;
2055                         memset(multipart_struct_s->data, 0x00, sizeof(MMS_MULTIPART_DATA_S));
2056
2057                         MMS_MULTIPART_DATA_S *multipart = (MMS_MULTIPART_DATA_S *)multipart_struct_s->data;
2058
2059                         pDbHandle->getColumnToString(index++, sizeof(multipart->szContentType), multipart->szContentType);
2060                         pDbHandle->getColumnToString(index++, sizeof(multipart->szFileName), multipart->szFileName);
2061                         pDbHandle->getColumnToString(index++, sizeof(multipart->szFilePath), multipart->szFilePath);
2062                         pDbHandle->getColumnToString(index++, sizeof(multipart->szContentID), multipart->szContentID);
2063                         pDbHandle->getColumnToString(index++, sizeof(multipart->szContentLocation), multipart->szContentLocation);
2064
2065                         multipart->tcs_bc_level = pDbHandle->getColumnToInt(index++);
2066                         multipart->malware_allow = pDbHandle->getColumnToInt(index++);
2067                         pDbHandle->getColumnToString(index++, sizeof(multipart->szThumbFilePath), multipart->szThumbFilePath);
2068
2069                         multipart_list = g_list_append(multipart_list, multipart_struct_s);
2070                 }
2071                 pConv->multipart_list = (msg_list_handle_t)multipart_list;
2072         }
2073
2074         pDbHandle->freeTable();
2075         return MSG_SUCCESS;
2076 }
2077
2078 msg_error_t MsgStoGetConversationViewItem(msg_message_id_t msgId, MSG_CONVERSATION_VIEW_S *pConv)
2079 {
2080         MsgDbHandler *dbHandle = getDbHandle();
2081         dbHandle->connectReadOnly();
2082
2083         int rowCnt = 0, index = 0;
2084
2085         char sqlQuery[MAX_QUERY_LEN+1];
2086
2087         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2088
2089         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2090                         DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2091                         MSG_DIRECTION, DPM_RESTRICTED, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, SIM_INDEX\
2092                         FROM %s WHERE MSG_ID = %d;",
2093                         MSGFW_MESSAGE_TABLE_NAME, msgId);
2094
2095         msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
2096
2097         if (err == MSG_ERR_DB_NORECORD) {
2098                 dbHandle->freeTable();
2099                 return MSG_SUCCESS;
2100         } else if (err != MSG_SUCCESS) {
2101                 MSG_DEBUG("Fail to getTable().");
2102                 dbHandle->freeTable();
2103                 return err;
2104         }
2105
2106         memset(pConv, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
2107         pConv->pText = NULL;
2108
2109         pConv->msgId = dbHandle->getColumnToInt(index++);
2110         pConv->threadId = dbHandle->getColumnToInt(index++);
2111         pConv->folderId = dbHandle->getColumnToInt(index++);
2112         pConv->storageId = dbHandle->getColumnToInt(index++);
2113         pConv->mainType = dbHandle->getColumnToInt(index++);
2114         pConv->subType = dbHandle->getColumnToInt(index++);
2115         pConv->displayTime = (time_t)dbHandle->getColumnToInt(index++);
2116         pConv->textSize = dbHandle->getColumnToInt(index++);
2117         pConv->networkStatus = dbHandle->getColumnToInt(index++);
2118         pConv->bRead = dbHandle->getColumnToInt(index++);
2119         pConv->bProtected = dbHandle->getColumnToInt(index++);
2120         pConv->direction = dbHandle->getColumnToInt(index++);
2121         pConv->bRestricted = dbHandle->getColumnToInt(index++);
2122         pConv->scheduledTime = (time_t)dbHandle->getColumnToInt(index++);
2123
2124         dbHandle->getColumnToString(index++, MAX_SUBJECT_LEN, pConv->subject);
2125         char *tmpText = g_strdup(dbHandle->getColumnToString(index++));
2126
2127         /*It does Not need to Get attach count in MSG_MESSAGE_TABLE. see MsgStoGetConversationPreview */
2128         /*pConv->attachCount = dbHandle->getColumnToInt(index++); */
2129         index++;
2130         if (pConv->bRestricted == true) {
2131                 pConv->textSize = 0;
2132                 memset(pConv->subject, 0x00, sizeof(pConv->subject));
2133                 if (tmpText)
2134                         tmpText[0] = '\0';
2135         }
2136
2137         pConv->simIndex = dbHandle->getColumnToInt(index++);
2138
2139         dbHandle->freeTable();
2140
2141         if (pConv->mainType == MSG_MMS_TYPE &&
2142                 (pConv->networkStatus == MSG_NETWORK_RETRIEVING || pConv->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pConv->subType == MSG_NOTIFICATIONIND_MMS)) {
2143                 pConv->pText = NULL;
2144                 pConv->textSize = 0;
2145         } else {
2146                 if (pConv->mainType == MSG_SMS_TYPE) {
2147                         pConv->pText = new char[pConv->textSize+2];
2148                         memset(pConv->pText, 0x00, pConv->textSize+2);
2149                         snprintf(pConv->pText, pConv->textSize+1, "%s", tmpText);
2150                 } else if (pConv->mainType == MSG_MMS_TYPE) {
2151                         if (tmpText) {
2152                                 pConv->textSize = strlen(tmpText);
2153
2154                                 pConv->pText = new char[pConv->textSize+1];
2155                                 memset(pConv->pText, 0x00, pConv->textSize+1);
2156
2157                                 strncpy(pConv->pText, tmpText, pConv->textSize);
2158                         }
2159
2160                         MsgStoGetConversationPreview(dbHandle, pConv);
2161                         MsgStoGetConversationMultipart(dbHandle, pConv);
2162                 }
2163         }
2164
2165         if (tmpText) {
2166                 g_free(tmpText);
2167                 tmpText = NULL;
2168         }
2169
2170         MSG_END();
2171
2172         return MSG_SUCCESS;
2173 }
2174
2175
2176 msg_error_t MsgStoGetConversationViewList(msg_thread_id_t threadId, msg_struct_list_s *pConvViewList)
2177 {
2178         MSG_BEGIN();
2179
2180         MsgDbHandler *dbHandle = getDbHandle();
2181         dbHandle->connectReadOnly();
2182
2183         pConvViewList->nCount = 0;
2184         pConvViewList->msg_struct_info = NULL;
2185
2186         int rowCnt = 0, index = 0;
2187
2188         char sqlQuery[MAX_QUERY_LEN+1];
2189
2190         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2191
2192 #ifdef MSG_NOTI_INTEGRATION
2193         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2194                         DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2195                         MSG_DIRECTION, DPM_RESTRICTED, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT, SIM_INDEX  \
2196                         FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME, MSG_ID ASC;",
2197                         MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
2198 #else
2199         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, CONV_ID, FOLDER_ID, STORAGE_ID, MAIN_TYPE, SUB_TYPE, \
2200                         DISPLAY_TIME, DATA_SIZE, NETWORK_STATUS, READ_STATUS, PROTECTED, \
2201                         MSG_DIRECTION, DPM_RESTRICTED, SCHEDULED_TIME, SUBJECT, MSG_TEXT, ATTACHMENT_COUNT \
2202                         FROM %s WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME, MSG_ID ASC;",
2203                         MSGFW_MESSAGE_TABLE_NAME, threadId, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
2204 #endif
2205
2206         msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
2207
2208         if (err == MSG_ERR_DB_NORECORD) {
2209                 dbHandle->freeTable();
2210                 return MSG_SUCCESS;
2211         } else if (err != MSG_SUCCESS) {
2212                 MSG_DEBUG("Fail to getTable().");
2213                 dbHandle->freeTable();
2214                 return err;
2215         }
2216
2217         pConvViewList->nCount = rowCnt;
2218         char *tmpText[rowCnt] = {NULL};
2219
2220         MSG_DEBUG("pConvViewList->nCount [%d]", pConvViewList->nCount);
2221
2222         pConvViewList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(msg_struct_t));
2223         memset(pConvViewList->msg_struct_info, 0x00, sizeof(msg_struct_t) * rowCnt);
2224
2225         msg_struct_s *conv = NULL;
2226         MSG_CONVERSATION_VIEW_S *pTmp = NULL;
2227
2228         for (int i = 0; i < rowCnt; i++) {
2229                 pConvViewList->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2230                 memset(pConvViewList->msg_struct_info[i], 0x00, sizeof(msg_struct_s));
2231
2232                 conv = (msg_struct_s *)pConvViewList->msg_struct_info[i];
2233
2234                 conv->type = MSG_STRUCT_CONV_INFO;
2235                 conv->data = new MSG_CONVERSATION_VIEW_S;
2236                 memset(conv->data, 0x00, sizeof(MSG_CONVERSATION_VIEW_S));
2237
2238                 pTmp = (MSG_CONVERSATION_VIEW_S *)conv->data;
2239
2240                 pTmp->pText = NULL;
2241
2242                 pTmp->msgId = dbHandle->getColumnToInt(index++);
2243                 pTmp->threadId = dbHandle->getColumnToInt(index++);
2244                 pTmp->folderId = dbHandle->getColumnToInt(index++);
2245                 pTmp->storageId = dbHandle->getColumnToInt(index++);
2246                 pTmp->mainType = dbHandle->getColumnToInt(index++);
2247                 pTmp->subType = dbHandle->getColumnToInt(index++);
2248                 pTmp->displayTime = (time_t)dbHandle->getColumnToInt(index++);
2249                 pTmp->textSize = dbHandle->getColumnToInt(index++);
2250                 pTmp->networkStatus = dbHandle->getColumnToInt(index++);
2251                 pTmp->bRead = dbHandle->getColumnToInt(index++);
2252                 pTmp->bProtected = dbHandle->getColumnToInt(index++);
2253                 pTmp->direction = dbHandle->getColumnToInt(index++);
2254                 pTmp->bRestricted = dbHandle->getColumnToInt(index++);
2255                 index++; /* This field is reserved. */
2256
2257                 dbHandle->getColumnToString(index++, MAX_SUBJECT_LEN, pTmp->subject);
2258                 tmpText[i] = g_strdup(dbHandle->getColumnToString(index++));
2259
2260                 /*It does Not need to Get attach count in MSG_MESSAGE_TABLE. see MsgStoGetConversationPreview */
2261                 /*pTmp->attachCount = dbHandle->getColumnToInt(index++); */
2262                 index++;
2263
2264                 if (pTmp->bRestricted == true) {
2265                         pTmp->textSize = 0;
2266                         memset(pTmp->subject, 0x00, sizeof(pTmp->subject));
2267                         if (tmpText[i])
2268                                 tmpText[i][0] = '\0';
2269                 }
2270                 pTmp->simIndex = dbHandle->getColumnToInt(index++);
2271         }
2272         dbHandle->freeTable();
2273
2274         for (int i = 0; i < pConvViewList->nCount; i++) {
2275                 conv = (msg_struct_s *)pConvViewList->msg_struct_info[i];
2276                 pTmp = (MSG_CONVERSATION_VIEW_S *)conv->data;
2277
2278                 if (pTmp->mainType == MSG_MMS_TYPE &&
2279                         (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
2280                         pTmp->pText = NULL;
2281                         pTmp->textSize = 0;
2282                 } else {
2283                         if (pTmp->mainType == MSG_SMS_TYPE) {
2284                                 pTmp->pText = new char[pTmp->textSize+2];
2285                                 memset(pTmp->pText, 0x00, pTmp->textSize+2);
2286                                 snprintf(pTmp->pText, pTmp->textSize+1, "%s", tmpText[i]);
2287                         } else if (pTmp->mainType == MSG_MMS_TYPE) {
2288                                 if (tmpText[i]) {
2289                                         pTmp->textSize = strlen(tmpText[i]);
2290
2291                                         pTmp->pText = new char[pTmp->textSize+1];
2292                                         memset(pTmp->pText, 0x00, pTmp->textSize+1);
2293
2294                                         strncpy(pTmp->pText, tmpText[i], pTmp->textSize);
2295                                 }
2296
2297                                 MsgStoGetConversationPreview(dbHandle, pTmp);
2298                                 MsgStoGetConversationMultipart(dbHandle, pTmp);
2299                         }
2300                 }
2301                 if (tmpText[i]) {
2302                         g_free(tmpText[i]);
2303                         tmpText[i] = NULL;
2304                 }
2305         }
2306
2307         MSG_END();
2308
2309         return MSG_SUCCESS;
2310 }
2311
2312
2313 msg_error_t MsgStoSearchMessage(const char *pSearchString, msg_struct_list_s *pThreadViewList, int contactCount)
2314 {
2315         if (!pSearchString)
2316                 return MSG_ERR_NULL_POINTER;
2317
2318         MsgDbHandler *dbHandle = getDbHandle();
2319         dbHandle->connectReadOnly();
2320         char *escapeAddressStr = NULL;
2321
2322         /* Clear Out Parameter */
2323         pThreadViewList->nCount = 0;
2324         pThreadViewList->msg_struct_info = NULL;
2325
2326         tr1::unordered_set<msg_thread_id_t> IdList;
2327         queue<MSG_THREAD_VIEW_S> searchList;
2328
2329         MSG_THREAD_VIEW_S threadView;
2330
2331         char sqlQuery[MAX_QUERY_LEN+1];
2332
2333         /* Search - Address, Name */
2334         memset(sqlQuery, 0x00, MAX_QUERY_LEN+1);
2335         snprintf(sqlQuery, MAX_QUERY_LEN, "SELECT A.CONV_ID, A.UNREAD_CNT, A.SMS_CNT, A.MMS_CNT, A.DISPLAY_NAME, "
2336                         "A.MAIN_TYPE, A.SUB_TYPE, A.MSG_DIRECTION, A.DISPLAY_TIME, A.MSG_TEXT, "
2337                         "(SELECT COUNT(*) FROM %s B WHERE B.CONV_ID = A.CONV_ID AND B.PROTECTED = 1) AS PROTECTED, "
2338                         "(SELECT COUNT(*) FROM %s B WHERE B.MSG_ID = A.LAST_MSG_ID AND B.FOLDER_ID = %d) AS DRAFT, "
2339                         "(SELECT COUNT(*) FROM %s B WHERE B.MSG_ID = A.LAST_MSG_ID AND B.NETWORK_STATUS = %d) AS FAILED, "
2340                         "(SELECT COUNT(*) FROM %s B WHERE B.MSG_ID = A.LAST_MSG_ID AND B.NETWORK_STATUS = %d) AS SENDING "
2341                         "FROM %s A WHERE (A.SMS_CNT > 0 OR A.MMS_CNT > 0) "
2342                         "AND A.CONV_ID IN "
2343                         "(SELECT DISTINCT(CONV_ID) FROM %s WHERE "
2344                         "ADDRESS_VAL LIKE ? ESCAPE '%c' ",
2345                         MSGFW_MESSAGE_TABLE_NAME,
2346                         MSGFW_MESSAGE_TABLE_NAME, MSG_DRAFT_ID,
2347                         MSGFW_MESSAGE_TABLE_NAME, MSG_NETWORK_SEND_FAIL,
2348                         MSGFW_MESSAGE_TABLE_NAME, MSG_NETWORK_SENDING,
2349                         MSGFW_CONVERSATION_TABLE_NAME,
2350                         MSGFW_ADDRESS_TABLE_NAME,
2351                         MSGFW_DB_ESCAPE_CHAR);
2352
2353         unsigned int tmpSize = 0;
2354         if (contactCount > 0) {
2355                 tmpSize = strlen(sqlQuery);
2356                 snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
2357                                 "OR ADDRESS_VAL IN (SELECT C.ADDRESS_VAL FROM %s C JOIN %s D ON (C.ADDRESS_VAL LIKE D.ADDRESS_VAL))"
2358                                 , MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TEMP_TABLE_NAME);
2359         }
2360
2361         tmpSize = strlen(sqlQuery);
2362         snprintf(sqlQuery+tmpSize, MAX_QUERY_LEN-tmpSize,
2363                         ") ORDER BY A.DISPLAY_TIME DESC;");
2364
2365         MSG_DEBUG("sqlQuery=[%s]", sqlQuery);
2366
2367         if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
2368                 MSG_DEBUG("Prepare query fail.");
2369                 return MSG_ERR_DB_PREPARE;
2370         }
2371
2372         MsgConvertStrWithEscape(pSearchString, &escapeAddressStr);
2373         MSG_DEBUG("escapeAddressStr [%s]", escapeAddressStr);
2374         dbHandle->bindText(escapeAddressStr, 1);
2375         /*dbHandle->bindText(escapeAddressStr, 2); */
2376         /*dbHandle->bindText(escapeAddressStr, 3); */
2377         /*dbHandle->bindText(escapeAddressStr, 4); */
2378
2379         while (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
2380                 memset(&threadView, 0x00, sizeof(threadView));
2381
2382                 threadView.threadId = dbHandle->columnInt(0);
2383                 threadView.unreadCnt = dbHandle->columnInt(1);
2384                 threadView.smsCnt = dbHandle->columnInt(2);
2385                 threadView.mmsCnt = dbHandle->columnInt(3);
2386
2387                 if (dbHandle->columnText(4))
2388                         strncpy(threadView.threadName, (char *)dbHandle->columnText(4), MAX_THREAD_NAME_LEN);
2389
2390                 threadView.mainType = dbHandle->columnInt(5);
2391                 threadView.subType = dbHandle->columnInt(6);
2392
2393                 threadView.direction = dbHandle->columnInt(7);
2394                 threadView.threadTime = (time_t)dbHandle->columnInt(8);
2395
2396                 if (dbHandle->columnText(9))
2397                         strncpy(threadView.threadData, (char *)dbHandle->columnText(9), MAX_THREAD_DATA_LEN);
2398
2399                 int protectedCnt = dbHandle->columnInt(10);
2400                 if (protectedCnt > 0)
2401                         threadView.bProtected = true;
2402
2403                 int draftCnt = dbHandle->columnInt(11);
2404                 if (draftCnt > 0)
2405                         threadView.bDraft = true;
2406
2407                 int failedCnt = dbHandle->columnInt(12);
2408                 if (failedCnt > 0)
2409                         threadView.bSendFailed = true;
2410
2411                 int sendingCnt = dbHandle->columnInt(13);
2412                 if (sendingCnt > 0)
2413                         threadView.bSending = true;
2414
2415                 tr1::unordered_set<msg_thread_id_t>::iterator it;
2416
2417                 it = IdList.find(threadView.threadId);
2418
2419                 if (it == IdList.end()) {
2420                         IdList.insert(threadView.threadId);
2421                         searchList.push(threadView);
2422                 }
2423         }
2424
2425         dbHandle->finalizeQuery();
2426
2427         if (escapeAddressStr) {
2428                 free(escapeAddressStr);
2429                 escapeAddressStr = NULL;
2430         }
2431
2432
2433         /* Add data to Out Parameter */
2434         pThreadViewList->nCount = searchList.size();
2435         pThreadViewList->msg_struct_info = (msg_struct_t *)calloc(searchList.size(), sizeof(msg_struct_t));
2436         if (pThreadViewList->msg_struct_info == NULL)
2437                 return MSG_ERR_MEMORY_ERROR;
2438
2439         MSG_THREAD_VIEW_S *pTmp = NULL;
2440         msg_struct_s *thread_t = NULL;
2441
2442         int index = 0;
2443
2444         while (!searchList.empty()) {
2445                 thread_t = (msg_struct_s *)new msg_struct_s;
2446                 pThreadViewList->msg_struct_info[index] = (msg_struct_t)thread_t;
2447
2448                 thread_t->type = MSG_STRUCT_THREAD_INFO;
2449                 thread_t->data = new MSG_THREAD_VIEW_S;
2450
2451                 pTmp = (MSG_THREAD_VIEW_S *)thread_t->data;
2452                 memset(pTmp, 0x00, sizeof(MSG_THREAD_VIEW_S));
2453
2454                 memcpy(pTmp, &(searchList.front()), sizeof(MSG_THREAD_VIEW_S));
2455
2456                 searchList.pop();
2457
2458                 index++;
2459         }
2460
2461         return MSG_SUCCESS;
2462 }
2463
2464
2465 msg_error_t MsgStoGetRejectMsgList(const char *pNumber, msg_struct_list_s *pRejectMsgList)
2466 {
2467         MsgDbHandler *dbHandle = getDbHandle();
2468         dbHandle->connectReadOnly();
2469
2470         /* Clear Out Parameter */
2471         pRejectMsgList->nCount = 0;
2472         pRejectMsgList->msg_struct_info = NULL;
2473
2474         int rowCnt = 0, index = 0;
2475
2476         char sqlQuery[MAX_QUERY_LEN+1];
2477
2478         /* Search Reject Msg */
2479         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2480
2481         if (pNumber != NULL) {
2482                 int addrSize = strlen(pNumber);
2483                 char phoneNumber[addrSize+1];
2484                 memset(phoneNumber, 0x00, sizeof(phoneNumber));
2485
2486                 if (addrSize > MsgContactGetMinMatchDigit())
2487                         MsgConvertNumber(pNumber, phoneNumber, addrSize);
2488                 else
2489                         strncpy(phoneNumber, pNumber, addrSize);
2490
2491                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
2492                                 "B.MSG_ID, "
2493                                 "B.MSG_TEXT, "
2494                                 "B.DISPLAY_TIME "
2495                                 "FROM %s A, %s B "
2496                                 "WHERE A.CONV_ID = B.CONV_ID "
2497                                 "AND B.MAIN_TYPE = %d "
2498                                 "AND B.SUB_TYPE = %d "
2499                                 "AND A.ADDRESS_VAL LIKE '%%%s' "
2500                                 "ORDER BY B.DISPLAY_TIME DESC;",
2501                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2502                                 MSG_SMS_TYPE,
2503                                 MSG_REJECT_SMS,
2504                                 phoneNumber);
2505         } else {
2506                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT "
2507                                 "B.MSG_ID, "
2508                                 "B.MSG_TEXT, "
2509                                 "B.DISPLAY_TIME "
2510                                 "FROM %s A, %s B "
2511                                 "WHERE A.CONV_ID = B.CONV_ID "
2512                                 "AND B.MAIN_TYPE = %d "
2513                                 "AND B.SUB_TYPE = %d "
2514                                 "ORDER BY B.DISPLAY_TIME DESC;",
2515                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME,
2516                                 MSG_SMS_TYPE,
2517                                 MSG_REJECT_SMS);
2518         }
2519
2520         msg_error_t err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
2521
2522         if (err != MSG_SUCCESS) {
2523                 MSG_DEBUG("Fail to getTable().");
2524                 dbHandle->freeTable();
2525                 return err;
2526         }
2527
2528         pRejectMsgList->nCount = rowCnt;
2529
2530         MSG_DEBUG("pRejectMsgList->nCount [%d]", pRejectMsgList->nCount);
2531
2532         pRejectMsgList->msg_struct_info = (msg_struct_t *)calloc(rowCnt, sizeof(MSG_REJECT_MSG_INFO_S *));
2533
2534         msg_struct_s* pTmp = NULL;
2535
2536         for (int i = 0; i < rowCnt; i++) {
2537                 pRejectMsgList->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2538
2539                 pTmp = (msg_struct_s *)pRejectMsgList->msg_struct_info[i];
2540                 pTmp->type = MSG_STRUCT_REJECT_MSG_INFO;
2541                 pTmp->data = new MSG_REJECT_MSG_INFO_S;
2542                 MSG_REJECT_MSG_INFO_S * pMsg = (MSG_REJECT_MSG_INFO_S *)pTmp->data;
2543                 memset(pMsg, 0x00, sizeof(MSG_REJECT_MSG_INFO_S));
2544
2545                 pMsg->msgId = dbHandle->getColumnToInt(index++);
2546                 memset(pMsg->msgText, 0x00, sizeof(pMsg->msgText));
2547                 dbHandle->getColumnToString(index++, MAX_MSG_TEXT_LEN, pMsg->msgText);
2548
2549                 pMsg->displayTime = (time_t)dbHandle->getColumnToInt(index++);
2550         }
2551
2552         dbHandle->freeTable();
2553
2554         return MSG_SUCCESS;
2555 }
2556
2557
2558 msg_error_t MsgStoGetAddressList(const msg_thread_id_t threadId, msg_struct_list_s *pAddrList)
2559 {
2560         MsgDbHandler *dbHandle = getDbHandle();
2561         dbHandle->connectReadOnly();
2562
2563         msg_error_t err = MSG_SUCCESS;
2564
2565         err = MsgStoGetAddressByConvId(dbHandle, threadId, pAddrList);
2566
2567         return err;
2568 }
2569
2570
2571 msg_error_t MsgStoGetMessageList(const MSG_LIST_CONDITION_S *pListCond, msg_struct_list_s *pMsgList, int contactCount)
2572 {
2573         MsgDbHandler *dbHandle = getDbHandle();
2574         dbHandle->connectReadOnly();
2575
2576         /* Clear Out Parameter */
2577         pMsgList->nCount = 0;
2578         pMsgList->msg_struct_info = NULL;
2579
2580         int index = 0;
2581         int multipartCnt = 0;
2582
2583         char sqlQuery[MAX_QUERY_LEN+1];
2584         char sqlQuerySubset[(MAX_QUERY_LEN/5)+1];
2585
2586         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2587         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s;", MSGFW_MMS_MULTIPART_TABLE_NAME);
2588
2589         if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
2590                 return MSG_ERR_DB_PREPARE;
2591
2592         if (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
2593                 multipartCnt = dbHandle->columnInt(0);
2594         } else {
2595                 dbHandle->finalizeQuery();
2596                 return MSG_ERR_DB_STEP;
2597         }
2598
2599         dbHandle->finalizeQuery();
2600
2601         memset(sqlQuery, 0x00, sizeof(sqlQuery));
2602         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT "
2603                         "A.MSG_ID, "
2604                         "A.CONV_ID, "
2605                         "A.FOLDER_ID, "
2606                         "A.STORAGE_ID, "
2607                         "A.MAIN_TYPE, "
2608                         "A.SUB_TYPE, "
2609                         "A.DISPLAY_TIME, "
2610                         "A.DATA_SIZE, "
2611                         "A.NETWORK_STATUS, "
2612                         "A.READ_STATUS, "
2613                         "A.PROTECTED, "
2614                         "A.BACKUP, "
2615                         "A.PRIORITY, "
2616                         "A.MSG_DIRECTION, "
2617                         "A.SCHEDULED_TIME, "
2618                         "A.SUBJECT, "
2619                         "A.MSG_TEXT, "
2620                         "A.ATTACHMENT_COUNT, "
2621                         "A.THUMB_PATH, "
2622                         "A.SIM_INDEX, "
2623                         "B.ADDRESS_TYPE, "
2624                         "B.RECIPIENT_TYPE, "
2625                         "B.ADDRESS_VAL ");
2626
2627         if (pListCond->pTextVal != NULL && multipartCnt > 0) {
2628                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2629                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "FROM %s C, %s B, %s A WHERE A.CONV_ID > 0 AND A.CONV_ID = B.CONV_ID ",
2630                         MSGFW_MMS_MULTIPART_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
2631         } else {
2632                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2633                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),        "FROM %s B, %s A WHERE A.CONV_ID > 0 AND A.CONV_ID = B.CONV_ID ",
2634                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
2635         }
2636
2637         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2638
2639         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2640         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.DPM_RESTRICTED = 0 ");
2641         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2642
2643         /* folder */
2644         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2645
2646         if (pListCond->folderId == MSG_ALLBOX_ID)
2647                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID > 0 AND A.FOLDER_ID < %d ", MSG_SPAMBOX_ID);
2648         else if (pListCond->folderId == MSG_IOSBOX_ID)
2649                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID > 0 AND A.FOLDER_ID < %d ", MSG_DRAFT_ID);
2650         else
2651                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.FOLDER_ID = %d ", pListCond->folderId);
2652
2653         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2654
2655
2656         /* thread */
2657         if (pListCond->threadId > 0) {
2658                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2659                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.CONV_ID = %d ", pListCond->threadId);
2660                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2661         }
2662
2663
2664         /* msg type */
2665         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2666
2667         switch (pListCond->msgType) {
2668                 case MSG_TYPE_SMS:
2669                         if (pListCond->pAddressVal == NULL)
2670                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d ", MSG_SMS_TYPE);
2671                         else
2672                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_NORMAL_SMS);
2673                         break;
2674
2675                 case MSG_TYPE_MMS:
2676                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d ", MSG_MMS_TYPE);
2677                         break;
2678
2679                 case MSG_TYPE_MMS_JAVA:
2680                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_MMS_TYPE, MSG_SENDREQ_JAVA_MMS);
2681                         break;
2682
2683                 case MSG_TYPE_SMS_SYNCML:
2684                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_SYNCML_CP);
2685                         break;
2686                 case MSG_TYPE_SMS_REJECT:
2687                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.MAIN_TYPE = %d AND A.SUB_TYPE = %d ", MSG_SMS_TYPE, MSG_REJECT_SMS);
2688                         break;
2689
2690                 default:
2691                         MSG_DEBUG("msg type is not set.");
2692                         break;
2693         }
2694
2695         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2696
2697
2698         /* storage */
2699         if (pListCond->storageId > MSG_STORAGE_UNKNOWN) {
2700                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2701                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.STORAGE_ID = %d ", pListCond->storageId);
2702                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2703         }
2704
2705
2706         /* protected */
2707         if (pListCond->bProtected) {
2708                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2709                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.PROTECTED = %d ", pListCond->bProtected);
2710                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2711         }
2712
2713
2714         /* scheduled */
2715         if (pListCond->bScheduled) {
2716                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2717                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.SCHEDULED_TIME > 0 ");
2718                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2719         }
2720
2721
2722         /* sim index */
2723         if (pListCond->simIndex > 0) {
2724                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2725                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.SIM_INDEX = %d ", pListCond->simIndex);
2726                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2727         }
2728
2729
2730         /* time range */
2731         if (pListCond->fromTime > 0) {
2732                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2733                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.DISPLAY_TIME >= %u ", (unsigned int)pListCond->fromTime);
2734                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2735         }
2736
2737         if (pListCond->toTime > 0) {
2738                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2739                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND A.DISPLAY_TIME <= %u ", (unsigned int)pListCond->toTime);
2740                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2741         }
2742
2743         if (pListCond->pAddressVal == NULL) {
2744                 /* Text */
2745                 if (pListCond->pTextVal != NULL) {
2746                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2747                         if (multipartCnt > 0) {
2748                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2749                                                 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c' OR (C.TEXT LIKE ? ESCAPE '%c' AND A.MSG_ID = C.MSG_ID AND C.CONTENT_TYPE = 'text/plain'))) ",
2750                                                 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2751                         } else {
2752                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2753                                                 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c')) ",
2754                                                 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2755                         }
2756                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2757                 }
2758         } else {
2759                 /* Text */
2760                 if (pListCond->pTextVal != NULL) {
2761                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2762                         if (multipartCnt > 0) {
2763                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2764                                                 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c' OR (C.TEXT LIKE ? ESCAPE '%c' AND A.MSG_ID = C.MSG_ID AND C.CONTENT_TYPE = 'text/plain')) ",
2765                                                 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2766                         } else {
2767                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2768                                                 "AND ((A.MSG_TEXT LIKE ? ESCAPE '%c' OR A.SUBJECT LIKE ? ESCAPE '%c') ",
2769                                                 MSGFW_DB_ESCAPE_CHAR, MSGFW_DB_ESCAPE_CHAR);
2770                         }
2771                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2772
2773                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2774                         if (pListCond->bAnd) {
2775                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "AND ");
2776                         } else {
2777                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "OR ");
2778                         }
2779                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2780
2781                         /* Address */
2782                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2783                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2784                                         "(B.ADDRESS_VAL LIKE ? ESCAPE '%c' ", MSGFW_DB_ESCAPE_CHAR);
2785                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2786
2787                         if (contactCount > 0) {
2788                                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2789                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2790                                                 "OR B.ADDRESS_VAL IN (SELECT D.ADDRESS_VAL FROM %s D JOIN %s E ON (D.ADDRESS_VAL LIKE E.ADDRESS_VAL)) "
2791                                                 , MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TEMP_TABLE_NAME);
2792                                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2793                         }
2794
2795                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2796                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ")) ");
2797                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2798                 } else {
2799                         /* Address */
2800                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2801                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2802                                         "AND (B.ADDRESS_VAL LIKE ? ESCAPE '%c' ", MSGFW_DB_ESCAPE_CHAR);
2803                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2804
2805                         if (contactCount > 0) {
2806                                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2807                                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset),
2808                                                 "OR B.ADDRESS_VAL IN (SELECT D.ADDRESS_VAL FROM %s D JOIN %s E ON (D.ADDRESS_VAL LIKE E.ADDRESS_VAL)) "
2809                                                 , MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TEMP_TABLE_NAME);
2810                                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2811                         }
2812
2813                         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2814                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ") ");
2815                         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2816                 }
2817         }
2818
2819         msg_struct_s *pSortRule = (msg_struct_s *)pListCond->sortRule;
2820
2821         if (pSortRule->type != MSG_STRUCT_SORT_RULE) {
2822                 /* Order */
2823                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2824                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.DISPLAY_TIME ");
2825
2826                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2827
2828                 /* Sorting type */
2829                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2830                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "DESC ");
2831
2832                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2833         } else {
2834                 MSG_SORT_RULE_S *pTmp = (MSG_SORT_RULE_S *)pSortRule->data;
2835                 /* order : TODO: have to finish this */
2836                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2837                 switch (pTmp->sortType) {
2838                 case MSG_SORT_BY_MSG_TYPE:
2839                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.MAIN_TYPE ");
2840                         break;
2841                 case MSG_SORT_BY_READ_STATUS:
2842                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.READ_STATUS ");
2843                         break;
2844                 case MSG_SORT_BY_STORAGE_TYPE:
2845                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.STORAGE_ID ");
2846                         break;
2847                 default:
2848                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ORDER BY A.DISPLAY_TIME ");
2849                         break;
2850                 }
2851                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2852
2853                 /* Sorting type */
2854                 memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2855                 if (pTmp->bAscending)
2856                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "ASC ");
2857                 else
2858                         snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "DESC ");
2859
2860                 strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2861         }
2862
2863         /* offset & limit */
2864         memset(sqlQuerySubset, 0x00, sizeof(sqlQuerySubset));
2865         if (pListCond->offset >= 0 && pListCond->limit > 0)
2866                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), "LIMIT %d OFFSET %d;", pListCond->limit, pListCond->offset);
2867         else
2868                 snprintf(sqlQuerySubset, sizeof(sqlQuerySubset), ";");
2869
2870         strncat(sqlQuery, sqlQuerySubset, MAX_QUERY_LEN-strlen(sqlQuery));
2871
2872
2873         /* 'til here sqlQuery is complete. */
2874
2875         queue<MSG_MESSAGE_HIDDEN_S*> searchList;
2876
2877         MSG_DEBUG("[%s]", sqlQuery);
2878
2879         if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
2880                 MSG_DEBUG("Prepare query fail.");
2881                 return MSG_ERR_DB_PREPARE;
2882         }
2883
2884         char *escapeTextStr = NULL;
2885         char *escapeAddressStr = NULL;
2886
2887         if (pListCond->pAddressVal == NULL) {
2888                 /* Text */
2889                 if (pListCond->pTextVal != NULL) {
2890                         MsgConvertStrWithEscape(pListCond->pTextVal, &escapeTextStr);
2891                         MSG_DEBUG("escapeTextStr [%s]", escapeTextStr);
2892                         dbHandle->bindText(escapeTextStr, 1);
2893                         dbHandle->bindText(escapeTextStr, 2);
2894                         if (multipartCnt > 0) dbHandle->bindText(escapeTextStr, 3);
2895                 }
2896         } else {
2897                 /* Text */
2898                 if (pListCond->pTextVal != NULL) {
2899                         MsgConvertStrWithEscape(pListCond->pTextVal, &escapeTextStr);
2900                         MSG_DEBUG("escapeTestStr [%s]", escapeTextStr);
2901
2902                         /* Address */
2903                         MsgConvertStrWithEscape(pListCond->pAddressVal, &escapeAddressStr);
2904                         MSG_DEBUG("escapeAddressStr [%s]", escapeAddressStr);
2905
2906                         dbHandle->bindText(escapeTextStr, 1);
2907                         dbHandle->bindText(escapeTextStr, 2);
2908                         if (multipartCnt > 0) {
2909                                 dbHandle->bindText(escapeTextStr, 3);
2910                                 dbHandle->bindText(escapeAddressStr, 4);
2911                         } else {
2912                                 dbHandle->bindText(escapeAddressStr, 3);
2913                         }
2914
2915                 } else {
2916                         /* Address */
2917                         MsgConvertStrWithEscape(pListCond->pAddressVal, &escapeAddressStr);
2918                         MSG_DEBUG("escapeAddressStr [%s]", escapeAddressStr);
2919                         dbHandle->bindText(escapeAddressStr, 1);
2920                 }
2921         }
2922
2923
2924         MSG_MESSAGE_HIDDEN_S *pTmp = NULL;
2925         int lastMsgId = 0;  /* for comparing same msg id. */
2926
2927         while (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
2928                 index = 0;
2929
2930                 int msgid = dbHandle->columnInt(index++);
2931                 MSG_DEBUG("msgid [%d]", msgid);
2932
2933                 if (lastMsgId != msgid) {
2934                         MSG_DEBUG("lastMsgId != msgid");
2935
2936                         lastMsgId = msgid;
2937
2938                         pTmp = new MSG_MESSAGE_HIDDEN_S;
2939
2940                         if(pTmp) {
2941                                 memset(pTmp, 0x00, sizeof(MSG_MESSAGE_HIDDEN_S));
2942
2943                                 pTmp->pData = NULL;
2944                                 pTmp->pMmsData = NULL;
2945                                 pTmp->addressList = NULL;
2946
2947                                 pTmp->msgId = msgid;
2948
2949                                 pTmp->threadId = dbHandle->columnInt(index++);
2950                                 pTmp->folderId = dbHandle->columnInt(index++);
2951                                 pTmp->storageId = dbHandle->columnInt(index++);
2952                                 pTmp->mainType = dbHandle->columnInt(index++);
2953                                 pTmp->subType = dbHandle->columnInt(index++);
2954                                 pTmp->displayTime = (time_t)dbHandle->columnInt(index++);
2955                                 pTmp->dataSize = dbHandle->columnInt(index++);
2956                                 pTmp->networkStatus = dbHandle->columnInt(index++);
2957                                 pTmp->bRead = dbHandle->columnInt(index++);
2958                                 pTmp->bProtected = dbHandle->columnInt(index++);
2959                                 pTmp->bBackup = dbHandle->columnInt(index++);
2960                                 pTmp->priority = dbHandle->columnInt(index++);
2961                                 pTmp->direction = dbHandle->columnInt(index++);
2962                                 index++; /* This field is reserved. */
2963
2964                                 strncpy(pTmp->subject, (char *)dbHandle->columnText(index++), MAX_SUBJECT_LEN);
2965
2966                                 if (pTmp->mainType == MSG_MMS_TYPE &&
2967                                         (pTmp->networkStatus == MSG_NETWORK_RETRIEVING || pTmp->networkStatus == MSG_NETWORK_RETRIEVE_FAIL || pTmp->subType == MSG_NOTIFICATIONIND_MMS)) {
2968                                         pTmp->pData = NULL;
2969                                         index++;
2970                                 } else {
2971                                         pTmp->pData = (void *)new char[pTmp->dataSize+2];
2972                                         memset(pTmp->pData, 0x00, pTmp->dataSize+2);
2973
2974                                         strncpy((char *)pTmp->pData, (char *)dbHandle->columnText(index++), pTmp->dataSize+1);
2975                                 }
2976
2977                                 pTmp->attachCount = dbHandle->columnInt(index++);
2978
2979                                 strncpy(pTmp->thumbPath, (char *)dbHandle->columnText(index++), MSG_FILEPATH_LEN_MAX);
2980
2981                                 pTmp->simIndex = dbHandle->columnInt(index++);
2982
2983                                 pTmp->addr_list = (msg_struct_list_s *)new msg_struct_list_s;
2984                                 pTmp->addr_list->nCount = 0;
2985                                 pTmp->addr_list->msg_struct_info = (msg_struct_t *)calloc(MAX_TO_ADDRESS_CNT, sizeof(msg_struct_t));
2986                                 for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
2987                                         pTmp->addr_list->msg_struct_info[i] = (msg_struct_t)new msg_struct_s;
2988                                         memset(pTmp->addr_list->msg_struct_info[i], 0x00, sizeof(msg_struct_s));
2989                                 }
2990
2991                                 searchList.push(pTmp);
2992                         }
2993
2994                 } else {
2995                         MSG_DEBUG("lastMsgId == msgid");
2996                         index += 19;
2997                 }
2998
2999                 if(pTmp) {
3000                         MSG_ADDRESS_INFO_S *pAddr = new MSG_ADDRESS_INFO_S;
3001                         memset(pAddr, 0x00, sizeof(MSG_ADDRESS_INFO_S));
3002
3003                         pAddr->addressType = dbHandle->columnInt(index++);
3004                         pAddr->recipientType = dbHandle->columnInt(index++);
3005
3006                         strncpy(pAddr->addressVal, (char *)dbHandle->columnText(index++), MAX_ADDRESS_VAL_LEN);
3007
3008                         strncpy(pAddr->displayName, pAddr->addressVal, MAX_DISPLAY_NAME_LEN);
3009
3010                         /* For GList *addressList */
3011                         msg_struct_s *addr_info_s = new msg_struct_s;
3012                         memset(addr_info_s, 0x00, sizeof(msg_struct_s));
3013                         addr_info_s->type = MSG_STRUCT_ADDRESS_INFO;
3014                         addr_info_s->data = new MSG_ADDRESS_INFO_S;
3015                         memset(addr_info_s->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
3016                         MSG_ADDRESS_INFO_S *addr_info = (MSG_ADDRESS_INFO_S *)addr_info_s->data;
3017                         addr_info->addressType = pAddr->addressType;
3018                         addr_info->recipientType = pAddr->recipientType;
3019                         addr_info->contactId = pAddr->contactId;
3020                         strncpy(addr_info->addressVal, pAddr->addressVal, MAX_ADDRESS_VAL_LEN);
3021                         strncpy(addr_info->displayName, pAddr->displayName, MAX_DISPLAY_NAME_LEN);
3022                         addr_info->displayName[MAX_DISPLAY_NAME_LEN] = '\0';
3023
3024                         pTmp->addressList = g_list_append(pTmp->addressList, addr_info_s);
3025
3026                         if (pTmp->addr_list->nCount >= MAX_TO_ADDRESS_CNT) {
3027                                 delete pAddr;
3028
3029                         } else {
3030                                 msg_struct_s *pStruct = (msg_struct_s *)pTmp->addr_list->msg_struct_info[pTmp->addr_list->nCount];
3031                                 pTmp->addr_list->nCount++;
3032                                 pStruct->type = MSG_STRUCT_ADDRESS_INFO;
3033                                 pStruct->data = pAddr;
3034                         }
3035                 }
3036         }
3037
3038         dbHandle->finalizeQuery();
3039
3040         pMsgList->nCount = searchList.size();
3041         MSG_DEBUG("pMsgList->nCount [%d]", pMsgList->nCount);
3042
3043         pMsgList->msg_struct_info = (msg_struct_t *)calloc(pMsgList->nCount, sizeof(msg_struct_t));
3044         if (pMsgList->msg_struct_info == NULL)
3045                 return MSG_ERR_MEMORY_ERROR;
3046
3047         int offset = 0;
3048         while (!searchList.empty()) {
3049                 msg_struct_s *msg = new msg_struct_s;
3050
3051                 pMsgList->msg_struct_info[offset++] = (msg_struct_t)msg;
3052
3053                 msg->type = MSG_STRUCT_MESSAGE_INFO;
3054                 msg->data = searchList.front();
3055
3056                 searchList.pop();
3057         }
3058
3059
3060         if (escapeTextStr)
3061                 free(escapeTextStr);
3062
3063         if (escapeAddressStr)
3064                 free(escapeAddressStr);
3065
3066         return MSG_SUCCESS;
3067 }
3068
3069
3070 msg_error_t MsgStoGetMediaList(const msg_thread_id_t threadId, msg_list_handle_t *pMediaList)
3071 {
3072         MSG_BEGIN();
3073         msg_error_t err = MSG_SUCCESS;
3074         MsgDbHandler *dbHandle = getDbHandle();
3075         dbHandle->connectReadOnly();
3076         char sqlQuery[MAX_QUERY_LEN+1];
3077         int msgIdCnt = 0;
3078         int wrn =0;
3079
3080         memset(sqlQuery, 0x00, sizeof(sqlQuery));
3081         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s WHERE MAIN_TYPE = %d AND DPM_RESTRICTED = 0 AND CONV_ID = %d;",
3082                         MSGFW_MESSAGE_TABLE_NAME, MSG_MMS_TYPE, threadId);
3083
3084         MSG_DEBUG("sqlQuery = [%s]", sqlQuery);
3085
3086         err = dbHandle->getTable(sqlQuery, &msgIdCnt, NULL);
3087         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
3088                 dbHandle->freeTable();
3089                 return err;
3090         } else if (err == MSG_ERR_DB_NORECORD) {
3091                 dbHandle->freeTable();
3092                 return MSG_SUCCESS;
3093         }
3094
3095         msg_message_id_t msgIds[msgIdCnt];
3096
3097         for (int i = 1; i <= msgIdCnt; i++) {
3098                 msgIds[i-1] = dbHandle->getColumnToInt(i);
3099         }
3100
3101         dbHandle->freeTable();
3102
3103         GList *media_list = NULL;
3104
3105         for (int i = 0; i < msgIdCnt; i++) {
3106                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
3107                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID, TCS_LEVEL, MALWARE_ALLOW, CONTENT_TYPE, FILE_PATH, THUMB_FILE_PATH, TCS_LEVEL, MALWARE_ALLOW "
3108                                 "FROM %s WHERE MSG_ID = %d AND SEQ <> -1 AND (TCS_LEVEL = -1 OR MALWARE_ALLOW = 1);",
3109                                 MSGFW_MMS_MULTIPART_TABLE_NAME, msgIds[i]);
3110
3111                 int rowCnt = 0, msg_id = 0, index = 0;
3112
3113                 err = dbHandle->getTable(sqlQuery, &rowCnt, &index);
3114
3115                 if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
3116                         dbHandle->freeTable();
3117                         return err;
3118                 }
3119
3120                 MSG_MEDIA_INFO_S *pMedia = NULL;
3121                 int tcs_level = -1, malware_allow = 0, thumb_tcs_level = -1, thumb_malware_allow = 0;
3122                 char mime_type[MAX_MIME_TYPE_LEN+1], media_item[MSG_FILEPATH_LEN_MAX+1], thumb_path[MSG_FILEPATH_LEN_MAX+1];
3123
3124                 for (int j = 0; j < rowCnt; j++) {
3125                         msg_id = dbHandle->getColumnToInt(index++);
3126                         tcs_level = dbHandle->getColumnToInt(index++);
3127                         malware_allow = dbHandle->getColumnToInt(index++);
3128                         memset(mime_type, 0x00, sizeof(mime_type));
3129                         dbHandle->getColumnToString(index++, MAX_MIME_TYPE_LEN, mime_type);
3130                         memset(media_item, 0x00, sizeof(media_item));
3131                         dbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, media_item);
3132                         memset(thumb_path, 0x00, sizeof(thumb_path));
3133                         dbHandle->getColumnToString(index++, MSG_FILEPATH_LEN_MAX, thumb_path);
3134                         thumb_tcs_level = dbHandle->getColumnToInt(index++);
3135                         thumb_malware_allow = dbHandle->getColumnToInt(index++);
3136
3137                         if (strstr(mime_type, "image") || strstr(mime_type, "video")) {
3138                                 msg_struct_s *media_struct_s = new msg_struct_s;
3139                                 media_struct_s->type = MSG_STRUCT_MEDIA_INFO;
3140                                 media_struct_s->data = new MSG_MEDIA_INFO_S;
3141                                 memset(media_struct_s->data, 0x00, sizeof(MSG_MEDIA_INFO_S));
3142
3143                                 pMedia = (MSG_MEDIA_INFO_S *)media_struct_s->data;
3144
3145                                 pMedia->msg_id = msg_id;
3146                                 pMedia->tcs_level = tcs_level;
3147                                 pMedia->malware_allow = malware_allow;
3148                                 wrn = snprintf(pMedia->mime_type, MAX_MIME_TYPE_LEN, "%s", mime_type);
3149                                 if(wrn<0)
3150                                         MSG_DEBUG("snprintf  was failed");
3151                                 wrn = snprintf(pMedia->media_item, MSG_FILEPATH_LEN_MAX, "%s", media_item);
3152                                 if(wrn<0)
3153                                         MSG_DEBUG("snprintf  was failed");
3154                                 wrn = snprintf(pMedia->thumb_path, MSG_FILEPATH_LEN_MAX, "%s", thumb_path);
3155                                 if(wrn<0)
3156                                         MSG_DEBUG("snprintf  was failed");
3157                                 pMedia->thumb_tcs_level = thumb_tcs_level;
3158                                 pMedia->thumb_malware_allow = thumb_malware_allow;
3159
3160                                 media_list = g_list_append(media_list, media_struct_s);
3161                         }
3162                 }
3163
3164                 dbHandle->freeTable();
3165
3166                 *pMediaList = (msg_list_handle_t)media_list;
3167         }
3168
3169         MSG_END();
3170         return MSG_SUCCESS;
3171 }
3172
3173
3174 msg_error_t MsgStoDbSelectWithQuery(const char *szQuery, char ***db_res, int *row_count, int *col_count)
3175 {
3176         MSG_BEGIN();
3177
3178         msg_error_t err = MSG_SUCCESS;
3179
3180         MsgDbHandler *dbHandle = getDbHandle();
3181         err = dbHandle->connectReadOnly();
3182         if (err != MSG_SUCCESS) {
3183                 MSG_ERR("db connect (read only) is failed [%d]", err);
3184                 return err;
3185         }
3186
3187         char *zSQL = sqlite3_mprintf("SELECT %q;", szQuery);
3188
3189         if (zSQL) {
3190                 err = dbHandle->getTableWithResult((const char *)zSQL, db_res, row_count, col_count);
3191                 sqlite3_free(zSQL);
3192                 zSQL = NULL;
3193         } else {
3194                 THROW(MsgException::INVALID_RESULT, "sqlite3_mprintf() is failed");
3195         }
3196
3197         MSG_DEBUG("getTableWithResult :: row_count=[%d], col_count=[%d]", *row_count, *col_count);
3198
3199         if (err == MSG_ERR_DB_NORECORD) {
3200                 dbHandle->freeTable(*db_res);
3201                 err = MSG_SUCCESS;
3202                 *db_res = NULL;
3203         } else if (err != MSG_SUCCESS) {
3204                 MSG_DEBUG("Fail to getTable().");
3205                 dbHandle->freeTable(*db_res);
3206                 *db_res = NULL;
3207         }
3208
3209         return err;
3210 }
3211
3212
3213 void MsgStoDbFree(char **db_res)
3214 {
3215         MsgDbHandler *dbHandle = getDbHandle();
3216         dbHandle->freeTable(db_res);
3217 }
3218
3219
3220 msg_error_t MsgStoClearUniquenessTable()
3221 {
3222         MSG_BEGIN();
3223
3224         msg_error_t err = MSG_SUCCESS;
3225
3226         MsgDbHandler *dbHandle = getDbHandle();
3227
3228         char sqlQuery[MAX_QUERY_LEN+1] = {0, };
3229         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE MSG_ID = 0", MSGFW_UNIQUENESS_INFO_TABLE_NAME);
3230
3231         err = dbHandle->execQuery(sqlQuery);
3232
3233         MSG_END();
3234
3235         return err;
3236 }
3237
3238
3239 msg_error_t MsgStoGetSimIndexByMsgId(msg_message_id_t msgId, int* simIndex)
3240 {
3241         MSG_BEGIN();
3242
3243         msg_error_t err = MSG_SUCCESS;
3244
3245         MsgDbHandler *dbHandle = getDbHandle();
3246
3247         char sqlQuery[MAX_QUERY_LEN+1];
3248         memset(sqlQuery, 0x00, sizeof(sqlQuery));
3249         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT SIM_INDEX FROM %s WHERE MSG_ID = %d;", MSGFW_MESSAGE_TABLE_NAME, msgId);
3250
3251         if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
3252                 return MSG_ERR_DB_PREPARE;
3253         }
3254
3255         if (dbHandle->stepQuery() == MSG_ERR_DB_ROW) {
3256                 *simIndex = dbHandle->columnInt(0);
3257                 dbHandle->finalizeQuery();
3258         } else {
3259                 MSG_DEBUG("MsgStepQuery() Error [%s]", sqlQuery);
3260                 dbHandle->finalizeQuery();
3261                 err = MSG_ERR_DB_STEP;
3262         }
3263
3264         MSG_END();
3265
3266         return err;
3267 }
3268
3269
3270 msg_error_t MsgStoGetNetworkStatusByMsgId(msg_message_id_t msgId, int *networkStatus)
3271 {
3272         char sqlQuery[MAX_QUERY_LEN + 1] = {0,};
3273         MsgDbHandler *dbHandle = getDbHandle();
3274
3275         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT NETWORK_STATUS FROM %s WHERE MSG_ID = %d;",
3276                         MSGFW_MESSAGE_TABLE_NAME, msgId);
3277
3278         if (dbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
3279                 return MSG_ERR_DB_PREPARE;
3280         }
3281
3282         if (dbHandle->stepQuery() != MSG_ERR_DB_ROW) {
3283                 dbHandle->finalizeQuery();
3284                 return MSG_ERR_STORAGE_ERROR;
3285         }
3286
3287         *networkStatus = dbHandle->columnInt(0);
3288         dbHandle->finalizeQuery();
3289
3290         return MSG_SUCCESS;
3291 }