saml/saml2/metadata/impl/ChainingMetadataProvider.cpp

   1 /*
   2  *  Copyright 2001-2010 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 "saml/binding/SAMLArtifact.h"
  26 #include "saml2/metadata/Metadata.h"
  27 #include "saml2/metadata/DiscoverableMetadataProvider.h"
  28 #include "saml2/metadata/ObservableMetadataProvider.h"
  29 #include "saml2/metadata/MetadataCredentialCriteria.h"
  30
  31 #include <memory>
  32 #include <xercesc/util/XMLUniDefs.hpp>
  33 #include <xmltooling/logging.h>
  34 #include <xmltooling/util/Threads.h>
  35 #include <xmltooling/util/XMLHelper.h>
  36
  37
  38 using namespace opensaml::saml2md;
  39 using namespace opensaml;
  40 using namespace xmlsignature;
  41 using namespace xmltooling::logging;
  42 using namespace xmltooling;
  43 using namespace std;
  44
  45 namespace opensaml {
  46     namespace saml2md {
  47
  48         // per-thread structure allocated to track locks and role->provider mappings
  49         struct SAML_DLLLOCAL tracker_t;
  50
  51         class SAML_DLLLOCAL ChainingMetadataProvider
  52             : public DiscoverableMetadataProvider, public ObservableMetadataProvider, public ObservableMetadataProvider::Observer {
  53         public:
  54             ChainingMetadataProvider(const xercesc::DOMElement* e=nullptr);
  55             virtual ~ChainingMetadataProvider();
  56
  57             using MetadataProvider::getEntityDescriptor;
  58             using MetadataProvider::getEntitiesDescriptor;
  59
  60             Lockable* lock();
  61             void unlock();
  62             void init();
  63             const XMLObject* getMetadata() const;
  64             const EntitiesDescriptor* getEntitiesDescriptor(const char* name, bool requireValidMetadata=true) const;
  65             pair<const EntityDescriptor*,const RoleDescriptor*> getEntityDescriptor(const Criteria& criteria) const;
  66
  67             const Credential* resolve(const CredentialCriteria* criteria=nullptr) const;
  68             vector<const Credential*>::size_type resolve(vector<const Credential*>& results, const CredentialCriteria* criteria=nullptr) const;
  69
  70             string getCacheTag() const {
  71                 Lock lock(m_trackerLock);
  72                 return m_feedTag;
  73             }
  74
  75             ostream& outputFeed(ostream& os) const {
  76                 os << "[\n";
  77                 // Lock each provider in turn and suck in its feed.
  78                 for (vector<MetadataProvider*>::const_iterator m = m_providers.begin(); m != m_providers.end(); ++m) {
  79                     DiscoverableMetadataProvider* d = dynamic_cast<DiscoverableMetadataProvider*>(*m);
  80                     if (d) {
  81                         Locker locker(d);
  82                         d->outputFeed(os);
  83                     }
  84                 }
  85                 os << "]\n";
  86                 return os;
  87             }
  88
  89             void onEvent(const ObservableMetadataProvider& provider) const {
  90                 // Reset the cache tag for the feed.
  91                 Lock lock(m_trackerLock);
  92                 SAMLConfig::getConfig().generateRandomBytes(m_feedTag, 4);
  93                 m_feedTag = SAMLArtifact::toHex(m_feedTag);
  94                 emitChangeEvent();
  95             }
  96
  97         protected:
  98             void generateFeed() {
  99                 // No-op.
 100             }
 101
 102         private:
 103             bool m_firstMatch;
 104             mutable Mutex* m_trackerLock;
 105             ThreadKey* m_tlsKey;
 106             vector<MetadataProvider*> m_providers;
 107             mutable set<tracker_t*> m_trackers;
 108             static void tracker_cleanup(void*);
 109             Category& m_log;
 110             friend struct tracker_t;
 111         };
 112
 113         struct SAML_DLLLOCAL tracker_t {
 114             tracker_t(const ChainingMetadataProvider* m) : m_metadata(m) {
 115                 Lock lock(m_metadata->m_trackerLock);
 116                 m_metadata->m_trackers.insert(this);
 117             }
 118
 119             void lock_if(MetadataProvider* m) {
 120                 if (m_locked.count(m) == 0)
 121                     m->lock();
 122             }
 123
 124             void unlock_if(MetadataProvider* m) {
 125                 if (m_locked.count(m) == 0)
 126                     m->unlock();
 127             }
 128
 129             void remember(MetadataProvider* m, const EntityDescriptor* entity=nullptr) {
 130                 m_locked.insert(m);
 131                 if (entity)
 132                     m_objectMap.insert(pair<const XMLObject*,const MetadataProvider*>(entity,m));
 133             }
 134
 135             const MetadataProvider* getProvider(const RoleDescriptor& role) {
 136                 map<const XMLObject*,const MetadataProvider*>::const_iterator i = m_objectMap.find(role.getParent());
 137                 return (i != m_objectMap.end()) ? i->second : nullptr;
 138             }
 139
 140             const ChainingMetadataProvider* m_metadata;
 141             set<MetadataProvider*> m_locked;
 142             map<const XMLObject*,const MetadataProvider*> m_objectMap;
 143         };
 144
 145         MetadataProvider* SAML_DLLLOCAL ChainingMetadataProviderFactory(const DOMElement* const & e)
 146         {
 147             return new ChainingMetadataProvider(e);
 148         }
 149
 150         static const XMLCh _MetadataProvider[] =    UNICODE_LITERAL_16(M,e,t,a,d,a,t,a,P,r,o,v,i,d,e,r);
 151         static const XMLCh precedence[] =           UNICODE_LITERAL_10(p,r,e,c,e,d,e,n,c,e);
 152         static const XMLCh last[] =                 UNICODE_LITERAL_4(l,a,s,t);
 153         static const XMLCh _type[] =                 UNICODE_LITERAL_4(t,y,p,e);
 154     };
 155 };
 156
 157 void ChainingMetadataProvider::tracker_cleanup(void* ptr)
 158 {
 159     if (ptr) {
 160         // free the tracker after removing it from the parent plugin's tracker set
 161         tracker_t* t = reinterpret_cast<tracker_t*>(ptr);
 162         Lock lock(t->m_metadata->m_trackerLock);
 163         t->m_metadata->m_trackers.erase(t);
 164         delete t;
 165     }
 166 }
 167
 168 ChainingMetadataProvider::ChainingMetadataProvider(const DOMElement* e)
 169     : ObservableMetadataProvider(e), m_firstMatch(true), m_trackerLock(nullptr), m_tlsKey(nullptr),
 170         m_log(Category::getInstance(SAML_LOGCAT".Metadata.Chaining"))
 171 {
 172     if (XMLString::equals(e ? e->getAttributeNS(nullptr, precedence) : nullptr, last))
 173         m_firstMatch = false;
 174
 175     e = XMLHelper::getFirstChildElement(e, _MetadataProvider);
 176     while (e) {
 177         string t = XMLHelper::getAttrString(e, nullptr, _type);
 178         if (!t.empty()) {
 179             try {
 180                 m_log.info("building MetadataProvider of type %s", t.c_str());
 181                 auto_ptr<MetadataProvider> provider(SAMLConfig::getConfig().MetadataProviderManager.newPlugin(t.c_str(), e));
 182                 ObservableMetadataProvider* obs = dynamic_cast<ObservableMetadataProvider*>(provider.get());
 183                 if (obs)
 184                     obs->addObserver(this);
 185                 m_providers.push_back(provider.get());
 186                 provider.release();
 187             }
 188             catch (exception& ex) {
 189                 m_log.error("error building MetadataProvider: %s", ex.what());
 190             }
 191         }
 192         e = XMLHelper::getNextSiblingElement(e, _MetadataProvider);
 193     }
 194     m_trackerLock = Mutex::create();
 195     m_tlsKey = ThreadKey::create(tracker_cleanup);
 196 }
 197
 198 ChainingMetadataProvider::~ChainingMetadataProvider()
 199 {
 200     delete m_tlsKey;
 201     delete m_trackerLock;
 202     for_each(m_trackers.begin(), m_trackers.end(), xmltooling::cleanup<tracker_t>());
 203     for_each(m_providers.begin(), m_providers.end(), xmltooling::cleanup<MetadataProvider>());
 204 }
 205
 206 void ChainingMetadataProvider::init()
 207 {
 208     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 209         try {
 210             (*i)->init();
 211         }
 212         catch (exception& ex) {
 213             m_log.crit("failure initializing MetadataProvider: %s", ex.what());
 214         }
 215     }
 216
 217     // Set an initial cache tag for the state of the plugins.
 218     SAMLConfig::getConfig().generateRandomBytes(m_feedTag, 4);
 219     m_feedTag = SAMLArtifact::toHex(m_feedTag);
 220 }
 221
 222 Lockable* ChainingMetadataProvider::lock()
 223 {
 224     return this;   // we're not lockable ourselves...
 225 }
 226
 227 void ChainingMetadataProvider::unlock()
 228 {
 229     // Check for locked providers and remove role mappings.
 230     void* ptr=m_tlsKey->getData();
 231     if (ptr) {
 232         tracker_t* t = reinterpret_cast<tracker_t*>(ptr);
 233         for_each(t->m_locked.begin(), t->m_locked.end(), mem_fun<void,Lockable>(&Lockable::unlock));
 234         t->m_locked.clear();
 235         t->m_objectMap.clear();
 236     }
 237 }
 238
 239 const XMLObject* ChainingMetadataProvider::getMetadata() const
 240 {
 241     throw MetadataException("getMetadata operation not implemented on this provider.");
 242 }
 243
 244 const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const
 245 {
 246     // Ensure we have a tracker to use.
 247     tracker_t* tracker = nullptr;
 248     void* ptr=m_tlsKey->getData();
 249     if (ptr) {
 250         tracker = reinterpret_cast<tracker_t*>(ptr);
 251     }
 252     else {
 253         tracker = new tracker_t(this);
 254         m_tlsKey->setData(tracker);
 255     }
 256
 257     MetadataProvider* held = nullptr;
 258     const EntitiesDescriptor* ret = nullptr;
 259     const EntitiesDescriptor* cur = nullptr;
 260     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 261         tracker->lock_if(*i);
 262         if (cur=(*i)->getEntitiesDescriptor(name,requireValidMetadata)) {
 263             // Are we using a first match policy?
 264             if (m_firstMatch) {
 265                 // Save locked provider.
 266                 tracker->remember(*i);
 267                 return cur;
 268             }
 269
 270             // Using last match wins. Did we already have one?
 271             if (held) {
 272                 m_log.warn("found duplicate EntitiesDescriptor (%s), using last matching copy", name);
 273                 tracker->unlock_if(held);
 274             }
 275
 276             // Save off the latest match.
 277             held = *i;
 278             ret = cur;
 279         }
 280         else {
 281             // No match, so just unlock this one and move on.
 282             tracker->unlock_if(*i);
 283         }
 284     }
 285
 286     // Preserve any lock we're holding.
 287     if (held)
 288         tracker->remember(held);
 289     return ret;
 290 }
 291
 292 pair<const EntityDescriptor*,const RoleDescriptor*> ChainingMetadataProvider::getEntityDescriptor(const Criteria& criteria) const
 293 {
 294     // Ensure we have a tracker to use.
 295     tracker_t* tracker = nullptr;
 296     void* ptr=m_tlsKey->getData();
 297     if (ptr) {
 298         tracker = reinterpret_cast<tracker_t*>(ptr);
 299     }
 300     else {
 301         tracker = new tracker_t(this);
 302         m_tlsKey->setData(tracker);
 303     }
 304
 305     // Do a search.
 306     MetadataProvider* held = nullptr;
 307     pair<const EntityDescriptor*,const RoleDescriptor*> ret = pair<const EntityDescriptor*,const RoleDescriptor*>(nullptr,nullptr);
 308     pair<const EntityDescriptor*,const RoleDescriptor*> cur = ret;
 309     for (vector<MetadataProvider*>::const_iterator i=m_providers.begin(); i!=m_providers.end(); ++i) {
 310         tracker->lock_if(*i);
 311         cur = (*i)->getEntityDescriptor(criteria);
 312         if (cur.first) {
 313             if (criteria.role) {
 314                 // We want a role also. Did we find one?
 315                 if (cur.second) {
 316                     // Are we using a first match policy?
 317                     if (m_firstMatch) {
 318                         // We could have an entity-only match from earlier, so unlock it.
 319                         if (held)
 320                             tracker->unlock_if(held);
 321                         // Save locked provider and role mapping.
 322                         tracker->remember(*i, cur.first);
 323                         return cur;
 324                     }
 325
 326                     // Using last match wins. Did we already have one?
 327                     if (held) {
 328                         if (ret.second) {
 329                             // We had a "complete" match, so log it.
 330                             if (criteria.entityID_ascii) {
 331                                 m_log.warn("found duplicate EntityDescriptor (%s) with role (%s), using last matching copy",
 332                                     criteria.entityID_ascii, criteria.role->toString().c_str());
 333                             }
 334                             else if (criteria.entityID_unicode) {
 335                                 auto_ptr_char temp(criteria.entityID_unicode);
 336                                 m_log.warn("found duplicate EntityDescriptor (%s) with role (%s), using last matching copy",
 337                                     temp.get(), criteria.role->toString().c_str());
 338                             }
 339                             else if (criteria.artifact) {
 340                                 m_log.warn("found duplicate EntityDescriptor for artifact source (%s) with role (%s), using last matching copy",
 341                                     criteria.artifact->getSource().c_str(), criteria.role->toString().c_str());
 342                             }
 343                         }
 344                         tracker->unlock_if(held);
 345                     }
 346
 347                     // Save off the latest match.
 348                     held = *i;
 349                     ret = cur;
 350                 }
 351                 else {
 352                     // We didn't find the role, so we're going to keep looking,
 353                     // but save this one if we didn't have the role yet.
 354                     if (ret.second) {
 355                         // We already had a role, so let's stick with that.
 356                         tracker->unlock_if(*i);
 357                     }
 358                     else {
 359                         // This is at least as good, so toss anything we had and keep it.
 360                         if (held)
 361                             tracker->unlock_if(held);
 362                         held = *i;
 363                         ret = cur;
 364                     }
 365                 }
 366             }
 367             else {
 368                 // Are we using a first match policy?
 369                 if (m_firstMatch) {
 370                     // I don't think this can happen, but who cares, check anyway.
 371                     if (held)
 372                         tracker->unlock_if(held);
 373
 374                     // Save locked provider.
 375                     tracker->remember(*i, cur.first);
 376                     return cur;
 377                 }
 378
 379                 // Using last match wins. Did we already have one?
 380                 if (held) {
 381                     if (criteria.entityID_ascii) {
 382                         m_log.warn("found duplicate EntityDescriptor (%s), using last matching copy", criteria.entityID_ascii);
 383                     }
 384                     else if (criteria.entityID_unicode) {
 385                         auto_ptr_char temp(criteria.entityID_unicode);
 386                         m_log.warn("found duplicate EntityDescriptor (%s), using last matching copy", temp.get());
 387                     }
 388                     else if (criteria.artifact) {
 389                         m_log.warn("found duplicate EntityDescriptor for artifact source (%s), using last matching copy",
 390                             criteria.artifact->getSource().c_str());
 391                     }
 392                     tracker->unlock_if(held);
 393                 }
 394
 395                 // Save off the latest match.
 396                 held = *i;
 397                 ret = cur;
 398             }
 399         }
 400         else {
 401             // No match, so just unlock this one and move on.
 402             tracker->unlock_if(*i);
 403         }
 404     }
 405
 406     // Preserve any lock we're holding.
 407     if (held)
 408         tracker->remember(held, ret.first);
 409     return ret;
 410 }
 411
 412 const Credential* ChainingMetadataProvider::resolve(const CredentialCriteria* criteria) const
 413 {
 414     void* ptr=m_tlsKey->getData();
 415     if (!ptr)
 416         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 417     tracker_t* tracker=reinterpret_cast<tracker_t*>(ptr);
 418
 419     const MetadataCredentialCriteria* mcc = dynamic_cast<const MetadataCredentialCriteria*>(criteria);
 420     if (!mcc)
 421         throw MetadataException("Cannot resolve credentials without a MetadataCredentialCriteria object.");
 422     const MetadataProvider* m = tracker->getProvider(mcc->getRole());
 423     if (!m)
 424         throw MetadataException("No record of corresponding MetadataProvider, where did the role object come from?");
 425     return m->resolve(mcc);
 426 }
 427
 428 vector<const Credential*>::size_type ChainingMetadataProvider::resolve(
 429     vector<const Credential*>& results, const CredentialCriteria* criteria
 430     ) const
 431 {
 432     void* ptr=m_tlsKey->getData();
 433     if (!ptr)
 434         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 435     tracker_t* tracker=reinterpret_cast<tracker_t*>(ptr);
 436
 437     const MetadataCredentialCriteria* mcc = dynamic_cast<const MetadataCredentialCriteria*>(criteria);
 438     if (!mcc)
 439         throw MetadataException("Cannot resolve credentials without a MetadataCredentialCriteria object.");
 440     const MetadataProvider* m = tracker->getProvider(mcc->getRole());
 441     if (!m)
 442         throw MetadataException("No record of corresponding MetadataProvider, where did the role object come from?");
 443     return m->resolve(results, mcc);
 444 }