/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "storagehandler.h"

#include "javacommonutils.h"

#include "javastoragenames.h"

#include "javastorage.h"

#include "logger.h"

using namespace std;

using namespace java::storage;

using namespace java::security;

using namespace java::util;

StorageHandler::StorageHandler()

{

    iStorage = JavaStorage::createInstance();

    iStorage->open(JAVA_DATABASE_NAME);

}

void StorageHandler::readValidCerts(const Uid& aUid, std::list<int>& aCerts)

{

    JavaStorageEntry attr;

    JavaStorageApplicationEntry_t entry;

    attr.setEntry(ID, aUid.toString());

    entry.insert(attr);

    attr.setEntry(VALID_CERTS, L"");

    entry.insert(attr);

    JavaStorageApplicationList_t foundApps;

    iStorage->search(MIDP_PACKAGE_TABLE, entry, foundApps);

    wstring certIndexes = L"";

    findEntry(foundApps, VALID_CERTS, certIndexes);

    wstring::size_type startIdx = 0;

    wstring::size_type endIdx = 0;

    const char delim = ',';

    while (wstring::npos != startIdx || wstring::npos != endIdx)

    {

        endIdx = certIndexes.find(delim, startIdx);

        if (endIdx == wstring::npos) break;    // Not found

        if (startIdx != endIdx)  // Skip 1,,2 case

        {

            addToValidCerts(certIndexes.substr(

                                startIdx, (endIdx - startIdx)), aCerts);

        }

        startIdx = endIdx + 1;

    }

    // Read last one

    if ((startIdx = certIndexes.find_last_of(delim)) != wstring::npos)

    {

        addToValidCerts(certIndexes.substr(startIdx + 1,

                                           (certIndexes.size() - startIdx)), aCerts);

    }

    // If only one cert index without delimiter

    if (aCerts.size() == 0 && certIndexes.size() > 0)

    {

        addToValidCerts(certIndexes, aCerts);

    }

}

void StorageHandler::getChainFromIndex(

    const JavaStorageApplicationList_t& aAttributes,

    const int aIndex,

    std::string& aChain)

{

    int i = 1;

    bool foundPart = true;

    const wstring attrPrefix = L"MIDlet-Certificate-";

    JavaStorageEntry attr;

    do

    {

        wstring indexedAttrName = attrPrefix;

        indexedAttrName.append(JavaCommonUtils::intToWstring(aIndex))

        .append(L"-").append(JavaCommonUtils::intToWstring(i));

        attr.setEntry(NAME, indexedAttrName);

        JavaStorageApplicationEntry_t findEntry;

        findEntry.insert(attr);

        bool found = false;

        JavaStorageApplicationList_t::const_iterator appIter;

        for (appIter = aAttributes.begin()

                       ; appIter != aAttributes.end()

                ; appIter++)

        {

            JavaStorageApplicationEntry_t::const_iterator entryFinder

            = (*appIter).find(attr);

            if (entryFinder != (*appIter).end()) // Correct one found.

            {

                attr.setEntry(VALUE, L"");

                entryFinder = (*appIter).find(attr); // Get its value.

                if (entryFinder != (*appIter).end())

                {

                    char* tmp = JavaCommonUtils::wstringToUtf8((*entryFinder).entryValue());

                    aChain.append(JavaCommonUtils::base64decode(tmp));

                    delete [] tmp;

                }

                found = true;

                break;

            }

        }

        if (!found)

        {

            foundPart = false;

        }

        i++;

    }

    while (foundPart);

}

void StorageHandler::findEntry(const JavaStorageApplicationList_t& queryResult,

                               const std::wstring& eName,

                               std::wstring& eValue)

{

    if (queryResult.size() > 0)

    {

        JavaStorageApplicationEntry_t entry = queryResult.front();

        JavaStorageEntry findPattern;

        findPattern.setEntry(eName, L"");

        JavaStorageApplicationEntry_t::const_iterator findIterator =

            entry.find(findPattern);

        if (findIterator != entry.end())

        {

            eValue = findIterator->entryValue();

        }

    }

}

void StorageHandler::addToValidCerts(

    const wstring& aValue, list<int>& aCerts)

{

    try

    {

        aCerts.push_back(JavaCommonUtils::wstringToInt(aValue));

    }

    catch (ExceptionBase eb)

    {

        WLOG1WSTR(EJavaStorage,

                  "Invalid cert index skipped: %s", aValue);

    }

}

StorageHandler::~StorageHandler()

{

    if (NULL != iStorage)

    {

        iStorage->close();

        delete iStorage;

        iStorage = NULL;

    }

}