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