#include <xmltooling/AbstractDOMCachingXMLObject.h>\r
#include <xmltooling/AttributeExtensibleXMLObject.h>\r
\r
-using namespace xercesc;\r
-\r
#if defined (_MSC_VER)\r
#pragma warning( push )\r
#pragma warning( disable : 4250 4251 )\r
throw UnmarshallingException("Unable to locate builder for cloned element.");\r
}\r
try {\r
- auto_ptr<XMLObject> objCopy(b->buildObject(domCopy));\r
- objCopy->unmarshall(domCopy, true); // bind document\r
- return objCopy.release();\r
+ return b->buildFromElement(domCopy,true); // bind document\r
}\r
catch (...) {\r
domCopy->getOwnerDocument()->release();\r
#include <xmltooling/AbstractDOMCachingXMLObject.h>\r
#include <xmltooling/ElementProxy.h>\r
\r
-using namespace xercesc;\r
-\r
#if defined (_MSC_VER)\r
#pragma warning( push )\r
#pragma warning( disable : 4250 4251 )\r
#define __xmltooling_xmlobjbuilder_h__\r
\r
#include <map>\r
-#include <xercesc/dom/DOM.hpp>\r
#include <xmltooling/QName.h>\r
#include <xmltooling/XMLObject.h>\r
\r
-using namespace xercesc;\r
-\r
#if defined (_MSC_VER)\r
#pragma warning( push )\r
#pragma warning( disable : 4250 4251 )\r
/**\r
* Creates an empty XMLObject.\r
* \r
- * @param e a construction hint based on the eventual unmarshalling source\r
* @return the empty XMLObject\r
*/\r
- virtual XMLObject* buildObject(const DOMElement* e=NULL) const=0;\r
+ virtual XMLObject* buildObject() const=0;\r
+\r
+ /**\r
+ * Creates an unmarshalled XMLObject from a DOM Element.\r
+ * \r
+ * @param element the unmarshalling source\r
+ * @param bindDocument true iff the XMLObject should take ownership of the DOM Document\r
+ * @return the unmarshalled XMLObject\r
+ */\r
+ virtual XMLObject* buildFromElement(DOMElement* element, bool bindDocument=false) const {\r
+ std::auto_ptr<XMLObject> ret(buildObject());\r
+ ret->unmarshall(element,bindDocument);\r
+ return ret.release();\r
+ }\r
+\r
+ /**\r
+ * Creates an unmarshalled XMLObject from the root of a DOM Document.\r
+ * \r
+ * @param doc the unmarshalling source\r
+ * @param bindDocument true iff the XMLObject should take ownership of the DOM Document\r
+ * @return the unmarshalled XMLObject\r
+ */\r
+ virtual XMLObject* buildFromDocument(DOMDocument* doc, bool bindDocument=true) const {\r
+ return buildFromElement(doc->getDocumentElement(),bindDocument);\r
+ }\r
\r
/**\r
* Creates an empty XMLObject using the default build method, if a builder can be found.\r
* \r
* @param key the key used to locate a builder\r
- * @param e a construction hint based on the eventual unmarshalling source\r
* @return the empty object or NULL if no builder is available \r
*/\r
- static XMLObject* buildObject(const QName& key, const DOMElement* e=NULL) {\r
+ static XMLObject* buildOne(const QName& key) {\r
const XMLObjectBuilder* b=getBuilder(key);\r
- return b ? b->buildObject(e) : NULL;\r
+ if (b)\r
+ return b->buildObject();\r
+ b=getDefaultBuilder();\r
+ return b ? b->buildObject() : NULL;\r
+ }\r
+\r
+ /**\r
+ * Creates an unmarshalled XMLObject using the default build method, if a builder can be found.\r
+ * \r
+ * @param element the unmarshalling source\r
+ * @param bindDocument true iff the new XMLObject should take ownership of the DOM Document\r
+ * @return the unmarshalled object or NULL if no builder is available \r
+ */\r
+ static XMLObject* buildOneFromElement(DOMElement* element, bool bindDocument=false) {\r
+ const XMLObjectBuilder* b=getBuilder(element);\r
+ return b ? b->buildFromElement(element,bindDocument) : NULL;\r
}\r
\r
/**\r
* \r
* @return the default builder or NULL\r
*/\r
- static const XMLObjectBuilder* getDefaultBuilder(const DOMElement* element) {\r
+ static const XMLObjectBuilder* getDefaultBuilder() {\r
return m_default;\r
}\r
\r
class XMLTOOL_DLLLOCAL UnknownElementBuilder : public XMLObjectBuilder\r
{\r
public:\r
- XMLObject* buildObject(const DOMElement* e=NULL) const {\r
+ UnknownElementImpl* buildObject() const {\r
return new UnknownElementImpl();\r
}\r
};\r
xmltooling::NDC ndc("unmarshall");\r
#endif\r
\r
+ if (!XMLString::equals(element->getNamespaceURI(),getElementQName().getNamespaceURI()) ||\r
+ !XMLString::equals(element->getLocalName(),getElementQName().getLocalPart())) {\r
+ throw UnmarshallingException("Unrecognized element supplied to implementation for unmarshalling.");\r
+ }\r
+\r
if (XT_log.isDebugEnabled()) {\r
auto_ptr_char dname(element->getNodeName());\r
XT_log.debug("unmarshalling DOM element (%s)", dname.get());\r
}\r
\r
// Retain ownership of the unmarshalled child until it's processed by the parent.\r
- auto_ptr<XMLObject> childObject(builder->buildObject(static_cast<DOMElement*>(childNode)));\r
- childObject->unmarshall(static_cast<DOMElement*>(childNode));\r
+ auto_ptr<XMLObject> childObject(builder->buildFromElement(static_cast<DOMElement*>(childNode)));\r
processChildElement(childObject.get(), static_cast<DOMElement*>(childNode));\r
childObject.release();\r
}\r
--- /dev/null
+/*\r
+ * Copyright 2001-2006 Internet2\r
+ * \r
+ * Licensed under the Apache License, Version 2.0 (the "License");\r
+ * you may not use this file except in compliance with the License.\r
+ * You may obtain a copy of the License at\r
+ *\r
+ * http://www.apache.org/licenses/LICENSE-2.0\r
+ *\r
+ * Unless required by applicable law or agreed to in writing, software\r
+ * distributed under the License is distributed on an "AS IS" BASIS,\r
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ * See the License for the specific language governing permissions and\r
+ * limitations under the License.\r
+ */\r
+\r
+/**\r
+ * @file VerifyingContext.h\r
+ * \r
+ * Interface to signature verification process supplied by a relying party \r
+ */\r
+\r
+#if !defined(__xmltooling_verctx_h__) && !defined(XMLTOOLING_NO_XMLSEC)\r
+#define __xmltooling_verctx_h__\r
+\r
+#include <xsec/dsig/DSIGSignature.hpp>\r
+\r
+namespace xmltooling {\r
+\r
+ /**\r
+ * Interface to signature verification process supplied by a relying party\r
+ */\r
+ class XMLTOOL_API VerifyingContext\r
+ {\r
+ MAKE_NONCOPYABLE(VerifyingContext);\r
+ public:\r
+ virtual ~VerifyingContext() {}\r
+\r
+ /**\r
+ * Given a native signature, asks the context to verify the signature\r
+ * in accordance with the relying party's requirements.\r
+ * \r
+ * @param sig native signature object\r
+ * \r
+ * @throws SignatureException raised if signature is invalid\r
+ */\r
+ virtual void verifySignature(DSIGSignature* sig) const=0;\r
+ \r
+ protected:\r
+ VerifyingContext() {}\r
+ };\r
+\r
+};\r
+\r
+#endif /* __xmltooling_verctx_h__ */\r
// Getters\r
const XMLCh* getCanonicalizationMethod() const { return m_c14n ? m_c14n : DSIGConstants::s_unicodeStrURIEXC_C14N_NOC; }\r
const XMLCh* getSignatureAlgorithm() const { return m_sm ? m_sm : DSIGConstants::s_unicodeStrURIRSA_SHA1; }\r
- DSIGKeyInfoList* getKeyInfo() const;\r
\r
// Setters\r
void setCanonicalizationMethod(const XMLCh* c14n) { m_c14n = prepareForAssignment(m_c14n,c14n); }\r
class XMLTOOL_DLLLOCAL XMLSecSignatureBuilder : public virtual XMLObjectBuilder\r
{\r
public:\r
- XMLObject* buildObject(const DOMElement* e=NULL) const {\r
+ XMLSecSignatureImpl* buildObject() const {\r
return new XMLSecSignatureImpl();\r
}\r
};\r
TS_ASSERT(b!=NULL);\r
\r
auto_ptr<WildcardXMLObject> wcObject(\r
- dynamic_cast<WildcardXMLObject*>(b->buildObject(doc->getDocumentElement())->unmarshall(doc->getDocumentElement(),true))\r
+ dynamic_cast<WildcardXMLObject*>(b->buildFromDocument(doc))\r
);\r
TS_ASSERT(wcObject.get()!=NULL);\r
\r
TS_TRACE("testMarshallingWithAttributes");\r
\r
auto_ptr_XMLCh expected("Firefly");\r
- auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::getBuilder(m_qname)->buildObject()));\r
+ auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::buildOne(m_qname)));\r
TS_ASSERT(sxObject.get()!=NULL);\r
sxObject->setId(expected.get());\r
\r
TS_TRACE("testMarshallingWithElementContent");\r
\r
auto_ptr_XMLCh expected("Sample Content");\r
- auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::getBuilder(m_qname)->buildObject()));\r
+ auto_ptr<SimpleXMLObject> sxObject(dynamic_cast<SimpleXMLObject*>(XMLObjectBuilder::buildOne(m_qname)));\r
TS_ASSERT(sxObject.get()!=NULL);\r
sxObject->setValue(expected.get());\r
\r
kids[1]->setValue(bar.get());\r
\r
// Append a Signature.\r
- Signature* sig=dynamic_cast<Signature*>(XMLObjectBuilder::buildObject(QName(XMLConstants::XMLSIG_NS,Signature::LOCAL_NAME)));\r
+ Signature* sig=dynamic_cast<Signature*>(XMLObjectBuilder::buildOne(QName(XMLConstants::XMLSIG_NS,Signature::LOCAL_NAME)));\r
sxObject->setSignature(sig);\r
\r
// Signing context for the whole document.\r
\r
istringstream in(buf);\r
DOMDocument* doc=nonvalidatingPool->parse(in);\r
- auto_ptr<SimpleXMLObject> sxObject2(dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true)));\r
+ auto_ptr<SimpleXMLObject> sxObject2(dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc)));\r
TS_ASSERT(sxObject2.get()!=NULL);\r
TS_ASSERT(sxObject2->getSignature()!=NULL);\r
\r
TS_ASSERT(b!=NULL);\r
\r
auto_ptr<SimpleXMLObject> sxObject(\r
- dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true))\r
+ dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc))\r
);\r
TS_ASSERT(sxObject.get()!=NULL);\r
\r
TS_ASSERT(b!=NULL);\r
\r
auto_ptr<SimpleXMLObject> sxObject(\r
- dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true))\r
+ dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc))\r
);\r
TS_ASSERT(sxObject.get()!=NULL);\r
\r
TS_ASSERT(b!=NULL);\r
\r
auto_ptr<SimpleXMLObject> sxObject(\r
- dynamic_cast<SimpleXMLObject*>(b->buildObject()->unmarshall(doc->getDocumentElement(),true))\r
+ dynamic_cast<SimpleXMLObject*>(b->buildFromDocument(doc))\r
);\r
TS_ASSERT(sxObject.get()!=NULL);\r
\r
const XMLObjectBuilder* b = XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
TS_ASSERT(b!=NULL);\r
\r
- auto_ptr<XMLObject> sxObject(b->buildObject());\r
- TS_ASSERT_THROWS(sxObject->unmarshall(doc->getDocumentElement(),true),UnmarshallingException);\r
+ TS_ASSERT_THROWS(b->buildFromDocument(doc),UnmarshallingException);\r
doc->release();\r
}\r
};\r
class SimpleXMLObjectBuilder : public XMLObjectBuilder
{
public:
- SimpleXMLObject* buildObject(const DOMElement* e=NULL) const {
+ SimpleXMLObject* buildObject() const {
return new SimpleXMLObject();
}
};
class WildcardXMLObjectBuilder : public XMLObjectBuilder
{
public:
- WildcardXMLObject* buildObject(const DOMElement* e=NULL) const {
- return new WildcardXMLObject(e->getNamespaceURI(),e->getLocalName(),e->getPrefix());
+ WildcardXMLObject* buildObject() const {
+ throw XMLObjectException("Default build operation is unsupported.");
+ }
+
+ WildcardXMLObject* buildObject(const QName& q) const {
+ return new WildcardXMLObject(q.getNamespaceURI(),q.getLocalPart(),q.getPrefix());
+ }
+
+ WildcardXMLObject* buildFromElement(DOMElement* e, bool bindDocument=false) const {
+ auto_ptr<WildcardXMLObject> ret(new WildcardXMLObject(e->getNamespaceURI(),e->getLocalName(),e->getPrefix()));
+ ret->unmarshall(e,bindDocument);
+ return ret.release();
}
};
const XMLObjectBuilder* b=XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
TS_ASSERT(b!=NULL);\r
\r
- auto_ptr<XMLObject> xmlObject(b->buildObject(doc->getDocumentElement())->unmarshall(doc->getDocumentElement(),true)); // bind document\r
+ auto_ptr<XMLObject> xmlObject(b->buildFromDocument(doc)); // bind document\r
TS_ASSERT(xmlObject.get()!=NULL);\r
\r
auto_ptr<XMLObject> clonedObject(xmlObject->clone());\r
const XMLObjectBuilder* b=XMLObjectBuilder::getBuilder(doc->getDocumentElement());\r
TS_ASSERT(b!=NULL);\r
\r
- auto_ptr<XMLObject> xmlObject(b->buildObject(doc->getDocumentElement())->unmarshall(doc->getDocumentElement(),true)); // bind document\r
+ auto_ptr<XMLObject> xmlObject(b->buildFromDocument(doc)); // bind document\r
TS_ASSERT(xmlObject.get()!=NULL);\r
\r
DOMDocument* newDoc=nonvalidatingPool->newDocument();\r