framework/storage-handler/MsgStorageManager.cpp

   1 /*
   2 * Copyright 2012  Samsung Electronics Co., Ltd
   3 *
   4 * Licensed under the Flora License, Version 1.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.tizenopensource.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 <stdio.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/stat.h>
  21 #include <errno.h>
  22
  23 #include <VMessage.h>
  24 #include <VCard.h>
  25 #include "MsgVMessage.h"
  26
  27 #include "MsgDebug.h"
  28 #include "MsgUtilFile.h"
  29 #include "MsgUtilStorage.h"
  30 #include "MsgGconfWrapper.h"
  31 #include "MsgSqliteWrapper.h"
  32 #include "MsgPluginManager.h"
  33 #include "MsgStorageHandler.h"
  34
  35
  36 /*==================================================================================================
  37                                      VARIABLES
  38 ==================================================================================================*/
  39 MsgDbHandler dbHandle;
  40
  41
  42 /*==================================================================================================
  43                                      FUNCTION IMPLEMENTATION
  44 ==================================================================================================*/
  45 msg_error_t MsgStoConnectDB()
  46 {
  47         return MSG_SUCCESS;
  48 }
  49
  50
  51 msg_error_t MsgStoDisconnectDB()
  52 {
  53         if (dbHandle.disconnect() != MSG_SUCCESS) {
  54                 MSG_DEBUG("DB Disconnect Fail");
  55                 return MSG_ERR_DB_DISCONNECT;
  56         }
  57
  58         MSG_DEBUG("DB Disconnect Success");
  59
  60         return MSG_SUCCESS;
  61 }
  62
  63
  64 msg_error_t MsgStoInitDB(bool bSimChanged)
  65 {
  66         MSG_BEGIN();
  67
  68         msg_error_t err = MSG_SUCCESS;
  69
  70 #ifdef MSG_DB_CREATE
  71         if (MsgCreateConversationTable() != MSG_SUCCESS)
  72                 return MSG_ERR_DB_STORAGE_INIT;
  73         if (MsgCreateAddressTable() != MSG_SUCCESS)
  74                 return MSG_ERR_DB_STORAGE_INIT;
  75         if (MsgCreateFolderTable() != MSG_SUCCESS)
  76                 return MSG_ERR_DB_STORAGE_INIT;
  77         if (MsgCreateMsgTable() != MSG_SUCCESS)
  78                 return MSG_ERR_DB_STORAGE_INIT;
  79         if (MsgCreateSimMessageTable() != MSG_SUCCESS)
  80                 return MSG_ERR_DB_STORAGE_INIT;
  81         if (MsgCreateWAPMessageTable() != MSG_SUCCESS)
  82                 return MSG_ERR_DB_STORAGE_INIT;
  83         if (MsgCreateCBMessageTable() != MSG_SUCCESS)
  84                 return MSG_ERR_DB_STORAGE_INIT;
  85         if (MsgCreateSyncMLMessageTable() != MSG_SUCCESS)
  86                 return MSG_ERR_DB_STORAGE_INIT;
  87         if (MsgCreateSmsSendOptTable() != MSG_SUCCESS)
  88                 return MSG_ERR_DB_STORAGE_INIT;
  89         if (MsgCreateFilterTable() != MSG_SUCCESS)
  90                 return MSG_ERR_DB_STORAGE_INIT;
  91         if (MsgCreateMmsTable() != MSG_SUCCESS)
  92                 return MSG_ERR_DB_STORAGE_INIT;
  93
  94         // Add Default Folders
  95         if (MsgAddDefaultFolders() != MSG_SUCCESS) {
  96                 MSG_DEBUG("Add Default Folders Fail");
  97                 return MSG_ERR_DB_STORAGE_INIT;
  98         }
  99
 100         // Add Default Address
 101         if (MsgAddDefaultAddress() != MSG_SUCCESS) {
 102                 MSG_DEBUG("Add Default Address Fail");
 103                 return MSG_ERR_DB_STORAGE_INIT;
 104         }
 105 #endif
 106
 107         // Delete Msgs in Hidden Folder
 108         MsgStoDeleteAllMessageInFolder(0, true, NULL);
 109
 110         // Reset network status
 111         MsgStoResetNetworkStatus();
 112
 113         //clear abnormal mms message
 114         MsgStoCleanAbnormalMmsData();
 115
 116         // Clear all old Sim data
 117         MsgStoClearSimMessageInDB();
 118
 119         int smsCnt = 0, mmsCnt = 0;
 120
 121         smsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_SMS_TYPE);
 122         mmsCnt = MsgStoGetUnreadCnt(&dbHandle, MSG_MMS_TYPE);
 123
 124         // Set Indicator
 125         MsgSettingSetIndicator(smsCnt, mmsCnt);
 126
 127         MSG_END();
 128
 129         return err;
 130 }
 131
 132
 133 msg_error_t MsgCreateConversationTable()
 134 {
 135         msg_error_t err = MSG_SUCCESS;
 136
 137         char sqlQuery[MAX_QUERY_LEN+1];
 138
 139         if (!dbHandle.checkTableExist(MSGFW_ADDRESS_TABLE_NAME)) {
 140                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 141
 142                 snprintf(sqlQuery, sizeof(sqlQuery),
 143                                 "CREATE TABLE %s ( \
 144                                 CONV_ID INTEGER NOT NULL , \
 145                                 UNREAD_CNT INTEGER DEFAULT 0 , \
 146                                 SMS_CNT INTEGER DEFAULT 0 , \
 147                                 MMS_CNT INTEGER DEFAULT 0 , \
 148                                 MAIN_TYPE INTEGER NOT NULL , \
 149                                 SUB_TYPE INTEGER NOT NULL , \
 150                                 MSG_DIRECTION INTEGER NOT NULL , \
 151                                 DISPLAY_TIME INTEGER , \
 152                                 DISPLAY_NAME TEXT , \
 153                                 MSG_TEXT TEXT );",
 154                                 MSGFW_CONVERSATION_TABLE_NAME);
 155
 156                 err = dbHandle.execQuery(sqlQuery);
 157
 158                 if (err == MSG_SUCCESS)
 159                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_CONVERSATION_TABLE_NAME);
 160                 else
 161                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_CONVERSATION_TABLE_NAME, err);
 162         }
 163
 164         return err;
 165 }
 166
 167
 168 msg_error_t MsgCreateAddressTable()
 169 {
 170         msg_error_t err = MSG_SUCCESS;
 171
 172         char sqlQuery[MAX_QUERY_LEN+1];
 173
 174         if (!dbHandle.checkTableExist(MSGFW_ADDRESS_TABLE_NAME)) {
 175                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 176
 177                 snprintf(sqlQuery, sizeof(sqlQuery),
 178                                 "CREATE TABLE %s ( \
 179                                 ADDRESS_ID INTEGER PRIMARY KEY , \
 180                                 CONV_ID INTEGER  NOT NULL , \
 181                                 ADDRESS_TYPE INTEGER , \
 182                                 RECIPIENT_TYPE INTEGER , \
 183                                 ADDRESS_VAL TEXT , \
 184                                 CONTACT_ID INTEGER , \
 185                                 DISPLAY_NAME TEXT , \
 186                                 FIRST_NAME TEXT , \
 187                                 LAST_NAME TEXT , \
 188                                 IMAGE_PATH TEXT , \
 189                                 SYNC_TIME DATETIME , \
 190                                 FOREIGN KEY(CONV_ID) REFERENCES %s (CONV_ID) );",
 191                                 MSGFW_ADDRESS_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME);
 192
 193                 err = dbHandle.execQuery(sqlQuery);
 194
 195                 if (err == MSG_SUCCESS)
 196                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_ADDRESS_TABLE_NAME);
 197                 else
 198                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_ADDRESS_TABLE_NAME, err);
 199         }
 200
 201         return err;
 202 }
 203
 204
 205 msg_error_t MsgCreateFolderTable()
 206 {
 207         msg_error_t err = MSG_SUCCESS;
 208
 209         char sqlQuery[MAX_QUERY_LEN+1];
 210
 211         if (!dbHandle.checkTableExist(MSGFW_FOLDER_TABLE_NAME)) {
 212                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 213
 214                 snprintf(sqlQuery, sizeof(sqlQuery),
 215                                 "CREATE TABLE %s ( \
 216                                 FOLDER_ID INTEGER PRIMARY KEY, \
 217                                 FOLDER_NAME TEXT NOT NULL, \
 218                                 FOLDER_TYPE INTEGER DEFAULT 0 );",
 219                                 MSGFW_FOLDER_TABLE_NAME);
 220
 221                 err = dbHandle.execQuery(sqlQuery);
 222
 223                 if (err == MSG_SUCCESS)
 224                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_FOLDER_TABLE_NAME);
 225                 else
 226                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_FOLDER_TABLE_NAME, err);
 227         }
 228
 229         return err;
 230 }
 231
 232
 233 msg_error_t MsgCreateMsgTable()
 234 {
 235         msg_error_t err = MSG_SUCCESS;
 236
 237         char sqlQuery[MAX_QUERY_LEN+1];
 238
 239         if (!dbHandle.checkTableExist(MSGFW_MESSAGE_TABLE_NAME)) {
 240                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 241
 242                 snprintf(sqlQuery, sizeof(sqlQuery),
 243                                 "CREATE TABLE %s ( \
 244                                 MSG_ID INTEGER PRIMARY KEY , \
 245                                 CONV_ID INTEGER NOT NULL , \
 246                                 FOLDER_ID INTEGER NOT NULL , \
 247                                 STORAGE_ID INTEGER NOT NULL , \
 248                                 MAIN_TYPE INTEGER NOT NULL , \
 249                                 SUB_TYPE INTEGER NOT NULL , \
 250                                 DISPLAY_TIME DATETIME , \
 251                                 DATA_SIZE INTEGER DEFAULT 0 , \
 252                                 NETWORK_STATUS INTEGER DEFAULT 0 , \
 253                                 READ_STATUS INTEGER DEFAULT 0 , \
 254                                 PROTECTED INTEGER DEFAULT 0 , \
 255                                 PRIORITY INTEGER DEFAULT 0 , \
 256                                 MSG_DIRECTION INTEGER NOT NULL , \
 257                                 SCHEDULED_TIME DATETIME , \
 258                                 BACKUP INTEGER DEFAULT 0 , \
 259                                 SUBJECT TEXT , \
 260                                 MSG_DATA TEXT , \
 261                                 THUMB_PATH TEXT , \
 262                                 MSG_TEXT TEXT , \
 263                                 ATTACHMENT_COUNT INTEGER DEFAULT 0 , \
 264                                 FOREIGN KEY(CONV_ID) REFERENCES %s (CONV_ID) , \
 265                                 FOREIGN KEY(FOLDER_ID) REFERENCES %s (FOLDER_ID) );",
 266                                 MSGFW_MESSAGE_TABLE_NAME, MSGFW_CONVERSATION_TABLE_NAME, MSGFW_FOLDER_TABLE_NAME);
 267
 268                 err = dbHandle.execQuery(sqlQuery);
 269
 270                 if (err == MSG_SUCCESS)
 271                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_MESSAGE_TABLE_NAME);
 272                 else
 273                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_MESSAGE_TABLE_NAME, err);
 274         }
 275
 276         return err;
 277 }
 278
 279
 280 msg_error_t MsgCreateSimMessageTable()
 281 {
 282         msg_error_t err = MSG_SUCCESS;
 283
 284         char sqlQuery[MAX_QUERY_LEN+1];
 285
 286         if (!dbHandle.checkTableExist(MSGFW_SIM_MSG_TABLE_NAME)) {
 287                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 288
 289                 snprintf(sqlQuery, sizeof(sqlQuery),
 290                                 "CREATE TABLE %s ( \
 291                                 MSG_ID INTEGER , \
 292                                 SIM_ID INTEGER NOT NULL , \
 293                                 FOREIGN KEY(MSG_ID) REFERENCES %s (MSG_ID) );",
 294                                 MSGFW_SIM_MSG_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 295
 296                 err = dbHandle.execQuery(sqlQuery);
 297
 298                 if (err == MSG_SUCCESS)
 299                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_SIM_MSG_TABLE_NAME);
 300                 else
 301                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_SIM_MSG_TABLE_NAME, err);
 302         }
 303
 304         return err;
 305 }
 306
 307
 308 msg_error_t MsgCreateWAPMessageTable()
 309 {
 310         msg_error_t err = MSG_SUCCESS;
 311
 312         char sqlQuery[MAX_QUERY_LEN+1];
 313
 314         if (!dbHandle.checkTableExist(MSGFW_PUSH_MSG_TABLE_NAME)) {
 315                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 316
 317                 snprintf(sqlQuery, sizeof(sqlQuery),
 318                                 "CREATE TABLE %s ( \
 319                                 MSG_ID INTEGER , \
 320                                 ACTION INTEGER , \
 321                                 CREATED INTEGER , \
 322                                 EXPIRES INTEGER , \
 323                                 ID TEXT , \
 324                                 HREF TEXT , \
 325                                 CONTENT TEXT , \
 326                                 FOREIGN KEY(MSG_ID) REFERENCES %s(MSG_ID) );",
 327                                 MSGFW_PUSH_MSG_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 328
 329                 err = dbHandle.execQuery(sqlQuery);
 330
 331                 if (err == MSG_SUCCESS)
 332                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_PUSH_MSG_TABLE_NAME);
 333                 else
 334                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_PUSH_MSG_TABLE_NAME, err);
 335         }
 336
 337         return err;
 338 }
 339
 340
 341 msg_error_t MsgCreateCBMessageTable()
 342 {
 343         msg_error_t err = MSG_SUCCESS;
 344
 345         char sqlQuery[MAX_QUERY_LEN+1];
 346
 347         if (!dbHandle.checkTableExist(MSGFW_CB_MSG_TABLE_NAME)) {
 348                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 349
 350                 snprintf(sqlQuery, sizeof(sqlQuery),
 351                                 "CREATE TABLE %s ( \
 352                                 MSG_ID INTEGER , \
 353                                 CB_MSG_ID INTEGER NOT NULL , \
 354                                 FOREIGN KEY(MSG_ID) REFERENCES %s (MSG_ID) );",
 355                                 MSGFW_CB_MSG_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 356
 357                 err = dbHandle.execQuery(sqlQuery);
 358
 359                 if (err == MSG_SUCCESS)
 360                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_CB_MSG_TABLE_NAME);
 361                 else
 362                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_CB_MSG_TABLE_NAME, err);
 363         }
 364
 365         return err;
 366 }
 367
 368
 369 msg_error_t MsgCreateSyncMLMessageTable()
 370 {
 371         msg_error_t err = MSG_SUCCESS;
 372
 373         char sqlQuery[MAX_QUERY_LEN+1];
 374
 375         if (!dbHandle.checkTableExist(MSGFW_SYNCML_MSG_TABLE_NAME)) {
 376                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 377
 378                 snprintf(sqlQuery, sizeof(sqlQuery),
 379                                 "CREATE TABLE %s ( \
 380                                 MSG_ID INTEGER , \
 381                                 EXT_ID INTEGER NOT NULL , \
 382                                 PINCODE INTEGER NOT NULL , \
 383                                 FOREIGN KEY(MSG_ID) REFERENCES %s(MSG_ID) );",
 384                                 MSGFW_SYNCML_MSG_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 385
 386                 err = dbHandle.execQuery(sqlQuery);
 387
 388                 if (err == MSG_SUCCESS)
 389                         MSG_DEBUG("SUCCESS : create %s.", MSGFW_SYNCML_MSG_TABLE_NAME);
 390                 else
 391                         MSG_DEBUG("FAIL : create %s [%d].", MSGFW_SYNCML_MSG_TABLE_NAME, err);
 392         }
 393
 394         return err;
 395 }
 396
 397 msg_error_t MsgCreateSmsSendOptTable()
 398 {
 399         msg_error_t err = MSG_SUCCESS;
 400
 401         char sqlQuery[MAX_QUERY_LEN+1];
 402
 403         if (!dbHandle.checkTableExist(MSGFW_SMS_SENDOPT_TABLE_NAME)) {
 404                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 405
 406                 snprintf(sqlQuery, sizeof(sqlQuery),
 407                                 "CREATE TABLE %s ( \
 408                                 MSG_ID INTEGER , \
 409                                 DELREP_REQ INTEGER NOT NULL , \
 410                                 KEEP_COPY INTEGER NOT NULL , \
 411                                 REPLY_PATH INTEGER NOT NULL , \
 412                                 FOREIGN KEY(MSG_ID) REFERENCES %s (MSG_ID) );",
 413                                 MSGFW_SMS_SENDOPT_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 414
 415                 err = dbHandle.execQuery(sqlQuery);
 416
 417                 if (err == MSG_SUCCESS)
 418                                 MSG_DEBUG("SUCCESS : create %s.", MSGFW_SMS_SENDOPT_TABLE_NAME);
 419                 else
 420                                 MSG_DEBUG("FAIL : create %s [%d].", MSGFW_SMS_SENDOPT_TABLE_NAME, err);
 421         }
 422
 423         return err;
 424 }
 425
 426
 427 msg_error_t MsgCreateFilterTable()
 428 {
 429         msg_error_t err = MSG_SUCCESS;
 430
 431         char sqlQuery[MAX_QUERY_LEN+1];
 432
 433         if (!dbHandle.checkTableExist(MSGFW_FILTER_TABLE_NAME)) {
 434                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 435
 436                 snprintf(sqlQuery, sizeof(sqlQuery),
 437                                 "CREATE TABLE %s ( \
 438                                 FILTER_ID INTEGER PRIMARY KEY , \
 439                                 FILTER_TYPE INTEGER NOT NULL , \
 440                                 FILTER_VALUE TEXT NOT NULL , \
 441                                 FILTER_ACTIVE INTEGER DEFAULT 0);",
 442                                 MSGFW_FILTER_TABLE_NAME);
 443
 444                 err = dbHandle.execQuery(sqlQuery);
 445
 446                 if (err == MSG_SUCCESS)
 447                                 MSG_DEBUG("SUCCESS : create %s.", MSGFW_FILTER_TABLE_NAME);
 448                 else
 449                                 MSG_DEBUG("FAIL : create %s [%d].", MSGFW_FILTER_TABLE_NAME, err);
 450         }
 451
 452         return err;
 453 }
 454
 455
 456 msg_error_t MsgCreateMmsTable()
 457 {
 458         msg_error_t err = MSG_SUCCESS;
 459
 460         char sqlQuery[MAX_QUERY_LEN+1];
 461
 462         if (!dbHandle.checkTableExist(MMS_PLUGIN_MESSAGE_TABLE_NAME)) {
 463                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 464
 465                 snprintf(sqlQuery, sizeof(sqlQuery),
 466                                 "CREATE TABLE %s ( \
 467                                 MSG_ID INTEGER , \
 468                                 TRANSACTION_ID TEXT , \
 469                                 MESSAGE_ID TEXT , \
 470                                 FWD_MESSAGE_ID TEXT , \
 471                                 CONTENTS_LOCATION TEXT , \
 472                                 FILE_PATH TEXT , \
 473                                 VERSION INTEGER NOT NULL , \
 474                                 DATA_TYPE INTEGER DEFAULT -1 , \
 475                                 DATE DATETIME , \
 476                                 HIDE_ADDRESS INTEGER DEFAULT 0 , \
 477                                 ASK_DELIVERY_REPORT INTEGER DEFAULT 0 , \
 478                                 REPORT_ALLOWED INTEGER DEFAULT 0 , \
 479                                 READ_REPORT_ALLOWED_TYPE INTEGER DEFAULT 0 , \
 480                                 ASK_READ_REPLY INTEGER DEFAULT 0 , \
 481                                 READ INTEGER DEFAULT 0 , \
 482                                 READ_REPORT_SEND_STATUS INTEGER DEFAULT 0 , \
 483                                 READ_REPORT_SENT INTEGER DEFAULT 0 , \
 484                                 PRIORITY INTEGER DEFAULT 0 , \
 485                                 KEEP_COPY INTEGER DEFAULT 0 , \
 486                                 MSG_SIZE INTEGER NOT NULL , \
 487                                 MSG_CLASS INTEGER DEFAULT -1 , \
 488                                 EXPIRY_TIME DATETIME , \
 489                                 CUSTOM_DELIVERY_TIME INTEGER DEFAULT 0 , \
 490                                 DELIVERY_TIME DATETIME , \
 491                                 MSG_STATUS INTEGER DEFAULT -1 , \
 492                                 FOREIGN KEY(MSG_ID) REFERENCES %s (MSG_ID) );",
 493                                 MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_MESSAGE_TABLE_NAME);
 494
 495                 err = dbHandle.execQuery(sqlQuery);
 496
 497                 if (err == MSG_SUCCESS)
 498                         MSG_DEBUG("SUCCESS : create %s.", MMS_PLUGIN_MESSAGE_TABLE_NAME);
 499                 else
 500                         MSG_DEBUG("FAIL : create %s [%d].", MMS_PLUGIN_MESSAGE_TABLE_NAME, err);
 501         }
 502
 503         return err;
 504 }
 505
 506
 507 msg_error_t MsgAddDefaultFolders()
 508 {
 509         int nRowCnt = 0;
 510         int nResult = 0;
 511
 512         char sqlQuery[MAX_QUERY_LEN+1];
 513
 514         // INBOX
 515         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 516         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 517                         MSGFW_FOLDER_TABLE_NAME, MSG_INBOX_ID);
 518
 519         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 520                 dbHandle.freeTable();
 521                 return MSG_ERR_DB_GETTABLE;
 522         }
 523
 524         nResult = dbHandle.getColumnToInt(1);
 525
 526         dbHandle.freeTable();
 527
 528         if (nResult == 0) {
 529                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 530                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'INBOX', %d);",
 531                                 MSGFW_FOLDER_TABLE_NAME, MSG_INBOX_ID, MSG_FOLDER_TYPE_INBOX);
 532
 533                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 534                         return MSG_ERR_DB_EXEC;
 535         }
 536
 537         // OUTBOX
 538         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 539         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 540                         MSGFW_FOLDER_TABLE_NAME, MSG_OUTBOX_ID);
 541
 542         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 543                 dbHandle.freeTable();
 544                 return MSG_ERR_DB_GETTABLE;
 545         }
 546
 547         nResult = dbHandle.getColumnToInt(1);
 548
 549         dbHandle.freeTable();
 550
 551         if (nResult == 0) {
 552                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 553                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'OUTBOX', %d);",
 554                                 MSGFW_FOLDER_TABLE_NAME, MSG_OUTBOX_ID, MSG_FOLDER_TYPE_OUTBOX);
 555
 556                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 557                         return MSG_ERR_DB_EXEC;
 558         }
 559
 560         // SENTBOX
 561         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 562         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 563                         MSGFW_FOLDER_TABLE_NAME, MSG_SENTBOX_ID);
 564
 565         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 566                 dbHandle.freeTable();
 567                 return MSG_ERR_DB_GETTABLE;
 568         }
 569
 570         nResult = dbHandle.getColumnToInt(1);
 571
 572         dbHandle.freeTable();
 573
 574         if (nResult == 0) {
 575                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 576                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'SENTBOX', %d);",
 577                                 MSGFW_FOLDER_TABLE_NAME, MSG_SENTBOX_ID, MSG_FOLDER_TYPE_OUTBOX);
 578
 579                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 580                         return MSG_ERR_DB_EXEC;
 581         }
 582
 583         // DRAFT
 584         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 585         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 586                         MSGFW_FOLDER_TABLE_NAME, MSG_DRAFT_ID);
 587
 588         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 589                 dbHandle.freeTable();
 590                 return MSG_ERR_DB_GETTABLE;
 591         }
 592
 593         nResult = dbHandle.getColumnToInt(1);
 594
 595         dbHandle.freeTable();
 596
 597         if (nResult == 0) {
 598                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 599                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'DRAFT', %d);",
 600                                 MSGFW_FOLDER_TABLE_NAME, MSG_DRAFT_ID, MSG_FOLDER_TYPE_DRAFT);
 601
 602                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 603                         return MSG_ERR_DB_EXEC;
 604         }
 605
 606         // CBMSGBOX
 607         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 608         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 609                         MSGFW_FOLDER_TABLE_NAME, MSG_CBMSGBOX_ID);
 610
 611         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 612                 dbHandle.freeTable();
 613                 return MSG_ERR_DB_GETTABLE;
 614         }
 615
 616         nResult = dbHandle.getColumnToInt(1);
 617
 618         dbHandle.freeTable();
 619
 620         if (nResult == 0) {
 621                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 622                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'CBMSGBOX', %d);",
 623                                 MSGFW_FOLDER_TABLE_NAME, MSG_CBMSGBOX_ID, MSG_FOLDER_TYPE_INBOX);
 624
 625                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 626                         return MSG_ERR_DB_EXEC;
 627         }
 628
 629         // SPAMBOX
 630         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 631         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 632                         MSGFW_FOLDER_TABLE_NAME, MSG_SPAMBOX_ID);
 633
 634         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 635                 dbHandle.freeTable();
 636                 return MSG_ERR_DB_GETTABLE;
 637         }
 638
 639         nResult = dbHandle.getColumnToInt(1);
 640
 641         dbHandle.freeTable();
 642
 643         if (nResult == 0) {
 644                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 645                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'SPAMBOX', %d);",
 646                                 MSGFW_FOLDER_TABLE_NAME, MSG_SPAMBOX_ID, MSG_FOLDER_TYPE_SPAMBOX);
 647
 648                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 649                         return MSG_ERR_DB_EXEC;
 650         }
 651
 652         // SMS TEMPLATE
 653         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 654         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 655                         MSGFW_FOLDER_TABLE_NAME, MSG_SMS_TEMPLATE_ID);
 656
 657         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 658                 dbHandle.freeTable();
 659                 return MSG_ERR_DB_GETTABLE;
 660         }
 661
 662         nResult = dbHandle.getColumnToInt(1);
 663
 664         dbHandle.freeTable();
 665
 666         if (nResult == 0) {
 667                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 668                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'SMS TEMPLATE', %d);",
 669                                 MSGFW_FOLDER_TABLE_NAME, MSG_SMS_TEMPLATE_ID, MSG_FOLDER_TYPE_TEMPLATE);
 670
 671                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 672                         return MSG_ERR_DB_EXEC;
 673         }
 674
 675         // MMS TEMPLATE
 676         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 677         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE FOLDER_ID = %d;",
 678                         MSGFW_FOLDER_TABLE_NAME, MSG_MMS_TEMPLATE_ID);
 679
 680         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 681                 dbHandle.freeTable();
 682                 return MSG_ERR_DB_GETTABLE;
 683         }
 684
 685         nResult = dbHandle.getColumnToInt(1);
 686
 687         dbHandle.freeTable();
 688
 689         if (nResult == 0) {
 690                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 691                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, 'MMS TEMPLATE', %d);",
 692                                 MSGFW_FOLDER_TABLE_NAME, MSG_MMS_TEMPLATE_ID, MSG_FOLDER_TYPE_TEMPLATE);
 693
 694                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 695                         return MSG_ERR_DB_EXEC;
 696         }
 697
 698         return MSG_SUCCESS;
 699 }
 700
 701
 702 msg_error_t MsgAddDefaultAddress()
 703 {
 704         MSG_BEGIN();
 705
 706         int nRowCnt = 0, nResult = 0;
 707
 708         char sqlQuery[MAX_QUERY_LEN+1];
 709
 710         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 711         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT COUNT(*) FROM %s WHERE ADDRESS_ID = 0;",
 712                         MSGFW_ADDRESS_TABLE_NAME);
 713
 714         if (dbHandle.getTable(sqlQuery, &nRowCnt) != MSG_SUCCESS) {
 715                 dbHandle.freeTable();
 716                 return MSG_ERR_DB_GETTABLE;
 717         }
 718
 719         nResult = dbHandle.getColumnToInt(1);
 720
 721         dbHandle.freeTable();
 722
 723         if (nResult == 0) {
 724                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 725                 snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (0, 0, 0, '', 0, '', '', '', '', 0, 0, 0, 0, 0, 0, 0, 0, '');",
 726                                 MSGFW_ADDRESS_TABLE_NAME);
 727
 728                 MSG_DEBUG("%s", sqlQuery);
 729
 730                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS)
 731                         return MSG_ERR_DB_EXEC;
 732         }
 733
 734         MSG_END();
 735
 736         return MSG_SUCCESS;
 737 }
 738
 739
 740 msg_error_t MsgStoResetDatabase()
 741 {
 742         msg_error_t err = MSG_SUCCESS;
 743
 744         char sqlQuery[MAX_QUERY_LEN+1];
 745
 746         const char* tableList[] = {MSGFW_FOLDER_TABLE_NAME, MSGFW_FILTER_TABLE_NAME,
 747                         MSGFW_PUSH_MSG_TABLE_NAME, MSGFW_CB_MSG_TABLE_NAME,
 748                         MMS_PLUGIN_MESSAGE_TABLE_NAME, MSGFW_SYNCML_MSG_TABLE_NAME,
 749                         MSGFW_SMS_SENDOPT_TABLE_NAME};
 750
 751         int listCnt = sizeof(tableList)/sizeof(char*);
 752
 753         dbHandle.beginTrans();
 754
 755         // Delete Database
 756         for (int i = 0; i < listCnt; i++)
 757         {
 758                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 759                 snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s;", tableList[i]);
 760
 761                 if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 762                         dbHandle.endTrans(false);
 763                         return MSG_ERR_DB_EXEC;
 764                 }
 765         }
 766
 767         // Delete Message Table
 768         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 769         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE STORAGE_ID <> %d;",
 770                         MSGFW_MESSAGE_TABLE_NAME, MSG_STORAGE_SIM);
 771
 772         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
 773                 dbHandle.endTrans(false);
 774                 return MSG_ERR_DB_EXEC;
 775         }
 776
 777         // Delete Conversation Table
 778         err = MsgStoClearConversationTable(&dbHandle);
 779
 780         if (err != MSG_SUCCESS) {
 781                 dbHandle.endTrans(false);
 782                 return err;
 783         }
 784
 785         // Add Default Folders
 786         if (MsgAddDefaultFolders() != MSG_SUCCESS) {
 787                 MSG_DEBUG("Add Default Folders Fail");
 788                 dbHandle.endTrans(false);
 789                 return MSG_ERR_DB_STORAGE_INIT;
 790         }
 791
 792         // Add Default Address
 793         if (MsgAddDefaultAddress() != MSG_SUCCESS) {
 794                 MSG_DEBUG("Add Default Address Fail");
 795                 dbHandle.endTrans(false);
 796                 return MSG_ERR_DB_STORAGE_INIT;
 797         }
 798
 799         dbHandle.endTrans(true);
 800
 801         // Delete MMS Files
 802         MsgRmRf((char*)MSG_DATA_PATH);
 803         MsgRmRf((char*)MSG_SMIL_FILE_PATH);
 804
 805         // Reset SMS Count
 806         if (MsgSettingSetIndicator(0, 0) != MSG_SUCCESS) {
 807                 MSG_DEBUG("MsgSettingSetIndicator() FAILED");
 808                 return MSG_ERR_SET_SETTING;
 809         }
 810
 811         // Reset MMS Count
 812         if (MsgSettingSetIndicator(0, 0) != MSG_SUCCESS) {
 813                 MSG_DEBUG("MsgSettingSetIndicator() FAILED");
 814                 return MSG_ERR_SET_SETTING;
 815         }
 816
 817         return MSG_SUCCESS;
 818 }
 819
 820
 821 msg_error_t MsgStoBackupMessage(msg_message_backup_type_t type, const char *filepath)
 822 {
 823         msg_error_t     err = MSG_SUCCESS;
 824
 825         char sqlQuery[MAX_QUERY_LEN+1];
 826         int rowCnt = 0;
 827         int index = 0;
 828         MSG_MESSAGE_INFO_S       msgInfo = {0, };
 829         char*                   encoded_data = NULL;
 830
 831         char fileName[MSG_FILENAME_LEN_MAX+1];
 832         memset(fileName, 0x00, sizeof(fileName));
 833         strncpy(fileName, filepath, MSG_FILENAME_LEN_MAX);
 834         if (remove(fileName) != 0) {
 835                 MSG_DEBUG("Fail to delete [%s].", fileName);
 836         }
 837
 838         memset(sqlQuery, 0x00, sizeof(sqlQuery));
 839
 840         MSG_DEBUG("backup type = %d, path = %s", type, filepath);
 841
 842         if (type == MSG_BACKUP_TYPE_SMS) {
 843                 snprintf(sqlQuery, sizeof(sqlQuery),
 844                                 "SELECT MSG_ID FROM %s "
 845                                 "WHERE STORAGE_ID = %d AND MAIN_TYPE = %d;",
 846                                 MSGFW_MESSAGE_TABLE_NAME, MSG_STORAGE_PHONE, MSG_SMS_TYPE);
 847         } else if (type == MSG_BACKUP_TYPE_MMS) {
 848                 snprintf(sqlQuery, sizeof(sqlQuery),
 849                                 "SELECT MSG_ID FROM %s "
 850                                 "WHERE STORAGE_ID = %d AND MAIN_TYPE = %d;",
 851                                 MSGFW_MESSAGE_TABLE_NAME, MSG_STORAGE_PHONE, MSG_MMS_TYPE);
 852         } else if (type == MSG_BACKUP_TYPE_ALL) {
 853                 snprintf(sqlQuery, sizeof(sqlQuery),
 854                                 "SELECT MSG_ID FROM %s "
 855                                 "WHERE STORAGE_ID = %d;",
 856                                 MSGFW_MESSAGE_TABLE_NAME, MSG_STORAGE_PHONE);
 857
 858         }
 859
 860         err = dbHandle.getTable(sqlQuery, &rowCnt);
 861
 862         if (err != MSG_SUCCESS) {
 863                 dbHandle.freeTable();
 864                 return err;
 865         }
 866         MSG_DEBUG("backup number = %d", rowCnt);
 867
 868         for (int i = 0; i < rowCnt; i++) {
 869                 err = MsgStoGetMessage(dbHandle.getColumnToInt(++index), &msgInfo, NULL);
 870                 if(err != MSG_SUCCESS) {
 871                         dbHandle.freeTable();
 872                         return err;
 873                 }
 874
 875                 encoded_data = MsgVMessageAddRecord(&dbHandle, &msgInfo);
 876
 877                 if (encoded_data != NULL) {
 878                         if (MsgAppendFile(fileName, encoded_data, strlen(encoded_data)) == false) {
 879                                 dbHandle.freeTable();
 880                                 free(encoded_data);
 881                                 return MSG_ERR_STORAGE_ERROR;
 882                         }
 883
 884                         free(encoded_data);
 885                 }
 886
 887                 memset(&msgInfo, 0, sizeof(MSG_MESSAGE_INFO_S));
 888         }
 889
 890         dbHandle.freeTable();
 891         MSG_END();
 892         return MSG_SUCCESS;
 893
 894 }
 895
 896 msg_error_t MsgStoUpdateMms(MSG_MESSAGE_INFO_S *pMsg)
 897 {
 898         char sqlQuery[MAX_QUERY_LEN+1];
 899
 900         if (pMsg->msgType.subType == MSG_SENDCONF_MMS) {
 901                 memset(sqlQuery, 0x00, sizeof(sqlQuery));
 902
 903                 dbHandle.beginTrans();
 904                 snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET THUMB_PATH = ?, MSG_TEXT = ? WHERE MSG_ID = %d;",
 905                                 MSGFW_MESSAGE_TABLE_NAME, pMsg->msgId);
 906
 907                 if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
 908                         dbHandle.endTrans(false);
 909                         return MSG_ERR_DB_EXEC;
 910                 }
 911
 912
 913                 dbHandle.bindText(pMsg->thumbPath, 1);
 914                 dbHandle.bindText(pMsg->msgText, 2);
 915                 MSG_DEBUG("thumbPath = %s , msgText = %s" , pMsg->thumbPath, pMsg->msgText);
 916                 MSG_DEBUG("%s", sqlQuery);
 917
 918                 if (dbHandle.stepQuery() != MSG_ERR_DB_DONE) {
 919                         dbHandle.finalizeQuery();
 920                         dbHandle.endTrans(false);
 921                         return MSG_ERR_DB_EXEC;
 922                 }
 923
 924                 dbHandle.finalizeQuery();
 925                 dbHandle.endTrans(true);
 926         } else {
 927                 MsgStoUpdateMMSMessage(pMsg);
 928         }
 929         return MSG_SUCCESS;
 930 }
 931
 932 msg_error_t MsgStoRestoreMessage(const char *filepath)
 933 {
 934         msg_error_t err = MSG_SUCCESS;
 935         MSG_MESSAGE_INFO_S msgInfo = {0,};
 936
 937         VTree* vMsg = NULL;
 938         VObject* pObject = NULL;
 939
 940         int dataSize = 0;
 941
 942         char fileName[MSG_FILENAME_LEN_MAX+1];
 943         char *pData = NULL;
 944         char *pCurrent = NULL;
 945         char *pTemp = NULL;
 946
 947 #ifdef MSG_FOR_DEBUG
 948         char sample[10000] = "BEGIN:VMSG\r\nX-MESSAGE-TYPE:SMS\r\nX-IRMC-BOX:INBOX\r\nX-SS-DT:20100709T155811Z\r\nBEGIN:VBODY\r\nX-BODY-SUBJECT:hekseh\r\nX-BODY-CONTENTS;ENCODING=BASE64:aGVsbG93b3JsZA==\r\nEND:VBODY\r\nBEGIN:VCARD\r\nVERSION:2.1\r\nTEL:01736510664\r\nEND:VCARD\r\nEND:VMSG\r\n";
 949         vMsg = vmsg_decode(sample);
 950 #else
 951         memset(fileName, 0x00, sizeof(fileName));
 952         strncpy(fileName, filepath, MSG_FILENAME_LEN_MAX);
 953         pData = MsgOpenAndReadMmsFile(fileName, 0, -1, &dataSize);
 954         if (pData == NULL)
 955                 return MSG_ERR_STORAGE_ERROR;
 956
 957         pCurrent = pData;
 958
 959         while ((pTemp = strstr(pCurrent, "END:VMSG")) != NULL)
 960         {
 961                 MSG_DEBUG("Start Position: %s", pCurrent);
 962
 963                 while (*pCurrent == '\r' || *pCurrent == '\n')
 964                         pCurrent++;
 965
 966                 MSG_DEBUG("Start Position2: %s", pCurrent);
 967
 968                 vMsg = vmsg_decode(pCurrent);
 969 #endif
 970
 971                 pObject = vMsg->pTop;
 972
 973                 memset(&msgInfo, 0x00, sizeof(MSG_MESSAGE_INFO_S));
 974
 975                 while (1)
 976                 {
 977                         while (1)
 978                         {
 979                                 MSG_DEBUG("pObject type [%d], pObject Value [%s]", pObject->property, pObject->pszValue[0]);
 980
 981                                 switch (pObject->property)
 982                                 {
 983                                         case VMSG_TYPE_MSGTYPE :
 984                                         {
 985                                                 if (!strncmp(pObject->pszValue[0], "SMS", strlen("SMS"))) {
 986                                                         msgInfo.msgType.mainType = MSG_SMS_TYPE;
 987                                                         msgInfo.msgType.subType = MSG_NORMAL_SMS;
 988                                                 } else if (!strncmp(pObject->pszValue[0], "MMS RETRIEVED", strlen("MMS RETRIEVED"))) {
 989                                                         msgInfo.msgType.mainType = MSG_MMS_TYPE;
 990                                                         msgInfo.msgType.subType = MSG_RETRIEVE_AUTOCONF_MMS;
 991                                                 } else if (!strncmp(pObject->pszValue[0], "MMS SEND", strlen("MMS SEND"))) {
 992                                                         msgInfo.msgType.mainType = MSG_MMS_TYPE;
 993                                                         msgInfo.msgType.subType = MSG_SENDCONF_MMS;
 994                                                 } else if (!strncmp(pObject->pszValue[0], "MMS NOTIFICATION", strlen("MMS NOTIFICATION"))) {
 995                                                         msgInfo.msgType.mainType = MSG_MMS_TYPE;
 996                                                         msgInfo.msgType.subType = MSG_NOTIFICATIONIND_MMS;
 997                                                 } else {
 998                                                         vmsg_free_vtree_memory(vMsg);
 999                                                         return MSG_ERR_STORAGE_ERROR;
1000                                                 }
1001                                         }
1002                                         break;
1003
1004                                         case VMSG_TYPE_MSGBOX :
1005                                         {
1006                                                 if(!strncmp(pObject->pszValue[0], "INBOX", strlen("INBOX"))) {
1007                                                         msgInfo.folderId= MSG_INBOX_ID;
1008                                                         msgInfo.direction=MSG_DIRECTION_TYPE_MT;
1009
1010                                                         msgInfo.networkStatus=MSG_NETWORK_RECEIVED;
1011                                                 } else if(!strncmp(pObject->pszValue[0], "OUTBOX", strlen("OUTBOX"))) {
1012                                                         msgInfo.folderId= MSG_OUTBOX_ID;
1013                                                         msgInfo.direction=MSG_DIRECTION_TYPE_MO;
1014
1015                                                         msgInfo.networkStatus=MSG_NETWORK_SEND_FAIL;
1016                                                 } else if(!strncmp(pObject->pszValue[0], "SENTBOX", strlen("SENTBOX"))) {
1017                                                         msgInfo.folderId= MSG_SENTBOX_ID;
1018                                                         msgInfo.direction=MSG_DIRECTION_TYPE_MO;
1019
1020                                                         msgInfo.networkStatus=MSG_NETWORK_SEND_SUCCESS;
1021                                                 } else if(!strncmp(pObject->pszValue[0], "DRAFTBOX", strlen("DRAFTBOX"))) {
1022                                                         msgInfo.folderId=MSG_DRAFT_ID;
1023                                                         msgInfo.direction=MSG_DIRECTION_TYPE_MO;
1024
1025                                                         msgInfo.networkStatus=MSG_NETWORK_NOT_SEND;
1026                                                 } else {
1027                                                         vmsg_free_vtree_memory(vMsg);
1028                                                         return MSG_ERR_STORAGE_ERROR;
1029                                                 }
1030                                         }
1031                                         break;
1032
1033                                         case VMSG_TYPE_STATUS :
1034                                         {
1035                                                 if(!strncmp(pObject->pszValue[0], "READ", strlen("READ"))) {
1036                                                         msgInfo.bRead = true;
1037                                                 } else if(!strncmp(pObject->pszValue[0], "UNREAD", strlen("UNREAD"))) {
1038                                                         msgInfo.bRead = false;
1039                                                 } else {
1040                                                         vmsg_free_vtree_memory(vMsg);
1041                                                         return MSG_ERR_STORAGE_ERROR;
1042                                                 }
1043                                         }
1044                                         break;
1045
1046                                         case VMSG_TYPE_DATE :
1047                                         {
1048                                                 struct tm       displayTime;
1049
1050                                                 if (!_convert_vdata_str_to_tm(pObject->pszValue[0], &displayTime)) {
1051                                                         vmsg_free_vtree_memory( vMsg );
1052                                                         return MSG_ERR_STORAGE_ERROR;
1053                                                 }
1054
1055                                                 msgInfo.displayTime = mktime(&displayTime);
1056                                         }
1057                                         break;
1058
1059                                         case VMSG_TYPE_SUBJECT :
1060                                         {
1061                                                 MSG_DEBUG("subject length is [%d].", strlen(pObject->pszValue[0]));
1062
1063                                                 if(strlen(pObject->pszValue[0]) > 0) {
1064                                                         strncpy(msgInfo.subject, pObject->pszValue[0], MAX_SUBJECT_LEN);
1065                                                         if ( msgInfo.subject[strlen(pObject->pszValue[0])-1] == '\r' )
1066                                                                 msgInfo.subject[strlen(pObject->pszValue[0])-1]= '\0';
1067                                                 }
1068                                         }
1069                                         break;
1070
1071                                         case VMSG_TYPE_BODY :
1072                                         {
1073                                                 if (msgInfo.msgType.mainType == MSG_SMS_TYPE) {
1074                                                         if (pObject->numOfBiData > MAX_MSG_DATA_LEN) {
1075                                                                 msgInfo.bTextSms = false;
1076                                                                 char fileName[MAX_COMMON_INFO_SIZE + 1];
1077                                                                 memset(fileName, 0x00, sizeof(fileName));
1078
1079                                                                 if (MsgCreateFileName(fileName) == false) {
1080                                                                         vmsg_free_vtree_memory(vMsg);
1081                                                                         return MSG_ERR_STORAGE_ERROR;
1082                                                                 }
1083
1084                                                                 if (MsgWriteIpcFile(fileName, pObject->pszValue[0], pObject->numOfBiData) == false) {
1085                                                                         vmsg_free_vtree_memory(vMsg);
1086                                                                         return MSG_ERR_STORAGE_ERROR;
1087                                                                 }
1088
1089                                                                 strncpy(msgInfo.msgData, fileName, MAX_MSG_DATA_LEN);
1090                                                                 msgInfo.dataSize = pObject->numOfBiData;
1091                                                         } else {
1092                                                                 msgInfo.bTextSms = true;
1093
1094                                                                 if(pObject->numOfBiData > 0) {
1095                                                                         memset(msgInfo.msgText, 0x00, sizeof(msgInfo.msgText));
1096                                                                         memcpy(msgInfo.msgText, pObject->pszValue[0], pObject->numOfBiData);
1097
1098                                                                         msgInfo.dataSize = pObject->numOfBiData;
1099                                                                 }
1100                                                         }
1101                                                 } else {
1102                                                         msgInfo.bTextSms = true;
1103                                                         if(msgInfo.msgType.subType == MSG_NOTIFICATIONIND_MMS) {
1104
1105                                                                         msgInfo.bTextSms = true;
1106
1107                                                                 // Save Message Data into File
1108                                                                 char fileName[MAX_COMMON_INFO_SIZE+1];
1109                                                                 memset(fileName, 0x00, sizeof(fileName));
1110
1111                                                                 if (MsgCreateFileName(fileName) == false) {
1112                                                                         vmsg_free_vtree_memory(vMsg);
1113                                                                         return MSG_ERR_STORAGE_ERROR;
1114                                                                 }
1115
1116                                                                 if (MsgWriteIpcFile(fileName, pObject->pszValue[0], pObject->numOfBiData) == false) {
1117                                                                         vmsg_free_vtree_memory(vMsg);
1118                                                                         return MSG_ERR_STORAGE_ERROR;
1119                                                                 }
1120                                                                 strncpy(msgInfo.msgData, MSG_IPC_DATA_PATH, MAX_MSG_DATA_LEN);
1121                                                                 strncat(msgInfo.msgData, fileName, MAX_MSG_DATA_LEN-strlen(msgInfo.msgData));
1122                                                                 msgInfo.dataSize = strlen(fileName);
1123                                                                 MsgPlugin* plg = MsgPluginManager::instance()->getPlugin(msgInfo.msgType.mainType);
1124                                                                 err =  plg->restoreMsg(&msgInfo, pObject->pszValue[0], pObject->numOfBiData, NULL);
1125
1126                                                         } else {
1127 //////////////// From here was avaliable
1128                                                                 char    retrievedFilePath[MAX_FULL_PATH_SIZE] = {0,};
1129                                                                 MsgPlugin* plg = MsgPluginManager::instance()->getPlugin(msgInfo.msgType.mainType);
1130                                                                 err =  plg->restoreMsg(&msgInfo, pObject->pszValue[0], pObject->numOfBiData, retrievedFilePath);
1131                                                                 msgInfo.bTextSms = false;
1132
1133                                                                 char fileName[MAX_COMMON_INFO_SIZE+1];
1134                                                                 memset(fileName, 0x00, sizeof(fileName));
1135
1136                                                                 if (MsgCreateFileName(fileName) == false) {
1137                                                                         vmsg_free_vtree_memory(vMsg);
1138                                                                         return MSG_ERR_STORAGE_ERROR;
1139                                                                 }
1140                                                                 MSG_DEBUG("fileName: %s, retrievedFilePath: %s (%d)", fileName, retrievedFilePath, strlen(retrievedFilePath));
1141
1142                                                                 if (MsgWriteIpcFile(fileName, retrievedFilePath, strlen(retrievedFilePath)+ 1) == false) {
1143                                                                         vmsg_free_vtree_memory(vMsg);
1144                                                                         return MSG_ERR_STORAGE_ERROR;
1145                                                                 }
1146                                                                 strncpy(msgInfo.msgData, fileName, MAX_MSG_DATA_LEN);
1147                                                                 msgInfo.dataSize = strlen(retrievedFilePath) + 1;
1148
1149                                                                 if (err != MSG_SUCCESS)
1150                                                                         return vmsg_free_vtree_memory(vMsg);
1151 ///////////////////////////
1152                                                         }
1153                                                 }
1154                                         }
1155                                         break;
1156
1157                                         case VCARD_TYPE_TEL :
1158                                         {
1159                                                 msgInfo.nAddressCnt++;
1160
1161                                                 msgInfo.addressList[msgInfo.nAddressCnt-1].addressType = MSG_ADDRESS_TYPE_PLMN;
1162                                                 msgInfo.addressList[msgInfo.nAddressCnt-1].recipientType = MSG_RECIPIENTS_TYPE_TO;
1163
1164                                                 strncpy(msgInfo.addressList[msgInfo.nAddressCnt-1].addressVal, pObject->pszValue[0], MAX_ADDRESS_VAL_LEN);
1165                                         }
1166                                         break;
1167                                 }
1168
1169                                 if (pObject->pSibling != NULL)
1170                                         pObject = pObject->pSibling;
1171                                 else
1172                                         break;
1173                         }
1174
1175                         if (vMsg->pNext != NULL) {
1176                                 vMsg = vMsg->pNext;
1177                                 pObject = vMsg->pTop;
1178                         } else {
1179                                 break;
1180                         }
1181                 }
1182
1183                 msgInfo.bBackup = true; // Set Backup Flag
1184                 msgInfo.storageId = MSG_STORAGE_PHONE; // Set Storage Id
1185                 msgInfo.priority = MSG_MESSAGE_PRIORITY_NORMAL; // Set Priority
1186
1187                 err = MsgStoAddMessage(&msgInfo, NULL);
1188                 if (err != MSG_SUCCESS) {
1189                         MSG_DEBUG("MsgStoAddMessage() error : %d", err);
1190                 }
1191
1192                 if (msgInfo.msgType.mainType == MSG_MMS_TYPE)
1193                         MsgStoUpdateMms(&msgInfo);
1194
1195                 vmsg_free_vtree_memory(vMsg);
1196
1197                 vMsg = NULL;
1198                 pCurrent = pTemp + strlen("END:VMSG");
1199         }
1200
1201         return MSG_SUCCESS;
1202 }
1203
1204 msg_error_t MsgStoAddPushEvent(MSG_PUSH_EVENT_INFO_S* pPushEvent)
1205 {
1206         msg_error_t err = MSG_SUCCESS;
1207         char sqlQuery[MAX_QUERY_LEN+1];
1208         unsigned int rowId = 0;
1209
1210         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1211
1212         // Check whether Same record exists or not.
1213         snprintf(sqlQuery, sizeof(sqlQuery), "SELECT * FROM %s WHERE CONTENT_TYPE LIKE '%s' AND APP_ID LIKE '%s' AND (PKG_NAME LIKE '%s' OR SECURE = 1);",
1214                         MSGFW_PUSH_CONFIG_TABLE_NAME, pPushEvent->contentType, pPushEvent->appId, pPushEvent->pkgName);
1215
1216         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
1217                 MSG_DEBUG("Query Failed [%s]", sqlQuery);
1218                 return MSG_ERR_DB_PREPARE;
1219         }
1220
1221         if (dbHandle.stepQuery() == MSG_ERR_DB_ROW) {
1222                 dbHandle.finalizeQuery();
1223                 return MSG_ERR_DB_ROW;
1224         }
1225         dbHandle.finalizeQuery();
1226
1227         dbHandle.beginTrans();
1228         err = dbHandle.getRowId(MSGFW_PUSH_CONFIG_TABLE_NAME, &rowId);
1229         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1230
1231         snprintf(sqlQuery, sizeof(sqlQuery), "INSERT INTO %s VALUES (%d, ?, ?, ?, %d, 0, 0);",
1232                         MSGFW_PUSH_CONFIG_TABLE_NAME, rowId, pPushEvent->bLaunch);
1233
1234
1235         MSG_DEBUG("QUERY : %s", sqlQuery);
1236
1237         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
1238                 dbHandle.endTrans(false);
1239                 return MSG_ERR_DB_EXEC;
1240         }
1241
1242         dbHandle.bindText(pPushEvent->contentType, 1);
1243         dbHandle.bindText(pPushEvent->appId, 2);
1244         dbHandle.bindText(pPushEvent->pkgName, 3);
1245
1246         if (dbHandle.stepQuery() != MSG_ERR_DB_DONE) {
1247                 dbHandle.finalizeQuery();
1248                 dbHandle.endTrans(false);
1249                 return MSG_ERR_DB_EXEC;
1250         }
1251
1252         dbHandle.finalizeQuery();
1253         dbHandle.endTrans(true);
1254
1255         return MSG_SUCCESS;
1256 }
1257
1258
1259 msg_error_t MsgStoDeletePushEvent(MSG_PUSH_EVENT_INFO_S* pPushEvent)
1260 {
1261         char sqlQuery[MAX_QUERY_LEN+1];
1262         dbHandle.beginTrans();
1263         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1264         snprintf(sqlQuery, sizeof(sqlQuery), "DELETE FROM %s WHERE CONTENT_TYPE LIKE '%s' AND APP_ID LIKE '%s' AND PKG_NAME LIKE '%s';",
1265                         MSGFW_PUSH_CONFIG_TABLE_NAME, pPushEvent->contentType, pPushEvent->appId, pPushEvent->pkgName);
1266
1267         if (dbHandle.execQuery(sqlQuery) != MSG_SUCCESS) {
1268                 dbHandle.endTrans(false);
1269                 return MSG_ERR_DB_EXEC;
1270         }
1271         dbHandle.endTrans(true);
1272         return MSG_SUCCESS;
1273 }
1274
1275 msg_error_t MsgStoUpdatePushEvent(MSG_PUSH_EVENT_INFO_S* pSrc, MSG_PUSH_EVENT_INFO_S* pDst)
1276 {
1277         char sqlQuery[MAX_QUERY_LEN+1];
1278         dbHandle.beginTrans();
1279         memset(sqlQuery, 0x00, sizeof(sqlQuery));
1280         snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE %s SET CONTENT_TYPE = ?, APP_ID = ?, PKG_NAME = ?, LAUNCH = %d WHERE CONTENT_TYPE LIKE '%s' AND APP_ID LIKE '%s' AND PKG_NAME LIKE '%s';",
1281                         MSGFW_PUSH_CONFIG_TABLE_NAME, pDst->bLaunch, pSrc->contentType, pSrc->appId, pSrc->pkgName);
1282
1283         if (dbHandle.prepareQuery(sqlQuery) != MSG_SUCCESS) {
1284                 dbHandle.endTrans(false);
1285                 return MSG_ERR_DB_EXEC;
1286         }
1287
1288         dbHandle.bindText(pDst->contentType, 1);
1289         dbHandle.bindText(pDst->appId, 2);
1290         dbHandle.bindText(pDst->pkgName, 3);
1291
1292         if (dbHandle.stepQuery() != MSG_ERR_DB_DONE) {
1293                 dbHandle.finalizeQuery();
1294                 dbHandle.endTrans(false);
1295                 return MSG_ERR_DB_EXEC;
1296         }
1297
1298         dbHandle.finalizeQuery();
1299         dbHandle.endTrans(true);
1300
1301         return MSG_SUCCESS;
1302 }