shib/ShibConfig.cpp

   1 /*
   2  * The Shibboleth License, Version 1.
   3  * Copyright (c) 2002
   4  * University Corporation for Advanced Internet Development, Inc.
   5  * All rights reserved
   6  *
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions are met:
  10  *
  11  * Redistributions of source code must retain the above copyright notice, this
  12  * list of conditions and the following disclaimer.
  13  *
  14  * Redistributions in binary form must reproduce the above copyright notice,
  15  * this list of conditions and the following disclaimer in the documentation
  16  * and/or other materials provided with the distribution, if any, must include
  17  * the following acknowledgment: "This product includes software developed by
  18  * the University Corporation for Advanced Internet Development
  19  * <http://www.ucaid.edu>Internet2 Project. Alternately, this acknowledegement
  20  * may appear in the software itself, if and wherever such third-party
  21  * acknowledgments normally appear.
  22  *
  23  * Neither the name of Shibboleth nor the names of its contributors, nor
  24  * Internet2, nor the University Corporation for Advanced Internet Development,
  25  * Inc., nor UCAID may be used to endorse or promote products derived from this
  26  * software without specific prior written permission. For written permission,
  27  * please contact shibboleth@shibboleth.org
  28  *
  29  * Products derived from this software may not be called Shibboleth, Internet2,
  30  * UCAID, or the University Corporation for Advanced Internet Development, nor
  31  * may Shibboleth appear in their name, without prior written permission of the
  32  * University Corporation for Advanced Internet Development.
  33  *
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  36  * AND WITH ALL FAULTS. ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  37  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  38  * PARTICULAR PURPOSE, AND NON-INFRINGEMENT ARE DISCLAIMED AND THE ENTIRE RISK
  39  * OF SATISFACTORY QUALITY, PERFORMANCE, ACCURACY, AND EFFORT IS WITH LICENSEE.
  40  * IN NO EVENT SHALL THE COPYRIGHT OWNER, CONTRIBUTORS OR THE UNIVERSITY
  41  * CORPORATION FOR ADVANCED INTERNET DEVELOPMENT, INC. BE LIABLE FOR ANY DIRECT,
  42  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  43  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  44  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  45  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  46  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  47  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  48  */
  49
  50
  51 /* ShibConfig.cpp - Shibboleth runtime configuration
  52
  53    Scott Cantor
  54    6/4/02
  55
  56    $History:$
  57 */
  58
  59 #include <time.h>
  60 #include <sys/types.h>
  61 #include <sys/stat.h>
  62
  63 #define SHIB_INSTANTIATE
  64
  65 #include "internal.h"
  66 #include <openssl/err.h>
  67
  68 using namespace saml;
  69 using namespace shibboleth;
  70 using namespace log4cpp;
  71 using namespace std;
  72
  73 SAML_EXCEPTION_FACTORY(UnsupportedProtocolException);
  74 SAML_EXCEPTION_FACTORY(MetadataException);
  75 SAML_EXCEPTION_FACTORY(CredentialException);
  76
  77 namespace {
  78     ShibInternalConfig g_config;
  79 }
  80
  81 ShibConfig::~ShibConfig() {}
  82
  83 bool ShibInternalConfig::init()
  84 {
  85     saml::NDC ndc("init");
  86
  87     REGISTER_EXCEPTION_FACTORY(edu.internet2.middleware.shibboleth.common,UnsupportedProtocolException);
  88     REGISTER_EXCEPTION_FACTORY(edu.internet2.middleware.shibboleth.common,MetadataException);
  89     REGISTER_EXCEPTION_FACTORY(edu.internet2.middleware.shibboleth.common,CredentialException);
  90
  91     return true;
  92 }
  93
  94 void ShibInternalConfig::regFactory(const char* type, MetadataFactory* factory)
  95 {
  96     if (type && factory)
  97         m_metadataFactoryMap[type]=factory;
  98 }
  99
 100 void ShibInternalConfig::regFactory(const char* type, RevocationFactory* factory)
 101 {
 102     if (type && factory)
 103         m_revocationFactoryMap[type]=factory;
 104 }
 105
 106 void ShibInternalConfig::regFactory(const char* type, TrustFactory* factory)
 107 {
 108     if (type && factory)
 109         m_trustFactoryMap[type]=factory;
 110 }
 111
 112 void ShibInternalConfig::regFactory(const char* type, CredentialsFactory* factory)
 113 {
 114     if (type && factory)
 115     {
 116         m_credFactoryMap[type]=factory;
 117         SAMLConfig::getConfig().binding_defaults.ssl_ctx_callback=
 118             reinterpret_cast<SAMLConfig::SAMLBindingConfig::ssl_ctx_callback_fn>(ssl_ctx_callback);
 119     }
 120 }
 121
 122 void ShibInternalConfig::regFactory(const char* type, CredResolverFactory* factory)
 123 {
 124     if (type && factory)
 125         m_credResolverFactoryMap[type]=factory;
 126 }
 127
 128 void ShibInternalConfig::regFactory(const char* type, AAPFactory* factory)
 129 {
 130     if (type && factory)
 131         m_aapFactoryMap[type]=factory;
 132 }
 133
 134 void ShibInternalConfig::unregFactory(const char* type)
 135 {
 136     if (type) {
 137         m_metadataFactoryMap.erase(type);
 138         m_revocationFactoryMap.erase(type);
 139         m_trustFactoryMap.erase(type);
 140         m_credFactoryMap.erase(type);
 141         m_aapFactoryMap.erase(type);
 142         m_credResolverFactoryMap.erase(type);
 143     }
 144 }
 145
 146 IMetadata* ShibInternalConfig::newMetadata(const char* type, const DOMElement* source) const
 147 {
 148     MetadataFactoryMap::const_iterator i=m_metadataFactoryMap.find(type);
 149     if (i==m_metadataFactoryMap.end())
 150     {
 151         NDC ndc("newMetadata");
 152         Category::getInstance(SHIB_LOGCAT".ShibInternalConfig").error("unknown metadata type: %s",type);
 153         return NULL;
 154     }
 155     return i->second(source);
 156 }
 157
 158 IRevocation* ShibInternalConfig::newRevocation(const char* type, const DOMElement* source) const
 159 {
 160     RevocationFactoryMap::const_iterator i=m_revocationFactoryMap.find(type);
 161     if (i==m_revocationFactoryMap.end())
 162     {
 163         NDC ndc("newRevocation");
 164         Category::getInstance(SHIB_LOGCAT".ShibInternalConfig").error("unknown revocation type: %s",type);
 165         return NULL;
 166     }
 167     return i->second(source);
 168 }
 169
 170 ITrust* ShibInternalConfig::newTrust(const char* type, const DOMElement* source) const
 171 {
 172     TrustFactoryMap::const_iterator i=m_trustFactoryMap.find(type);
 173     if (i==m_trustFactoryMap.end())
 174     {
 175         NDC ndc("newTrust");
 176         Category::getInstance(SHIB_LOGCAT".ShibInternalConfig").error("unknown trust type: %s",type);
 177         return NULL;
 178     }
 179     return i->second(source);
 180 }
 181
 182 ICredentials* ShibInternalConfig::newCredentials(const char* type, const DOMElement* source) const
 183 {
 184     CredentialsFactoryMap::const_iterator i=m_credFactoryMap.find(type);
 185     if (i==m_credFactoryMap.end())
 186     {
 187         NDC ndc("newCredentials");
 188         Category::getInstance(SHIB_LOGCAT".ShibInternalConfig").error("unknown credentials type: %s",type);
 189         return NULL;
 190     }
 191     return i->second(source);
 192 }
 193
 194 IAAP* ShibInternalConfig::newAAP(const char* type, const DOMElement* source) const
 195 {
 196     AAPFactoryMap::const_iterator i=m_aapFactoryMap.find(type);
 197     if (i==m_aapFactoryMap.end())
 198     {
 199         NDC ndc("newAAP");
 200         Category::getInstance(SHIB_LOGCAT".ShibInternalConfig").error("unknown AAP type: %s",type);
 201         return NULL;
 202     }
 203     return i->second(source);
 204 }
 205
 206 ICredResolver* ShibInternalConfig::newCredResolver(const char* type, const DOMElement* source) const
 207 {
 208     CredResolverFactoryMap::const_iterator i=m_credResolverFactoryMap.find(type);
 209     if (i==m_credResolverFactoryMap.end())
 210     {
 211         NDC ndc("newCredResolver");
 212         Category::getInstance(SHIB_LOGCAT".ShibInternalConfig").error("unknown cred resolver type: %s",type);
 213         return NULL;
 214     }
 215     return i->second(source);
 216 }
 217
 218 ShibConfig& ShibConfig::getConfig()
 219 {
 220     return g_config;
 221 }
 222
 223 void shibboleth::log_openssl()
 224 {
 225     const char* file;
 226     const char* data;
 227     int flags,line;
 228
 229     unsigned long code=ERR_get_error_line_data(&file,&line,&data,&flags);
 230     while (code)
 231     {
 232         Category& log=Category::getInstance("OpenSSL");
 233         log.errorStream() << "error code: " << code << " in " << file << ", line " << line << CategoryStream::ENDLINE;
 234         if (data && (flags & ERR_TXT_STRING))
 235             log.errorStream() << "error data: " << data << CategoryStream::ENDLINE;
 236         code=ERR_get_error_line_data(&file,&line,&data,&flags);
 237     }
 238 }