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