utils/MsgUtilStorage.cpp

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