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:  StorageServer

    15 *

    16 */

    17 

    18 

    19 #include <sqlite3.h>

    20 

    21 #include "commsmessage.h"

    22 #include "javacommonutils.h"

    23 #include "javastorageexception.h"

    24 #include "javastoragemessage.h"

    25 #include "logger.h"

    26 #include "monitor.h"

    27 #include "storagedbhandler.h"

    28 #include "storageserver.h"

    29 

    30 using namespace java::comms;

    31 using namespace java::storage;

    32 using namespace java::util;

    33 using namespace std;

    34 

    35 StorageServer::StorageServer(java::util::Monitor* aMonitor)

    36         :iDbHandler(0), iMonitor(aMonitor)

    37 {

    38 }

    39 

    40 StorageServer::~StorageServer()

    41 {

    42     JELOG2(EJavaStorage);

    43     iComms.stop();

    44     if (iDbHandler != 0)

    45     {

    46         delete iDbHandler;

    47         iDbHandler = 0;

    48     }

    49 

    50 }

    51 

    52 void StorageServer::start()

    53 {

    54     JELOG2(EJavaStorage);

    55     iComms.registerDefaultListener(this);

    56     if (0 != iComms.start(IPC_ADDRESS_JAVA_STORAGE_C) && iMonitor)

    57     {

    58         iMonitor->notify();

    59         return;

    60     }

    61 

    62     iDbHandler = new StorageDBHandler();

    63 }

    64 

    65 void StorageServer::stop()

    66 {

    67     JELOG2(EJavaStorage);

    68     iMonitor->notify();

    69 }

    70 

    71 void StorageServer::processMessage(CommsMessage& aMessage)

    72 {

    73     JELOG2(EJavaStorage);

    74 

    75     wstring headers;

    76     wstring sqlStatement;

    77     bool connectionExists = false;

    78 

    79     aMessage>>headers;

    80     aMessage>>sqlStatement;

    81 

    82     CommsMessage returnMessage;

    83 

    84     if (0 == headers.size())

    85     {

    86         returnMessage << EInvalidDataStructure;

    87         returnMessage << L"Invalid message structure";

    88         respond(aMessage, returnMessage);

    89         return;

    90     }

    91 

    92     wstring sessionID;

    93     int messageID;

    94 

    95     try

    96     {

    97         int messageIDSize;

    98 

    99         messageIDSize = JavaCommonUtils::wstringToInt(headers.substr(0, 1));

   100         messageID = JavaCommonUtils::wstringToInt(

   101                         headers.substr(1, messageIDSize));

   102         sessionID = headers.substr(messageIDSize + 1, headers.size());

   103     }

   104     catch (...)

   105     {

   106         returnMessage << EInvalidDataStructure;

   107         returnMessage << L"Invalid message identifier";

   108         respond(aMessage, returnMessage);

   109         return;

   110     }

   111 

   112     // Select appropriate database connection if one already exists

   113     if (iDbHandler->selectConnection(sessionID))

   114     {

   115         connectionExists = true;

   116 

   117         // Return the same session ID if client sends a duplicate

   118         // open message for an already existing connection.

   119         if (JavaStorageMessage::EOpen == messageID)

   120         {

   121             returnMessage<<0;

   122             returnMessage<<iDbHandler->returnSessionID();

   123             respond(aMessage, returnMessage);

   124             return;

   125         }

   126     }

   127     else if (JavaStorageMessage::EOpen != messageID

   128              && JavaStorageMessage::EShutdown != messageID)

   129     {

   130         returnMessage << EInvalidConnection;

   131         returnMessage << L"Invalid sessionID";

   132         respond(aMessage, returnMessage);

   133         return;

   134     }

   135 

   136     int returnStatus = 1;

   137     int dbReturnCode = SQLITE_OK;

   138     wstring resultSet = L"";

   139 

   140     switch (messageID)

   141     {

   142     case JavaStorageMessage::ESearch:

   143     case JavaStorageMessage::ERead:

   144     case JavaStorageMessage::EUpdate:

   145     case JavaStorageMessage::EWrite:

   146     case JavaStorageMessage::ERemove:

   147     case JavaStorageMessage::ECreateTable:

   148     case JavaStorageMessage::EAppendTable:

   149     {

   150         if (0 < sqlStatement.size())

   151         {

   152             returnStatus = iDbHandler->prepare(sqlStatement);

   153             if (returnStatus == 0)

   154             {

   155                 resultSet = iDbHandler->executeStmt();

   156                 dbReturnCode = iDbHandler->getErrorCode();

   157                 if (dbReturnCode != SQLITE_OK && dbReturnCode != SQLITE_DONE)

   158                 {

   159                     returnStatus = EGeneralFailure;

   160                     resultSet = JavaCommonUtils::utf8ToWstring(

   161                                     iDbHandler->getErrorMessage());

   162                 }

   163             }

   164             else

   165             {

   166                 returnStatus = EGeneralFailure;

   167                 resultSet = JavaCommonUtils::utf8ToWstring(

   168                                 iDbHandler->getErrorMessage());

   169             }

   170         }

   171         else

   172         {

   173             returnMessage << EInvalidDataStructure;

   174             returnMessage << L"Invalid message structure";

   175         }

   176         break;

   177     }

   178     case JavaStorageMessage::EOpen:

   179     {

   180         returnStatus = iDbHandler->open(sqlStatement);

   181         // Pass the session ID

   182         resultSet = iDbHandler->returnSessionID();

   183         break;

   184     }

   185     case JavaStorageMessage::EClose:

   186     {

   187         returnStatus = iDbHandler->close();

   188         break;

   189     }

   190     case JavaStorageMessage::EStartTransaction:

   191     {

   192         returnStatus = iDbHandler->startTransaction();

   193         break;

   194     }

   195     case JavaStorageMessage::ECommit:

   196     {

   197         returnStatus = iDbHandler->commit();

   198         break;

   199     }

   200     case JavaStorageMessage::ERollback:

   201     {

   202         returnStatus = iDbHandler->rollback();

   203         break;

   204     }

   205     case JavaStorageMessage::EShutdown:

   206     {

   207         printf("StorageServer, Shutdown message received. \n");

   208         stop();

   209         break;

   210     }

   211     default:

   212         ELOG1(EJavaStorage, "Unknown messageID: %d", messageID);

   213         returnStatus = EInvalidDataStructure;

   214         resultSet = L"Invalid message identifier";

   215     }

   216 

   217     returnMessage << returnStatus;

   218     returnMessage << resultSet;

   219 

   220     LOG1(EJavaStorage, EInfo, "ResultStatus: %d", returnStatus);

   221     LOG1WSTR(EJavaStorage, EInfo, "ResultSet: %s", resultSet);

   222 

   223     respond(aMessage, returnMessage);

   224 }

   225 

   226 void StorageServer::respond(const CommsMessage& aReceivedMessage,

   227                             CommsMessage& aResponseMessage)

   228 {

   229     aResponseMessage.setReceiver(aReceivedMessage.getSender());

   230     aResponseMessage.setModuleId(aReceivedMessage.getModuleId());

   231     aResponseMessage.setMessageRef(aReceivedMessage.getMessageRef());

   232 

   233     int retValue = iComms.send(aResponseMessage);

   234 

   235     if (0 != retValue)

   236     {

   237         ELOG1(EJavaStorage, "Failed to respond via COMMS: %d",

   238               retValue);

   239     }

   240 }