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