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<void,MetadataProvider>(&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 KeyResolver* ChainingMetadataProvider::getKeyResolver() const
 110 {
 111     // Check for a locked provider.
 112     void* ptr=m_tlsKey->getData();
 113     return ptr ? reinterpret_cast<MetadataProvider*>(ptr)->getKeyResolver() : NULL;
 114
 115 }
 116
 117 const XMLObject* ChainingMetadataProvider::getMetadata() const
 118 {
 119     throw XMLToolingException("getMetadata operation not implemented on this provider.");
 120 }
 121
 122 const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const
 123 {
 124     // Clear any existing lock.
 125     const_cast<ChainingMetadataProvider*>(this)->unlock();
 126
 127     // Do a search.
 128     const EntitiesDescriptor* ret=NULL;
 129     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 130         (*i)->lock();
 131         if (ret=(*i)->getEntitiesDescriptor(name,requireValidMetadata)) {
 132             // Save locked provider.
 133             m_tlsKey->setData(*i);
 134             return ret;
 135         }
 136         (*i)->unlock();
 137     }
 138
 139     return NULL;
 140 }
 141
 142 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const char* id, bool requireValidMetadata) const
 143 {
 144     // Clear any existing lock.
 145     const_cast<ChainingMetadataProvider*>(this)->unlock();
 146
 147     // Do a search.
 148     const EntityDescriptor* ret=NULL;
 149     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 150         (*i)->lock();
 151         if (ret=(*i)->getEntityDescriptor(id,requireValidMetadata)) {
 152             // Save locked provider.
 153             m_tlsKey->setData(*i);
 154             return ret;
 155         }
 156         (*i)->unlock();
 157     }
 158
 159     return NULL;
 160 }
 161
 162 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const SAMLArtifact* artifact) const
 163 {
 164     // Clear any existing lock.
 165     const_cast<ChainingMetadataProvider*>(this)->unlock();
 166
 167     // Do a search.
 168     const EntityDescriptor* ret=NULL;
 169     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 170         (*i)->lock();
 171         if (ret=(*i)->getEntityDescriptor(artifact)) {
 172             // Save locked provider.
 173             m_tlsKey->setData(*i);
 174             return ret;
 175         }
 176         (*i)->unlock();
 177     }
 178
 179     return NULL;
 180 }