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     m_tlsKey.reset();   // need to free this ahead of trackers in a command line case
 213     for_each(m_trackers.begin(), m_trackers.end(), xmltooling::cleanup<tracker_t>());
 214 }
 215
 216 void ChainingMetadataProvider::setContext(const MetadataFilterContext* ctx)
 217 {
 218     for_each(m_providers.begin(), m_providers.end(), boost::bind(&MetadataProvider::setContext, _1, ctx));
 219 }
 220
 221 void ChainingMetadataProvider::init()
 222 {
 223     for (ptr_vector<MetadataProvider>::iterator i = m_providers.begin(); i != m_providers.end(); ++i) {
 224         try {
 225             i->init();
 226         }
 227         catch (std::exception& ex) {
 228             m_log.crit("failure initializing MetadataProvider: %s", ex.what());
 229         }
 230     }
 231
 232     // Set an initial cache tag for the state of the plugins.
 233     SAMLConfig::getConfig().generateRandomBytes(m_feedTag, 4);
 234     m_feedTag = SAMLArtifact::toHex(m_feedTag);
 235 }
 236
 237 void ChainingMetadataProvider::outputStatus(ostream& os) const
 238 {
 239     for_each(m_providers.begin(), m_providers.end(), boost::bind(&MetadataProvider::outputStatus, _1, boost::ref(os)));
 240 }
 241
 242 Lockable* ChainingMetadataProvider::lock()
 243 {
 244     return this;   // we're not lockable ourselves...
 245 }
 246
 247 void ChainingMetadataProvider::unlock()
 248 {
 249     // Check for locked providers and remove role mappings.
 250     void* ptr=m_tlsKey->getData();
 251     if (ptr) {
 252         tracker_t* t = reinterpret_cast<tracker_t*>(ptr);
 253         for_each(t->m_locked.begin(), t->m_locked.end(), mem_fun(&Lockable::unlock));
 254         t->m_locked.clear();
 255         t->m_objectMap.clear();
 256     }
 257 }
 258
 259 const XMLObject* ChainingMetadataProvider::getMetadata() const
 260 {
 261     throw MetadataException("getMetadata operation not implemented on this provider.");
 262 }
 263
 264 const EntitiesDescriptor* ChainingMetadataProvider::getEntitiesDescriptor(const char* name, bool requireValidMetadata) const
 265 {
 266     // Ensure we have a tracker to use.
 267     tracker_t* tracker = nullptr;
 268     void* ptr=m_tlsKey->getData();
 269     if (ptr) {
 270         tracker = reinterpret_cast<tracker_t*>(ptr);
 271     }
 272     else {
 273         tracker = new tracker_t(this);
 274         m_tlsKey->setData(tracker);
 275     }
 276
 277     MetadataProvider* held = nullptr;
 278     const EntitiesDescriptor* ret = nullptr;
 279     const EntitiesDescriptor* cur = nullptr;
 280     for (ptr_vector<MetadataProvider>::iterator i = m_providers.begin(); i != m_providers.end(); ++i) {
 281         tracker->lock_if(&(*i));
 282         if ((cur = i->getEntitiesDescriptor(name,requireValidMetadata))) {
 283             // Are we using a first match policy?
 284             if (m_firstMatch) {
 285                 // Save locked provider.
 286                 tracker->remember(&(*i));
 287                 return cur;
 288             }
 289
 290             // Using last match wins. Did we already have one?
 291             if (held) {
 292                 m_log.warn("found duplicate EntitiesDescriptor (%s), using last matching copy", name);
 293                 tracker->unlock_if(held);
 294             }
 295
 296             // Save off the latest match.
 297             held = &(*i);
 298             ret = cur;
 299         }
 300         else {
 301             // No match, so just unlock this one and move on.
 302             tracker->unlock_if(&(*i));
 303         }
 304     }
 305
 306     // Preserve any lock we're holding.
 307     if (held)
 308         tracker->remember(held);
 309     return ret;
 310 }
 311
 312 pair<const EntityDescriptor*,const RoleDescriptor*> ChainingMetadataProvider::getEntityDescriptor(const Criteria& criteria) const
 313 {
 314     // Ensure we have a tracker to use.
 315     tracker_t* tracker = nullptr;
 316     void* ptr=m_tlsKey->getData();
 317     if (ptr) {
 318         tracker = reinterpret_cast<tracker_t*>(ptr);
 319     }
 320     else {
 321         tracker = new tracker_t(this);
 322         m_tlsKey->setData(tracker);
 323     }
 324
 325     // Do a search.
 326     MetadataProvider* held = nullptr;
 327     pair<const EntityDescriptor*,const RoleDescriptor*> ret = pair<const EntityDescriptor*,const RoleDescriptor*>(nullptr,nullptr);
 328     pair<const EntityDescriptor*,const RoleDescriptor*> cur = ret;
 329     for (ptr_vector<MetadataProvider>::iterator i = m_providers.begin(); i != m_providers.end(); ++i) {
 330         tracker->lock_if(&(*i));
 331         cur = i->getEntityDescriptor(criteria);
 332         if (cur.first) {
 333             if (criteria.role) {
 334                 // We want a role also. Did we find one?
 335                 if (cur.second) {
 336                     // Are we using a first match policy?
 337                     if (m_firstMatch) {
 338                         // We could have an entity-only match from earlier, so unlock it.
 339                         if (held)
 340                             tracker->unlock_if(held);
 341                         // Save locked provider and role mapping.
 342                         tracker->remember(&(*i), cur.first);
 343                         return cur;
 344                     }
 345
 346                     // Using last match wins. Did we already have one?
 347                     if (held) {
 348                         if (ret.second) {
 349                             // We had a "complete" match, so log it.
 350                             if (criteria.entityID_ascii) {
 351                                 m_log.warn("found duplicate EntityDescriptor (%s) with role (%s), using last matching copy",
 352                                     criteria.entityID_ascii, criteria.role->toString().c_str());
 353                             }
 354                             else if (criteria.entityID_unicode) {
 355                                 auto_ptr_char temp(criteria.entityID_unicode);
 356                                 m_log.warn("found duplicate EntityDescriptor (%s) with role (%s), using last matching copy",
 357                                     temp.get(), criteria.role->toString().c_str());
 358                             }
 359                             else if (criteria.artifact) {
 360                                 m_log.warn("found duplicate EntityDescriptor for artifact source (%s) with role (%s), using last matching copy",
 361                                     criteria.artifact->getSource().c_str(), criteria.role->toString().c_str());
 362                             }
 363                         }
 364                         tracker->unlock_if(held);
 365                     }
 366
 367                     // Save off the latest match.
 368                     held = &(*i);
 369                     ret = cur;
 370                 }
 371                 else {
 372                     // We didn't find the role, so we're going to keep looking,
 373                     // but save this one if we didn't have the role yet.
 374                     if (ret.second) {
 375                         // We already had a role, so let's stick with that.
 376                         tracker->unlock_if(&(*i));
 377                     }
 378                     else {
 379                         // This is at least as good, so toss anything we had and keep it.
 380                         if (held)
 381                             tracker->unlock_if(held);
 382                         held = &(*i);
 383                         ret = cur;
 384                     }
 385                 }
 386             }
 387             else {
 388                 // Are we using a first match policy?
 389                 if (m_firstMatch) {
 390                     // I don't think this can happen, but who cares, check anyway.
 391                     if (held)
 392                         tracker->unlock_if(held);
 393
 394                     // Save locked provider.
 395                     tracker->remember(&(*i), cur.first);
 396                     return cur;
 397                 }
 398
 399                 // Using last match wins. Did we already have one?
 400                 if (held) {
 401                     if (criteria.entityID_ascii) {
 402                         m_log.warn("found duplicate EntityDescriptor (%s), using last matching copy", criteria.entityID_ascii);
 403                     }
 404                     else if (criteria.entityID_unicode) {
 405                         auto_ptr_char temp(criteria.entityID_unicode);
 406                         m_log.warn("found duplicate EntityDescriptor (%s), using last matching copy", temp.get());
 407                     }
 408                     else if (criteria.artifact) {
 409                         m_log.warn("found duplicate EntityDescriptor for artifact source (%s), using last matching copy",
 410                             criteria.artifact->getSource().c_str());
 411                     }
 412                     tracker->unlock_if(held);
 413                 }
 414
 415                 // Save off the latest match.
 416                 held = &(*i);
 417                 ret = cur;
 418             }
 419         }
 420         else {
 421             // No match, so just unlock this one and move on.
 422             tracker->unlock_if(&(*i));
 423         }
 424     }
 425
 426     // Preserve any lock we're holding.
 427     if (held)
 428         tracker->remember(held, ret.first);
 429     return ret;
 430 }
 431
 432 const Credential* ChainingMetadataProvider::resolve(const CredentialCriteria* criteria) const
 433 {
 434     void* ptr=m_tlsKey->getData();
 435     if (!ptr)
 436         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 437     tracker_t* tracker=reinterpret_cast<tracker_t*>(ptr);
 438
 439     const MetadataCredentialCriteria* mcc = dynamic_cast<const MetadataCredentialCriteria*>(criteria);
 440     if (!mcc)
 441         throw MetadataException("Cannot resolve credentials without a MetadataCredentialCriteria object.");
 442     const MetadataProvider* m = tracker->getProvider(mcc->getRole());
 443     if (!m)
 444         throw MetadataException("No record of corresponding MetadataProvider, where did the role object come from?");
 445     return m->resolve(mcc);
 446 }
 447
 448 vector<const Credential*>::size_type ChainingMetadataProvider::resolve(
 449     vector<const Credential*>& results, const CredentialCriteria* criteria
 450     ) const
 451 {
 452     void* ptr=m_tlsKey->getData();
 453     if (!ptr)
 454         throw MetadataException("No locked MetadataProvider, where did the role object come from?");
 455     tracker_t* tracker=reinterpret_cast<tracker_t*>(ptr);
 456
 457     const MetadataCredentialCriteria* mcc = dynamic_cast<const MetadataCredentialCriteria*>(criteria);
 458     if (!mcc)
 459         throw MetadataException("Cannot resolve credentials without a MetadataCredentialCriteria object.");
 460     const MetadataProvider* m = tracker->getProvider(mcc->getRole());
 461     if (!m)
 462         throw MetadataException("No record of corresponding MetadataProvider, where did the role object come from?");
 463     return m->resolve(results, mcc);
 464 }