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