/stamp-h1
/xmltooling.spec
/.settings
+/doxyfile
#---------------------------------------------------------------------------
# Project related configuration options
#---------------------------------------------------------------------------
-PROJECT_NAME = $(PROJECT)-$(VERSION)
-PROJECT_NUMBER =
+PROJECT_NAME = $(PROJECT)
+PROJECT_NUMBER = $(VERSION)
OUTPUT_DIRECTORY = $(DOCDIR)
CREATE_SUBDIRS = NO
OUTPUT_LANGUAGE = English
*/
/**
- * @file Encrypter.h
+ * @file xmltooling/encryption/Decrypter.h
*
- * Methods for encrypting XMLObjects and other data.
+ * Wrapper API for XML Decryption functionality.
*/
#if !defined(__xmltooling_decrypter_h__) && !defined(XMLTOOLING_NO_XMLSEC)
*/
/**
- * @file Encrypter.h
+ * @file xmltooling/encryption/Encrypter.h
*
* Methods for encrypting XMLObjects and other data.
*/
#include <xmltooling/signature/KeyInfo.h>
+/**
+ * Macro for declaring encryption builders.
+ *
+ * @param cname name of class being built
+ */
#define DECL_XMLENCOBJECTBUILDER(cname) \
DECL_XMLOBJECTBUILDER(XMLTOOL_API,cname,xmlconstants::XMLENC_NS,xmlconstants::XMLENC_PREFIX)
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
+ /// @cond OFF
public:
virtual ~AnyElementImpl() {}
IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
void marshallAttributes(DOMElement* domElement) const;
- void processChildElement(XMLObject* childXMLObject, const DOMElement* root);
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* childRoot);
void processAttribute(const DOMAttr* attribute);
};
+ /// @endcond
/**
* Builder for AnyElementImpl objects.
/**
* @file AbstractXMLObjectMarshaller.h
*
- * A thread-safe abstract marshaller.
+ * A mix-in to implement object marshalling with DOM reuse.
*/
#if !defined(__xmltooling_xmlmarshaller_h__)
namespace xmltooling {
/**
- * A thread-safe abstract marshaller.
+ * A mix-in to implement object marshalling with DOM reuse.
*/
class XMLTOOL_API AbstractXMLObjectMarshaller : public virtual AbstractXMLObject
{
document->appendChild(element);
}
+#ifndef XMLTOOLING_NO_XMLSEC
/**
* Marshalls the XMLObject into the given DOM Element.
* The DOM Element must be within a DOM tree rooted in the owning Document.
*
* @param targetElement the Element into which the XMLObject is marshalled into
- * @param ctx optional marshalling context
+ * @param sigs optional array of signatures to create after marshalling
*
* @throws MarshallingException thrown if there is a problem marshalling the object
* @throws SignatureException thrown if a problem occurs during signature creation
*/
- void marshallInto(
- DOMElement* targetElement
-#ifndef XMLTOOLING_NO_XMLSEC
- ,const std::vector<xmlsignature::Signature*>* sigs
+ void marshallInto(DOMElement* targetElement, const std::vector<xmlsignature::Signature*>* sigs) const;
+#else
+ /**
+ * Marshalls the XMLObject into the given DOM Element.
+ * The DOM Element must be within a DOM tree rooted in the owning Document.
+ *
+ * @param targetElement the Element into which the XMLObject is marshalled into
+ *
+ * @throws MarshallingException thrown if there is a problem marshalling the object
+ */
+ void marshallInto(DOMElement* targetElement) const;
#endif
- ) const;
/**
* Creates an xsi:type attribute, corresponding to the given type of the XMLObject, on the DOM element.
/**
* @file AbstractXMLObjectUnmarshaller.h
*
- * A thread-safe abstract unmarshaller.
+ * A mix-in to implement object unmarshalling.
*/
#ifndef __xmltooling_xmlunmarshaller_h__
namespace xmltooling {
/**
- * A thread-safe abstract unmarshaller.
+ * A mix-in to implement object unmarshalling.
*/
class XMLTOOL_API AbstractXMLObjectUnmarshaller : public virtual AbstractXMLObject
{
class XMLTOOL_API PKIXValidationInfoIterator {
MAKE_NONCOPYABLE(PKIXValidationInfoIterator);
protected:
+ /** Reference to KeyResolver to use. */
const xmlsignature::KeyResolver& m_keyResolver;
+ /**
+ * Constructor
+ *
+ * @param keyResolver reference to KeyResolver to use
+ */
PKIXValidationInfoIterator(const xmlsignature::KeyResolver& keyResolver) : m_keyResolver(keyResolver) {}
public:
#include <xsec/utils/XSECSafeBuffer.hpp>
namespace xmltooling {
+ /**
+ * OpenSSL-based class for handling X.509 CRLs
+ */
class XMLTOOL_API OpenSSLCryptoX509CRL : public XSECCryptoX509CRL {
public:
OpenSSLCryptoX509CRL() : mp_X509CRL(NULL), m_DERX509CRL("") {}
return m_DERX509CRL;
}
+ /**
+ * Constructor
+ *
+ * @param x a native CRL object
+ */
OpenSSLCryptoX509CRL(X509_CRL* x);
- X509_CRL* getOpenSSLX509CRL(void) {
+
+ /**
+ * Returns native CRL object.
+ *
+ * @return native CRL object, or NULL
+ */
+ X509_CRL* getOpenSSLX509CRL() {
return mp_X509CRL;
}
*/
virtual XSECCryptoX509CRL* clone() const=0;
+ /**
+ * Load a Base64-encoded CRL into the object.
+ *
+ * @param buf buffer containing the base64-encoded CRL
+ * @param len number of bytes of data in the CRL buffer (0 if the string is null terminated)
+ */
virtual void loadX509CRLBase64Bin(const char* buf, unsigned int len)=0;
/**
* Load a PEM encoded CRL into the object.
*
- * Takes a PEM encoded CRL and loads it.
- *
* @param buf buffer containing the PEM encoded CRL
* @param len number of bytes of data in the CRL buffer (0 if the string is null terminated)
*/
#include <xmltooling/XMLObjectBuilder.h>
#include <xmltooling/util/XMLConstants.h>
+/**
+ * Macro for declaring signature builders.
+ *
+ * @param cname name of class being built
+ */
#define DECL_XMLSIGOBJECTBUILDER(cname) \
DECL_XMLOBJECTBUILDER(XMLTOOL_API,cname,xmlconstants::XMLSIG_NS,xmlconstants::XMLSIG_PREFIX)
xmltooling::XSECCryptoX509CRL* resolveCRL(const Signature* sig) const;
protected:
+ /** Stores an explicit key. */
XSECCryptoKey* m_key;
/**
#else
virtual xmltooling::XMLObject* buildObject() const;
#endif
+ /** Singleton builder. */
static Signature* buildSignature() {
const SignatureBuilder* b = dynamic_cast<const SignatureBuilder*>(
xmltooling::XMLObjectBuilder::getBuilder(
virtual void validate(const xmltooling::XMLObject* xmlObject) const;
+ /**
+ * Type-safe validator.
+ *
+ * @param signature object to validate
+ */
virtual void validate(const Signature* signature) const;
/**
}
protected:
+ /** Verification key. */
XSECCryptoKey* m_key;
+
+ /** KeyResolver to use against signature. */
KeyResolver* m_resolver;
};
* @param value header value to send
* @return true iff the header is successfully set
*/
- virtual bool setRequestHeader(const char* name, const char* val) const=0;
+ virtual bool setRequestHeader(const char* name, const char* value) const=0;
/**
* Returns the values of an HTTP response header.
#include <xmltooling/util/XMLConstants.h>
#include <xercesc/util/XMLUniDefs.hpp>
+/**
+ * Macro for declaring SOAP builders.
+ *
+ * @param cname name of class being built
+ */
#define DECL_SOAP11OBJECTBUILDER(cname) \
DECL_XMLOBJECTBUILDER(XMLTOOL_API,cname,xmlconstants::SOAP11ENV_NS,xmlconstants::SOAP11ENV_PREFIX)
{
MAKE_NONCOPYABLE(SOAPClient);
public:
+ /**
+ * Constructor
+ *
+ * @param validate true iff schema validation should be used
+ */
SOAPClient(bool validate=false) : m_validate(validate), m_transport(NULL) {}
+
virtual ~SOAPClient();
/**
*/
virtual bool check(const char* context, const char* s, time_t expires);
- bool check(const char* context, const XMLCh* str, time_t expires) {
- auto_ptr_char temp(str);
+ /**
+ * Returns true iff the check value is not found in the cache, and stores it.
+ *
+ * @param context a context label to subdivide the cache
+ * @param s value to check
+ * @param expires time for disposal of value from cache
+ */
+ bool check(const char* context, const XMLCh* s, time_t expires) {
+ auto_ptr_char temp(s);
return check(context, temp.get(), expires);
}
*
* @param seconds time to sleep
*/
- static void sleep(int secounds);
+ static void sleep(int seconds);
#ifndef WIN32
/**
* Masks all signals from a thread.
MAKE_NONCOPYABLE(XercesJanitor);
T* m_held;
public:
+ /**
+ * Constructor
+ *
+ * @param resource object to release when leaving scope
+ */
XercesJanitor(T* resource) : m_held(resource) {}
~XercesJanitor() {
projects / shibboleth / cpp-xmltooling.git / commitdiff