saml/saml2/metadata/impl/ChainingMetadataProvider.cpp

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