utils/MsgUtilStorage.cpp

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