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