// **********************************************************************
//
// Copyright (c) 2003-2006 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

#include <Instance.h>
#include <EndpointI.h>
#include <Util.h>
#include <Ice/Communicator.h>
#include <Ice/LocalException.h>
#include <Ice/Logger.h>
#include <Ice/Properties.h>
#include <Ice/ProtocolPluginFacade.h>

using namespace std;
using namespace Ice;
using namespace IceSSL;

void IceInternal::incRef(IceSSL::Instance* p) { p->__incRef(); }
void IceInternal::decRef(IceSSL::Instance* p) { p->__decRef(); }

IceSSL::Instance::Instance(const CommunicatorPtr& communicator)
{
    __setNoDelete(true);

    PropertiesPtr properties = communicator->getProperties();

    _facade = IceInternal::getProtocolPluginFacade(communicator);
    _securityTraceLevel = properties->getPropertyAsInt("IceSSL.Trace.Security");
    _securityTraceCategory = "Security";

    //
    // Create the context.
    //
    // If IceSSL.DelayInit=1, postpone the creation of the context until
    // the application manually initializes the plugin.
    //
    if(properties->getPropertyAsInt("IceSSL.DelayInit") == 0)
    {
	_context = new Context(this, 0);
    }

    //
    // Register the endpoint factory.
    //
    _facade->addEndpointFactory(new EndpointFactoryI(this));

    __setNoDelete(false);
}

void
IceSSL::Instance::initialize(SSL_CTX* context)
{
    if(_context)
    {
	SecurityException ex(__FILE__, __LINE__);
	ex.reason = "plugin is already initialized";
	throw ex;
    }
    else
    {
	_context = new Context(this, context);
    }
}

void
IceSSL::Instance::setCertificateVerifier(const CertificateVerifierPtr& verifier)
{
    _verifier = verifier;
}

void
IceSSL::Instance::setPasswordPrompt(const PasswordPromptPtr& prompt)
{
    _prompt = prompt;
}

CommunicatorPtr
IceSSL::Instance::communicator() const
{
    return _facade->getCommunicator();
}

string
IceSSL::Instance::defaultHost() const
{
    return _facade->getDefaultHost();
}

int
IceSSL::Instance::networkTraceLevel() const
{
    return _facade->getNetworkTraceLevel();
}

string
IceSSL::Instance::networkTraceCategory() const
{
    return _facade->getNetworkTraceCategory();
}

int
IceSSL::Instance::securityTraceLevel() const
{
    return _securityTraceLevel;
}

string
IceSSL::Instance::securityTraceCategory() const
{
    return _securityTraceCategory;
}

ContextPtr
IceSSL::Instance::context() const
{
    if(!_context)
    {
	PluginInitializationException ex(__FILE__, __LINE__);
	ex.reason = "IceSSL: plugin is not fully initialized";
	throw ex;
    }
    return _context;
}

CertificateVerifierPtr
IceSSL::Instance::certificateVerifier() const
{
    return _verifier;
}

PasswordPromptPtr
IceSSL::Instance::passwordPrompt() const
{
    return _prompt;
}

string
IceSSL::Instance::sslErrors() const
{
    return getSslErrors(_securityTraceLevel >= 1);
}

void
IceSSL::Instance::destroy()
{
    _facade = 0;
    _context = 0;
}