using namespace opensaml::saml2md;
using namespace xmltooling::logging;
using namespace xmltooling;
+using namespace boost;
using namespace std;
#if defined (_MSC_VER)
virtual ~XMLMetadataProvider() {
shutdown();
- delete m_object;
}
- void init() {
- try {
- if (!m_id.empty()) {
- string threadid("[");
- threadid += m_id + ']';
- logging::NDC::push(threadid);
- }
- background_load();
- startup();
- }
- catch (...) {
- startup();
- if (!m_id.empty()) {
- logging::NDC::pop();
- }
- throw;
- }
-
- if (!m_id.empty()) {
- logging::NDC::pop();
- }
- }
+ void init();
const char* getId() const {
return m_id.c_str();
}
- void outputStatus(ostream& os) const {
- os << "<MetadataProvider";
-
- if (getId() && *getId()) {
- os << " id='" << getId() << "'";
- }
-
- if (!m_source.empty()) {
- os << " source='" << m_source << "'";
- }
-
- if (m_lastUpdate > 0) {
- DateTime ts(m_lastUpdate);
- ts.parseDateTime();
- auto_ptr_char timestamp(ts.getFormattedString());
- os << " lastUpdate='" << timestamp.get() << "'";
- }
-
- if (!m_local && m_reloadInterval > 0) {
- os << " reloadInterval='" << m_reloadInterval << "'";
- }
-
- os << "/>";
- }
+ void outputStatus(ostream& os) const;
const XMLObject* getMetadata() const {
- return m_object;
+ return m_object.get();
}
protected:
void index(time_t& validUntil);
time_t computeNextRefresh();
- XMLObject* m_object;
- bool m_discoveryFeed;
+ scoped_ptr<XMLObject> m_object;
+ bool m_discoveryFeed,m_dropDOM;
double m_refreshDelayFactor;
unsigned int m_backoffFactor;
time_t m_minRefreshDelay,m_maxRefreshDelay,m_lastValidUntil;
}
static const XMLCh discoveryFeed[] = UNICODE_LITERAL_13(d,i,s,c,o,v,e,r,y,F,e,e,d);
+ static const XMLCh dropDOM[] = UNICODE_LITERAL_7(d,r,o,p,D,O,M);
static const XMLCh minRefreshDelay[] = UNICODE_LITERAL_15(m,i,n,R,e,f,r,e,s,h,D,e,l,a,y);
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);
+
+ // TODO: need to move this into xmltooling as a utility function
+ static void xml_encode(ostream& os, const char* start)
+ {
+ size_t pos;
+ while (start && *start) {
+ pos = strcspn(start, "\"<>&");
+ if (pos > 0) {
+ os.write(start,pos);
+ start += pos;
+ }
+ else {
+ switch (*start) {
+ case '"': os << """; break;
+ case '<': os << "<"; break;
+ case '>': os << ">"; break;
+ case '&': os << "&"; break;
+ default: os << *start;
+ }
+ start++;
+ }
+ }
+ }
};
};
XMLMetadataProvider::XMLMetadataProvider(const DOMElement* e)
: MetadataProvider(e), AbstractMetadataProvider(e), DiscoverableMetadataProvider(e),
- ReloadableXMLFile(e, Category::getInstance(SAML_LOGCAT".MetadataProvider.XML"), false),
- m_object(nullptr), m_discoveryFeed(XMLHelper::getAttrBool(e, true, discoveryFeed)),
+ ReloadableXMLFile(e, Category::getInstance(SAML_LOGCAT ".MetadataProvider.XML"), false),
+ m_discoveryFeed(XMLHelper::getAttrBool(e, true, discoveryFeed)),
+ m_dropDOM(XMLHelper::getAttrBool(e, true, dropDOM)),
m_refreshDelayFactor(0.75), m_backoffFactor(1),
m_minRefreshDelay(XMLHelper::getAttrInt(e, 600, minRefreshDelay)),
m_maxRefreshDelay(m_reloadInterval), m_lastValidUntil(SAMLTIME_MAX)
}
}
+void XMLMetadataProvider::init()
+{
+ try {
+ if (!m_id.empty()) {
+ string threadid("[");
+ threadid += m_id + ']';
+ logging::NDC::push(threadid);
+ }
+ background_load();
+ startup();
+ }
+ catch (...) {
+ startup();
+ if (!m_id.empty()) {
+ logging::NDC::pop();
+ }
+ throw;
+ }
+
+ if (!m_id.empty()) {
+ logging::NDC::pop();
+ }
+}
+
pair<bool,DOMElement*> XMLMetadataProvider::load(bool backup)
{
if (!backup) {
XercesJanitor<DOMDocument> docjanitor(raw.first ? raw.second->getOwnerDocument() : nullptr);
// Unmarshall objects, binding the document.
- auto_ptr<XMLObject> xmlObject(XMLObjectBuilder::buildOneFromElement(raw.second, true));
+ scoped_ptr<XMLObject> xmlObject(XMLObjectBuilder::buildOneFromElement(raw.second, true));
docjanitor.release();
if (!dynamic_cast<const EntitiesDescriptor*>(xmlObject.get()) && !dynamic_cast<const EntityDescriptor*>(xmlObject.get()))
try {
SchemaValidators.validate(xmlObject.get());
}
- catch (exception& ex) {
- m_log.error("metadata intance failed manual validation checking: %s", ex.what());
+ catch (std::exception& ex) {
+ m_log.error("metadata instance failed manual validation checking: %s", ex.what());
throw MetadataException("Metadata instance failed manual validation checking.");
}
+ const TimeBoundSAMLObject* validityCheck = dynamic_cast<TimeBoundSAMLObject*>(xmlObject.get());
+ if (!validityCheck || !validityCheck->isValid()) {
+ m_log.error("metadata instance was invalid at time of acquisition");
+ throw MetadataException("Metadata instance was invalid at time of acquisition.");
+ }
+
// This is the best place to take a backup, since it's superficially "correct" metadata.
string backupKey;
if (!backup && !m_backing.empty()) {
ofstream backer(backupKey.c_str());
backer << *(raw.second->getOwnerDocument());
}
- catch (exception& ex) {
+ catch (std::exception& ex) {
m_log.crit("exception while backing up metadata: %s", ex.what());
backupKey.erase();
}
}
try {
- doFilters(*xmlObject.get());
+ doFilters(*xmlObject);
}
- catch (exception&) {
+ catch (std::exception&) {
if (!backupKey.empty())
remove(backupKey.c_str());
throw;
preserveCacheTag();
}
- xmlObject->releaseThisAndChildrenDOM();
- xmlObject->setDocument(nullptr);
+ if (m_dropDOM) {
+ xmlObject->releaseThisAndChildrenDOM();
+ xmlObject->setDocument(nullptr);
+ }
// Swap it in after acquiring write lock if necessary.
if (m_lock)
m_lock->wrlock();
SharedLock locker(m_lock, false);
bool changed = m_object!=nullptr;
- delete m_object;
- m_object = xmlObject.release();
+ m_object.swap(xmlObject);
m_lastValidUntil = SAMLTIME_MAX;
index(m_lastValidUntil);
if (m_discoveryFeed)
return load(true);
throw;
}
- catch (exception&) {
+ catch (std::exception& ex) {
if (!m_local) {
m_reloadInterval = m_minRefreshDelay * m_backoffFactor++;
if (m_reloadInterval > m_maxRefreshDelay)
m_reloadInterval = m_maxRefreshDelay;
m_log.warn("adjusted reload interval to %u seconds", m_reloadInterval);
- if (!m_loaded && !m_backing.empty())
+ if (!m_loaded && !m_backing.empty()) {
+ m_log.warn("trying backup file, exception loading remote resource: %s", ex.what());
return load(true);
+ }
}
throw;
}
else {
// Compute the smaller of the validUntil / cacheDuration constraints.
time_t ret = m_lastValidUntil - now;
- const CacheableSAMLObject* cacheable = dynamic_cast<const CacheableSAMLObject*>(m_object);
+ const CacheableSAMLObject* cacheable = dynamic_cast<const CacheableSAMLObject*>(m_object.get());
if (cacheable && cacheable->getCacheDuration())
ret = min(ret, cacheable->getCacheDurationEpoch());
void XMLMetadataProvider::index(time_t& validUntil)
{
clearDescriptorIndex();
- EntitiesDescriptor* group=dynamic_cast<EntitiesDescriptor*>(m_object);
+ EntitiesDescriptor* group = dynamic_cast<EntitiesDescriptor*>(m_object.get());
if (group) {
indexGroup(group, validUntil);
return;
}
- indexEntity(dynamic_cast<EntityDescriptor*>(m_object), validUntil);
+ indexEntity(dynamic_cast<EntityDescriptor*>(m_object.get()), validUntil);
+}
+
+void XMLMetadataProvider::outputStatus(ostream& os) const
+{
+ os << "<MetadataProvider";
+
+ if (getId() && *getId()) {
+ os << " id='"; xml_encode(os, getId()); os << "'";
+ }
+
+ if (!m_source.empty()) {
+ os << " source='"; xml_encode(os, m_source.c_str()); os << "'";
+ }
+
+ if (m_lastUpdate > 0) {
+ DateTime ts(m_lastUpdate);
+ ts.parseDateTime();
+ auto_ptr_char timestamp(ts.getFormattedString());
+ os << " lastUpdate='" << timestamp.get() << "'";
+ }
+
+ if (!m_local && m_reloadInterval > 0) {
+ os << " reloadInterval='" << m_reloadInterval << "'";
+ }
+
+ os << "/>";
}
projects / shibboleth / cpp-opensaml.git / blobdiff