saml/saml2/metadata/impl/ChainingMetadataProvider.cpp

   1 /*
   2  *  Copyright 2001-2007 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  * ChainingMetadataProvider.cpp
  19  *
  20  * MetadataProvider that uses multiple providers in sequence.
  21  */
  22
  23 #include "internal.h"
  24 #include "exceptions.h"
  25 #include "saml2/metadata/ChainingMetadataProvider.h"
  26
  27 #include <log4cpp/Category.hh>
  28 #include <xmltooling/util/XMLHelper.h>
  29 #include <xercesc/util/XMLUniDefs.hpp>
  30
  31 using namespace opensaml::saml2md;
  32 using namespace opensaml;
  33 using namespace xmlsignature;
  34 using namespace xmltooling;
  35 using namespace log4cpp;
  36 using namespace std;
  37
  38 namespace opensaml {
  39     namespace saml2md {
  40         MetadataProvider* SAML_DLLLOCAL ChainingMetadataProviderFactory(const DOMElement* const & e)
  41         {
  42             return new ChainingMetadataProvider(e);
  43         }
  44     };
  45 };
  46
  47 static const XMLCh _MetadataProvider[] =    UNICODE_LITERAL_16(M,e,t,a,d,a,t,a,P,r,o,v,i,d,e,r);
  48 static const XMLCh type[] =                 UNICODE_LITERAL_4(t,y,p,e);
  49
  50 ChainingMetadataProvider::ChainingMetadataProvider(const DOMElement* e) : ObservableMetadataProvider(e), m_tlsKey(NULL)
  51 {
  52     Category& log=Category::getInstance(SAML_LOGCAT".Metadata");
  53     e = e ? XMLHelper::getFirstChildElement(e, _MetadataProvider) : NULL;
  54     while (e) {
  55         auto_ptr_char temp(e->getAttributeNS(NULL,type));
  56         if (temp.get() && *temp.get()) {
  57             try {
  58                 log.info("building MetadataProvider of type %s", temp.get());
  59                 auto_ptr<MetadataProvider> provider(
  60                     SAMLConfig::getConfig().MetadataProviderManager.newPlugin(temp.get(), e)
  61                     );
  62                 ObservableMetadataProvider* obs = dynamic_cast<ObservableMetadataProvider*>(provider.get());
  63                 if (obs)
  64                     obs->addObserver(this);
  65                 m_providers.push_back(provider.get());
  66                 provider.release();
  67             }
  68             catch (exception& ex) {
  69                 log.error("error building MetadataProvider: %s", ex.what());
  70             }
  71         }
  72         e = XMLHelper::getNextSiblingElement(e, _MetadataProvider);
  73     }
  74     m_tlsKey = ThreadKey::create(NULL);
  75 }
  76
  77 ChainingMetadataProvider::~ChainingMetadataProvider()
  78 {
  79     delete m_tlsKey;
  80     for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());
  81 }
  82
  83 void ChainingMetadataProvider::onEvent(const ObservableMetadataProvider& provider) const
  84 {
  85     emitChangeEvent();
  86 }
  87
  88 void ChainingMetadataProvider::init()
  89 {
  90     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
  91         try {
  92             (*i)->init();
  93         }
  94         catch (exception& ex) {
  95             Category::getInstance(SAML_LOGCAT".Metadata").error("failure initializing MetadataProvider: %s", ex.what());
  96         }
  97     }
  98 }
  99
 100 Lockable* ChainingMetadataProvider::lock()
 101 {
 102     return this;   // we're not lockable ourselves...
 103 }
 104
 105 void ChainingMetadataProvider::unlock()
 106 {
 107     // Check for a locked provider.
 108     void* ptr=m_tlsKey->getData();
 109     if (ptr) {
 110         m_tlsKey->setData(NULL);
 111         reinterpret_cast<MetadataProvider*>(ptr)->unlock();
 112     }
 113 }
 114
 115 const XMLObject* ChainingMetadataProvider::getMetadata() const
 116 {
 117     throw XMLToolingException("getMetadata operation not implemented on this provider.");
 118 }
 119
 120 const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const
 121 {
 122     // Clear any existing lock.
 123     const_cast<ChainingMetadataProvider*>(this)->unlock();
 124
 125     // Do a search.
 126     const EntitiesDescriptor* ret=NULL;
 127     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 128         (*i)->lock();
 129         if (ret=(*i)->getEntitiesDescriptor(name,requireValidMetadata)) {
 130             // Save locked provider.
 131             m_tlsKey->setData(*i);
 132             return ret;
 133         }
 134         (*i)->unlock();
 135     }
 136
 137     return NULL;
 138 }
 139
 140 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const char* id, bool requireValidMetadata) const
 141 {
 142     // Clear any existing lock.
 143     const_cast<ChainingMetadataProvider*>(this)->unlock();
 144
 145     // Do a search.
 146     const EntityDescriptor* ret=NULL;
 147     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 148         (*i)->lock();
 149         if (ret=(*i)->getEntityDescriptor(id,requireValidMetadata)) {
 150             // Save locked provider.
 151             m_tlsKey->setData(*i);
 152             return ret;
 153         }
 154         (*i)->unlock();
 155     }
 156
 157     return NULL;
 158 }
 159
 160 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const SAMLArtifact* artifact) const
 161 {
 162     // Clear any existing lock.
 163     const_cast<ChainingMetadataProvider*>(this)->unlock();
 164
 165     // Do a search.
 166     const EntityDescriptor* ret=NULL;
 167     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 168         (*i)->lock();
 169         if (ret=(*i)->getEntityDescriptor(artifact)) {
 170             // Save locked provider.
 171             m_tlsKey->setData(*i);
 172             return ret;
 173         }
 174         (*i)->unlock();
 175     }
 176
 177     return NULL;
 178 }
 179
 180 const Credential* ChainingMetadataProvider::resolve(const CredentialCriteria* criteria) const
 181 {
 182     // Check for a locked provider.
 183     void* ptr=m_tlsKey->getData();
 184     if (!ptr)
 185         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 186
 187     return reinterpret_cast<MetadataProvider*>(ptr)->resolve(criteria);
 188 }
 189
 190 vector<const Credential*>::size_type ChainingMetadataProvider::resolve(
 191     vector<const Credential*>& results, const CredentialCriteria* criteria
 192     ) const
 193 {
 194     // Check for a locked provider.
 195     void* ptr=m_tlsKey->getData();
 196     if (!ptr)
 197         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 198
 199     return reinterpret_cast<MetadataProvider*>(ptr)->resolve(results, criteria);
 200 }