/*
* Copyright (c) 2008 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:  Provides functionality for verifying the server certificate
 *
*/


#include "nativecertificatemanager.h"

#include <x509keys.h>
#include <asn1dec.h>
#include <x509cert.h>
#include <unifiedcertstore.h>
#include <unifiedkeystore.h>
#include <mctwritablecertstore.h>
#include <charconv.h>
#include <pkcs10.h>
#include <secdlg.h>
#include <PKIDlg.h>
#include <securityerr.h>
#include <pkixcertchain.h>
#include "logger.h"

#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <ssl.h>
#else
#include <ssl_internal.h>
#endif

using namespace java::util;
//using namespace java::certificatemanagement;

// CONSTANTS
//_LIT( KSTSSymbianKeyStoreLabel, "Software key store" );
//_LIT(KSTSSymbianCertificateStoreLabel, "Software certificate store");
//_LIT(KSTSSymbianTrustCertStoreLabel, "trust server certstore");

NativeCertificateManager* NativeCertificateManager::NewL(X509* aCert)
{
    JELOG2(ESOCKET);
    NativeCertificateManager* self = new(ELeave) NativeCertificateManager;
    CallMethod(self, &NativeCertificateManager::AddToScheduler, self);
    CallMethodL(self, &NativeCertificateManager::ConstructL, aCert, self);
    return self;
}

void NativeCertificateManager::AddToScheduler()
{
    CActiveScheduler::Add(this);
}

void NativeCertificateManager::doClose()
{
    iFileServer.Close();
}

// Destructor
NativeCertificateManager::~NativeCertificateManager()
{
    CallMethod(this, &NativeCertificateManager::doClose, this);
    //stopServer();

}

int NativeCertificateManager::doValidationL()
{
    JELOG2(ESOCKET);
    unsigned char *der, *data;

    int len = i2d_X509(iCert, NULL);
    der = (unsigned char *) OPENSSL_malloc(len);
    if (der == NULL)
        User::Leave(-1);
    data = der;
    int ret = i2d_X509(iCert, &data);
    HBufC8* certData = HBufC8::NewL(len);
    TPtr8 tmpPtr(certData->Des()); // pointer to hbuf
    tmpPtr.Copy(der, ret);         // copy the der format data to hbuf

    TTime ValidationTime;
    ValidationTime.UniversalTime();
    CPKIXValidationResult *certVerificationResult =
        CPKIXValidationResult::NewL();
    CPKIXCertChain *serverCertsChain = CPKIXCertChain::NewL(iFileServer,
                                       certData->Des(), TUid::Uid(KUidUnicodeSSLProtocolModule));
    serverCertsChain->ValidateL(*certVerificationResult, ValidationTime,
                                iStatus);

    OPENSSL_free(der);
    delete certData;
    return 0;
}

// NativeCertificateManager::RunL
// CActive callback
// -----------------------------------------------------------------------------
//
void NativeCertificateManager::RunL()
{
    ILOG2(ESOCKET, "++NativeCertificateManager::RunL iState %d, iStatus = %d", iState, iStatus.Int());
    if (iStatus != KErrNone)
    {
        // Error has occured; inform java
        Complete(iStatus.Int());
    }
    else
    {
        switch (iState)
        {
        case EValidating:
            Complete(KErrNone);
            break;
        default:
        {
            Complete(KErrGeneral);
        }
        }
    }
}

// -----------------------------------------------------------------------------
// NativeCertificateManager::RunError
// CActive error callback
// -----------------------------------------------------------------------------
//
TInt NativeCertificateManager::RunError(TInt /*aError*/)
{
    // Complete( aError );
    return KErrNone;
}

// -----------------------------------------------------------------------------
// NativeCertificateManager::NativeCertificateManager
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
NativeCertificateManager::NativeCertificateManager() :
        CActive(EPriorityStandard), java::util::FunctionServer("Myserver"), iState(
            EValidating), iCertVerErrCode(0)
{
    createServerToNewThread();
}

void NativeCertificateManager::DoCancel()
{

}

int NativeCertificateManager::doValidateX509Certificate()
{
    TRAPD(err, doValidationL());
    if (err < KErrNone)
    {
        iCertVerErrCode = err;
        ELOG1(ESOCKET, "Error in X509 certificate validation: %d", err);
    }
    else
    {
        WaitForCompletion();

    }
    return iCertVerErrCode;
}

int NativeCertificateManager::validation()
{
    int ret = 0;
    CallMethod(ret, this, &NativeCertificateManager::doValidateX509Certificate,
               this);
    return ret;

}

int NativeCertificateManager::validateX509Certificate(X509 *aCert)
{
    JELOG2(ESOCKET);
    int ret = 0;
    NativeCertificateManager *obj = NULL;
    TRAPD(err, obj = NativeCertificateManager::NewL(aCert));
    if (err < 0)
    {
        return err;
    }
    ret = obj->validation();
    // obj->Dispose();
    delete obj;
    return ret;

}

// -----------------------------------------------------------------------------
// NativeCertificateManager::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void NativeCertificateManager::ConstructL(X509* aCert)
{
    iCert = aCert;
    User::LeaveIfError(iFileServer.Connect());
    iWait = new(ELeave) CActiveSchedulerWait;
    iState = EValidating;
}

// -----------------------------------------------------------------------------
// NativeCertificateManager::Complete
// Completes the operation
// -----------------------------------------------------------------------------
//
void NativeCertificateManager::Complete(TInt aError)
{
    JELOG2(ESOCKET);
    if (KErrNone == aError)
    {
        iCertVerErrCode = KErrNone;
    }
    else
    {
        iCertVerErrCode = aError;
    }
    iWait->AsyncStop();
}

// -----------------------------------------------------------------------------
// NativeCertificateManager::WaitForCompletion()
// Wait for completion, leave on error
// -----------------------------------------------------------------------------
//
void NativeCertificateManager::WaitForCompletion()
{
    SetActive();
    iWait->Start(); // will return at the end of complete
}

void NativeCertificateManager::vmAttached()
{

}

void NativeCertificateManager::doServerSideInit()
{

    FunctionServer::doServerSideInit();

}