utils/MsgUtilStorage.cpp

   1 /*
   2 * Copyright 2012-2013  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.1 (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://floralicense.org/license/
   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 "MsgDebug.h"
  18 #include "MsgUtilFile.h"
  19 #include "MsgContact.h"
  20 #include "MsgCppTypes.h"
  21 #include "MsgGconfWrapper.h"
  22 #include "MsgNotificationWrapper.h"
  23 #include "MsgUtilStorage.h"
  24
  25 #include <sys/stat.h>
  26 #include <sys/vfs.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29
  30 #define DB_MSG_SERVICE_GROUPE   6011
  31
  32 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}};
  33
  34
  35 /*==================================================================================================
  36                                      FUNCTION IMPLEMENTATION
  37 ==================================================================================================*/
  38 unsigned int MsgStoAddMessageTable(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo)
  39 {
  40         MSG_BEGIN();
  41
  42         msg_error_t err = MSG_SUCCESS;
  43
  44         msg_message_id_t msgId = 0;
  45
  46         err = pDbHandle->getRowId(MSGFW_MESSAGE_TABLE_NAME, &msgId);
  47
  48         if (err != MSG_SUCCESS)
  49                 return 0;
  50
  51         int fileSize = 0;
  52
  53         char* pFileData = NULL;
  54         AutoPtr<char> buf(&pFileData);
  55
  56         // Get File Data
  57         if (pMsgInfo->bTextSms == false) {
  58                 if (MsgOpenAndReadFile(pMsgInfo->msgData, &pFileData, &fileSize) == false)
  59                         return 0;
  60
  61                 MSG_DEBUG("file size [%d]", fileSize);
  62         }
  63
  64         // Add Message
  65         char sqlQuery[MAX_QUERY_LEN+1];
  66
  67         memset(sqlQuery, 0x00, sizeof(sqlQuery));
  68
  69         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, %d, %d, %ld, %d, %d, %d, %d, %d, %d, %ld, %d, ?, ?, ?, ?, 0);",
  70                         MSGFW_MESSAGE_TABLE_NAME, msgId, pMsgInfo->threadId, pMsgInfo->folderId, pMsgInfo->storageId, pMsgInfo->msgType.mainType,
  71                         pMsgInfo->msgType.subType, pMsgInfo->displayTime, pMsgInfo->dataSize, pMsgInfo->networkStatus, pMsgInfo->bRead, pMsgInfo->bProtected,
  72                         pMsgInfo->priority, pMsgInfo->direction, 0, pMsgInfo->bBackup);
  73
  74         MSG_DEBUG("QUERY : %s", sqlQuery);
  75
  76         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
  77                 return 0;
  78
  79         pDbHandle->bindText(pMsgInfo->subject, 1);
  80
  81         pDbHandle->bindText(pMsgInfo->msgData, 2);
  82
  83         pDbHandle->bindText(pMsgInfo->thumbPath, 3);
  84
  85         if (pMsgInfo->bTextSms == false)
  86                 pDbHandle->bindText(pFileData, 4);
  87         else
  88                 pDbHandle->bindText(pMsgInfo->msgText, 4);
  89
  90         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
  91                 pDbHandle->finalizeQuery();
  92                 return 0;
  93         }
  94
  95         pDbHandle->finalizeQuery();
  96
  97         return msgId;
  98 }
  99
 100
 101 msg_error_t MsgStoSetReadStatus(MsgDbHandler *pDbHandle, msg_message_id_t msgId, bool bRead)
 102 {
 103         char sqlQuery[MAX_QUERY_LEN+1];
 104
 105         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 106         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET READ_STATUS = %d WHERE MSG_ID = %d;",
 107                         MSGFW_MESSAGE_TABLE_NAME, (int)bRead, msgId);
 108
 109         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
 110                 return MSG_ERR_DB_EXEC;
 111
 112         // Get MAIN_TYPE, SUB_TYPE, STORAGE_ID
 113         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 114         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.MAIN_TYPE, A.SUB_TYPE, B.CONV_ID \
 115                         FROM %s A, %s B WHERE A.MSG_ID = %d AND A.CONV_ID = B.CONV_ID;",
 116                         MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME, msgId);
 117
 118         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 119                 return MSG_ERR_DB_PREPARE;
 120
 121         MSG_MESSAGE_TYPE_S msgType;
 122         msg_thread_id_t convId;
 123
 124         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 125                 msgType.mainType = pDbHandle->columnInt(0);
 126                 msgType.subType = pDbHandle->columnInt(1);
 127                 convId = pDbHandle->columnInt(2);
 128         } else {
 129                 pDbHandle->finalizeQuery();
 130                 return MSG_ERR_DB_STEP;
 131         }
 132
 133         pDbHandle->finalizeQuery();
 134
 135         MSG_DEBUG("Main Type:[%d] SubType:[%d] ConvId:[%d]", msgType.mainType, msgType.subType, convId);
 136
 137         if (MsgStoUpdateConversation(pDbHandle, convId) != MSG_SUCCESS) {
 138                 MSG_DEBUG("MsgStoUpdateConversation() Error");
 139                 return MSG_ERR_STORAGE_ERROR;
 140         }
 141
 142         int smsCnt = 0, mmsCnt = 0;
 143
 144         smsCnt = MsgStoGetUnreadCnt(pDbHandle, MSG_SMS_TYPE);
 145         mmsCnt = MsgStoGetUnreadCnt(pDbHandle, MSG_MMS_TYPE);
 146
 147         MsgSettingSetIndicator(smsCnt, mmsCnt);
 148
 149         MsgRefreshNoti(false);
 150
 151         return MSG_SUCCESS;
 152 }
 153
 154
 155 msg_error_t MsgStoGetOldestMessage(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsgInfo, msg_message_id_t *pMsgId)
 156 {
 157         char sqlQuery[MAX_QUERY_LEN+1];
 158
 159         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 160
 161         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MSG_ID FROM %s \
 162                         WHERE SUB_TYPE = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND PROTECTED = 0 \
 163                         ORDER BY DISPLAY_TIME ASC",
 164                         MSGFW_MESSAGE_TABLE_NAME, pMsgInfo->msgType.subType, pMsgInfo->folderId, MSG_STORAGE_PHONE);
 165
 166         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 167                 return MSG_ERR_DB_PREPARE;
 168
 169         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 170                 *pMsgId = pDbHandle->columnInt(0);
 171         } else {
 172                 pDbHandle->finalizeQuery();
 173                 return MSG_ERR_DB_STEP;
 174         }
 175
 176         pDbHandle->finalizeQuery();
 177
 178         return MSG_SUCCESS;
 179 }
 180
 181
 182 msg_error_t MsgStoCheckMsgCntFull(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
 183 {
 184         MSG_BEGIN();
 185
 186         msg_error_t err = MSG_SUCCESS;
 187                 struct statfs buf = {0};
 188                 int fd, ret;
 189
 190                 if (statfs(MSG_DATA_ROOT_PATH, &buf) == -1) {
 191                         MSG_DEBUG("statfs(\"%s\") failed - %d", MSG_DATA_ROOT_PATH);
 192                         if (mkdir(MSG_DATA_ROOT_PATH, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) < 0) {
 193                                 MSG_DEBUG("Error while mkdir %s", MSG_DATA_ROOT_PATH);
 194                                 return MSG_ERR_STORAGE_ERROR;
 195                         } else {
 196                                 fd = creat(MSG_DATA_ROOT_PATH, 0755);
 197                                 if (0 <= fd){
 198                                         ret = fchown(fd, -1, DB_MSG_SERVICE_GROUPE);
 199                                         if (-1 == ret){
 200                                                 MSG_DEBUG("Failed to fchown on %s",MSG_DATA_ROOT_PATH);
 201                                         }
 202                                         close(fd);
 203                                 }
 204                         }
 205                 }
 206
 207                 unsigned long freeSpace = (buf.f_bfree * buf.f_bsize);
 208
 209                 MSG_DEBUG("f_bfree [%d] f_bsize [%d]", buf.f_bfree, buf.f_bsize);
 210                 MSG_DEBUG("Free space of storage is [%ul] MB.", freeSpace);
 211
 212                 if (freeSpace < SMS_MINIMUM_SPACE && pMsgType->mainType == MSG_SMS_TYPE)
 213                         err = MSG_ERR_MESSAGE_COUNT_FULL;
 214                 else if(freeSpace < MMS_MINIMUM_SPACE && pMsgType->mainType == MSG_MMS_TYPE)
 215                         err = MSG_ERR_MESSAGE_COUNT_FULL;
 216
 217         MSG_END();
 218
 219         return err;
 220 }
 221
 222
 223 msg_error_t MsgStoCountMsgByLimitCategory(MsgDbHandler *pDbHandle, const MSG_MESSAGE_TYPE_S *pMsgType, int *pMsgCount, msg_folder_id_t folderId)
 224 {
 225         if (pMsgType == NULL) {
 226                 MSG_DEBUG("pMsgType is NULL");
 227                 return MSG_ERR_NULL_POINTER;
 228         }
 229
 230         *pMsgCount = 0;
 231
 232         char sqlQuery[MAX_QUERY_LEN+1];
 233         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 234
 235         if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_WAP_SI_SMS ||pMsgType->subType == MSG_WAP_SL_SMS)) { // PUSH
 236                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d) AND FOLDER_ID = %d;",
 237                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_WAP_SI_SMS, MSG_WAP_SL_SMS, MSG_INBOX_ID);
 238         } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_CB_SMS)) { // CB
 239                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
 240                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_CB_SMS, MSG_CBMSGBOX_ID);
 241         } else if ((pMsgType->mainType == MSG_SMS_TYPE) && (pMsgType->subType == MSG_SYNCML_CP)) { // Provision
 242                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d) AND FOLDER_ID = %d;",
 243                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SYNCML_CP, MSG_INBOX_ID);
 244         } else if ((pMsgType->mainType == MSG_SMS_TYPE)) { // SMS
 245                 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;",
 246                                 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
 247         } else if ((pMsgType->mainType == MSG_MMS_TYPE) &&
 248                         (pMsgType->subType == MSG_SENDREQ_MMS || pMsgType->subType == MSG_SENDCONF_MMS || pMsgType->subType == MSG_RETRIEVE_AUTOCONF_MMS ||
 249                                         pMsgType->subType == MSG_RETRIEVE_MANUALCONF_MMS || pMsgType->subType == MSG_NOTIFICATIONIND_MMS)) { // MMS
 250                 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;",
 251                                 MSGFW_MESSAGE_TABLE_NAME, pMsgType->mainType, MSG_SENDREQ_MMS, MSG_SENDCONF_MMS, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS, folderId);
 252         } else {
 253                 return MSG_ERR_INVALID_PARAMETER;
 254         }
 255
 256         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 257                 return MSG_ERR_DB_PREPARE;
 258
 259         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 260                 *pMsgCount = pDbHandle->columnInt(0);
 261         } else {
 262                 pDbHandle->finalizeQuery();
 263                 return MSG_ERR_DB_STEP;
 264         }
 265
 266         pDbHandle->finalizeQuery();
 267
 268         return MSG_SUCCESS;
 269 }
 270
 271
 272 int MsgStoCheckMsgCntLimit(const MSG_MESSAGE_TYPE_S* pMsgType, msg_folder_id_t folderId)
 273 {
 274         int msgboxType = -1;
 275         int msgType= -1;
 276
 277         switch (folderId)
 278         {
 279                 case MSG_INBOX_ID :
 280                         msgboxType = MSG_COUNT_LIMIT_INBOX_TYPE;
 281                 break;
 282
 283                 case MSG_OUTBOX_ID :
 284                         msgboxType = MSG_COUNT_LIMIT_OUTBOX_TYPE;
 285                 break;
 286
 287                 case MSG_SENTBOX_ID :
 288                         msgboxType = MSG_COUNT_LIMIT_SENTBOX_TYPE;
 289                 break;
 290
 291                 case MSG_DRAFT_ID :
 292                         msgboxType = MSG_COUNT_LIMIT_DRAFTBOX_TYPE;
 293                 break;
 294
 295                 case MSG_CBMSGBOX_ID :
 296                         msgboxType = MSG_COUNT_LIMIT_CBMSGBOX_TYPE;
 297                 break;
 298
 299                 default:
 300                         MSG_DEBUG("Unknown mailbox Type [%d]", folderId);
 301                 return -1;
 302         }
 303
 304         switch (pMsgType->subType)
 305         {
 306                 case MSG_NORMAL_SMS:
 307                 case MSG_REPLACE_TYPE1_SMS:
 308                 case MSG_REPLACE_TYPE2_SMS:
 309                 case MSG_REPLACE_TYPE3_SMS:
 310                 case MSG_REPLACE_TYPE4_SMS:
 311                 case MSG_REPLACE_TYPE5_SMS:
 312                 case MSG_REPLACE_TYPE6_SMS:
 313                 case MSG_REPLACE_TYPE7_SMS:
 314                 case MSG_MWI_VOICE_SMS:
 315                 case MSG_MWI_FAX_SMS:
 316                 case MSG_MWI_EMAIL_SMS:
 317                 case MSG_MWI_OTHER_SMS:
 318                 case MSG_STATUS_REPORT_SMS:
 319                         msgType = MSG_COUNT_LIMIT_SMS_TYPE;
 320                 break;
 321
 322                 case MSG_CB_SMS:
 323                         msgType = MSG_COUNT_LIMIT_CB_TYPE;
 324                 break;
 325
 326                 case MSG_WAP_SI_SMS:
 327                 case MSG_WAP_SL_SMS:
 328                         msgType = MSG_COUNT_LIMIT_WAPPUSH_TYPE;
 329                 break;
 330
 331                 case MSG_SYNCML_CP:
 332                         msgType = MSG_COUNT_LIMIT_PROVISION_TYPE;
 333                 break;
 334
 335                 case MSG_SENDREQ_MMS:
 336                 case MSG_SENDCONF_MMS:
 337                 case MSG_NOTIFICATIONIND_MMS:
 338                 case MSG_RETRIEVE_AUTOCONF_MMS:
 339                 case MSG_RETRIEVE_MANUALCONF_MMS:
 340                         msgType = MSG_COUNT_LIMIT_MMS_TYPE;
 341                 break;
 342
 343                 default:
 344                         MSG_DEBUG("Unknown Message Type [%d]", pMsgType->subType);
 345                 return -1;
 346         }
 347
 348         return msgCntLimit[msgboxType][msgType];
 349 }
 350
 351
 352 msg_error_t MsgStoAddAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
 353 {
 354         msg_error_t err = MSG_SUCCESS;
 355
 356         char sqlQuery[MAX_QUERY_LEN+1];
 357
 358         // Check if new address or not
 359         if (MsgExistAddress(pDbHandle, pMsg, pConvId) == true) {
 360                 MSG_DEBUG("The address already exists. Conversation ID : [%d]", *pConvId);
 361                 return err;
 362         }
 363
 364         MSG_DEBUG("Conversation ID : [%d]", *pConvId);
 365
 366         /* conversation insert */
 367         err = MsgStoAddConversation(pDbHandle, pConvId);
 368         if (err != MSG_SUCCESS) {
 369                 MSG_DEBUG("MsgStoAddConversation() fail [%d]", err);
 370                 return err;
 371         }
 372
 373         /* insert address in loop */
 374         for (int i=0; i<pMsg->nAddressCnt; i++) {
 375
 376                 unsigned int addrId;
 377                 MSG_CONTACT_INFO_S contactInfo;
 378                 memset(&contactInfo, 0x00, sizeof(MSG_CONTACT_INFO_S));
 379
 380                 // Get Contact Info
 381                 if (MsgGetContactInfo(&(pMsg->addressList[i]), &contactInfo) != MSG_SUCCESS) {
 382                         MSG_DEBUG("MsgGetContactInfo() fail.");
 383                 }
 384
 385                 err = pDbHandle->getRowId(MSGFW_ADDRESS_TABLE_NAME, &addrId);
 386                 if (err != MSG_SUCCESS) {
 387                         MSG_DEBUG("pDbHandle->getRowId fail. [%d]", err);
 388                         return err;
 389                 }
 390
 391                 // Add Address
 392                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 393                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, %d, %d, %d, '%s', %d, ?, ?, ?, '%s', 0);",
 394                                         MSGFW_ADDRESS_TABLE_NAME, addrId, *pConvId, pMsg->addressList[i].addressType, pMsg->addressList[i].recipientType, pMsg->addressList[i].addressVal,
 395                                         contactInfo.contactId, contactInfo.imagePath);
 396
 397                 MSG_DEBUG("Add Address Info. [%s]", sqlQuery);
 398
 399                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 400                         return MSG_ERR_DB_PREPARE;
 401
 402                 pDbHandle->bindText(contactInfo.displayName, 1);
 403                 pDbHandle->bindText(contactInfo.firstName, 2);
 404                 pDbHandle->bindText(contactInfo.lastName, 3);
 405
 406                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 407                         pDbHandle->finalizeQuery();
 408                         return MSG_ERR_DB_STEP;
 409                 }
 410
 411                 pDbHandle->finalizeQuery();
 412
 413                 // set conversation display name by conv id
 414                 MsgStoSetConversationDisplayName(pDbHandle, *pConvId);
 415
 416         }
 417
 418         return err;
 419 }
 420
 421 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int contactNameOrder, int *nAddressCnt, MSG_ADDRESS_INFO_S *pAddress)
 422 {
 423         char sqlQuery[MAX_QUERY_LEN+1];
 424         char firstName[MAX_DISPLAY_NAME_LEN+1];
 425         char lastName[MAX_DISPLAY_NAME_LEN+1];
 426
 427         *nAddressCnt = 0;
 428
 429         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 430         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ADDRESS_TYPE, A.RECIPIENT_TYPE, \
 431                                 A.CONTACT_ID, A.ADDRESS_VAL, A.DISPLAY_NAME, A.FIRST_NAME, A.LAST_NAME \
 432                                 FROM %s A, %s B WHERE A.CONV_ID = B.CONV_ID AND B.MSG_ID = %d;",
 433                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
 434
 435         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 436                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 437                 return MSG_ERR_DB_PREPARE;
 438         }
 439
 440         while (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 441                 memset(firstName, 0x00, sizeof(firstName));
 442                 memset(lastName, 0x00, sizeof(lastName));
 443
 444                 pAddress[*nAddressCnt].addressType = pDbHandle->columnInt(0);
 445                 pAddress[*nAddressCnt].recipientType = pDbHandle->columnInt(1);
 446                 pAddress[*nAddressCnt].contactId = pDbHandle->columnInt(2);
 447
 448                 if (pDbHandle->columnText(3) != NULL)
 449                         strncpy(pAddress[*nAddressCnt].addressVal, (char *)pDbHandle->columnText(3), MAX_ADDRESS_VAL_LEN);
 450
 451                 if (pDbHandle->columnText(4) != NULL && ((char *)pDbHandle->columnText(4))[0]!='\0') {
 452                         MSG_DEBUG("displayName  : [%s]", pDbHandle->columnText(4));
 453                         strncpy(pAddress[*nAddressCnt].displayName, (char *)pDbHandle->columnText(4), MAX_DISPLAY_NAME_LEN);
 454                 } else {
 455                         if (pDbHandle->columnText(5) != NULL)
 456                                         strncpy(firstName, (char *)pDbHandle->columnText(5), MAX_DISPLAY_NAME_LEN);
 457
 458                         if (pDbHandle->columnText(6) != NULL)
 459                                         strncpy(lastName, (char *)pDbHandle->columnText(6), MAX_DISPLAY_NAME_LEN);
 460
 461                         if (contactNameOrder == 0) {
 462                                 if (strlen(firstName) > 0) {
 463                                         strncpy(pAddress[*nAddressCnt].displayName, firstName, MAX_DISPLAY_NAME_LEN);
 464                                 }
 465                                 if (strlen(lastName) > 0) {
 466                                         strncat(pAddress[*nAddressCnt].displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 467                                         strncat(pAddress[*nAddressCnt].displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 468                                 }
 469                         } else if (contactNameOrder == 1) {
 470                                 if (strlen(lastName) > 0) {
 471                                         strncpy(pAddress[*nAddressCnt].displayName, lastName, MAX_DISPLAY_NAME_LEN);
 472                                         strncat(pAddress[*nAddressCnt].displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 473                                 }
 474
 475                                 if (strlen(firstName) > 0) {
 476                                         strncat(pAddress[*nAddressCnt].displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(pAddress[*nAddressCnt].displayName));
 477                                 }
 478                         }
 479                 }
 480
 481                 (*nAddressCnt)++;
 482         }
 483
 484         pDbHandle->finalizeQuery();
 485
 486         return MSG_SUCCESS;
 487 }
 488
 489 msg_error_t MsgStoGetAddressByMsgId(MsgDbHandler *pDbHandle, msg_message_id_t msgId, int contactNameOrder, msg_struct_list_s *pAddress)
 490 {
 491         char sqlQuery[MAX_QUERY_LEN+1];
 492         char firstName[MAX_DISPLAY_NAME_LEN+1];
 493         char lastName[MAX_DISPLAY_NAME_LEN+1];
 494
 495         pAddress->nCount = 0;
 496         pAddress->msg_struct_info = NULL;
 497
 498         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 499         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ADDRESS_TYPE, A.RECIPIENT_TYPE, \
 500                         A.CONTACT_ID, A.ADDRESS_VAL, A.DISPLAY_NAME, A.FIRST_NAME, A.LAST_NAME \
 501                         FROM %s A, %s B WHERE A.CONV_ID = B.CONV_ID AND B.MSG_ID = %d;",
 502                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
 503
 504         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 505                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 506                 return MSG_ERR_DB_PREPARE;
 507         }
 508
 509         msg_struct_s *pTmp = NULL;
 510         MSG_ADDRESS_INFO_S *pAddr = NULL;
 511
 512         pAddress->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * MAX_TO_ADDRESS_CNT];
 513
 514         for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
 515                 pAddress->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
 516                 pTmp = (msg_struct_s *)pAddress->msg_struct_info[i];
 517                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
 518                 pTmp->data = new char[sizeof(MSG_ADDRESS_INFO_S)];
 519                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 520         }
 521
 522
 523         while (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 524                 memset(firstName, 0x00, sizeof(firstName));
 525                 memset(lastName, 0x00, sizeof(lastName));
 526
 527                 pTmp = (msg_struct_s *)pAddress->msg_struct_info[pAddress->nCount];
 528                 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
 529
 530                 pAddr->addressType = pDbHandle->columnInt(0);
 531                 pAddr->recipientType = pDbHandle->columnInt(1);
 532                 pAddr->contactId = pDbHandle->columnInt(2);
 533
 534                 if (pDbHandle->columnText(3) != NULL)
 535                                         strncpy(pAddr->addressVal, (char *)pDbHandle->columnText(3), MAX_ADDRESS_VAL_LEN);
 536
 537                 if (pDbHandle->columnText(4) != NULL && ((char *)pDbHandle->columnText(4))[0]!='\0') {
 538                                         MSG_DEBUG("displayName  : [%s]", pDbHandle->columnText(4));
 539                                         strncpy(pAddr->displayName, (char *)pDbHandle->columnText(4), MAX_DISPLAY_NAME_LEN);
 540                 } else {
 541                         if (pDbHandle->columnText(5) != NULL)
 542                                 strncpy(firstName, (char *)pDbHandle->columnText(5), MAX_DISPLAY_NAME_LEN);
 543
 544                         if (pDbHandle->columnText(6) != NULL)
 545                                 strncpy(lastName, (char *)pDbHandle->columnText(6), MAX_DISPLAY_NAME_LEN);
 546
 547                         if (contactNameOrder == 0) {
 548                                 if (strlen(firstName) > 0) {
 549                                         strncpy(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN);
 550                                 }
 551
 552                                 if (strlen(lastName) > 0) {
 553                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 554                                         strncat(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 555                                 }
 556                         } else if (contactNameOrder == 1) {
 557                                 if (strlen(lastName) > 0) {
 558                                         strncpy(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN);
 559                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 560                                 }
 561
 562                                 if (strlen(firstName) > 0) {
 563                                         strncat(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 564                                 }
 565                         }
 566                 }
 567
 568                 pAddress->nCount++;
 569         }
 570
 571         pDbHandle->finalizeQuery();
 572
 573         return MSG_SUCCESS;
 574 }
 575
 576
 577 msg_error_t MsgStoGetAddressByConvId(MsgDbHandler *pDbHandle, msg_thread_id_t convId, int contactNameOrder, msg_struct_list_s *pAddrlist)
 578 {
 579         char sqlQuery[MAX_QUERY_LEN+1];
 580         char firstName[MAX_DISPLAY_NAME_LEN+1];
 581         char lastName[MAX_DISPLAY_NAME_LEN+1];
 582         int index = 7;
 583         int rowCnt = 0;
 584
 585         pAddrlist->nCount = 0;
 586         pAddrlist->msg_struct_info = NULL;
 587
 588         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 589         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT ADDRESS_TYPE, RECIPIENT_TYPE, \
 590                         CONTACT_ID, ADDRESS_VAL, DISPLAY_NAME, FIRST_NAME, LAST_NAME \
 591                         FROM %s WHERE CONV_ID  = %d;",
 592                         MSGFW_ADDRESS_TABLE_NAME, convId);
 593
 594         msg_error_t  err = pDbHandle->getTable(sqlQuery, &rowCnt);
 595
 596         if (err == MSG_ERR_DB_NORECORD) {
 597                 pDbHandle->freeTable();
 598                 return MSG_SUCCESS;
 599         } else if (err != MSG_SUCCESS) {
 600                 MSG_DEBUG("sqlQuery is - %s", sqlQuery);
 601                 pDbHandle->freeTable();
 602                 return err;
 603         }
 604
 605         pAddrlist->nCount = rowCnt;
 606
 607         MSG_DEBUG("pAddrlist->nCount [%d]", pAddrlist->nCount);
 608
 609         msg_struct_s *pTmp = NULL;
 610         MSG_ADDRESS_INFO_S *pAddr = NULL;
 611
 612         pAddrlist->msg_struct_info = (msg_struct_t *)new char[sizeof(msg_struct_t) * MAX_TO_ADDRESS_CNT];
 613
 614         for (int i = 0; i < MAX_TO_ADDRESS_CNT; i++) {
 615                 pAddrlist->msg_struct_info[i] = (msg_struct_t)new char[sizeof(msg_struct_s)];
 616                 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
 617                 pTmp->type = MSG_STRUCT_ADDRESS_INFO;
 618                 pTmp->data = new char[sizeof(MSG_ADDRESS_INFO_S)];
 619                 memset(pTmp->data, 0x00, sizeof(MSG_ADDRESS_INFO_S));
 620         }
 621
 622         for (int i = 0; i < rowCnt; i++) {
 623                 pTmp = (msg_struct_s *)pAddrlist->msg_struct_info[i];
 624                 pAddr = (MSG_ADDRESS_INFO_S *)pTmp->data;
 625
 626                 pAddr->addressType = pDbHandle->getColumnToInt(index++);
 627                 pAddr->recipientType = pDbHandle->getColumnToInt(index++);
 628                 pAddr->contactId = pDbHandle->getColumnToInt(index++);
 629                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, pAddr->addressVal);
 630                 pDbHandle->getColumnToString(index++, MAX_DISPLAY_NAME_LEN, pAddr->displayName);
 631                 if(!strlen(pAddr->displayName)) {
 632                         pDbHandle->getColumnToString(index++,MAX_DISPLAY_NAME_LEN, firstName);
 633                         pDbHandle->getColumnToString(index++,MAX_DISPLAY_NAME_LEN, lastName);
 634
 635                         if (contactNameOrder == 0) {
 636                                 if (strlen(firstName) > 0) {
 637                                         strncpy(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN);
 638                                 }
 639
 640                                 if (strlen(lastName) > 0) {
 641                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 642                                         strncat(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 643                                 }
 644                         } else if (contactNameOrder == 1) {
 645                                 if (strlen(lastName) > 0) {
 646                                         strncpy(pAddr->displayName, lastName, MAX_DISPLAY_NAME_LEN);
 647                                         strncat(pAddr->displayName, " ", MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 648                                 }
 649
 650                                 if (strlen(firstName) > 0) {
 651                                         strncat(pAddr->displayName, firstName, MAX_DISPLAY_NAME_LEN-strlen(pAddr->displayName));
 652                                 }
 653                         }
 654                 } else {
 655                         index++; // firstname
 656                         index++; // lastname
 657                 }
 658
 659         }
 660         pDbHandle->freeTable();
 661
 662         return MSG_SUCCESS;
 663 }
 664
 665 /* Have to use trigger for this function. */
 666 msg_error_t MsgStoUpdateConversation(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
 667 {
 668         MSG_BEGIN();
 669
 670         msg_error_t err = MSG_SUCCESS;
 671
 672         int unreadCnt = 0;
 673         int smsCnt = 0;
 674         int mmsCnt = 0;
 675
 676         char msgText[MAX_THREAD_DATA_LEN+1];
 677         char sqlQuery[MAX_QUERY_LEN+1];
 678
 679         memset(msgText, 0x00, sizeof(msgText));
 680
 681         // Get Unread Count
 682         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 683
 684         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s WHERE CONV_ID = %d AND FOLDER_ID = %d AND STORAGE_ID = %d AND READ_STATUS = 0;",
 685                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_INBOX_ID, MSG_STORAGE_PHONE);
 686
 687         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 688                 return MSG_ERR_DB_PREPARE;
 689
 690         err = pDbHandle->stepQuery();
 691
 692         if (err == MSG_ERR_DB_ROW) {
 693                 unreadCnt = pDbHandle->columnInt(0);
 694         } else if (err != MSG_ERR_DB_DONE) {
 695                 pDbHandle->finalizeQuery();
 696                 return MSG_ERR_DB_STEP;
 697         }
 698
 699         pDbHandle->finalizeQuery();
 700
 701         // Get SMS Count
 702         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 703
 704         snprintf(sqlQuery, sizeof(sqlQuery), "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;",
 705                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_SMS_TYPE, MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 706
 707         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 708                 return MSG_ERR_DB_PREPARE;
 709
 710         err = pDbHandle->stepQuery();
 711
 712         if (err == MSG_ERR_DB_ROW) {
 713                 smsCnt = pDbHandle->columnInt(0);
 714         }
 715         else if (err != MSG_ERR_DB_DONE) {
 716                 pDbHandle->finalizeQuery();
 717                 return MSG_ERR_DB_STEP;
 718         }
 719
 720         pDbHandle->finalizeQuery();
 721
 722         // Get MMS Count
 723         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 724
 725         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s \
 726                         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;",
 727                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_MMS_TYPE, MSG_DELIVERYIND_MMS, MSG_READRECIND_MMS, MSG_READORGIND_MMS,
 728                         MSG_ALLBOX_ID, MSG_CBMSGBOX_ID, MSG_STORAGE_PHONE);
 729
 730         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 731                 return MSG_ERR_DB_PREPARE;
 732
 733         err = pDbHandle->stepQuery();
 734
 735         if (err == MSG_ERR_DB_ROW) {
 736                 mmsCnt = pDbHandle->columnInt(0);
 737         } else if (err != MSG_ERR_DB_DONE) {
 738                 pDbHandle->finalizeQuery();
 739                 return MSG_ERR_DB_STEP;
 740         }
 741
 742         pDbHandle->finalizeQuery();
 743
 744         // Get Latest Msg Data
 745         MSG_MAIN_TYPE_T mainType = MSG_UNKNOWN_TYPE;
 746         MSG_SUB_TYPE_T subType = MSG_NORMAL_SMS;
 747         msg_direction_type_t direction = MSG_DIRECTION_TYPE_MO;
 748         time_t msgTime = 0;
 749
 750         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 751
 752         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT MAIN_TYPE, SUB_TYPE, MSG_DIRECTION, DISPLAY_TIME, SUBJECT, MSG_TEXT FROM %s \
 753                         WHERE CONV_ID = %d AND FOLDER_ID > %d AND FOLDER_ID < %d AND STORAGE_ID = %d ORDER BY DISPLAY_TIME DESC;",
 754                         MSGFW_MESSAGE_TABLE_NAME, convId, MSG_ALLBOX_ID, MSG_SPAMBOX_ID, MSG_STORAGE_PHONE);
 755
 756         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 757                 return MSG_ERR_DB_PREPARE;
 758
 759         err = pDbHandle->stepQuery();
 760
 761         if (err == MSG_ERR_DB_ROW) {
 762                 mainType = pDbHandle->columnInt(0);
 763                 subType = pDbHandle->columnInt(1);
 764                 direction = pDbHandle->columnInt(2);
 765
 766                 msgTime = (time_t)pDbHandle->columnInt(3);
 767
 768                 memset(msgText, 0x00, sizeof(msgText));
 769
 770                 if (mainType == MSG_SMS_TYPE) {
 771                         if (pDbHandle->columnText(5) != NULL)
 772                                 strncpy(msgText, (char*)pDbHandle->columnText(5), MAX_THREAD_DATA_LEN);
 773                 } else if (mainType == MSG_MMS_TYPE) {
 774                         if (pDbHandle->columnText(4) != NULL) {
 775                                 strncpy(msgText, (char*)pDbHandle->columnText(4), MAX_THREAD_DATA_LEN);
 776                         }
 777
 778                         if ((strlen(msgText) <= 0) && (pDbHandle->columnText(5) != NULL) && (subType != MSG_NOTIFICATIONIND_MMS)) {
 779                                 memset(msgText, 0x00, sizeof(msgText));
 780                                 strncpy(msgText, (char*)pDbHandle->columnText(5), MAX_THREAD_DATA_LEN);
 781                         }
 782                 }
 783         } else if (err != MSG_ERR_DB_DONE) {
 784                 pDbHandle->finalizeQuery();
 785                 return MSG_ERR_DB_STEP;
 786         }
 787
 788         pDbHandle->finalizeQuery();
 789
 790         // Update Address Table
 791         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 792
 793         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
 794                         UNREAD_CNT = %d, SMS_CNT = %d, MMS_CNT = %d, MAIN_TYPE = %d, SUB_TYPE = %d, MSG_DIRECTION = %d, DISPLAY_TIME = %ld, MSG_TEXT = ? \
 795                         WHERE CONV_ID = %d;", MSGFW_CONVERSATION_TABLE_NAME, unreadCnt, smsCnt, mmsCnt, mainType, subType, direction, msgTime, convId);
 796
 797         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 798                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 799                 return MSG_ERR_DB_PREPARE;
 800         }
 801
 802         pDbHandle->bindText(msgText, 1);
 803
 804         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
 805                 pDbHandle->finalizeQuery();
 806                 MSG_DEBUG("Update Address Info. Fail [%d] [%s]", err, sqlQuery);
 807                 return MSG_ERR_DB_STEP;
 808         }
 809
 810         pDbHandle->finalizeQuery();
 811
 812         MSG_END();
 813
 814         return MSG_SUCCESS;
 815 }
 816
 817
 818 /* consider to replcae this function to trigger. */
 819 msg_error_t MsgStoClearConversationTable(MsgDbHandler *pDbHandle)
 820 {
 821         msg_error_t err = MSG_SUCCESS;
 822
 823         char sqlQuery[MAX_QUERY_LEN+1];
 824
 825         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 826
 827         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s \
 828                         WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s) AND CONV_ID <> 0;",
 829                         MSGFW_CONVERSATION_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 830
 831         err = pDbHandle->execQuery(sqlQuery);
 832
 833         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE CONV_ID NOT IN (SELECT CONV_ID FROM %s);",
 834                         MSGFW_ADDRESS_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME);
 835
 836         err = pDbHandle->execQuery(sqlQuery);
 837
 838         return err;
 839 }
 840
 841
 842 void MsgConvertNumber(const char* pSrcNum, char* pDestNum)
 843 {
 844         int overLen = 0;
 845         int i = 0;
 846
 847         overLen = strlen(pSrcNum) - MAX_PRECONFIG_NUM;
 848
 849         for (i = 0; i < MAX_PRECONFIG_NUM; i++)
 850                 pDestNum[i] = pSrcNum[i+overLen];
 851
 852         pDestNum[i] = '\0';
 853 }
 854
 855 /* Change the function name to conversation related. */
 856 bool MsgExistAddress(MsgDbHandler *pDbHandle, const MSG_MESSAGE_INFO_S *pMsg, msg_thread_id_t *pConvId)
 857 {
 858         msg_error_t err = MSG_SUCCESS;
 859
 860         char sqlQuery[MAX_QUERY_LEN+1];
 861
 862         *pConvId = 0;
 863
 864         if(pMsg->nAddressCnt == 1) {
 865                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 866
 867                 snprintf(sqlQuery, sizeof(sqlQuery),
 868                                 "SELECT CONV_ID FROM (SELECT B.CONV_ID FROM %s A, %s B WHERE A.ADDRESS_VAL = '%s' AND A.CONV_ID=B.CONV_ID) GROUP BY CONV_ID HAVING COUNT(CONV_ID)=1;",
 869                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[0].addressVal);
 870
 871                 int rowCnt = 0;
 872                 msg_thread_id_t convId = 0;
 873                 err = pDbHandle->getTable(sqlQuery, &rowCnt);
 874
 875                 /* No record or other error */
 876                 if (err != MSG_SUCCESS) {
 877                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
 878                         pDbHandle->freeTable();
 879                         return false;
 880                 }
 881
 882                 if(rowCnt > 0) {
 883                         convId = pDbHandle->getColumnToInt(1);
 884
 885                         MSG_DEBUG("CONV_ID : [%d]", convId);
 886
 887                         if (convId > 0) {
 888                                 *pConvId = convId;
 889                                 pDbHandle->freeTable();
 890                                 return true;
 891                         } else {
 892                                 pDbHandle->freeTable();
 893                                 return false;
 894                         }
 895                 }
 896
 897         } else { /* multiple address */
 898                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 899
 900                 snprintf(sqlQuery, sizeof(sqlQuery),
 901                                 "SELECT CONV_ID FROM (SELECT B.CONV_ID FROM %s A, %s B WHERE A.ADDRESS_VAL = '%s' AND A.CONV_ID=B.CONV_ID) GROUP BY CONV_ID HAVING COUNT(CONV_ID)=%d;",
 902                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_ADDRESS_TABLE_NAME, pMsg->addressList[0].addressVal, pMsg->nAddressCnt);
 903
 904                 int rowCnt = 0;
 905                 int convId = 0;
 906
 907                 MSG_DEBUG("Query [%s]", sqlQuery);
 908
 909                 err = pDbHandle->getTable(sqlQuery, &rowCnt);
 910
 911                 /* No record or other error */
 912                 if (err != MSG_SUCCESS) {
 913                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
 914                         pDbHandle->freeTable();
 915                         return false;
 916                 }
 917
 918                 for (int i = 1; i <= rowCnt; i++) {
 919                         convId = pDbHandle->getColumnToInt(i);
 920
 921                         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 922
 923                         snprintf(sqlQuery, sizeof(sqlQuery),
 924                                         "SELECT COUNT(*) FROM %s WHERE CONV_ID=%d AND (",
 925                                         MSGFW_ADDRESS_TABLE_NAME, convId);
 926
 927                         for (int j = 0; j<(pMsg->nAddressCnt); j++ ) {
 928
 929                                 if (j!=0)
 930                                         strncat(sqlQuery, "OR ", MAX_QUERY_LEN-strlen(sqlQuery));
 931
 932                                 strncat(sqlQuery, "ADDRESS_VAL = '", MAX_QUERY_LEN-strlen(sqlQuery));
 933
 934                                 strncat(sqlQuery, pMsg->addressList[j].addressVal, MAX_QUERY_LEN-strlen(sqlQuery));
 935
 936                                 strncat(sqlQuery, "' ", MAX_QUERY_LEN-strlen(sqlQuery));
 937                         }
 938                         strncat(sqlQuery, ");", MAX_QUERY_LEN-strlen(sqlQuery));
 939                         MSG_DEBUG("Query [%s]", sqlQuery);
 940                         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
 941                                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
 942                                 pDbHandle->freeTable();
 943                                 pDbHandle->finalizeQuery();
 944                                 return false;
 945                         }
 946
 947                         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 948                                 if (pMsg->nAddressCnt == pDbHandle->columnInt(0)) {
 949                                         *pConvId = convId;
 950                                         pDbHandle->finalizeQuery();
 951                                         pDbHandle->freeTable();
 952                                         return true;
 953                                 }
 954                         }
 955                         pDbHandle->finalizeQuery();
 956                 }
 957                 pDbHandle->freeTable();
 958         }
 959
 960         return false;
 961 }
 962
 963
 964 int MsgStoGetUnreadCnt(MsgDbHandler *pDbHandle, MSG_MAIN_TYPE_T msgType)
 965 {
 966         int msgCnt = 0;
 967
 968         char sqlQuery[MAX_QUERY_LEN+1];
 969
 970         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 971
 972         if (msgType == MSG_SMS_TYPE) {
 973                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s \
 974                                 WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d, %d, %d, %d, %d) AND FOLDER_ID = %d AND READ_STATUS = 0;",
 975                                 MSGFW_MESSAGE_TABLE_NAME, MSG_SMS_TYPE, 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, MSG_INBOX_ID);
 976         } else if (msgType == MSG_MMS_TYPE) {
 977                 snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(MSG_ID) FROM %s \
 978                                 WHERE MAIN_TYPE = %d AND SUB_TYPE IN (%d, %d, %d) AND FOLDER_ID = %d AND READ_STATUS = 0;",
 979                                 MSGFW_MESSAGE_TABLE_NAME, MSG_MMS_TYPE, MSG_RETRIEVE_AUTOCONF_MMS, MSG_RETRIEVE_MANUALCONF_MMS, MSG_NOTIFICATIONIND_MMS, MSG_INBOX_ID);
 980         }
 981
 982         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
 983                 return 0;
 984
 985         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
 986                 msgCnt = pDbHandle->columnInt(0);
 987         } else {
 988                 pDbHandle->finalizeQuery();
 989                 return 0;
 990         }
 991
 992         pDbHandle->finalizeQuery();
 993
 994         return msgCnt;
 995 }
 996
 997
 998 msg_error_t MsgStoAddContactInfo(MsgDbHandler *pDbHandle, MSG_CONTACT_INFO_S *pContactInfo, const char *pNumber)
 999 {
1000         char sqlQuery[MAX_QUERY_LEN+1];
1001
1002         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1003         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET "
1004                         "CONTACT_ID = %d, "
1005                         "DISPLAY_NAME = ?, "
1006                         "FIRST_NAME = ?, "
1007                         "LAST_NAME = ?, "
1008                         "IMAGE_PATH = '%s' "
1009                         "WHERE ADDRESS_VAL = '%s';",
1010                         MSGFW_ADDRESS_TABLE_NAME, pContactInfo->contactId, pContactInfo->imagePath, pNumber);
1011
1012         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1013                 MSG_DEBUG("sqlQuery [%s]", sqlQuery);
1014                 return MSG_ERR_DB_PREPARE;
1015         }
1016
1017         pDbHandle->bindText(pContactInfo->displayName, 1);
1018         pDbHandle->bindText(pContactInfo->firstName, 2);
1019         pDbHandle->bindText(pContactInfo->lastName, 3);
1020
1021         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1022                 pDbHandle->finalizeQuery();
1023                 MSG_DEBUG("Update contact Info. Fail [%s]", sqlQuery);
1024                 return MSG_ERR_DB_STEP;
1025         }
1026
1027         pDbHandle->finalizeQuery();
1028
1029         return MSG_SUCCESS;
1030 }
1031
1032
1033 msg_error_t MsgStoResetContactInfo(MsgDbHandler *pDbHandle, int contactId)
1034 {
1035         msg_error_t err = MSG_SUCCESS;
1036
1037         char sqlQuery[MAX_QUERY_LEN+1];
1038         int rowCnt = 0;
1039         int index = 2;
1040
1041         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1042
1043         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT ADDRESS_VAL, CONV_ID FROM %s WHERE CONTACT_ID = %d;",
1044                         MSGFW_ADDRESS_TABLE_NAME, contactId);
1045
1046         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1047
1048         if (err != MSG_SUCCESS) {
1049                 pDbHandle->freeTable();
1050                 MSG_DEBUG("[Error]Failed to Get Table");
1051                 return err;
1052         }
1053
1054         MsgDbHandler tmpDbHandle;
1055         for (int i=0; i<rowCnt; i++) {
1056
1057                 MSG_CONTACT_INFO_S contactInfo;
1058                 memset(&contactInfo, 0x00, sizeof(MSG_CONTACT_INFO_S));
1059                 MSG_ADDRESS_INFO_S addrInfo;
1060                 memset(&addrInfo, 0x00, sizeof(MSG_ADDRESS_INFO_S));
1061
1062                 pDbHandle->getColumnToString(index++, MAX_ADDRESS_VAL_LEN, addrInfo.addressVal);
1063
1064                 MsgGetContactInfo(&addrInfo, &contactInfo);
1065                 MsgStoAddContactInfo(&tmpDbHandle, &contactInfo, addrInfo.addressVal);
1066
1067                 MsgStoSetConversationDisplayName(&tmpDbHandle, (msg_thread_id_t)pDbHandle->getColumnToInt(index++));
1068         }
1069
1070         pDbHandle->freeTable();
1071
1072         return err;
1073 }
1074
1075
1076 msg_error_t MsgStoClearContactInfo(MsgDbHandler *pDbHandle, int contactId, const char *pNumber)
1077 {
1078         char newPhoneNum[MAX_PRECONFIG_NUM+1];
1079         char sqlQuery[MAX_QUERY_LEN+1];
1080
1081         memset(newPhoneNum, 0x00, sizeof(newPhoneNum));
1082         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1083
1084         if (strlen(pNumber) > MAX_PRECONFIG_NUM) {
1085                 MsgConvertNumber(pNumber, newPhoneNum);
1086
1087                 MSG_DEBUG("Phone Number to Compare : [%s]", newPhoneNum);
1088
1089                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1090                                 CONTACT_ID = 0, DISPLAY_NAME = '', FIRST_NAME = '', LAST_NAME = '', IMAGE_PATH = '' \
1091                                 WHERE CONTACT_ID = %d AND ADDRESS_VAL NOT LIKE '%%%s';",
1092                                 MSGFW_ADDRESS_TABLE_NAME, contactId, newPhoneNum);
1093         } else {
1094                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET \
1095                                 CONTACT_ID = 0, DISPLAY_NAME = '', FIRST_NAME = '', LAST_NAME = '', IMAGE_PATH = '' \
1096                                 WHERE CONTACT_ID = %d AND ADDRESS_VAL <> '%s';",
1097                                 MSGFW_ADDRESS_TABLE_NAME, contactId, pNumber);
1098         }
1099
1100         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1101                 MSG_DEBUG("Fail to execute query");
1102                 return MSG_ERR_DB_EXEC;
1103         }
1104
1105         return MSG_SUCCESS;
1106 }
1107
1108
1109 msg_error_t MsgStoGetMmsRawFilePath(MsgDbHandler *pDbHandle, msg_message_id_t msgId, char *pFilePath)
1110 {
1111         char sqlQuery[MAX_QUERY_LEN+1];
1112
1113         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1114
1115         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.FILE_PATH FROM %s A, %s B \
1116                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1117                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1118
1119         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS)
1120                 return MSG_ERR_DB_PREPARE;
1121
1122         if (pDbHandle->stepQuery() == MSG_ERR_DB_ROW) {
1123                 if (pDbHandle->columnText(0) != NULL)
1124                         strncpy(pFilePath, (char*)pDbHandle->columnText(0), MSG_FILEPATH_LEN_MAX);
1125         } else {
1126                 pDbHandle->finalizeQuery();
1127                 return MSG_ERR_DB_STEP;
1128         }
1129
1130         pDbHandle->finalizeQuery();
1131
1132         return MSG_SUCCESS;
1133 }
1134
1135
1136 bool MsgStoCheckReadReportRequested(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1137 {
1138         msg_error_t err = MSG_SUCCESS;
1139
1140         char sqlQuery[MAX_QUERY_LEN+1];
1141         int rowCnt = 0;
1142         bool bReadReportRequested = false;
1143
1144         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1145
1146         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.ASK_READ_REPLY FROM %s A, %s B \
1147                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1148                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1149
1150         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1151
1152         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1153                 pDbHandle->freeTable();
1154                 MSG_DEBUG("[Error]Failed to Get Table");
1155                 return bReadReportRequested;
1156         }
1157
1158         if (rowCnt != 1) {
1159                 pDbHandle->freeTable();
1160                 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1161                 return bReadReportRequested;
1162         }
1163
1164         bReadReportRequested = pDbHandle->getColumnToInt(1);
1165
1166         pDbHandle->freeTable();
1167
1168         return bReadReportRequested;
1169 }
1170
1171
1172 bool MsgStoCheckReadReportIsSent(MsgDbHandler *pDbHandle, msg_message_id_t msgId)
1173 {
1174         msg_error_t err = MSG_SUCCESS;
1175
1176         char sqlQuery[MAX_QUERY_LEN+1];
1177
1178         int rowCnt = 0;
1179         bool bReadReportIsSent = true;
1180
1181         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1182
1183         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT A.READ_REPORT_SENT FROM %s A, %s B \
1184                         WHERE A.MSG_ID = B.MSG_ID AND B.MSG_ID = %d;",
1185                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME, msgId);
1186
1187         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1188
1189         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1190                 pDbHandle->freeTable();
1191                 MSG_DEBUG("[Error]Failed to Get Table");
1192                 return bReadReportIsSent;
1193         }
1194
1195         if (rowCnt != 1) {
1196                 pDbHandle->freeTable();
1197                 MSG_DEBUG("[Error]MSG_ERR_DB_NORECORD");
1198                 return bReadReportIsSent;
1199         }
1200
1201         bReadReportIsSent = (bool)pDbHandle->getColumnToInt(1);
1202
1203         pDbHandle->freeTable();
1204
1205         return bReadReportIsSent;
1206 }
1207
1208
1209 msg_error_t MsgStoAddConversation(MsgDbHandler *pDbHandle, msg_thread_id_t *pConvId)
1210 {
1211         char sqlQuery[MAX_QUERY_LEN+1];
1212
1213         if (pDbHandle->getRowId(MSGFW_CONVERSATION_TABLE_NAME, pConvId) != MSG_SUCCESS) {
1214                 return MSG_ERR_DB_EXEC;
1215         }
1216
1217         // Add Conversation
1218         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1219         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 0, 0, 0, 0, 0, 0, 0, '', '');",
1220                         MSGFW_CONVERSATION_TABLE_NAME, *pConvId);
1221
1222         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS) {
1223                 MSG_DEBUG("Query Failed. [%s]", sqlQuery);
1224                 return MSG_ERR_DB_EXEC;
1225         }
1226
1227         return MSG_SUCCESS;
1228 }
1229
1230
1231 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, int contactId)
1232 {
1233         msg_error_t err = MSG_SUCCESS;
1234         int rowCnt = 0;
1235         char displayName[MAX_DISPLAY_NAME_LEN+1];
1236         char sqlQuery[MAX_QUERY_LEN+1];
1237
1238         MSG_DEBUG("contactId [%d]", contactId);
1239
1240         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1241         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT DISTINCT(CONV_ID) FROM %s WHERE CONTACT_ID = %d;",
1242                         MSGFW_ADDRESS_TABLE_NAME, contactId);
1243
1244         err = pDbHandle->getTable(sqlQuery, &rowCnt);
1245
1246         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1247                 pDbHandle->freeTable();
1248                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1249                 return err;
1250         }
1251
1252         int order = MsgGetContactNameOrder();
1253         msg_struct_s *pAddrInfo = NULL;
1254         MSG_ADDRESS_INFO_S *address = NULL;
1255
1256         for (int i = 1; i <= rowCnt; i++)
1257         {
1258                 memset(displayName, 0x00, sizeof(displayName));
1259                 MsgDbHandler tmpDbHandle;
1260                 msg_struct_list_s addressList = {0,};
1261                 MsgStoGetAddressByConvId(&tmpDbHandle, (msg_thread_id_t)pDbHandle->getColumnToInt(i), order, &addressList);
1262
1263                 for (int j = 0; j < addressList.nCount; j++)
1264                 {
1265                         if (j >0)
1266                                 strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1267
1268                         pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1269                         address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1270
1271                         if (address->displayName[0] == '\0')
1272                                 strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1273                         else
1274                                 strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1275                 }
1276
1277                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
1278                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1279                                 MSGFW_CONVERSATION_TABLE_NAME, pDbHandle->getColumnToInt(i));
1280
1281                 if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1282                         MSG_DEBUG("Query Failed [%s]", sqlQuery);
1283                         return MSG_ERR_DB_PREPARE;
1284                 }
1285
1286                 pDbHandle->bindText(displayName, 1);
1287
1288                 if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1289                         pDbHandle->finalizeQuery();
1290                         MSG_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1291                         return MSG_ERR_DB_STEP;
1292                 }
1293
1294                 pDbHandle->finalizeQuery();
1295
1296                 // free address list
1297                 for(int j = 0; j < MAX_TO_ADDRESS_CNT; j++){
1298                         msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1299                         delete [] (MSG_ADDRESS_INFO_S *)pStruct->data;
1300                         delete [] (msg_struct_s *)pStruct;
1301                 }
1302         }
1303
1304         pDbHandle->freeTable();
1305
1306         return err;
1307 }
1308
1309
1310 msg_error_t MsgStoSetConversationDisplayName(MsgDbHandler *pDbHandle, msg_thread_id_t convId)
1311 {
1312         msg_error_t err = MSG_SUCCESS;
1313
1314         char displayName[MAX_DISPLAY_NAME_LEN+1];
1315         char sqlQuery[MAX_QUERY_LEN+1];
1316
1317         msg_struct_list_s addressList = {0,};
1318
1319         int order = MsgGetContactNameOrder();
1320         msg_struct_s *pAddrInfo = NULL;
1321         MSG_ADDRESS_INFO_S *address = NULL;
1322
1323         memset(displayName, 0x00, sizeof(displayName));
1324
1325         MsgStoGetAddressByConvId(pDbHandle, convId, order, &addressList);
1326
1327         for (int j = 0; j < addressList.nCount; j++)
1328         {
1329                 if (j >0)
1330                         strncat(displayName, ", ", MAX_DISPLAY_NAME_LEN-strlen(displayName));
1331
1332                 pAddrInfo = (msg_struct_s *)addressList.msg_struct_info[j];
1333                 address = (MSG_ADDRESS_INFO_S *)pAddrInfo->data;
1334
1335                 if (address->displayName[0] == '\0')
1336                         strncat(displayName, address->addressVal, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1337                 else
1338                         strncat(displayName, address->displayName, MAX_DISPLAY_NAME_LEN-strlen(displayName));
1339         }
1340
1341         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1342         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET DISPLAY_NAME = ? WHERE CONV_ID = %d;",
1343                         MSGFW_CONVERSATION_TABLE_NAME, convId);
1344
1345         if (pDbHandle->prepareQuery(sqlQuery) != MSG_SUCCESS) {
1346                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1347                 return MSG_ERR_DB_PREPARE;
1348         }
1349
1350         pDbHandle->bindText(displayName, 1);
1351
1352         if (pDbHandle->stepQuery() != MSG_ERR_DB_DONE) {
1353                 pDbHandle->finalizeQuery();
1354                 MSG_DEBUG("Update Conversation disply name. Fail [%s]", sqlQuery);
1355                 return MSG_ERR_DB_STEP;
1356         }
1357
1358         pDbHandle->finalizeQuery();
1359
1360         for(int j = 0; j < MAX_TO_ADDRESS_CNT; j++){
1361                 msg_struct_s *pStruct = (msg_struct_s *)addressList.msg_struct_info[j];
1362                 delete [] (MSG_ADDRESS_INFO_S *)pStruct->data;
1363                 delete [] (msg_struct_s *)pStruct;
1364         }
1365
1366         return err;
1367 }
1368
1369 msg_error_t MsgStoUpdateNetworkStatus(MsgDbHandler *pDbHandle, MSG_MESSAGE_INFO_S *pMsgInfo, msg_network_status_t status)
1370 {
1371         msg_error_t err = MSG_SUCCESS;
1372
1373         char sqlQuery[MAX_QUERY_LEN+1];
1374
1375         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1376
1377         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET NETWORK_STATUS = %d WHERE MSG_ID = %d;",
1378                         MSGFW_MESSAGE_TABLE_NAME, status, pMsgInfo->msgId);
1379
1380         if (pDbHandle->execQuery(sqlQuery) != MSG_SUCCESS)
1381                 err = MSG_ERR_DB_EXEC;
1382
1383         return err;
1384 }
1385
1386 char *MsgStoReplaceString(const char *origStr, const char *oldStr, const char *newStr)
1387 {
1388         if (origStr == NULL)
1389                 return NULL;
1390
1391         char *replaceStr = NULL;
1392         char *pTemp = NULL;
1393         int i = 0;
1394         int matchedCnt = 0;
1395         int oldStrLen = 0;
1396         int newStrLen = 0;
1397
1398         if (g_strcmp0(oldStr, newStr) != 0) {
1399                 oldStrLen = strlen(oldStr);
1400                 newStrLen = strlen(newStr);
1401
1402                 for (i = 0; origStr[i] != '\0';) {
1403                         if (memcmp(&origStr[i], oldStr, oldStrLen) == 0) {
1404                                 matchedCnt++;
1405                                 i += oldStrLen;
1406                         } else {
1407                                 i++;
1408                         }
1409                 }
1410         } else {
1411                 return g_strdup(origStr);
1412         }
1413
1414         replaceStr = (char *)calloc(1, i + sizeof(char) * (matchedCnt * (newStrLen - oldStrLen) + 1));
1415         if (replaceStr == NULL)
1416                 return NULL;
1417
1418         pTemp = replaceStr;
1419
1420         while (*origStr) {
1421                 if (memcmp(origStr, oldStr, oldStrLen) == 0) {
1422                         memcpy(pTemp, newStr, newStrLen);
1423                         pTemp += newStrLen;
1424                         origStr += oldStrLen;
1425                 } else {
1426                         *pTemp++ = *origStr++;
1427                 }
1428         }
1429
1430         return replaceStr;
1431 }
1432
1433
1434 msg_error_t MsgStoRefreshConversationDisplayName()
1435 {
1436         msg_error_t err = MSG_SUCCESS;
1437         MsgDbHandler dbHandle;
1438         int rowCnt = 0;
1439         char displayName[MAX_DISPLAY_NAME_LEN+1];
1440         char sqlQuery[MAX_QUERY_LEN+1];
1441
1442         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1443         snprintf(sqlQuery, sizeof(sqlQuery),
1444                         "SELECT DISTINCT(CONTACT_ID) FROM %s;",
1445                         MSGFW_ADDRESS_TABLE_NAME);
1446
1447         err = dbHandle.getTable(sqlQuery, &rowCnt);
1448
1449         if (err != MSG_SUCCESS && err != MSG_ERR_DB_NORECORD) {
1450                 dbHandle.freeTable();
1451                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1452                 return err;
1453         }
1454
1455         for (int i = 1; i <= rowCnt; i++)
1456         {
1457                 MsgUpdateContact(dbHandle.getColumnToInt(i), -1);
1458         }
1459
1460         dbHandle.freeTable();
1461
1462         return err;
1463 }