it_bus_config/http_client_configuration.h

#ifndef _IT_BUS_CONFIG_HTTPCLIENT_H_
#define _IT_BUS_CONFIG_HTTPCLIENT_H_

#include <it_dsa/vector.h>
#include <it_bus/api_defines.h>
#include <it_bus/qname.h>
#include <it_bus/sequence_complex_type.h>
#include <it_bus_config/http_wsdl_extension_element.h>
#include <it_bus/complex_type_reader.h>
#include <it_bus/complex_type_writer.h>
#include <it_bus_pdk/context_attrs/http_conf_xsdTypes.h>
#ifndef IT_MINIMISE_INCLUDES
#include <it_bus/bus.h>
#include <it_bus_pdk/messaging_transport.h>
#endif

namespace IT_Bus
{
    class BusContextRegistry;
    class ContextContainer;
}
namespace IT_WSDL
{
    class WSDLPort;
}

namespace IT_HTTP
{
    class HTTPClient;
    class HTTPClientInputMessageAttributes;
    class HttpWSDLExtensionFactory;

    class IT_BUS_API HTTPClientConfiguration : 
        public IT_HTTP::HttpWSDLExtensionElement,
        public IT_Bus::SequenceComplexType
    {

      public: 

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

        virtual
        ~HTTPClientConfiguration();

        void 
        set_defaults();

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

        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 
        SetConnectParameters(
                HTTPClient& HTTPClient,
                IT_Bus::ContextContainer * context_container = 0
        );

        void 
        setUseSecureSockets(
                const IT_Bool& bUseSecureSockets
        ) 
        { 
                m_bUseSecureSockets = bUseSecureSockets; 
        }

        const IT_Bool& 
        getUseSecureSockets() const
        { 
            return m_bUseSecureSockets; 
        }

        IT_Bool& 
        getUseSecureSockets() 
        { 
            return m_bUseSecureSockets; 
        }

        void 
        setClientCertificate(
            const IT_Bus::String& strClientCertificate
        ) 
        { 
            m_ClientCertificate = strClientCertificate; 
        }

        const IT_Bus::String& 
        getClientCertificate() const 
        { 
            return m_ClientCertificate; 
        }

        IT_Bus::String& 
        getClientCertificate() 
        { 
            return m_ClientCertificate; 
        }

        void 
        setClientPrivateKey(
            const IT_Bus::String& strClientPrivateKey
        ) 
        { 
            m_ClientPrivateKey = strClientPrivateKey; 
        }

        const IT_Bus::String& 
        getClientPrivateKey() const 
        { 
            return m_ClientPrivateKey; 
        }

        IT_Bus::String& 
        getClientPrivateKey()
        { 
            return m_ClientPrivateKey; 
        }

        void 
        setClientPrivateKeyPassword(
                const IT_Bus::String& strClientPrivateKeyPassword
        ) 
        { 
                m_ClientPrivateKeyPassword = strClientPrivateKeyPassword; 
        }

        const IT_Bus::String& 
        getClientPrivateKeyPassword() const 
        { 
            return m_ClientPrivateKeyPassword; 
        }

        IT_Bus::String& 
        getClientPrivateKeyPassword()
        { 
            return m_ClientPrivateKeyPassword; 
        }

        void 
        setTrustedRootCertificates(
                const IT_Bus::String& strTrustedRootCertificates
        ) 
        { 
                m_TrustedRootCertificates = strTrustedRootCertificates; 
        }

        const IT_Bus::String& 
        getTrustedRootCertificates() const 
        { 
            return m_TrustedRootCertificates; 
        }

        IT_Bus::String& 
        getTrustedRootCertificates()
        { 
            return m_TrustedRootCertificates; 
        }

        void 
        setClientCertificateChain(
                const IT_Bus::String& strClientCertificateChain
        ) 
        { 
                m_ClientCertificateChain = strClientCertificateChain; 
        }

        const IT_Bus::String& 
        getClientCertificateChain() const 
        { 
                return m_ClientCertificateChain; 
        }

        IT_Bus::String& 
        getClientCertificateChain()
        { 
            return m_ClientCertificateChain; 
        }

        void 
        setPort(
                const IT_ULong& ulPort
        ) 
        { 
                m_ulPort = ulPort; 
        }

        const IT_ULong& 
        getPort() const 
        { 
                return m_ulPort; 
        }

        void
        set_connection_attempts(
                unsigned short connection_attempts
        )
        {
                m_connection_attempts = connection_attempts;
        }

        unsigned short
        get_connection_attempts() const
        {
                return m_connection_attempts;
        }

        void 
        setSendTimeout(
                const IT_ULong& lSendTimeout
        ) 
        { 
                m_lSendTimeout = lSendTimeout; 
        }

        const IT_ULong& 
        getSendTimeout() const 
        { 
                return m_lSendTimeout; 
        }

        void 
        setReceiveTimeout(
                const IT_ULong& lReceiveTimeout
        ) 
        { 
                m_lReceiveTimeout = lReceiveTimeout; 
        }

        const IT_ULong& 
        getReceiveTimeout() const 
        { 
                return m_lReceiveTimeout; 
        }

        void 
        setMethod(
                const IT_Bus::String& strMethod
        ) 
        { 
                m_Method = strMethod; 
        }

        const IT_Bus::String& 
        getMethod() const 
        { 
                return m_Method; 
        }

        void 
        setURL(
                const IT_Bus::String& strURL
        )
        { 
                m_URL = strURL;
                if (!m_bUseSecureSockets)
                {
                //see if the location/URL indicates https
                if (strncasecmp(m_URL.c_str(), "https://", strlen("https://")) == 0)
                {
                    m_bUseSecureSockets = true;
                }
                }

                if (m_bUseSecureSockets)
                {
                m_ulPort = 443;
                }
                else
                {
                m_ulPort = 80;
                }
        }        

        const IT_Bus::String& 
        getURL() const 
        { 
                return m_URL; 
        }

        void 
        setAuthorization(
                const IT_Bus::String& strAuthorization
        ) 
        { 
                m_Authorization = strAuthorization; 
        }

        const IT_Bus::String& 
        getAuthorization() const 
        { 
                return m_Authorization; 
        }

        void 
        setAuthorizationType(
                const IT_Bus::String& strAuthorizationType
        ) 
        { 
                m_AuthorizationType = strAuthorizationType; 
        }

        const IT_Bus::String& 
        getAuthorizationType() const 
        { 
                return m_AuthorizationType; 
        }

        void 
        setUserName(
                const IT_Bus::String& strUserName
        ) 
        { 
                m_UserName = strUserName; 
        }

        const IT_Bus::String& 
        getUserName() const 
        { 
                return m_UserName; 
        }

        void 
        setPassword(
                const IT_Bus::String& strPassword
        ) 
        { 
                m_Password = strPassword; 
        }

        const IT_Bus::String& 
        getPassword() const 
        { 
                return m_Password; 
        }

        void 
        setProxyServer(
                const IT_Bus::String& strProxyServer
        ) 
        {
                m_ProxyServer = strProxyServer; 
        }

        const IT_Bus::String& 
        getProxyServer() const 
        { 
                return m_ProxyServer; 
        }

        void 
        setProxyAuthorization(
                const IT_Bus::String& strProxyAuthorization
        ) 
        { 
                m_ProxyAuthorization = strProxyAuthorization; 
        }

        const IT_Bus::String& 
        getProxyAuthorization() const 
        { 
                return m_ProxyAuthorization; 
        }

        void 
        setProxyAuthorizationType(
                const IT_Bus::String& strProxyAuthorizationType
        ) 
        { 
                m_ProxyAuthorizationType = strProxyAuthorizationType; 
        }

        const IT_Bus::String& 
        getProxyAuthorizationType() const 
        { 
                return m_ProxyAuthorizationType; 
        }

        void 
        setProxyUserName(
                const IT_Bus::String& strProxyUserName
        ) 
        { 
                m_ProxyUserName = strProxyUserName; 
        }

        const IT_Bus::String& 
        getProxyUserName() const 
        { 
                return m_ProxyUserName; 
        }

        void 
        setProxyPassword(
                const IT_Bus::String& strProxyPassword
        ) 
        { 
                m_ProxyPassword = strProxyPassword; 
        }

        const IT_Bus::String& 
        getProxyPassword() const 
        { 
                return m_ProxyPassword; 
        }

        void 
        setAccept(
                const IT_Bus::String& strAccept
        ) 
        { 
                m_Accept = strAccept; 
        }

        const IT_Bus::String& 
        getAccept() const 
        { 
                return m_Accept; 
        }

        void 
        setAcceptLanguage(
                const IT_Bus::String& strAcceptLanguage
        ) 
        { 
                m_AcceptLanguage = strAcceptLanguage; 
        }

        const IT_Bus::String& 
        getAcceptLanguage() const 
        { 
                return m_AcceptLanguage; 
        }

        void
        setAcceptEncoding(
                const IT_Bus::String& strAcceptEncoding
        ) 
        { 
                m_AcceptEncoding = strAcceptEncoding; 
        }

        const IT_Bus::String& 
        getAcceptEncoding() const 
        { 
                return m_AcceptEncoding; 
        }

        void 
        setContentType(
                const IT_Bus::String& strContentType
        ) 
        { 
                m_ContentType = strContentType; 
        }

        const IT_Bus::String& 
        getContentType() const 
        { 
                return m_ContentType; 
        }

        void 
        setHost(
                const IT_Bus::String& strHost
        ) 
        { 
                m_Host = strHost; 
        }

        const IT_Bus::String& 
        getHost() const 
        { 
                return m_Host; 
        }

        void 
        setConnection(
                const IT_Bus::String& strConnection
        ) 
        { 
                m_Connection = strConnection; 
        }

        const IT_Bus::String& 
        getConnection() const 
        { 
                return m_Connection; 
        }

        void 
        setKeepAlive(
                const IT_Bool& bKeepAlive
        ) 
        { 
                m_bKeepAlive = bKeepAlive; 
        }

        const IT_Bool& 
        getKeepAlive() const 
        { 
                return m_bKeepAlive; 
        }

        void 
        setCacheControl(
                const IT_Bus::String& strCacheControl
        ) 
        { 
                m_CacheControl = strCacheControl; 
        }

        const IT_Bus::String& 
        getCacheControl() const 
        { 
                return m_CacheControl; 
        }

        void 
        setCacheDNS(
                const IT_Bool& cache_dns
        ) 
        { 
                m_cache_dns = cache_dns; 
        }

        const IT_Bool& 
        getCacheDNS() const 
        { 
                return m_cache_dns; 
        }

        void
        setCookie(
                const IT_Bus::String& strCookie
        ) 
        {
                m_Cookie = strCookie; 
        }

        const IT_Bus::String& 
        getCookie() const 
        {
                return m_Cookie; 
        }

        /*
         * Set the BrowserType, allows client to inform the 
         * server what browser is in use.
         * Not important for Artix.
         * 
         * @param String
         */
        void 
        setBrowserType(
                const IT_Bus::String& strBrowserType
        ) 
        { 
                m_BrowserType = strBrowserType; 
        }

        /*
         * Return the value of the BrowserType setting.
         *
         * @return String
         */
        const IT_Bus::String& 
        getBrowserType() const 
        { 
                return m_BrowserType; 
        }

        // Referer -     tells the server where did the link come from
        void 
        setReferer(
                const IT_Bus::String& strReferer
        ) 
        { 
                m_Referer = strReferer; 
        }

        const IT_Bus::String& 
        getReferer() const 
        { 
                return m_Referer; 
        }

        // IfModifiedSince - Conditional Get -- gets a file only if newer "If-Modified-Since"
        void 
        setIfModifiedSince(
                const IT_Bus::String& strIfModifiedSince
        ) 
        { 
                m_IfModifiedSince = strIfModifiedSince; 
        }

        const IT_Bus::String& 
        getIfModifiedSince() const 
        {
                return m_IfModifiedSince; 
        }

        // ETag - Entity Tag for unique document id
        void 
        setETag(
            const IT_Bus::String& strETag
        ) 
        { 
            m_ETag = strETag; 
        }
        
        const IT_Bus::String& 
        getETag() const 
        { 
            return m_ETag; 
        }
        
        // UsingHTTP11 - Any 1.1 features needed
        void 
        setUsingHTTP11(
            const IT_Bool& bUsingHTTP11
        ) 
        { 
            m_bUsingHTTP11 = bUsingHTTP11; 
        }
        
        const IT_Bool& 
        getUsingHTTP11() const 
        { 
            return m_bUsingHTTP11; 
        }
        
        // SuppressTLSv1 - Turn off TLSv1
        void 
        setSuppressTLSv1(
            const IT_Bool& bSuppressTLSv1
        ) 
        { 
            m_bSuppressTLSv1 = bSuppressTLSv1; 
        }
        
        const IT_Bool& 
        getSuppressTLSv1() const 
        { 
            return m_bSuppressTLSv1; 
        }
        
        // SuppressBugTolerance - Turn off Bug Tolerance
        void 
        setSuppressBugTolerance(
            const IT_Bool& bSuppressBugTolerance
        ) 
        { 
            m_bSuppressBugTolerance = bSuppressBugTolerance; 
        }
        
        const IT_Bool& 
        getSuppressBugTolerance() const 
        { 
            return m_bSuppressBugTolerance; 
        }

        void 
        setSoapAction(
            const IT_Bus::String& strSoapAction
        ) 
        { 
            m_SoapAction = strSoapAction; 
        }

        const IT_Bus::String& 
        getSoapAction() const 
        { 
            return m_SoapAction; 
        }

        HTTPClientConfiguration(
            const HTTPClientConfiguration& copyThis
        );

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

        void 
        InitializeFromURL(
            const IT_Bus::String& strURL
        );

        void 
        InitializeFromFile(
            const IT_Bus::String& strFile
        );

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

        virtual bool
        export_to_client() const
        {
            return true;
        }

        /*
         * SequenceComplexType virtual methods.
         */

        virtual void
        read_contents(
            IT_Bus::ComplexTypeReader & os
        ) throw((IT_Bus::DeserializationException));

        virtual void
        write_contents(
            IT_Bus::ComplexTypeWriter & os
        ) const throw((IT_Bus::SerializationException));

        virtual void
        read(
            const IT_Bus::QName& element_name,
            IT_Bus::ComplexTypeReader & reader
        ) throw((IT_Bus::DeserializationException));
        
        virtual void
        write(
            const IT_Bus::QName& element_name,
            IT_Bus::ComplexTypeWriter & writer
        ) const throw((IT_Bus::SerializationException));

        virtual void
        write_attributes(
            IT_Bus::ComplexTypeWriter & writer
        ) const throw((IT_Bus::SerializationException));

        virtual void
        read_attributes(
            IT_Bus::ComplexTypeReader & reader
        ) throw((IT_Bus::DeserializationException));

        virtual const IT_Bus::QName &
        get_type() const;

        virtual 
        IT_Bus::AnyType&
        copy(
            const IT_Bus::AnyType& rhs
        );

        IT_WSDL::WSDLExtensionElement*
        clone() const;

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

      private:

        void EnsureHTTP11Compliance();
        void set_proxy_server(
            const IT_Bus::XMLIterator& iter_protocol_config
        );

        //https secure sockets parameters
        IT_Bool                 m_bUseSecureSockets;
        IT_Bus::String          m_ClientCertificate;

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

        IT_Bus::String          m_ClientPrivateKeyPassword;
        IT_Bus::String          m_TrustedRootCertificates;

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

        //standard http parameters
        IT_ULong                m_ulPort;
        IT_ULong                m_lSendTimeout;
        IT_ULong                m_lReceiveTimeout;

        IT_Bus::String          m_Method;
        IT_Bus::String          m_URL;
    
        IT_Bus::String          m_Authorization;          // allows us to send username for basic authentication
        IT_Bus::String          m_AuthorizationType;      // allows us to send username for basic authentication
        IT_Bus::String          m_UserName;               // allows us to send username for basic authentication
        IT_Bus::String          m_Password;               // allows us to send password for basic authentication

        IT_Bus::String          m_ProxyServer;            // enables connection to Proxy Server (format is Server:Port, :Port is optional
        IT_Bus::String          m_ProxyAuthorization;     // allows us to send username for basic authentication
        IT_Bus::String          m_ProxyAuthorizationType; // allows us to send username for basic authentication
        IT_Bus::String          m_ProxyUserName;          // allows us to send username for basic authentication
        IT_Bus::String          m_ProxyPassword;          // allows us to send password for basic authentication

        IT_Bus::String          m_Accept;                 // tells the server what mime types are ok
        IT_Bus::String          m_AcceptLanguage;         // tells the server what language is OK for us
        IT_Bus::String          m_AcceptEncoding;         // tells the server what Encoding is OK for us

        IT_Bus::String          m_ContentType;            // what kind of stream is this we're sending (e.g., application/x-www-form-urlencoded)
        IT_Bus::String          m_Host;                   // what host we want this to come from (e.g., overriding default processing for caching, etc.)
        IT_Bus::String          m_Connection;             // connection directives (e.g., Keep-Alive or close);
        unsigned short          m_connection_attempts;    // number of attempts to be done in case of server shutdown
        IT_Bool                 m_bKeepAlive;             // preparse of m_Connection for "Keep-Alive"
        IT_Bus::String          m_CacheControl;           // request cache directives 
        IT_Bool                 m_cache_dns;

        IT_Bus::String          m_Cookie;                 // sends the cookie to the server for this client
        IT_Bus::String          m_BrowserType;            // allows us to tell the server (this is IE, or this is PalmVII)
        IT_Bus::String          m_Referer;                // tells the server where did the link come from
        IT_Bus::String          m_IfModifiedSince;        // Conditional Get -- gets a file only if newer "If-Modified-Since"

        IT_Bus::String          m_ETag;                   // Entity Tag for unique document id

        IT_Bool                 m_bUsingHTTP11;           // Any 1.1 features needed

        IT_Bool                 m_bSuppressTLSv1;         // Turn off TLSv1
        IT_Bool                 m_bSuppressBugTolerance;  // Turn off Bug Tolerance

        IT_Bus::String          m_SoapAction;

        IT_Bus::BinaryBuffer    m_ClientTrustedRootCertificatesData;

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

        IT_Bus::BinaryBuffer    m_ClientCertificateData;

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

        //this caches the header (it is expensive to encode it)
        char                    m_szAuthorizationHeader[256];
        char                    m_szProxyAuthorizationHeader[256];

        IT_HTTP::HttpWSDLExtensionFactory* m_extension_factory;

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

}

#endif 

---