X-Git-Url: http://www.project-moonshot.org/gitweb/?a=blobdiff_plain;f=xmltooling%2FXMLToolingConfig.h;h=6aa6af9a13b03b0b755d2cf81b0c8dac3d5f76af;hb=420effca96f38dfa5f2a6549679a5d455a3945a7;hp=4111fe0ac1c6b9b036d38be8d8710d234ea234ef;hpb=e5b5c9e4e7320a5199116fbf389d3d462fc754cc;p=shibboleth%2Fcpp-xmltooling.git

diff --git a/xmltooling/XMLToolingConfig.h b/xmltooling/XMLToolingConfig.h
index 4111fe0..6aa6af9 100644
--- a/xmltooling/XMLToolingConfig.h
+++ b/xmltooling/XMLToolingConfig.h
@@ -1,5 +1,5 @@
 /*
- *  Copyright 2001-2006 Internet2
+ *  Copyright 2001-2010 Internet2
  * 
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,9 @@
  */
 
 /**
- * @file XMLToolingConfig.h
+ * @file xmltooling/XMLToolingConfig.h
  * 
- * Library configuration 
+ * Library configuration.
  */
 
 #ifndef __xmltooling_config_h__
@@ -25,14 +25,10 @@
 
 #include <xmltooling/Lockable.h>
 #include <xmltooling/PluginManager.h>
-#include <xmltooling/util/ParserPool.h>
+#include <xmltooling/soap/SOAPTransport.h>
 
-#ifndef XMLTOOLING_NO_XMLSEC
-namespace xmlsignature {
-    class XMLTOOL_API CredentialResolver;
-    class XMLTOOL_API KeyResolver;
-};
-#endif
+#include <string>
+#include <xercesc/dom/DOM.hpp>
 
 #if defined (_MSC_VER)
     #pragma warning( push )
@@ -41,34 +37,53 @@ namespace xmlsignature {
 
 namespace xmltooling {
     
+    class XMLTOOL_API ParserPool;
+    class XMLTOOL_API PathResolver;
+    class XMLTOOL_API TemplateEngine;
+    class XMLTOOL_API URLEncoder;
+#ifndef XMLTOOLING_LITE
     class XMLTOOL_API ReplayCache;
-    class XMLTOOL_API SOAPTransport;
     class XMLTOOL_API StorageService;
-    class XMLTOOL_API TemplateEngine;
+#endif
+#ifndef XMLTOOLING_NO_XMLSEC
+    class XMLTOOL_API CredentialResolver;
+    class XMLTOOL_API KeyInfoResolver;
     class XMLTOOL_API TrustEngine;
-    class XMLTOOL_API KeyInfoSource;
     class XMLTOOL_API XSECCryptoX509CRL;
+#endif
 
     /**
      * Singleton object that manages library startup/shutdown.configuration.
      * 
-     * A locking interface is supplied as a convenience for code that wants to
+     * <p>A locking interface is supplied as a convenience for code that wants to
      * obtain a global system lock, but the actual configuration itself is not
      * synchronized.
      */
-    class XMLTOOL_API XMLToolingConfig : public Lockable
+    class XMLTOOL_API XMLToolingConfig : public virtual Lockable
     {
         MAKE_NONCOPYABLE(XMLToolingConfig);
     protected:
-        XMLToolingConfig() : m_replayCache(NULL), clock_skew_secs(180) {}
-        
+        XMLToolingConfig();
+
+#ifndef XMLTOOLING_NO_XMLSEC
+        /** Global KeyInfoResolver instance. */
+        KeyInfoResolver* m_keyInfoResolver;
+
         /** Global ReplayCache instance. */
         ReplayCache* m_replayCache;
+#endif
+
+        /** Global PathResolver instance. */
+        PathResolver* m_pathResolver;
         
         /** Global TemplateEngine instance. */
         TemplateEngine* m_templateEngine;
+
+        /** Global URLEncoder instance for use by URL-related functions. */
+        URLEncoder* m_urlEncoder;
+
     public:
-        virtual ~XMLToolingConfig() {}
+        virtual ~XMLToolingConfig();
 
         /**
          * Returns the global configuration object for the library.
@@ -89,42 +104,40 @@ namespace xmltooling {
         
         /**
          * Shuts down library
-         * 
-         * Each process using the library SHOULD call this function exactly once
+         * <p>Each process using the library SHOULD call this function exactly once
          * before terminating itself
          */
         virtual void term()=0;
 
         /**
          * Loads a shared/dynamic library extension.
-         * 
-         * Extension libraries are managed using a pair of "C" linkage functions:<br>
+         *
+         * <p>Extension libraries are managed using a pair of "C" linkage functions:<br>
          *      extern "C" int xmltooling_extension_init(void* context);<br>
          *      extern "C" void xmltooling_extension_term();
-         * 
-         * This method is internally synchronized.
+         *
+         * <p>This method is internally synchronized.
          * 
          * @param path      pathname of shared library to load into process
          * @param context   arbitrary data to pass to library initialization hook
          * @return true iff library was loaded successfully
          */
-        virtual bool load_library(const char* path, void* context=NULL)=0;
+        virtual bool load_library(const char* path, void* context=nullptr)=0;
         
         /**
          * Configure logging system.
-         * 
-         * May be called first, before initializing the library. Other calls to it
+         * <p>May be called first, before initializing the library. Other calls to it
          * must be externally synchronized. 
          * 
          * @param config    either a logging configuration file, or a level from the set
          *                  (DEBUG, INFO, NOTICE, WARN, ERROR, CRIT, ALERT, FATAL, EMERG)
          * @return true iff configuration was successful
          */
-        virtual bool log_config(const char* config=NULL)=0;
+        virtual bool log_config(const char* config=nullptr)=0;
 
         /**
          * Obtains a non-validating parser pool.
-         * Library must be initialized first.
+         * <p>Library must be initialized first.
          *
          * @return reference to a non-validating parser pool.
          */
@@ -132,34 +145,80 @@ namespace xmltooling {
 
         /**
          * Obtains a validating parser pool.
-         * Library must be initialized first. Schema/catalog registration must be
+         * <p>Library must be initialized first. Schema/catalog registration must be
          * externally synchronized.
          *
          * @return reference to a validating parser pool.
          */
         virtual ParserPool& getValidatingParser() const=0;
 
+#ifndef XMLTOOLING_NO_XMLSEC
+        /**
+         * Returns the global KeyInfoResolver instance.
+         * 
+         * @return  global KeyInfoResolver or nullptr
+         */
+        const KeyInfoResolver* getKeyInfoResolver() const;
+
+        /**
+         * Returns the global ReplayCache instance.
+         * 
+         * @return  global ReplayCache or nullptr
+         */
+        ReplayCache* getReplayCache() const;
+
+        /**
+         * Sets the global KeyInfoResolver instance.
+         * <p>This method must be externally synchronized with any code that uses the object.
+         * Any previously set object is destroyed.
+         * 
+         * @param keyInfoResolver   new KeyInfoResolver instance to store
+         */
+        void setKeyInfoResolver(KeyInfoResolver* keyInfoResolver);
+
         /**
          * Sets the global ReplayCache instance.
-         * This method must be externally synchronized with any code that uses the object.
+         * <p>This method must be externally synchronized with any code that uses the object.
          * Any previously set object is destroyed.
          * 
          * @param replayCache   new ReplayCache instance to store
          */
         void setReplayCache(ReplayCache* replayCache);
+#endif
 
         /**
-         * Returns the global ReplayCache instance.
+         * Returns the global PathResolver instance.
          * 
-         * @return  global ReplayCache or NULL
+         * @return  global PathResolver or nullptr
          */
-        ReplayCache* getReplayCache() const {
-            return m_replayCache;
-        }
+        PathResolver* getPathResolver() const;
+        
+        /**
+         * Returns the global TemplateEngine instance.
+         * 
+         * @return  global TemplateEngine or nullptr
+         */
+        TemplateEngine* getTemplateEngine() const;
 
         /**
+         * Returns the global URLEncoder instance.
+         * 
+         * @return  global URLEncoder or nullptr
+         */
+        const URLEncoder* getURLEncoder() const;
+
+        /**
+         * Sets the global PathResolver instance.
+         * <p>This method must be externally synchronized with any code that uses the object.
+         * Any previously set object is destroyed.
+         * 
+         * @param pathResolver   new PathResolver instance to store
+         */
+        void setPathResolver(PathResolver* pathResolver);
+        
+        /**
          * Sets the global TemplateEngine instance.
-         * This method must be externally synchronized with any code that uses the object.
+         * <p>This method must be externally synchronized with any code that uses the object.
          * Any previously set object is destroyed.
          * 
          * @param templateEngine   new TemplateEngine instance to store
@@ -167,21 +226,24 @@ namespace xmltooling {
         void setTemplateEngine(TemplateEngine* templateEngine);
 
         /**
-         * Returns the global TemplateEngine instance.
+         * Sets the global URLEncoder instance.
+         * <p>This method must be externally synchronized with any code that uses the object.
+         * Any previously set object is destroyed.
          * 
-         * @return  global TemplateEngine or NULL
+         * @param urlEncoder   new URLEncoder instance to store
          */
-        TemplateEngine* getTemplateEngine() const {
-            return m_templateEngine;
-        }
-                
+        void setURLEncoder(URLEncoder* urlEncoder);
+        
         /**
          * List of catalog files to load into validating parser pool at initialization time.
-         * Like other path settings, the separator depends on the platform
+         * <p>Like other path settings, the separator depends on the platform
          * (semicolon on Windows, colon otherwise). 
          */
         std::string catalog_path;
-        
+
+        /** A User-Agent header to include in HTTP client requests. */
+        std::string user_agent;
+
         /**
          * Adjusts any clock comparisons to be more liberal/permissive by the
          * indicated number of seconds.
@@ -195,30 +257,75 @@ namespace xmltooling {
         virtual XSECCryptoX509CRL* X509CRL() const=0;
 
         /**
-         * Manages factories for KeyResolver plugins.
+         * Manages factories for KeyInfoResolver plugins.
          */
-        PluginManager<xmlsignature::KeyResolver,const DOMElement*> KeyResolverManager;
+        PluginManager<KeyInfoResolver,std::string,const xercesc::DOMElement*> KeyInfoResolverManager;
 
         /**
          * Manages factories for CredentialResolver plugins.
          */
-        PluginManager<xmlsignature::CredentialResolver,const DOMElement*> CredentialResolverManager;
+        PluginManager<CredentialResolver,std::string,const xercesc::DOMElement*> CredentialResolverManager;
 
         /**
          * Manages factories for TrustEngine plugins.
          */
-        PluginManager<TrustEngine,const DOMElement*> TrustEngineManager;
-#endif
+        PluginManager<TrustEngine,std::string,const xercesc::DOMElement*> TrustEngineManager;
 
         /**
-         * Manages factories for SOAPTransport plugins.
+         * Manages factories for StorageService plugins.
          */
-        PluginManager<SOAPTransport,std::pair<const KeyInfoSource*,const char*> > SOAPTransportManager;
+        PluginManager<StorageService,std::string,const xercesc::DOMElement*> StorageServiceManager;
 
         /**
-         * Manages factories for StorageService plugins.
+         * Maps an XML Signature/Encryption algorithm identifier to a library-specific
+         * key algorithm and size for use in resolving credentials.
+         *
+         * @param xmlAlgorithm  XML Signature/Encryption algorithm identifier
+         * @return  a general key algorithm and key size (or 0 if the size is irrelevant)
+         */
+        virtual std::pair<const char*,unsigned int> mapXMLAlgorithmToKeyAlgorithm(const XMLCh* xmlAlgorithm) const=0;
+
+        /**
+         * Types of XML Security algorithms.
+         */
+        enum XMLSecurityAlgorithmType {
+            ALGTYPE_UNK,
+            ALGTYPE_DIGEST,
+            ALGTYPE_SIGN,
+            ALGTYPE_ENCRYPT,
+            ALGTYPE_KEYENCRYPT,
+            ALGTYPE_KEYAGREE
+        };
+
+        /**
+         * Registers an XML Signature/Encryption algorithm identifier against a library-specific
+         * key algorithm and size for use in resolving credentials.
+         *
+         * @param xmlAlgorithm  XML Signature/Encryption algorithm identifier
+         * @param keyAlgorithm  a key algorithm
+         * @param size          a key size (or 0 if the size is irrelevant)
+         * @param type          type of algorithm, if known
+         */
+        virtual void registerXMLAlgorithm(
+            const XMLCh* xmlAlgorithm, const char* keyAlgorithm, unsigned int size=0, XMLSecurityAlgorithmType type=ALGTYPE_UNK
+            )=0;
+
+        /**
+         * Checks for implementation support of a particular XML Security algorithm.
+         *
+         * @param xmlAlgorithm  XML Signature/Encryption algorithm identifier
+         * @param type          type of algorithm, or ALGTYPE_UNK to ignore
+         * @return  true iff the algorithm is supported by the underlying libraries
+         */
+        virtual bool isXMLAlgorithmSupported(const XMLCh* xmlAlgorithm, XMLSecurityAlgorithmType type=ALGTYPE_UNK)=0;
+#endif
+
+        /**
+         * Manages factories for SOAPTransport plugins.
+         * 
+         * <p>The factory interface takes a peer name/endpoint pair.
          */
-        PluginManager<StorageService,const DOMElement*> StorageServiceManager;
+        PluginManager<SOAPTransport,std::string,SOAPTransport::Address> SOAPTransportManager;
     };
 
 };