1 /*

     2 * Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of CStorageBackupUtil

    15 *

    16 */

    17 

    18 

    19 #include "javastoragebackuputil.h"

    20 #include "midp2backupplugin.h"

    21 #include "midp2backupdataids.h"

    22 

    23 #include "javastorageentry.h"

    24 #include "javastorage.h"

    25 #include "javastoragenames.h"

    26 

    27 #include "logger.h"

    28 #include "javauid.h"

    29 #include "javaoslayer.h"

    30 #include "javacommonutils.h"

    31 #include "s60commonutils.h"

    32 #include "javasymbianoslayer.h"

    33 

    34 #include <memory>

    35 #include <s32mem.h>

    36 

    37 using namespace std;

    38 using namespace java::storage;

    39 using namespace java::backup;

    40 

    41 // ======== MEMBER FUNCTIONS ========

    42 

    43 CStorageBackupUtil::CStorageBackupUtil()

    44 {

    45     LOG(EBackup, EInfo, "CStorageBackupUtil constructor");

    46 }

    47 

    48 void CStorageBackupUtil::ConstructL()

    49 {

    50     LOG(EBackup, EInfo, "CStorageBackupUtil::ConstructL");

    51 

    52     iFirstCalltoBackupStorageData = ETrue;

    53     iFirstCalltoRestoreStorageData = ETrue;

    54 

    55     iBufferSpaceLeft = 0;

    56 

    57     iRemainingString = EFalse;

    58     iStrCount = 0;

    59 

    60     for (int tableNumber = 0; tableNumber < NUMBER_OF_TABLES; tableNumber++)

    61     {

    62         iTableSize[tableNumber] = 0;

    63     }

    64 }

    65 

    66 CStorageBackupUtil* CStorageBackupUtil::NewL()

    67 {

    68     LOG(EBackup, EInfo, "CStorageBackupUtil::NewL");

    69 

    70     CStorageBackupUtil* self = new(ELeave) CStorageBackupUtil();

    71     CleanupStack::PushL(self);

    72     self->ConstructL();

    73     CleanupStack::Pop();

    74 

    75     return self;

    76 }

    77 

    78 CStorageBackupUtil::~CStorageBackupUtil()

    79 {

    80     LOG(EBackup, EInfo, "CStorageBackupUtil Destructor");

    81 

    82     // clear the vectors to free all the heap data.

    83     iStringVector.clear();

    84 }

    85 

    86 

    87 void CStorageBackupUtil::BackupStorageDataL(RDesWriteStream& aStream, TBool& aBackupNotFinished, TInt& aBufferSpaceLeft)

    88 {

    89     LOG(EBackup, EInfo, "CStorageBackupUtil::BackupStorageDataL");

    90 

    91     iBufferSpaceLeft = aBufferSpaceLeft;

    92 

    93     if (iFirstCalltoBackupStorageData)

    94     {

    95         int err = FillVectorWithStorageData();

    96 

    97         if (err != KErrNone)

    98         {

    99             User::Leave(err);

   100         }

   101         LOG1(EBackup, EInfo, "Total no of rows in vector: %d", iStringVector.size());

   102 

   103         // First write the total no of rows in the vector to the stream

   104 

   105         aStream.WriteInt32L(iStringVector.size());

   106         iBufferSpaceLeft -= sizeof(TInt32);

   107 

   108         /* Then write the number of rows in each table to the stream.

   109            This will be used while writing the data to storage. */

   110 

   111         for (int tableNumber = 0; tableNumber < NUMBER_OF_TABLES; tableNumber++)

   112         {

   113             aStream.WriteInt16L(iTableSize[tableNumber]);

   114             iBufferSpaceLeft -= sizeof(TInt16);

   115         }

   116 

   117         iFirstCalltoBackupStorageData = EFalse;

   118     }

   119 

   120     // Now write the actual string data into the stream.

   121 

   122     while (iBufferSpaceLeft > 0 && iStrCount < iStringVector.size())

   123     {

   124         WriteStringtoStreamL(aStream, iStringVector[iStrCount]);

   125         LOG1(EBackup, EInfo, "StrCount = %d", iStrCount);

   126     }

   127 

   128     if (iStrCount >= iStringVector.size())

   129     {

   130         LOG(EBackup, EInfo, "Backup of storage data finished");

   131         aBackupNotFinished = EFalse;

   132     }

   133 }

   134 

   135 void CStorageBackupUtil::RestoreStorageDataL(RDesReadStream& aStream, TInt& aRestoreState, TInt& aBufferSpaceLeft)

   136 {

   137     LOG(EBackup, EInfo, "CStorageBackupUtil::RestoreStorageDataL()");

   138 

   139     iBufferSpaceLeft = aBufferSpaceLeft;

   140 

   141     if (iFirstCalltoRestoreStorageData)

   142     {

   143         // the no of strings in the stream

   144         iStrCount = aStream.ReadInt32L();

   145         iBufferSpaceLeft -= sizeof(TInt32);

   146 

   147         // read the number of rows in each table

   148         for (int tableNumber = 0; tableNumber < NUMBER_OF_TABLES; tableNumber++)

   149         {

   150             iTableSize[tableNumber] = aStream.ReadInt16L();

   151             iBufferSpaceLeft -= sizeof(TInt16);

   152         }

   153         iFirstCalltoRestoreStorageData = EFalse;

   154     }

   155 

   156     while (iBufferSpaceLeft > 0 && iStrCount > 0)

   157     {

   158         ReadStringfromStreamL(aStream);

   159     }

   160 

   161     if (iStrCount == 0)

   162     {

   163         LOG1(EBackup, EInfo, "Finished reading from stream, row count = %d", iStringVector.size());

   164 

   165 

   166         int err = WriteDataToStorage();

   167 

   168         if (err != KErrNone)

   169         {

   170             CleanupStack::PopAndDestroy(&aStream);

   171             User::Leave(KErrGeneral);

   172         }

   173 

   174         // Storage restore is over; Set state to EAppArc

   175         aRestoreState = EAppArc;

   176         aBufferSpaceLeft = iBufferSpaceLeft;

   177     }

   178 }

   179 

   180 

   181 void CStorageBackupUtil::WriteStringtoStreamL(RDesWriteStream& aStream, wstring aStr)

   182 {

   183     iLenOfString = aStr.length();

   184 

   185     // if length of string is 0, do not write any string to the stream.

   186     if (iLenOfString == 0)

   187     {

   188         aStream.WriteInt16L(iLenOfString*2);

   189         iBufferSpaceLeft -= sizeof(TInt16);

   190         iStrCount++;

   191     }

   192 

   193     else

   194     {

   195         /* if space is not enough for writing the complete string,

   196            do not write it. Could be written next time.  */

   197         if (((iLenOfString*2) + sizeof(TInt16)) > iBufferSpaceLeft)

   198         {

   199             LOG(EBackup, EInfo, "Stream size is not enough to hold the string");

   200             // set the bufferspaceleft to zero

   201             iBufferSpaceLeft = 0;

   202         }

   203         // stream has enough space for the length and the string data.

   204         else

   205         {

   206             aStream.WriteInt16L(iLenOfString*2);

   207             iBufferSpaceLeft -= sizeof(TInt16);

   208 

   209             HBufC* tempstr = java::util::S60CommonUtils::wstringToDes(aStr.c_str());

   210             TPtrC tempStr = tempstr->Des();

   211             aStream.WriteL(tempStr);

   212             iBufferSpaceLeft -= (iLenOfString*2);

   213             delete tempstr;

   214 

   215             iStrCount++;

   216         }

   217     }

   218 }

   219 

   220 void CStorageBackupUtil::ReadStringfromStreamL(RDesReadStream& aStream)

   221 {

   222     wstring emptyString;

   223 

   224     /* if only part of the string was read last time,

   225        read the remaining and append it to that string.  */

   226     if (iRemainingString)

   227     {

   228         // if the whole string cannot be read, read part of it and store it.

   229         if (iLenOfString > iBufferSpaceLeft)

   230         {

   231             LOG(EBackup, EInfo, "Cant read the full string; read only part of it");

   232 

   233             HBufC* data = HBufC::NewL(iBufferSpaceLeft/2+1);

   234             TPtr pdata = data->Des();

   235 

   236             aStream.ReadL(pdata, iBufferSpaceLeft/2);

   237             iLenOfString -= iBufferSpaceLeft;

   238             iBufferSpaceLeft = 0;

   239 

   240             wchar_t* str = desToWstring(pdata);

   241             wstring stringData(str);

   242             iHalfReadString += stringData;

   243 

   244             delete data;

   245             iRemainingString = ETrue;

   246         }

   247         // else read the complete string

   248         else

   249         {

   250             HBufC* data = HBufC::NewL(iLenOfString/2+1);

   251             TPtr pdata = data->Des();

   252 

   253             aStream.ReadL(pdata, iLenOfString/2);

   254             iBufferSpaceLeft -= (iLenOfString);

   255 

   256             wchar_t* str = desToWstring(pdata);

   257             wstring stringData(str);

   258             iHalfReadString += stringData;

   259 

   260             iStringVector.push_back(iHalfReadString);

   261 

   262             delete data;

   263             iStrCount--;

   264             iRemainingString = EFalse;

   265             iHalfReadString = emptyString;

   266         }

   267     }

   268 

   269     else

   270     {

   271         iLenOfString = aStream.ReadInt16L();

   272         iBufferSpaceLeft -= sizeof(TInt16);

   273 

   274         if (iLenOfString > 0)

   275         {

   276             // if full string cannot be read, read only part of it.

   277             if (iLenOfString > iBufferSpaceLeft)

   278             {

   279                 /* if the stream does not have even part of the string,

   280                    just set the iRemainingFlag to ETrue so that the

   281                    string can be read next time. */

   282 

   283                 if (iBufferSpaceLeft == 0)

   284                 {

   285                     iRemainingString = ETrue;

   286                     iHalfReadString = emptyString;

   287                 }

   288                 // else stream contains part of the stream. Read it

   289                 else

   290                 {

   291                     LOG(EBackup, EInfo, "Cant read the full string; read only part of it");

   292 

   293                     HBufC* data = HBufC::NewL(iBufferSpaceLeft/2+1);

   294                     TPtr pdata = data->Des();

   295 

   296                     aStream.ReadL(pdata, iBufferSpaceLeft/2);

   297                     iLenOfString -= iBufferSpaceLeft;

   298                     iBufferSpaceLeft = 0;

   299 

   300                     wchar_t* str = desToWstring(pdata);

   301                     wstring stringData(str);

   302                     iHalfReadString = stringData;

   303                     delete data;

   304                     iRemainingString = ETrue;

   305                 }

   306             }

   307             // else full string can be read

   308             else

   309             {

   310                 HBufC* data = HBufC::NewL(iLenOfString/2+1);

   311                 TPtr pdata = data->Des();

   312 

   313                 aStream.ReadL(pdata, iLenOfString/2);

   314                 iBufferSpaceLeft -= (iLenOfString);

   315 

   316                 wchar_t* str = desToWstring(pdata);

   317                 wstring stringData(str);

   318 

   319                 iStringVector.push_back(stringData);

   320                 iStrCount--;

   321                 delete data;

   322             }

   323         }

   324         /* if length of string is 0, do not read anything from the stream;

   325            just push an empty string into the vector */

   326         else

   327         {

   328             iStringVector.push_back(emptyString);

   329             iStrCount--;

   330         }

   331     }

   332 }

   333 

   334 

   335 int CStorageBackupUtil::FillVectorWithStorageData()

   336 {

   337     // get data from storage

   338 

   339     LOG(EBackup, EInfo, "CStorageBackupUtil::FillVectorsWithData");

   340 

   341     auto_ptr<JavaStorage> js(JavaStorage::createInstance());

   342     LOG(EBackup, EInfo, "Opening connection to JAVA_DATABASE");

   343 

   344     try

   345     {

   346         js->open(JAVA_DATABASE_NAME);

   347         LOG(EBackup, EInfo, "Opening commection succeeded");

   348     }

   349     catch (JavaStorageException jse)

   350     {

   351         ELOG1(EBackup, "Opening JAVA_DATABASE failed; %S", jse.toString().c_str());

   352         return KErrGeneral;

   353     }

   354 

   355     JavaStorageEntry attribute;

   356     JavaStorageApplicationEntry_t findPattern;

   357     JavaStorageApplicationList_t foundEntries;

   358 

   359 

   360     // table 1 : Application package table

   361     {

   362         LOG(EBackup, EInfo, "Read entries from APPLICATION_PACKAGE_TABLE");

   363 

   364         try

   365         {

   366             js->search(APPLICATION_PACKAGE_TABLE, findPattern, foundEntries);

   367             LOG(EBackup, EInfo, "Search in Java Storage succeded");

   368         }

   369         catch (JavaStorageException jse)

   370         {

   371             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   372             js->close();

   373             return KErrGeneral;

   374         }

   375 

   376         iTableSize[0] = FillVectorwithAppPackageTableData(foundEntries);

   377         foundEntries.clear();

   378 

   379         if (iTableSize[0] == 0)

   380         {

   381             LOG(EBackup, EInfo,  "No data in Storage; So no midlets in system;");

   382             return KErrGeneral;

   383         }

   384     }

   385 

   386 

   387     // table 2: Application table

   388     {

   389         LOG(EBackup, EInfo,  "Read entries from APPLICATION_TABLE");

   390 

   391         try

   392         {

   393             js->search(APPLICATION_TABLE, findPattern, foundEntries);

   394             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   395         }

   396         catch (JavaStorageException jse)

   397         {

   398             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   399             js->close();

   400             return KErrGeneral;

   401         }

   402 

   403         iTableSize[1] = FillVectorwithAppTableData(foundEntries);

   404 

   405         foundEntries.clear();

   406     }

   407 

   408     // table 3: Application package attributes table

   409 

   410     /* for this table, since there are very large number of rows,

   411        read the data from the table suite-by-suite

   412        ie. read entries for the first suite, then read entries for the

   413        second suite. This would prevent stack overflow  */

   414     {

   415         LOG(EBackup, EInfo,  "Read entries from APPLICATION_PACKAGE_ATTRIBUTES_TABLE");

   416 

   417         int rowCount = 0;

   418 

   419         for (int suiteNumber = 0; suiteNumber < iTableSize[0]; suiteNumber++)

   420         {

   421             attribute.setEntry(ID, iStringVector[suiteNumber*14]);

   422             findPattern.insert(attribute);

   423 

   424             try

   425             {

   426                 js->search(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, findPattern, foundEntries);

   427                 LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   428             }

   429             catch (JavaStorageException jse)

   430             {

   431                 ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   432                 js->close();

   433                 return KErrGeneral;

   434             }

   435 

   436             rowCount += FillVectorwithAppPackageAttTableData(foundEntries);

   437 

   438             foundEntries.clear();

   439             findPattern.clear();

   440         }

   441         iTableSize[2] = rowCount;

   442     }

   443 

   444     // table 4: Midp package table

   445     {

   446         LOG(EBackup, EInfo,  "Read entries from MIDP_PACKAGE_TABLE");

   447 

   448         try

   449         {

   450             js->search(MIDP_PACKAGE_TABLE, findPattern, foundEntries);

   451             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   452         }

   453         catch (JavaStorageException jse)

   454         {

   455             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   456             js->close();

   457             return KErrGeneral;

   458         }

   459 

   460         iTableSize[3] = FillVectorwithMidpPackageTableData(foundEntries);

   461 

   462         foundEntries.clear();

   463     }

   464 

   465     // table 5: Midp permissions table

   466 

   467     /* for this table, since there are very large number of rows,

   468        read the data from the table suite-by-suite

   469        ie. read entries for the first suite, then read entries for the

   470        second suite. This would prevent stack overflow  */

   471     {

   472         LOG(EBackup, EInfo,  "Read entries from MIDP_PERMISSIONS_TABLE");

   473 

   474         int rowCount = 0;

   475 

   476         for (int suiteNumber = 0; suiteNumber < iTableSize[0]; suiteNumber++)

   477         {

   478             attribute.setEntry(ID, iStringVector[suiteNumber*14]);

   479             findPattern.insert(attribute);

   480 

   481             try

   482             {

   483                 js->search(MIDP_PERMISSIONS_TABLE, findPattern, foundEntries);

   484                 LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   485             }

   486             catch (JavaStorageException jse)

   487             {

   488                 ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   489                 js->close();

   490                 return KErrGeneral;

   491             }

   492 

   493             rowCount += FillVectorwithMidpPermTableData(foundEntries);

   494 

   495             foundEntries.clear();

   496             findPattern.clear();

   497         }

   498         iTableSize[4] = rowCount;

   499     }

   500 

   501     // table 6: Midp function group settings table

   502     {

   503         LOG(EBackup, EInfo,  "Read entries from MIDP_FUNC_GRP_SETTINGS_TABLE");

   504 

   505         try

   506         {

   507             js->search(MIDP_FUNC_GRP_SETTINGS_TABLE, findPattern, foundEntries);

   508             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   509         }

   510         catch (JavaStorageException jse)

   511         {

   512             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   513             js->close();

   514             return KErrGeneral;

   515         }

   516 

   517         iTableSize[5] = FillVectorwithMidpFuncGrpSetTableData(foundEntries);

   518 

   519         foundEntries.clear();

   520     }

   521 

   522     // table 7: push registration table

   523     {

   524         LOG(EBackup, EInfo,  "Read entries from PUSH_REGISTRATIONS_TABLE");

   525 

   526         try

   527         {

   528             js->search(PUSH_REGISTRATIONS_TABLE, findPattern, foundEntries);

   529             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   530         }

   531         catch (JavaStorageException jse)

   532         {

   533             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   534             js->close();

   535             return KErrGeneral;

   536         }

   537 

   538         iTableSize[6] = FillVectorwithPushRegTableData(foundEntries);

   539 

   540         foundEntries.clear();

   541     }

   542 

   543     // table 8: alarm registration table

   544     {

   545         LOG(EBackup, EInfo,  "Read entries from ALARM_REGISTRATIONS_TABLE");

   546 

   547         try

   548         {

   549             js->search(ALARM_REGISTRATIONS_TABLE, findPattern, foundEntries);

   550             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   551         }

   552         catch (JavaStorageException jse)

   553         {

   554             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   555             js->close();

   556             return KErrGeneral;

   557         }

   558 

   559         iTableSize[7] = FillVectorwithAlarmRegTableData(foundEntries);

   560 

   561         foundEntries.clear();

   562     }

   563 

   564     // table 9: runtime settings table

   565     {

   566         LOG(EBackup, EInfo,  "Read entries from RUNTIME_SETTINGS_TABLE");

   567 

   568         try

   569         {

   570             js->search(RUNTIME_SETTINGS_TABLE, findPattern, foundEntries);

   571             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   572         }

   573         catch (JavaStorageException jse)

   574         {

   575             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   576             js->close();

   577             return KErrGeneral;

   578         }

   579 

   580         iTableSize[8] = FillVectorwithRuntimeSetTableData(foundEntries);

   581 

   582         foundEntries.clear();

   583     }

   584 

   585     // table 10: pre-install table

   586     {

   587         LOG(EBackup, EInfo,  "Read entries from PREINSTALL_TABLE");

   588 

   589         try

   590         {

   591             js->search(PREINSTALL_TABLE, findPattern, foundEntries);

   592             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   593         }

   594         catch (JavaStorageException jse)

   595         {

   596             ELOG1(EBackup, "Search in Java Storage failed; %S", jse.toString().c_str());

   597             js->close();

   598             return KErrGeneral;

   599         }

   600 

   601         iTableSize[9] = FillVectorwithPreinstallTableData(foundEntries);

   602 

   603         foundEntries.clear();

   604     }

   605 

   606     // Data read from JAVA_DATABASE; So close the connection

   607     js->close();

   608 

   609     // table 11: ota status table

   610     /* Stored in another database called javaotadatabase.

   611        so open a new connection to that database.  */

   612     {

   613         LOG(EBackup, EInfo,  "Read entries from OTA_STATUS_TABLE");

   614 

   615         auto_ptr<JavaStorage> jos(JavaStorage::createInstance());

   616 

   617         try

   618         {

   619             jos->open(JAVA_OTA_DATABASE_NAME);

   620             ILOG(EBackup, "Opening connection to OTA database succeeded");

   621         }

   622         catch (JavaStorageException jse)

   623         {

   624             ELOG1(EBackup, "Opening OTA database failed: %s", jse.toString().c_str());

   625             return KErrGeneral;

   626         }

   627 

   628         try

   629         {

   630             jos->search(OTA_STATUS_TABLE, findPattern, foundEntries);

   631             LOG(EBackup, EInfo,  "Search in Java Storage succeded");

   632         }

   633         catch (JavaStorageException jse)

   634         {

   635             ELOG1(EBackup, "Search in Java Storage failed; %s", jse.toString().c_str());

   636             jos->close();

   637             return KErrGeneral;

   638         }

   639 

   640         iTableSize[10] = FillVectorwithOtaStatusTableData(foundEntries);

   641 

   642         foundEntries.clear();

   643         jos->close();

   644     }

   645 

   646     //################ printing the vectors #############

   647     //printVector();

   648     //###################################################

   649 

   650     ILOG(EBackup, "Vector filled with data");

   651     return KErrNone;

   652 }

   653 

   654 

   655 int CStorageBackupUtil::WriteDataToStorage()

   656 {

   657     JELOG2(EBackup);

   658     ILOG(EBackup, "Create instance of JAVA_DATABASE_NAME and open the database");

   659 

   660     auto_ptr<JavaStorage> js(JavaStorage::createInstance());

   661 

   662     try

   663     {

   664         js->open(JAVA_DATABASE_NAME);

   665         ILOG(EBackup, "Opening database succeded");

   666     }

   667     catch (JavaStorageException jse)

   668     {

   669         ELOG1(EBackup, "Opening database failed: %S", jse.toString().c_str());

   670         return KErrGeneral;

   671     }

   672 

   673     try

   674     {

   675         js->startTransaction();

   676         ILOG(EBackup, "Transaction started");

   677     }

   678     catch (JavaStorageException jse)

   679     {

   680         ELOG1(EBackup, "startTransaction() failed: %S", jse.toString().c_str());

   681         js->close();

   682         return KErrGeneral;

   683     }

   684 

   685     ILOG(EBackup, "Before writing data to storage, existing data must be cleared");

   686 

   687     // call delete * from table one-by-one

   688     {

   689         JavaStorageApplicationEntry_t emptyEntry;

   690 

   691         try

   692         {

   693             js->remove(APPLICATION_PACKAGE_TABLE, emptyEntry);

   694             js->remove(APPLICATION_TABLE, emptyEntry);

   695             js->remove(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, emptyEntry);

   696             js->remove(MIDP_PACKAGE_TABLE, emptyEntry);

   697             js->remove(MIDP_PERMISSIONS_TABLE, emptyEntry);

   698             js->remove(MIDP_FUNC_GRP_SETTINGS_TABLE, emptyEntry);

   699             js->remove(PUSH_REGISTRATIONS_TABLE, emptyEntry);

   700             js->remove(ALARM_REGISTRATIONS_TABLE, emptyEntry);

   701             js->remove(RUNTIME_SETTINGS_TABLE, emptyEntry);

   702             js->remove(PREINSTALL_TABLE, emptyEntry);

   703 

   704             ILOG(EBackup, "Data removed successfully from table");

   705         }

   706         catch (JavaStorageException jse)

   707         {

   708             ELOG1(EBackup, "Failed during removal of entries from table: %S", jse.toString().c_str());

   709             js->close();

   710             return KErrGeneral;

   711         }

   712     }

   713 

   714     JavaStorageEntry attribute;

   715     JavaStorageApplicationEntry_t insertEntry;

   716 

   717     ILOG(EBackup, "Start transaction for writing into the database");

   718 

   719     int count = 0;

   720     // table 1 : Application package table

   721     {

   722         LOG(EBackup, EInfo,  "Writing to APPLICATION_PACKAGE_TABLE");

   723 

   724         for (int rowNumber = 0; rowNumber < iTableSize[0]; rowNumber++)

   725         {

   726             attribute.setEntry(ID, iStringVector[count++]);

   727             insertEntry.insert(attribute);

   728 

   729             attribute.setEntry(PACKAGE_NAME, iStringVector[count++]);

   730             insertEntry.insert(attribute);

   731 

   732             attribute.setEntry(VENDOR, iStringVector[count++]);

   733             insertEntry.insert(attribute);

   734 

   735             attribute.setEntry(VERSION, iStringVector[count++]);

   736             insertEntry.insert(attribute);

   737 

   738             attribute.setEntry(ROOT_PATH, iStringVector[count++]);

   739             insertEntry.insert(attribute);

   740 

   741             attribute.setEntry(MEDIA_ID, iStringVector[count++]);

   742             insertEntry.insert(attribute);

   743 

   744             attribute.setEntry(INITIAL_SIZE, iStringVector[count++]);

   745             insertEntry.insert(attribute);

   746 

   747             attribute.setEntry(JAD_PATH, iStringVector[count++]);

   748             insertEntry.insert(attribute);

   749 

   750             attribute.setEntry(JAR_PATH, iStringVector[count++]);

   751             insertEntry.insert(attribute);

   752 

   753             attribute.setEntry(JAD_URL, iStringVector[count++]);

   754             insertEntry.insert(attribute);

   755 

   756             attribute.setEntry(JAR_URL, iStringVector[count++]);

   757             insertEntry.insert(attribute);

   758 

   759             attribute.setEntry(ACCESS_POINT, iStringVector[count++]);

   760             insertEntry.insert(attribute);

   761 

   762             attribute.setEntry(CONTENT_INFO, iStringVector[count++]);

   763             insertEntry.insert(attribute);

   764 

   765             attribute.setEntry(CONTENT_ID, iStringVector[count++]);

   766             insertEntry.insert(attribute);

   767 

   768             try

   769             {

   770                 js->write(APPLICATION_PACKAGE_TABLE, insertEntry);

   771                 ILOG(EBackup, "Writing to table succeded");

   772             }

   773             catch (JavaStorageException jse)

   774             {

   775                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

   776                 js->close();

   777                 return KErrGeneral;

   778             }

   779             insertEntry.clear();

   780         }

   781     }

   782 

   783     // table 2: Application table

   784     {

   785         LOG(EBackup, EInfo,  "Writing to APPLICATION_TABLE");

   786 

   787         for (int rowNumber = 0; rowNumber < iTableSize[1]; rowNumber++)

   788         {

   789             attribute.setEntry(ID, iStringVector[count++]);

   790             insertEntry.insert(attribute);

   791 

   792             attribute.setEntry(PACKAGE_ID, iStringVector[count++]);

   793             insertEntry.insert(attribute);

   794 

   795             attribute.setEntry(NAME, iStringVector[count++]);

   796             insertEntry.insert(attribute);

   797 

   798             attribute.setEntry(MAIN_CLASS, iStringVector[count++]);

   799             insertEntry.insert(attribute);

   800 

   801             attribute.setEntry(AUTORUN, iStringVector[count++]);

   802             insertEntry.insert(attribute);

   803 

   804             try

   805             {

   806                 js->write(APPLICATION_TABLE, insertEntry);

   807                 ILOG(EBackup, "Writing to table succeded");

   808             }

   809             catch (JavaStorageException jse)

   810             {

   811                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

   812                 js->close();

   813                 return KErrGeneral;

   814             }

   815             insertEntry.clear();

   816         }

   817     }

   818 

   819     // table 3: Application package attributes table

   820     {

   821         LOG(EBackup, EInfo,  "Writing to APPLICATION_PACKAGE_ATTRIBUTES_TABLE");

   822 

   823         for (int rowNumber = 0; rowNumber < iTableSize[2]; rowNumber++)

   824         {

   825             attribute.setEntry(ID, iStringVector[count++]);

   826             insertEntry.insert(attribute);

   827 

   828             attribute.setEntry(NAME, iStringVector[count++]);

   829             insertEntry.insert(attribute);

   830 

   831             attribute.setEntry(VALUE, iStringVector[count++]);

   832             insertEntry.insert(attribute);

   833 

   834             attribute.setEntry(TRUSTED, iStringVector[count++]);

   835             insertEntry.insert(attribute);

   836 

   837             try

   838             {

   839                 js->write(APPLICATION_PACKAGE_ATTRIBUTES_TABLE, insertEntry);

   840                 ILOG(EBackup, "Writing to table succeded");

   841             }

   842             catch (JavaStorageException jse)

   843             {

   844                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

   845                 js->close();

   846                 return KErrGeneral;

   847             }

   848             insertEntry.clear();

   849         }

   850     }

   851 

   852     // table 4: Midp package table

   853     {

   854         LOG(EBackup, EInfo,  "Writing to MIDP_PACKAGE_TABLE");

   855 

   856         for (int rowNumber = 0; rowNumber < iTableSize[3]; rowNumber++)

   857         {

   858             attribute.setEntry(ID, iStringVector[count++]);

   859             insertEntry.insert(attribute);

   860 

   861             attribute.setEntry(TYPE, iStringVector[count++]);

   862             insertEntry.insert(attribute);

   863 

   864             attribute.setEntry(SECURITY_DOMAIN, iStringVector[count++]);

   865             insertEntry.insert(attribute);

   866 

   867             attribute.setEntry(SECURITY_DOMAIN_CATEGORY, iStringVector[count++]);

   868             insertEntry.insert(attribute);

   869 

   870             attribute.setEntry(HASH, iStringVector[count++]);

   871             insertEntry.insert(attribute);

   872 

   873             attribute.setEntry(CERT_HASH, iStringVector[count++]);

   874             insertEntry.insert(attribute);

   875 

   876             attribute.setEntry(RMS, iStringVector[count++]);

   877             insertEntry.insert(attribute);

   878 

   879             attribute.setEntry(VALID_CERTS, iStringVector[count++]);

   880             insertEntry.insert(attribute);

   881 

   882             attribute.setEntry(ON_SCREEN_KEYPAD, iStringVector[count++]);

   883             insertEntry.insert(attribute);

   884 

   885             try

   886             {

   887                 js->write(MIDP_PACKAGE_TABLE, insertEntry);

   888                 ILOG(EBackup, "Writing to table succeded");

   889             }

   890             catch (JavaStorageException jse)

   891             {

   892                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

   893                 js->close();

   894                 return KErrGeneral;

   895             }

   896             insertEntry.clear();

   897         }

   898     }

   899 

   900     // table 5: Midp permissions table

   901     {

   902         LOG(EBackup, EInfo,  "Writing to MIDP_PERMISSIONS_TABLE");

   903 

   904         for (int rowNumber = 0; rowNumber < iTableSize[4]; rowNumber++)

   905         {

   906             attribute.setEntry(ID, iStringVector[count++]);

   907             insertEntry.insert(attribute);

   908 

   909             attribute.setEntry(CLASS, iStringVector[count++]);

   910             insertEntry.insert(attribute);

   911 

   912             attribute.setEntry(NAME, iStringVector[count++]);

   913             insertEntry.insert(attribute);

   914 

   915             attribute.setEntry(ACTION, iStringVector[count++]);

   916             insertEntry.insert(attribute);

   917 

   918             attribute.setEntry(FUNCTION_GROUP, iStringVector[count++]);

   919             insertEntry.insert(attribute);

   920 

   921             try

   922             {

   923                 js->write(MIDP_PERMISSIONS_TABLE, insertEntry);

   924                 ILOG(EBackup, "Writing to table succeded");

   925             }

   926             catch (JavaStorageException jse)

   927             {

   928                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

   929                 js->close();

   930                 return KErrGeneral;

   931             }

   932             insertEntry.clear();

   933         }

   934     }

   935 

   936     // table 6: Midp function group settings table

   937     {

   938         LOG(EBackup, EInfo,  "MIDP_FUNC_GRP_SETTINGS_TABLE");

   939 

   940         for (int rowNumber = 0; rowNumber < iTableSize[5]; rowNumber++)

   941         {

   942             attribute.setEntry(ID, iStringVector[count++]);

   943             insertEntry.insert(attribute);

   944 

   945             attribute.setEntry(FUNCTION_GROUP, iStringVector[count++]);

   946             insertEntry.insert(attribute);

   947 

   948             attribute.setEntry(ALLOWED_SETTINGS, iStringVector[count++]);

   949             insertEntry.insert(attribute);

   950 

   951             attribute.setEntry(CURRENT_SETTING, iStringVector[count++]);

   952             insertEntry.insert(attribute);

   953 

   954             attribute.setEntry(BLANKET_PROMPT, iStringVector[count++]);

   955             insertEntry.insert(attribute);

   956 

   957             try

   958             {

   959                 js->write(MIDP_FUNC_GRP_SETTINGS_TABLE, insertEntry);

   960                 ILOG(EBackup, "Writing to table succeded");

   961             }

   962             catch (JavaStorageException jse)

   963             {

   964                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

   965                 js->close();

   966                 return KErrGeneral;

   967             }

   968             insertEntry.clear();

   969         }

   970     }

   971 

   972     // table 7: push registration table

   973     {

   974         LOG(EBackup, EInfo,  "Writing to PUSH_REGISTRATIONS_TABLE");

   975 

   976         for (int rowNumber = 0; rowNumber < iTableSize[6]; rowNumber++)

   977         {

   978             attribute.setEntry(ID, iStringVector[count++]);

   979             insertEntry.insert(attribute);

   980 

   981             attribute.setEntry(URL, iStringVector[count++]);

   982             insertEntry.insert(attribute);

   983 

   984             attribute.setEntry(NAME, iStringVector[count++]);

   985             insertEntry.insert(attribute);

   986 

   987             attribute.setEntry(FILTER, iStringVector[count++]);

   988             insertEntry.insert(attribute);

   989 

   990             attribute.setEntry(REGISTRATION_TYPE, iStringVector[count++]);

   991             insertEntry.insert(attribute);

   992 

   993             try

   994             {

   995                 js->write(PUSH_REGISTRATIONS_TABLE, insertEntry);

   996                 ILOG(EBackup, "Writing to table succeded");

   997             }

   998             catch (JavaStorageException jse)

   999             {

  1000                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

  1001                 js->close();

  1002                 return KErrGeneral;

  1003             }

  1004             insertEntry.clear();

  1005         }

  1006     }

  1007 

  1008     // table 8: alarm registration table

  1009     {

  1010         LOG(EBackup, EInfo,  "Writing to ALARM_REGISTRATIONS_TABLE");

  1011 

  1012         for (int rowNumber = 0; rowNumber < iTableSize[7]; rowNumber++)

  1013         {

  1014             attribute.setEntry(ID, iStringVector[count++]);

  1015             insertEntry.insert(attribute);

  1016 

  1017             attribute.setEntry(ALARM_TIME, iStringVector[count++]);

  1018             insertEntry.insert(attribute);

  1019 

  1020             try

  1021             {

  1022                 js->write(ALARM_REGISTRATIONS_TABLE, insertEntry);

  1023                 ILOG(EBackup, "Writing to table succeded");

  1024             }

  1025             catch (JavaStorageException jse)

  1026             {

  1027                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

  1028                 js->close();

  1029                 return KErrGeneral;

  1030             }

  1031             insertEntry.clear();

  1032         }

  1033     }

  1034 

  1035 

  1036     // table 9: runtime settings table

  1037     {

  1038         LOG(EBackup, EInfo,  "Writing to RUNTIME_SETTINGS_TABLE");

  1039 

  1040         for (int rowNumber = 0; rowNumber < iTableSize[8]; rowNumber++)

  1041         {

  1042             attribute.setEntry(EXTENSIONS, iStringVector[count++]);

  1043             insertEntry.insert(attribute);

  1044 

  1045             try

  1046             {

  1047                 js->write(RUNTIME_SETTINGS_TABLE, insertEntry);

  1048                 ILOG(EBackup, "Writing to table succeded");

  1049             }

  1050             catch (JavaStorageException jse)

  1051             {

  1052                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

  1053                 js->close();

  1054                 return KErrGeneral;

  1055             }

  1056             insertEntry.clear();

  1057         }

  1058     }

  1059 

  1060     // table 10: pre-install table

  1061     {

  1062         LOG(EBackup, EInfo,  "Writing to PREINSTALL_TABLE");

  1063 

  1064         for (int rowNumber = 0; rowNumber < iTableSize[9]; rowNumber++)

  1065         {

  1066             attribute.setEntry(NAME, iStringVector[count++]);

  1067             insertEntry.insert(attribute);

  1068 

  1069             attribute.setEntry(VENDOR, iStringVector[count++]);

  1070             insertEntry.insert(attribute);

  1071 

  1072             attribute.setEntry(VERSION, iStringVector[count++]);

  1073             insertEntry.insert(attribute);

  1074 

  1075             attribute.setEntry(INSTALL_STATE, iStringVector[count++]);

  1076             insertEntry.insert(attribute);

  1077 

  1078             try

  1079             {

  1080                 js->write(PREINSTALL_TABLE, insertEntry);

  1081                 ILOG(EBackup, "Writing to table succeded");

  1082             }

  1083             catch (JavaStorageException jse)

  1084             {

  1085                 ELOG1(EBackup, "Writing to table failed: %S", jse.toString().c_str());

  1086                 js->close();

  1087                 return KErrGeneral;

  1088             }

  1089             insertEntry.clear();

  1090         }

  1091     }

  1092 

  1093     ILOG(EBackup, "Data written to JAVA_DATABASE; So Commit the transaction and close the database");

  1094     ILOG(EBackup, "Committing the transaction");

  1095 

  1096     try

  1097     {

  1098         js->commitTransaction();

  1099         ILOG(EBackup, "Transaction committed successfully");

  1100     }

  1101     catch (JavaStorageException jse)

  1102     {

  1103         ELOG1(EBackup, "Committing the transaction failed: %S", jse.toString().c_str());

  1104         js->close();

  1105         return KErrGeneral;

  1106     }

  1107 

  1108     ILOG(EBackup, "Close the database");

  1109 

  1110     // close the JAVA_DATABASE

  1111     js->close();

  1112 

  1113 

  1114     // table 11: ota status table

  1115     /* stored in another database called javaotadatabase.

  1116        so open a new connection to that database   */

  1117 

  1118     {

  1119         ILOG(EBackup, "Create instance of JAVA_OTA_DATABASE_NAME and open the database");

  1120         auto_ptr<JavaStorage> jos(JavaStorage::createInstance());

  1121 

  1122         try

  1123         {

  1124             jos->open(JAVA_OTA_DATABASE_NAME);

  1125             ILOG(EBackup, "Opening database succeded");

  1126         }

  1127         catch (JavaStorageException jse)

  1128         {

  1129             ELOG1(EBackup, "Opening database failed: %S", jse.toString().c_str());

  1130             return KErrGeneral;

  1131         }

  1132 

  1133         ILOG(EBackup, "Start a transaction for writing to this database");