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