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