2 * Copyright 2010 Internet2
\r
4 * Licensed under the Apache License, Version 2.0 (the "License");
\r
5 * you may not use this file except in compliance with the License.
\r
6 * You may obtain a copy of the License at
\r
8 * http://www.apache.org/licenses/LICENSE-2.0
\r
10 * Unless required by applicable law or agreed to in writing, software
\r
11 * distributed under the License is distributed on an "AS IS" BASIS,
\r
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
13 * See the License for the specific language governing permissions and
\r
14 * limitations under the License.
\r
18 * XMLProtocolProvider.cpp
\r
20 * XML-based protocol provider.
\r
23 #include "internal.h"
\r
24 #include "exceptions.h"
\r
25 #include "binding/ProtocolProvider.h"
\r
26 #include "util/DOMPropertySet.h"
\r
27 #include "util/SPConstants.h"
\r
30 #include <xmltooling/io/HTTPResponse.h>
\r
31 #include <xmltooling/util/NDC.h>
\r
32 #include <xmltooling/util/ReloadableXMLFile.h>
\r
33 #include <xmltooling/util/Threads.h>
\r
34 #include <xmltooling/util/XMLHelper.h>
\r
35 #include <xercesc/util/XMLUniDefs.hpp>
\r
37 using shibspconstants::SHIB2SPPROTOCOLS_NS;
\r
38 using namespace shibsp;
\r
39 using namespace xmltooling;
\r
40 using namespace std;
\r
44 static const XMLCh _id[] = UNICODE_LITERAL_2(i,d);
\r
45 static const XMLCh Binding[] = UNICODE_LITERAL_7(B,i,n,d,i,n,g);
\r
46 static const XMLCh Initiator[] = UNICODE_LITERAL_9(I,n,i,t,i,a,t,o,r);
\r
47 static const XMLCh Protocol[] = UNICODE_LITERAL_8(P,r,o,t,o,c,o,l);
\r
48 static const XMLCh Protocols[] = UNICODE_LITERAL_9(P,r,o,t,o,c,o,l,s);
\r
49 static const XMLCh Service[] = UNICODE_LITERAL_7(S,e,r,v,i,c,e);
\r
51 #if defined (_MSC_VER)
\r
52 #pragma warning( push )
\r
53 #pragma warning( disable : 4250 )
\r
56 class SHIBSP_DLLLOCAL XMLProtocolProviderImpl : public DOMNodeFilter, DOMPropertySet
\r
59 XMLProtocolProviderImpl(const DOMElement* e, Category& log);
\r
60 ~XMLProtocolProviderImpl() {
\r
61 for (protmap_t::iterator i = m_map.begin(); i != m_map.end(); ++i) {
\r
62 delete i->second.first;
\r
63 for_each(i->second.second.begin(), i->second.second.end(), xmltooling::cleanup<PropertySet>());
\r
66 m_document->release();
\r
69 void setDocument(DOMDocument* doc) {
\r
73 #ifdef SHIBSP_XERCESC_SHORT_ACCEPTNODE
\r
78 acceptNode(const DOMNode* node) const {
\r
79 return FILTER_REJECT;
\r
83 DOMDocument* m_document;
\r
84 // Map of protocol/service pair to an Initiator propset plus an array of Binding propsets.
\r
85 typedef map< pair<string,string>, pair< PropertySet*,vector<const PropertySet*> > > protmap_t;
\r
88 friend class SHIBSP_DLLLOCAL XMLProtocolProvider;
\r
91 class XMLProtocolProvider : public ProtocolProvider, public ReloadableXMLFile
\r
94 XMLProtocolProvider(const DOMElement* e)
\r
95 : ReloadableXMLFile(e, Category::getInstance(SHIBSP_LOGCAT".ProtocolProvider.XML")), m_impl(nullptr) {
\r
96 background_load(); // guarantees an exception or the policy is loaded
\r
99 ~XMLProtocolProvider() {
\r
104 const PropertySet* getInitiator(const char* protocol, const char* service) const {
\r
105 XMLProtocolProviderImpl::protmap_t::const_iterator i = m_impl->m_map.find(pair<string,string>(protocol,service));
\r
106 return (i != m_impl->m_map.end()) ? i->second.first : nullptr;
\r
109 const vector<const PropertySet*>& getBindings(const char* protocol, const char* service) const {
\r
110 XMLProtocolProviderImpl::protmap_t::const_iterator i = m_impl->m_map.find(pair<string,string>(protocol,service));
\r
111 return (i != m_impl->m_map.end()) ? i->second.second : m_noBindings;
\r
115 pair<bool,DOMElement*> load(bool backup);
\r
116 pair<bool,DOMElement*> background_load();
\r
119 static vector<const PropertySet*> m_noBindings;
\r
120 XMLProtocolProviderImpl* m_impl;
\r
123 #if defined (_MSC_VER)
\r
124 #pragma warning( pop )
\r
127 ProtocolProvider* SHIBSP_DLLLOCAL XMLProtocolProviderFactory(const DOMElement* const & e)
\r
129 return new XMLProtocolProvider(e);
\r
133 void SHIBSP_API shibsp::registerProtocolProviders()
\r
135 SPConfig::getConfig().ProtocolProviderManager.registerFactory(XML_PROTOCOL_PROVIDER, XMLProtocolProviderFactory);
\r
138 ProtocolProvider::ProtocolProvider()
\r
142 ProtocolProvider::~ProtocolProvider()
\r
146 vector<const PropertySet*> XMLProtocolProvider::m_noBindings;
\r
148 XMLProtocolProviderImpl::XMLProtocolProviderImpl(const DOMElement* e, Category& log) : m_document(nullptr)
\r
151 xmltooling::NDC ndc("XMLProtocolProviderImpl");
\r
153 //typedef map< pair<string,string>, pair< PropertySet*,vector<const PropertySet*> > > protmap_t;
\r
155 if (!XMLHelper::isNodeNamed(e, SHIB2SPPROTOCOLS_NS, Protocols))
\r
156 throw ConfigurationException("XML ProtocolProvider requires prot:Protocols at root of configuration.");
\r
158 e = XMLHelper::getFirstChildElement(e, SHIB2SPPROTOCOLS_NS, Protocol);
\r
160 string id = XMLHelper::getAttrString(e, nullptr, _id);
\r
162 const DOMElement* svc = XMLHelper::getFirstChildElement(e, SHIB2SPPROTOCOLS_NS, Service);
\r
164 string svcid = XMLHelper::getAttrString(svc, nullptr, _id);
\r
165 if (!svcid.empty() && m_map.count(make_pair(id,svcid)) == 0) {
\r
166 pair< PropertySet*,vector<const PropertySet*> >& entry = m_map[make_pair(id,svcid)];
\r
167 // Wrap the Initiator in a propset, if any.
\r
168 const DOMElement* child = XMLHelper::getFirstChildElement(svc, SHIB2SPPROTOCOLS_NS, Initiator);
\r
170 DOMPropertySet* initprop = new DOMPropertySet();
\r
171 entry.first = initprop;
\r
172 initprop->load(child, nullptr, this);
\r
175 entry.first = nullptr;
\r
178 // Walk the Bindings.
\r
179 child = XMLHelper::getFirstChildElement(svc, SHIB2SPPROTOCOLS_NS, Binding);
\r
181 DOMPropertySet* bindprop = new DOMPropertySet();
\r
182 entry.second.push_back(bindprop);
\r
183 bindprop->load(child, nullptr, this);
\r
184 child = XMLHelper::getNextSiblingElement(child, SHIB2SPPROTOCOLS_NS, Binding);
\r
187 svc = XMLHelper::getNextSiblingElement(svc, SHIB2SPPROTOCOLS_NS, Service);
\r
190 e = XMLHelper::getNextSiblingElement(e, SHIB2SPPROTOCOLS_NS, Protocol);
\r
195 pair<bool,DOMElement*> XMLProtocolProvider::load(bool backup)
\r
197 // Load from source using base class.
\r
198 pair<bool,DOMElement*> raw = ReloadableXMLFile::load(backup);
\r
200 // If we own it, wrap it.
\r
201 XercesJanitor<DOMDocument> docjanitor(raw.first ? raw.second->getOwnerDocument() : nullptr);
\r
203 XMLProtocolProviderImpl* impl = new XMLProtocolProviderImpl(raw.second, m_log);
\r
205 // If we held the document, transfer it to the impl. If we didn't, it's a no-op.
\r
206 impl->setDocument(docjanitor.release());
\r
208 // Perform the swap inside a lock.
\r
211 SharedLock locker(m_lock, false);
\r
216 return make_pair(false,(DOMElement*)nullptr);
\r
219 pair<bool,DOMElement*> XMLProtocolProvider::background_load()
\r
222 return load(false);
\r
225 if (ex == HTTPResponse::XMLTOOLING_HTTP_STATUS_NOTMODIFIED)
\r
226 m_log.info("remote resource (%s) unchanged", m_source.c_str());
\r
227 if (!m_loaded && !m_backing.empty())
\r
231 catch (exception&) {
\r
232 if (!m_loaded && !m_backing.empty())
\r