shibsp/SPConfig.h

   1 /*
   2  *  Copyright 2001-2010 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * @file shibsp/SPConfig.h
  19  *
  20  * Library configuration.
  21  */
  22
  23 #ifndef __shibsp_config_h__
  24 #define __shibsp_config_h__
  25
  26 #include <shibsp/base.h>
  27
  28 #include <string>
  29 #ifndef SHIBSP_LITE
  30 # include <saml/binding/MessageDecoder.h>
  31 # include <saml/binding/MessageEncoder.h>
  32 #endif
  33 #include <xmltooling/PluginManager.h>
  34 #include <xmltooling/QName.h>
  35 #include <xercesc/dom/DOM.hpp>
  36
  37 /**
  38  * @namespace shibsp
  39  * Shibboleth Service Provider Library
  40  */
  41 namespace shibsp {
  42
  43     class SHIBSP_API AccessControl;
  44     class SHIBSP_API Handler;
  45     class SHIBSP_API ListenerService;
  46     class SHIBSP_API RequestMapper;
  47     class SHIBSP_API ProtocolProvider;
  48     class SHIBSP_API ServiceProvider;
  49     class SHIBSP_API SessionCache;
  50     class SHIBSP_API SessionInitiator;
  51
  52 #ifndef SHIBSP_LITE
  53     class SHIBSP_API AttributeDecoder;
  54     class SHIBSP_API AttributeExtractor;
  55     class SHIBSP_API AttributeFilter;
  56     class SHIBSP_API AttributeResolver;
  57     class SHIBSP_API FilterPolicyContext;
  58     class SHIBSP_API MatchFunctor;
  59     class SHIBSP_API SecurityPolicyProvider;
  60 #endif
  61
  62 #if defined (_MSC_VER)
  63     #pragma warning( push )
  64     #pragma warning( disable : 4250 4251 )
  65 #endif
  66
  67     /**
  68      * Singleton object that manages library startup/shutdown.
  69      */
  70     class SHIBSP_API SPConfig
  71     {
  72         MAKE_NONCOPYABLE(SPConfig);
  73     public:
  74         SPConfig();
  75
  76         virtual ~SPConfig();
  77
  78         /**
  79          * Returns the global configuration object for the library.
  80          *
  81          * @return reference to the global library configuration object
  82          */
  83         static SPConfig& getConfig();
  84
  85         /**
  86          * Bitmask values representing subsystems of the library.
  87          */
  88         enum components_t {
  89             Listener = 1,
  90             Caching = 2,
  91 #ifndef SHIBSP_LITE
  92             Metadata = 4,
  93             Trust = 8,
  94             Credentials = 16,
  95             AttributeResolution = 32,
  96 #endif
  97             RequestMapping = 64,
  98             OutOfProcess = 128,
  99             InProcess = 256,
 100             Logging = 512,
 101             Handlers = 1024
 102         };
 103
 104         /**
 105          * Set a bitmask of subsystems to activate.
 106          *
 107          * @param enabled   bitmask of component constants
 108          */
 109         void setFeatures(unsigned long enabled);
 110
 111         /**
 112          * Test whether a subsystem is enabled.
 113          *
 114          * @param feature   subsystem/component to test
 115          * @return true iff feature is enabled
 116          */
 117         bool isEnabled(components_t feature);
 118
 119         /**
 120          * Initializes library
 121          *
 122          * Each process using the library MUST call this function exactly once
 123          * before using any library classes.
 124          *
 125          * @param catalog_path  delimited set of schema catalog files to load
 126          * @param inst_prefix   installation prefix for software
 127          * @return true iff initialization was successful
 128          */
 129         virtual bool init(const char* catalog_path=nullptr, const char* inst_prefix=nullptr);
 130
 131         /**
 132          * Shuts down library
 133          *
 134          * Each process using the library SHOULD call this function exactly once
 135          * before terminating itself.
 136          */
 137         virtual void term();
 138
 139         /**
 140          * Sets the global ServiceProvider instance.
 141          * This method must be externally synchronized with any code that uses the object.
 142          * Any previously set object is destroyed.
 143          *
 144          * @param serviceProvider   new ServiceProvider instance to store
 145          */
 146         void setServiceProvider(ServiceProvider* serviceProvider);
 147
 148         /**
 149          * Returns the global ServiceProvider instance.
 150          *
 151          * @return  global ServiceProvider or nullptr
 152          */
 153         ServiceProvider* getServiceProvider() const;
 154
 155         /**
 156          * Instantiates and installs a ServiceProvider instance based on an XML configuration string
 157          * or a configuration pathname.
 158          *
 159          * @param config    a snippet of XML to parse (it <strong>MUST</strong> contain a type attribute) or a pathname
 160          * @param rethrow   true iff caught exceptions should be rethrown instead of just returning the status
 161          * @return true iff instantiation was successful
 162          */
 163         virtual bool instantiate(const char* config=nullptr, bool rethrow=false);
 164
 165 #ifndef SHIBSP_LITE
 166         /**
 167          * Sets the global ArtifactResolver instance.
 168          *
 169          * <p>This method must be externally synchronized with any code that uses the object.
 170          * Any previously set object is destroyed.
 171          *
 172          * @param artifactResolver   new ArtifactResolver instance to store
 173          */
 174         void setArtifactResolver(opensaml::MessageDecoder::ArtifactResolver* artifactResolver);
 175
 176         /**
 177          * Returns the global ArtifactResolver instance.
 178          *
 179          * @return  global ArtifactResolver or nullptr
 180          */
 181         const opensaml::MessageDecoder::ArtifactResolver* getArtifactResolver() const;
 182 #endif
 183
 184         /** Separator for serialized values of multi-valued attributes. */
 185         char attribute_value_delimeter;
 186
 187         /**
 188          * Manages factories for AccessControl plugins.
 189          */
 190         xmltooling::PluginManager<AccessControl,std::string,const xercesc::DOMElement*> AccessControlManager;
 191
 192 #ifndef SHIBSP_LITE
 193         /**
 194          * Manages factories for AttributeDecoder plugins.
 195          */
 196         xmltooling::PluginManager<AttributeDecoder,xmltooling::QName,const xercesc::DOMElement*> AttributeDecoderManager;
 197
 198         /**
 199          * Manages factories for AttributeExtractor plugins.
 200          */
 201         xmltooling::PluginManager<AttributeExtractor,std::string,const xercesc::DOMElement*> AttributeExtractorManager;
 202
 203         /**
 204          * Manages factories for AttributeFilter plugins.
 205          */
 206         xmltooling::PluginManager<AttributeFilter,std::string,const xercesc::DOMElement*> AttributeFilterManager;
 207
 208         /**
 209          * Manages factories for AttributeResolver plugins.
 210          */
 211         xmltooling::PluginManager<AttributeResolver,std::string,const xercesc::DOMElement*> AttributeResolverManager;
 212
 213         /**
 214          * Manages factories for MatchFunctor plugins.
 215          */
 216         xmltooling::PluginManager< MatchFunctor,xmltooling::QName,std::pair<const FilterPolicyContext*,const xercesc::DOMElement*> > MatchFunctorManager;
 217
 218         /**
 219          * Manages factories for SecurityPolicyProvider plugins.
 220          */
 221         xmltooling::PluginManager<SecurityPolicyProvider,std::string,const xercesc::DOMElement*> SecurityPolicyProviderManager;
 222 #endif
 223
 224         /**
 225          * Manages factories for Handler plugins that implement ArtifactResolutionService functionality.
 226          */
 227         xmltooling::PluginManager< Handler,std::string,std::pair<const xercesc::DOMElement*,const char*> > ArtifactResolutionServiceManager;
 228
 229         /**
 230          * Manages factories for Handler plugins that implement AssertionConsumerService functionality.
 231          */
 232         xmltooling::PluginManager< Handler,std::string,std::pair<const xercesc::DOMElement*,const char*> > AssertionConsumerServiceManager;
 233
 234         /**
 235          * Manages factories for Handler plugins that implement customized functionality.
 236          */
 237         xmltooling::PluginManager< Handler,std::string,std::pair<const xercesc::DOMElement*,const char*> > HandlerManager;
 238
 239         /**
 240          * Manages factories for ListenerService plugins.
 241          */
 242         xmltooling::PluginManager<ListenerService,std::string,const xercesc::DOMElement*> ListenerServiceManager;
 243
 244         /**
 245          * Manages factories for Handler plugins that implement LogoutInitiator functionality.
 246          */
 247         xmltooling::PluginManager< Handler,std::string,std::pair<const xercesc::DOMElement*,const char*> > LogoutInitiatorManager;
 248
 249         /**
 250          * Manages factories for Handler plugins that implement ManageNameIDService functionality.
 251          */
 252         xmltooling::PluginManager< Handler,std::string,std::pair<const xercesc::DOMElement*,const char*> > ManageNameIDServiceManager;
 253
 254         /**
 255          * Manages factories for ProtocolProvider plugins.
 256          */
 257         xmltooling::PluginManager<ProtocolProvider,std::string,const xercesc::DOMElement*> ProtocolProviderManager;
 258
 259         /**
 260          * Manages factories for RequestMapper plugins.
 261          */
 262         xmltooling::PluginManager<RequestMapper,std::string,const xercesc::DOMElement*> RequestMapperManager;
 263
 264         /**
 265          * Manages factories for ServiceProvider plugins.
 266          */
 267         xmltooling::PluginManager<ServiceProvider,std::string,const xercesc::DOMElement*> ServiceProviderManager;
 268
 269         /**
 270          * Manages factories for SessionCache plugins.
 271          */
 272         xmltooling::PluginManager<SessionCache,std::string,const xercesc::DOMElement*> SessionCacheManager;
 273
 274         /**
 275          * Manages factories for Handler plugins that implement SessionInitiator functionality.
 276          */
 277         xmltooling::PluginManager< SessionInitiator,std::string,std::pair<const xercesc::DOMElement*,const char*> > SessionInitiatorManager;
 278
 279         /**
 280          * Manages factories for Handler plugins that implement SingleLogoutService functionality.
 281          */
 282         xmltooling::PluginManager< Handler,std::string,std::pair<const xercesc::DOMElement*,const char*> > SingleLogoutServiceManager;
 283
 284     protected:
 285         /** Global ServiceProvider instance. */
 286         ServiceProvider* m_serviceProvider;
 287
 288 #ifndef SHIBSP_LITE
 289         /** Global ArtifactResolver instance. */
 290         opensaml::MessageDecoder::ArtifactResolver* m_artifactResolver;
 291 #endif
 292
 293     private:
 294         unsigned long m_features;
 295         xercesc::DOMDocument* m_configDoc;
 296     };
 297
 298 #if defined (_MSC_VER)
 299     #pragma warning( pop )
 300 #endif
 301
 302 };
 303
 304 #endif /* __shibsp_config_h__ */