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     try {
  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                 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             e = XMLHelper::getNextSiblingElement(e, _MetadataProvider);
  69         }
  70     }
  71     catch (exception&) {
  72         for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());
  73         throw;
  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(MetadataProvider& provider)
  85 {
  86     emitChangeEvent();
  87 }
  88
  89 void ChainingMetadataProvider::init()
  90 {
  91     for_each(m_providers.begin(), m_providers.end(), mem_fun(&MetadataProvider::init));
  92 }
  93
  94 Lockable* ChainingMetadataProvider::lock()
  95 {
  96     return this;   // we're not lockable ourselves...
  97 }
  98
  99 void ChainingMetadataProvider::unlock()
 100 {
 101     // Check for a locked provider.
 102     void* ptr=m_tlsKey->getData();
 103     if (ptr) {
 104         m_tlsKey->setData(NULL);
 105         reinterpret_cast<MetadataProvider*>(ptr)->unlock();
 106     }
 107 }
 108
 109 const XMLObject* ChainingMetadataProvider::getMetadata() const
 110 {
 111     throw XMLToolingException("getMetadata operation not implemented on this provider.");
 112 }
 113
 114 const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const
 115 {
 116     // Clear any existing lock.
 117     const_cast<ChainingMetadataProvider*>(this)->unlock();
 118
 119     // Do a search.
 120     const EntitiesDescriptor* ret=NULL;
 121     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 122         (*i)->lock();
 123         if (ret=(*i)->getEntitiesDescriptor(name,requireValidMetadata)) {
 124             // Save locked provider.
 125             m_tlsKey->setData(*i);
 126             return ret;
 127         }
 128         (*i)->unlock();
 129     }
 130
 131     return NULL;
 132 }
 133
 134 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const char* id, bool requireValidMetadata) const
 135 {
 136     // Clear any existing lock.
 137     const_cast<ChainingMetadataProvider*>(this)->unlock();
 138
 139     // Do a search.
 140     const EntityDescriptor* ret=NULL;
 141     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 142         (*i)->lock();
 143         if (ret=(*i)->getEntityDescriptor(id,requireValidMetadata)) {
 144             // Save locked provider.
 145             m_tlsKey->setData(*i);
 146             return ret;
 147         }
 148         (*i)->unlock();
 149     }
 150
 151     return NULL;
 152 }
 153
 154 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const SAMLArtifact* artifact) const
 155 {
 156     // Clear any existing lock.
 157     const_cast<ChainingMetadataProvider*>(this)->unlock();
 158
 159     // Do a search.
 160     const EntityDescriptor* ret=NULL;
 161     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 162         (*i)->lock();
 163         if (ret=(*i)->getEntityDescriptor(artifact)) {
 164             // Save locked provider.
 165             m_tlsKey->setData(*i);
 166             return ret;
 167         }
 168         (*i)->unlock();
 169     }
 170
 171     return NULL;
 172 }
 173
 174 const Credential* ChainingMetadataProvider::resolve(const CredentialCriteria* criteria) const
 175 {
 176     // Check for a locked provider.
 177     void* ptr=m_tlsKey->getData();
 178     if (!ptr)
 179         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 180
 181     return reinterpret_cast<MetadataProvider*>(ptr)->resolve(criteria);
 182 }
 183
 184 vector<const Credential*>::size_type ChainingMetadataProvider::resolve(
 185     vector<const Credential*>& results, const CredentialCriteria* criteria
 186     ) const
 187 {
 188     // Check for a locked provider.
 189     void* ptr=m_tlsKey->getData();
 190     if (!ptr)
 191         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 192
 193     return reinterpret_cast<MetadataProvider*>(ptr)->resolve(results, criteria);
 194 }