saml/saml2/metadata/impl/XMLMetadataProvider.cpp

   1 /*
   2  *  Copyright 2001-2010 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * XMLMetadataProvider.cpp
  19  *
  20  * Supplies metadata from an XML file
  21  */
  22
  23 #include "internal.h"
  24 #include "binding/SAMLArtifact.h"
  25 #include "saml2/metadata/Metadata.h"
  26 #include "saml2/metadata/MetadataFilter.h"
  27 #include "saml2/metadata/AbstractMetadataProvider.h"
  28 #include "saml2/metadata/DiscoverableMetadataProvider.h"
  29
  30 #include <fstream>
  31 #include <xmltooling/XMLToolingConfig.h>
  32 #include <xmltooling/io/HTTPResponse.h>
  33 #include <xmltooling/util/NDC.h>
  34 #include <xmltooling/util/PathResolver.h>
  35 #include <xmltooling/util/ReloadableXMLFile.h>
  36 #include <xmltooling/util/Threads.h>
  37 #include <xmltooling/validation/ValidatorSuite.h>
  38
  39 #if defined(OPENSAML_LOG4SHIB)
  40 # include <log4shib/NDC.hh>
  41 #elif defined(OPENSAML_LOG4CPP)
  42 # include <log4cpp/NDC.hh>
  43 #endif
  44
  45 using namespace opensaml::saml2md;
  46 using namespace xmltooling::logging;
  47 using namespace xmltooling;
  48 using namespace std;
  49
  50 #if defined (_MSC_VER)
  51     #pragma warning( push )
  52     #pragma warning( disable : 4250 )
  53 #endif
  54
  55 namespace opensaml {
  56     namespace saml2md {
  57
  58         class SAML_DLLLOCAL XMLMetadataProvider
  59             : public AbstractMetadataProvider, public DiscoverableMetadataProvider, public ReloadableXMLFile
  60         {
  61         public:
  62             XMLMetadataProvider(const DOMElement* e);
  63
  64             virtual ~XMLMetadataProvider() {
  65                 shutdown();
  66                 delete m_object;
  67             }
  68
  69             void init() {
  70                 try {
  71                     if (!m_id.empty()) {
  72                         string threadid("[");
  73                         threadid += m_id + ']';
  74                         logging::NDC::push(threadid);
  75                     }
  76                     background_load();
  77                     startup();
  78                 }
  79                 catch (...) {
  80                     startup();
  81                     if (!m_id.empty()) {
  82                         logging::NDC::pop();
  83                     }
  84                     throw;
  85                 }
  86
  87                 if (!m_id.empty()) {
  88                     logging::NDC::pop();
  89                 }
  90             }
  91
  92             const XMLObject* getMetadata() const {
  93                 return m_object;
  94             }
  95
  96         protected:
  97             pair<bool,DOMElement*> load(bool backup);
  98             pair<bool,DOMElement*> background_load();
  99
 100         private:
 101             using AbstractMetadataProvider::index;
 102             void index(time_t& validUntil);
 103             time_t computeNextRefresh();
 104
 105             XMLObject* m_object;
 106             bool m_discoveryFeed;
 107             double m_refreshDelayFactor;
 108             unsigned int m_backoffFactor;
 109             time_t m_minRefreshDelay,m_maxRefreshDelay,m_lastValidUntil;
 110         };
 111
 112         MetadataProvider* SAML_DLLLOCAL XMLMetadataProviderFactory(const DOMElement* const & e)
 113         {
 114             return new XMLMetadataProvider(e);
 115         }
 116
 117         static const XMLCh discoveryFeed[] =        UNICODE_LITERAL_13(d,i,s,c,o,v,e,r,y,F,e,e,d);
 118         static const XMLCh minRefreshDelay[] =      UNICODE_LITERAL_15(m,i,n,R,e,f,r,e,s,h,D,e,l,a,y);
 119         static const XMLCh refreshDelayFactor[] =   UNICODE_LITERAL_18(r,e,f,r,e,s,h,D,e,l,a,y,F,a,c,t,o,r);
 120     };
 121 };
 122
 123 #if defined (_MSC_VER)
 124     #pragma warning( pop )
 125 #endif
 126
 127 XMLMetadataProvider::XMLMetadataProvider(const DOMElement* e)
 128     : MetadataProvider(e), AbstractMetadataProvider(e), DiscoverableMetadataProvider(e),
 129         ReloadableXMLFile(e, Category::getInstance(SAML_LOGCAT".MetadataProvider.XML"), false),
 130         m_object(nullptr), m_discoveryFeed(XMLHelper::getAttrBool(e, true, discoveryFeed)),
 131         m_refreshDelayFactor(0.75), m_backoffFactor(1),
 132         m_minRefreshDelay(XMLHelper::getAttrInt(e, 600, minRefreshDelay)),
 133         m_maxRefreshDelay(m_reloadInterval), m_lastValidUntil(SAMLTIME_MAX)
 134 {
 135     if (!m_local && m_maxRefreshDelay) {
 136         const XMLCh* setting = e->getAttributeNS(nullptr, refreshDelayFactor);
 137         if (setting && *setting) {
 138             auto_ptr_char delay(setting);
 139             m_refreshDelayFactor = atof(delay.get());
 140             if (m_refreshDelayFactor <= 0.0 || m_refreshDelayFactor >= 1.0) {
 141                 m_log.error("invalid refreshDelayFactor setting, using default");
 142                 m_refreshDelayFactor = 0.75;
 143             }
 144         }
 145
 146         if (m_minRefreshDelay > m_maxRefreshDelay) {
 147             m_log.warn("minRefreshDelay setting exceeds maxRefreshDelay/reloadInterval setting, lowering to match it");
 148             m_minRefreshDelay = m_maxRefreshDelay;
 149         }
 150     }
 151 }
 152
 153 pair<bool,DOMElement*> XMLMetadataProvider::load(bool backup)
 154 {
 155     if (!backup) {
 156         // Lower the refresh rate in case of an error.
 157         m_reloadInterval = m_minRefreshDelay;
 158     }
 159
 160     // Call the base class to load/parse the appropriate XML resource.
 161     pair<bool,DOMElement*> raw = ReloadableXMLFile::load(backup);
 162
 163     // If we own it, wrap it for now.
 164     XercesJanitor<DOMDocument> docjanitor(raw.first ? raw.second->getOwnerDocument() : nullptr);
 165
 166     // Unmarshall objects, binding the document.
 167     auto_ptr<XMLObject> xmlObject(XMLObjectBuilder::buildOneFromElement(raw.second, true));
 168     docjanitor.release();
 169
 170     if (!dynamic_cast<const EntitiesDescriptor*>(xmlObject.get()) && !dynamic_cast<const EntityDescriptor*>(xmlObject.get()))
 171         throw MetadataException(
 172             "Root of metadata instance not recognized: $1", params(1,xmlObject->getElementQName().toString().c_str())
 173             );
 174
 175     // Preprocess the metadata (even if we schema-validated).
 176     try {
 177         SchemaValidators.validate(xmlObject.get());
 178     }
 179     catch (exception& ex) {
 180         m_log.error("metadata intance failed manual validation checking: %s", ex.what());
 181         throw MetadataException("Metadata instance failed manual validation checking.");
 182     }
 183
 184     // This is the best place to take a backup, since it's superficially "correct" metadata.
 185     string backupKey;
 186     if (!backup && !m_backing.empty()) {
 187         // We compute a random filename extension to the "real" location.
 188         SAMLConfig::getConfig().generateRandomBytes(backupKey, 2);
 189         backupKey = m_backing + '.' + SAMLArtifact::toHex(backupKey);
 190         m_log.debug("backing up remote metadata resource to (%s)", backupKey.c_str());
 191         try {
 192             ofstream backer(backupKey.c_str());
 193             backer << *(raw.second->getOwnerDocument());
 194         }
 195         catch (exception& ex) {
 196             m_log.crit("exception while backing up metadata: %s", ex.what());
 197             backupKey.erase();
 198         }
 199     }
 200
 201     try {
 202         doFilters(*xmlObject.get());
 203     }
 204     catch (exception&) {
 205         if (!backupKey.empty())
 206             remove(backupKey.c_str());
 207         throw;
 208     }
 209
 210     if (!backupKey.empty()) {
 211         m_log.debug("committing backup file to permanent location (%s)", m_backing.c_str());
 212         Locker locker(getBackupLock());
 213         remove(m_backing.c_str());
 214         if (rename(backupKey.c_str(), m_backing.c_str()) != 0)
 215             m_log.crit("unable to rename metadata backup file");
 216         preserveCacheTag();
 217     }
 218
 219     xmlObject->releaseThisAndChildrenDOM();
 220     xmlObject->setDocument(nullptr);
 221
 222     // Swap it in after acquiring write lock if necessary.
 223     if (m_lock)
 224         m_lock->wrlock();
 225     SharedLock locker(m_lock, false);
 226     bool changed = m_object!=nullptr;
 227     delete m_object;
 228     m_object = xmlObject.release();
 229     m_lastValidUntil = SAMLTIME_MAX;
 230     index(m_lastValidUntil);
 231     if (m_discoveryFeed)
 232         generateFeed();
 233     if (changed)
 234         emitChangeEvent();
 235
 236     // Tracking cacheUntil through the tree is TBD, but
 237     // validUntil is the tightest interval amongst the children.
 238
 239     // If a remote resource that's monitored, adjust the reload interval.
 240     if (!backup && !m_local && m_lock) {
 241         m_backoffFactor = 1;
 242         m_reloadInterval = computeNextRefresh();
 243         m_log.info("adjusted reload interval to %d seconds", m_reloadInterval);
 244     }
 245
 246     m_loaded = true;
 247     return make_pair(false,(DOMElement*)nullptr);
 248 }
 249
 250 pair<bool,DOMElement*> XMLMetadataProvider::background_load()
 251 {
 252     try {
 253         return load(false);
 254     }
 255     catch (long& ex) {
 256         if (ex == HTTPResponse::XMLTOOLING_HTTP_STATUS_NOTMODIFIED) {
 257             // Unchanged document, so re-establish previous refresh interval.
 258             m_reloadInterval = computeNextRefresh();
 259             m_log.info("remote resource (%s) unchanged, adjusted reload interval to %u seconds", m_source.c_str(), m_reloadInterval);
 260         }
 261         else {
 262             // Any other status code, just treat as an error.
 263             m_reloadInterval = m_minRefreshDelay * m_backoffFactor++;
 264             if (m_reloadInterval > m_maxRefreshDelay)
 265                 m_reloadInterval = m_maxRefreshDelay;
 266             m_log.warn("adjusted reload interval to %u seconds", m_reloadInterval);
 267         }
 268         if (!m_loaded && !m_backing.empty())
 269             return load(true);
 270         throw;
 271     }
 272     catch (exception&) {
 273         if (!m_local) {
 274             m_reloadInterval = m_minRefreshDelay * m_backoffFactor++;
 275             if (m_reloadInterval > m_maxRefreshDelay)
 276                 m_reloadInterval = m_maxRefreshDelay;
 277             m_log.warn("adjusted reload interval to %u seconds", m_reloadInterval);
 278             if (!m_loaded && !m_backing.empty())
 279                 return load(true);
 280         }
 281         throw;
 282     }
 283 }
 284
 285 time_t XMLMetadataProvider::computeNextRefresh()
 286 {
 287     time_t now = time(nullptr);
 288
 289     // If some or all of the metadata is already expired, reload after the minimum.
 290     if (m_lastValidUntil < now) {
 291         return m_minRefreshDelay;
 292     }
 293     else {
 294         // Compute the smaller of the validUntil / cacheDuration constraints.
 295         time_t ret = m_lastValidUntil - now;
 296         const CacheableSAMLObject* cacheable = dynamic_cast<const CacheableSAMLObject*>(m_object);
 297         if (cacheable && cacheable->getCacheDuration())
 298             ret = min(ret, cacheable->getCacheDurationEpoch());
 299
 300         // Adjust for the delay factor.
 301         ret *= m_refreshDelayFactor;
 302
 303         // Bound by max and min.
 304         if (ret > m_maxRefreshDelay)
 305             return m_maxRefreshDelay;
 306         else if (ret < m_minRefreshDelay)
 307             return m_minRefreshDelay;
 308
 309         return ret;
 310     }
 311 }
 312
 313 void XMLMetadataProvider::index(time_t& validUntil)
 314 {
 315     clearDescriptorIndex();
 316     EntitiesDescriptor* group=dynamic_cast<EntitiesDescriptor*>(m_object);
 317     if (group) {
 318         indexGroup(group, validUntil);
 319         return;
 320     }
 321     indexEntity(dynamic_cast<EntityDescriptor*>(m_object), validUntil);
 322 }