it_bus_config/http_wsdl_server.h

#ifndef _IT_BUS_CONFIG_HTTP_WSDL_SERVER_H_
#define _IT_BUS_CONFIG_HTTP_WSDL_SERVER_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#include <it_dsa/vector.h>
#include <it_ts/mutex.h>
#include <it_bus/types.h>
#include <it_bus_config/http_wsdl_extension_element.h>
#include <it_bus_pdk/messaging_transport.h>
#ifndef IT_MINIMISE_INCLUDES
#include <it_bus_pdk/context_attrs/http_conf_xsdTypes.h>
#endif

typedef IT_Vector<IT_Bus::String> vecString;

namespace IT_Bus
{
    class BusContextRegistry;
}

namespace IT_HTTP
{    
    class HttpListener;
    class HttpConnection;
    class HttpWSDLExtensionFactory;

    class IT_BUS_API HTTPServerConfiguration :
        public IT_HTTP::HttpWSDLExtensionElement
    {

      public: 
        HTTPServerConfiguration(
            IT_Bus::BusContextRegistry* registry,
            unsigned long default_port
        );

        HTTPServerConfiguration(
            IT_HTTP::HttpWSDLExtensionFactory * factory,
            IT_WSDL::WSDLExtensibleNode*        parent,
            IT_Bus::BusContextRegistry*         registry
        );

        virtual
        ~HTTPServerConfiguration();

        bool
        parse(
            const IT_Bus::XMLIterator & element_iterator,
            const IT_Bus::XMLNode &     element,
            IT_WSDL::WSDLErrorHandler & error_handler
        );

        void
        setURL(
            const IT_Bus::String& strURL,
            IT_WSDL::WSDLPort* wsdl_port = 0
        );

        const IT_Bus::String&
        getURL();
        
        const IT_Bus::String&
        get_path();

        void
        get_port_from_url(
            IT_Bus::String & port_string
        );


        void
        initialize(
            IT_Bus::XMLHelper& Configuration
        );


        void
        initialize(
            const IT_Bus::XMLIterator& Configuration
        );

        void
        ReadCookieConfiguration(
            IT_Bus::XMLHelper& Configuration
        );

        void
        ReadCookieConfiguration(
            const IT_Bus::XMLIterator& Configuration
        );

        void
        setContentType(
            const IT_Bus::String& strContentType
        );

        const IT_Bus::String&
        getContentType();


        void
        SetListenParameters(
            unsigned long dynamic_port
        );

        HTTPServerConfiguration(
            const HTTPServerConfiguration& copyThis
        );


        const HTTPServerConfiguration&
        operator=(
            const HTTPServerConfiguration& assignThis
        );

        virtual void
        write(
            IT_Bus::XMLOutputStream & stream
        ) const throw((IT_Bus::IOException));


        virtual void
        read(
            const IT_Bus::QName&       /*element_name*/,
            IT_Bus::ComplexTypeReader& /*reader*/
        ) throw((IT_Bus::DeserializationException))
        {
            // complete
        }

        virtual void
        write(
            const IT_Bus::QName&       /*element_name*/,
            IT_Bus::ComplexTypeWriter& /*writer*/
        ) const throw((IT_Bus::SerializationException))
        {
            // complete
        }


        virtual void
        write_attributes(
            IT_Bus::XMLOutputStream & stream
        ) const throw((IT_Bus::IOException));

        IT_WSDL::WSDLExtensionElement*
        clone() const;

        static HTTPServerConfiguration* 
        get_from_port(
            const IT_WSDL::WSDLPort& wsdl_port
        );

        void
        set_path(
           const IT_Bus::String & str_url
        );

        virtual 
        IT_Bus::AnyType&
        operator=(
            const IT_Bus::AnyType& /*rhs*/
        )
        {
            return *this;
        }

        const IT_Bus::BinaryBuffer &
        get_server_cert_data() const
        {
            return m_ServerCertificateData;
        }

        const IT_Bus::BinaryBuffer &
        get_server_cert_chain_data() const
        {
            return m_ServerCertificateChainData;
        }

        const IT_Bus::BinaryBuffer &
        get_server_privkey_data() const
        {
            return m_ServerPrivateKeyData;
        }

        const IT_Bus::BinaryBuffer &
        get_trusted_cert_data() const
        {
            return m_TrustedRootCertificatesData;
        }

        unsigned long
        get_default_port() const
        {
            return m_default_port;
        }
        
        void
        set_default_port(
            unsigned long default_port
        )
        {
            m_default_port = default_port;
        }

        unsigned long
        get_port();

        bool            m_bUseSecureSockets;
        IT_Bus::String  m_ServerCertificate;

        /* This will be deprecated due to the move to PKCS12. */
        IT_Bus::String  m_ServerPrivateKey;

        IT_Bus::String  m_ServerPrivateKeyPassword;
        IT_Bus::String  m_TrustedRootCertificates;

        /* This will be deprecated due to the move to PKCS12. */
        IT_Bus::String  m_ServerCertificateChain;

        unsigned long       m_ulPort;
        long                m_lSendTimeout;
        long                m_lReceiveTimeout;
        bool                m_bSuppressClientSendErrors;
        bool                m_bSuppressClientReceiveErrors;

        IT_ULong                    m_HTTPReplyCode;            

        IT_Bus::String              m_HTTPReply;                

        bool                        m_bHonorKeepAlive;

        IT_Bus::String              m_RedirectURL;

        vecString                   m_cookies;

        IT_Bus::String              m_Pragma;

        IT_Bus::String              m_CacheControl;

        IT_Bus::String              m_ContentLocation;

        IT_Bus::String              m_ContentEncoding;

        IT_Bus::String              m_ContentLanguage;

        IT_Bus::String              m_ServerType;

        IT_Bus::String              m_WWWAuthenticate;  

        bool                        m_bSuppressTLSv1;

        bool                        m_bSuppressBugTolerance;

        unsigned long               m_port_range_max;

        void
        set_encoding(
            const IT_Bus::String& encoding
        )
        {
            m_encoding = encoding;
        }

        const IT_Bus::String&
        get_encoding() const
        {
            return m_encoding;
        }

    protected:

        bool
        is_integer_string(
            const IT_Bus::String & to_test
        );


    private:

        unsigned long                       m_default_port;
        
        IT_Bus::String                      m_ContentType;
        IT_Bus::String                      m_URL;
        IT_Bus::String                      m_path;

        IT_Bus::BinaryBuffer                m_ServerCertificateData;

        /* This will be deprecated due to the move to PKCS12. */
        IT_Bus::BinaryBuffer                m_ServerCertificateChainData;
        IT_Bus::BinaryBuffer                m_ServerPrivateKeyData;

        IT_Bus::BinaryBuffer                m_TrustedRootCertificatesData;

        IT_HTTP::HttpWSDLExtensionFactory * m_extension_factory;

        IT_Bus::BusContextRegistry*         m_ctx_registry;            
        IT_Bus::String                      m_encoding;    // charset encoding name

        IT_Mutex                            m_mutex;

    };

}

#endif  

---