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