saml/saml2/metadata/impl/ChainingMetadataProvider.cpp

   1 /*\r
   2  *  Copyright 2001-2005 Internet2\r
   3  * \r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  *\r
   8  *     http://www.apache.org/licenses/LICENSE-2.0\r
   9  *\r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 /**\r
  18  * ChainingMetadataProvider.cpp\r
  19  * \r
  20  * MetadataProvider that uses multiple providers in sequence.\r
  21  */\r
  22 \r
  23 #include "internal.h"\r
  24 #include "exceptions.h"\r
  25 #include "saml2/metadata/ChainingMetadataProvider.h"\r
  26 \r
  27 #include <xmltooling/util/XMLHelper.h>\r
  28 #include <xercesc/util/XMLUniDefs.hpp>\r
  29 \r
  30 using namespace opensaml::saml2md;\r
  31 using namespace opensaml;\r
  32 using namespace xmlsignature;\r
  33 using namespace xmltooling;\r
  34 using namespace std;\r
  35 \r
  36 namespace opensaml {\r
  37     namespace saml2md {\r
  38         MetadataProvider* SAML_DLLLOCAL ChainingMetadataProviderFactory(const DOMElement* const & e)\r
  39         {\r
  40             return new ChainingMetadataProvider(e);\r
  41         }\r
  42     };\r
  43 };\r
  44 \r
  45 static const XMLCh GenericMetadataProvider[] =      UNICODE_LITERAL_16(M,e,t,a,d,a,t,a,P,r,o,v,i,d,e,r);\r
  46 static const XMLCh type[] =                         UNICODE_LITERAL_4(t,y,p,e);\r
  47 \r
  48 ChainingMetadataProvider::ChainingMetadataProvider(const DOMElement* e) : ObservableMetadataProvider(e), m_tlsKey(NULL)\r
  49 {\r
  50     try {\r
  51         e = e ? xmltooling::XMLHelper::getFirstChildElement(e, GenericMetadataProvider) : NULL;\r
  52         while (e) {\r
  53             auto_ptr_char temp(e->getAttributeNS(NULL,type));\r
  54             if (temp.get()) {\r
  55                 auto_ptr<MetadataProvider> provider(\r
  56                     SAMLConfig::getConfig().MetadataProviderManager.newPlugin(temp.get(), e)\r
  57                     );\r
  58                 ObservableMetadataProvider* obs = dynamic_cast<ObservableMetadataProvider*>(provider.get());\r
  59                 if (obs)\r
  60                     obs->addObserver(this);\r
  61                 m_providers.push_back(provider.get());\r
  62                 provider.release();\r
  63             }\r
  64             e = XMLHelper::getNextSiblingElement(e, GenericMetadataProvider);\r
  65         }\r
  66     }\r
  67     catch (XMLToolingException&) {\r
  68         for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());\r
  69         throw;\r
  70     }\r
  71     m_tlsKey = ThreadKey::create(NULL);\r
  72 }\r
  73 \r
  74 ChainingMetadataProvider::~ChainingMetadataProvider()\r
  75 {\r
  76     delete m_tlsKey;\r
  77     for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());\r
  78 }\r
  79 \r
  80 void ChainingMetadataProvider::onEvent(MetadataProvider& provider)\r
  81 {\r
  82     emitChangeEvent();\r
  83 }\r
  84 \r
  85 void ChainingMetadataProvider::init()\r
  86 {\r
  87     for_each(m_providers.begin(), m_providers.end(), mem_fun<void,MetadataProvider>(&MetadataProvider::init));\r
  88 }\r
  89 \r
  90 Lockable* ChainingMetadataProvider::lock()\r
  91 {\r
  92     return this;   // we're not lockable ourselves...\r
  93 }\r
  94 \r
  95 void ChainingMetadataProvider::unlock()\r
  96 {\r
  97     // Check for a locked provider.\r
  98     void* ptr=m_tlsKey->getData();\r
  99     if (ptr) {\r
 100         m_tlsKey->setData(NULL);\r
 101         reinterpret_cast<MetadataProvider*>(ptr)->unlock();\r
 102     }\r
 103 }\r
 104 \r
 105 const KeyResolver* ChainingMetadataProvider::getKeyResolver() const\r
 106 {\r
 107     // Check for a locked provider.\r
 108     void* ptr=m_tlsKey->getData();\r
 109     return ptr ? reinterpret_cast<MetadataProvider*>(ptr)->getKeyResolver() : NULL;\r
 110     \r
 111 }\r
 112 \r
 113 const XMLObject* ChainingMetadataProvider::getMetadata() const\r
 114 {\r
 115     throw XMLToolingException("getMetadata operation not implemented on this provider.");\r
 116 }\r
 117 \r
 118 const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const\r
 119 {\r
 120     // Clear any existing lock.\r
 121     const_cast<ChainingMetadataProvider*>(this)->unlock();\r
 122 \r
 123     // Do a search.\r
 124     const EntitiesDescriptor* ret=NULL;\r
 125     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {\r
 126         (*i)->lock();\r
 127         if (ret=(*i)->getEntitiesDescriptor(name,requireValidMetadata)) {\r
 128             // Save locked provider.\r
 129             m_tlsKey->setData(*i);\r
 130             return ret;\r
 131         }\r
 132         (*i)->unlock();\r
 133     }\r
 134 \r
 135     return NULL;\r
 136 }\r
 137 \r
 138 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const char* id, bool requireValidMetadata) const\r
 139 {\r
 140     // Clear any existing lock.\r
 141     const_cast<ChainingMetadataProvider*>(this)->unlock();\r
 142 \r
 143     // Do a search.\r
 144     const EntityDescriptor* ret=NULL;\r
 145     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {\r
 146         (*i)->lock();\r
 147         if (ret=(*i)->getEntityDescriptor(id,requireValidMetadata)) {\r
 148             // Save locked provider.\r
 149             m_tlsKey->setData(*i);\r
 150             return ret;\r
 151         }\r
 152         (*i)->unlock();\r
 153     }\r
 154 \r
 155     return NULL;\r
 156 }\r
 157 \r
 158 const EntityDescriptor* ChainingMetadataProvider::getEntityDescriptor(const SAMLArtifact* artifact) const\r
 159 {\r
 160     // Clear any existing lock.\r
 161     const_cast<ChainingMetadataProvider*>(this)->unlock();\r
 162 \r
 163     // Do a search.\r
 164     const EntityDescriptor* ret=NULL;\r
 165     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {\r
 166         (*i)->lock();\r
 167         if (ret=(*i)->getEntityDescriptor(artifact)) {\r
 168             // Save locked provider.\r
 169             m_tlsKey->setData(*i);\r
 170             return ret;\r
 171         }\r
 172         (*i)->unlock();\r
 173     }\r
 174 \r
 175     return NULL;\r
 176 }\r