*/
/**
- * AssertionsImpl.cpp
+ * Assertions20Impl.cpp
*
* Implementation classes for SAML 2.0 Assertions schema
*/
#include "internal.h"
#include "exceptions.h"
+#include "saml/encryption/EncryptedKeyResolver.h"
#include "saml2/core/Assertions.h"
#include <xmltooling/AbstractChildlessElement.h>
#include <xmltooling/AbstractComplexElement.h>
#include <xmltooling/AbstractElementProxy.h>
#include <xmltooling/AbstractSimpleElement.h>
+#include <xmltooling/encryption/Decrypter.h>
#include <xmltooling/impl/AnyElement.h>
#include <xmltooling/io/AbstractXMLObjectMarshaller.h>
#include <xmltooling/io/AbstractXMLObjectUnmarshaller.h>
#include <xmltooling/util/XMLHelper.h>
-#include <xmltooling/validation/AbstractValidatingXMLObject.h>
#include <ctime>
#include <xercesc/util/XMLUniDefs.hpp>
using namespace opensaml::saml2;
using namespace opensaml;
+using namespace xmlencryption;
using namespace xmlsignature;
using namespace xmltooling;
using namespace std;
public AbstractSimpleElement,
public AbstractChildlessElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
}
NameIDTypeImpl(const NameIDTypeImpl& src)
- : AbstractXMLObject(src), AbstractSimpleElement(src),
- AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
init();
setNameQualifier(src.getNameQualifier());
setSPNameQualifier(src.getSPNameQualifier());
PROC_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,NULL);
PROC_STRING_ATTRIB(Format,FORMAT,NULL);
PROC_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
}
};
+ class SAML_DLLLOCAL EncryptedElementTypeImpl : public virtual EncryptedElementType,
+ public AbstractComplexElement,
+ public AbstractDOMCachingXMLObject,
+ public AbstractXMLObjectMarshaller,
+ public AbstractXMLObjectUnmarshaller
+ {
+ void init() {
+ m_EncryptedData=NULL;
+ m_children.push_back(NULL);
+ m_pos_EncryptedData=m_children.begin();
+ }
+
+ protected:
+ EncryptedElementTypeImpl() {
+ init();
+ }
+
+ public:
+ virtual ~EncryptedElementTypeImpl() {}
+
+ EncryptedElementTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ init();
+ }
+
+ EncryptedElementTypeImpl(const EncryptedElementTypeImpl& src)
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
+ init();
+ if (src.getEncryptedData())
+ setEncryptedData(src.getEncryptedData()->cloneEncryptedData());
+ VectorOf(EncryptedKey) v=getEncryptedKeys();
+ for (vector<EncryptedKey*>::const_iterator i=src.m_EncryptedKeys.begin(); i!=src.m_EncryptedKeys.end(); i++) {
+ if (*i) {
+ v.push_back((*i)->cloneEncryptedKey());
+ }
+ }
+ }
+
+ XMLObject* decrypt(KeyResolver* KEKresolver, const XMLCh* recipient) const
+ {
+ if (!m_EncryptedData)
+ throw DecryptionException("No encrypted data present.");
+ Decrypter decrypter(KEKresolver, new EncryptedKeyResolver(*this, recipient));
+ DOMDocumentFragment* frag = decrypter.decryptData(m_EncryptedData);
+ if (frag->hasChildNodes() && frag->getFirstChild()==frag->getLastChild()) {
+ DOMNode* plaintext=frag->getFirstChild();
+ if (plaintext->getNodeType()==DOMNode::ELEMENT_NODE) {
+ auto_ptr<XMLObject> ret(XMLObjectBuilder::buildOneFromElement(static_cast<DOMElement*>(plaintext)));
+ ret->releaseThisAndChildrenDOM();
+ return ret.release();
+ }
+ }
+ frag->release();
+ throw DecryptionException("Decryption did not result in a single element.");
+ }
+
+ IMPL_XMLOBJECT_CLONE(EncryptedElementType);
+ IMPL_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption);
+ IMPL_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,m_children.end());
+
+ protected:
+ void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
+ PROC_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption,XMLConstants::XMLENC_NS,false);
+ PROC_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,XMLConstants::XMLENC_NS,false);
+ AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
+ }
+ };
+
+ class SAML_DLLLOCAL EncryptedIDImpl : public virtual EncryptedID, public EncryptedElementTypeImpl
+ {
+ public:
+ virtual ~EncryptedIDImpl() {}
+
+ EncryptedIDImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
+
+ EncryptedIDImpl(const EncryptedIDImpl& src) : AbstractXMLObject(src), EncryptedElementTypeImpl(src) {}
+
+ IMPL_XMLOBJECT_CLONE(EncryptedID);
+ EncryptedElementType* cloneEncryptedElementType() const {
+ return new EncryptedIDImpl(*this);
+ }
+ };
+
class SAML_DLLLOCAL AudienceRestrictionImpl : public virtual AudienceRestriction,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- AudienceRestrictionImpl(const AudienceRestrictionImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ AudienceRestrictionImpl(const AudienceRestrictionImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
VectorOf(Audience) v=getAudiences();
for (vector<Audience*>::const_iterator i=src.m_Audiences.begin(); i!=src.m_Audiences.end(); i++) {
if (*i) {
class SAML_DLLLOCAL OneTimeUseImpl : public virtual OneTimeUse,
public AbstractChildlessElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- OneTimeUseImpl(const OneTimeUseImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ OneTimeUseImpl(const OneTimeUseImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
}
IMPL_XMLOBJECT_CLONE(OneTimeUse);
class SAML_DLLLOCAL ProxyRestrictionImpl : public virtual ProxyRestriction,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
public:
- virtual ~ProxyRestrictionImpl() {}
+ virtual ~ProxyRestrictionImpl() {
+ XMLString::release(&m_Count);
+ }
ProxyRestrictionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
+ m_Count=NULL;
}
- ProxyRestrictionImpl(const ProxyRestrictionImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
- setCount(src.getCount());
+ ProxyRestrictionImpl(const ProxyRestrictionImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
+ setCount(src.m_Count);
VectorOf(Audience) v=getAudiences();
for (vector<Audience*>::const_iterator i=src.m_Audiences.begin(); i!=src.m_Audiences.end(); i++) {
if (*i) {
void processAttribute(const DOMAttr* attribute) {
PROC_INTEGER_ATTRIB(Count,COUNT,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
class SAML_DLLLOCAL ConditionsImpl : public virtual Conditions,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- ConditionsImpl(const ConditionsImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ ConditionsImpl(const ConditionsImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setNotBefore(src.getNotBefore());
setNotOnOrAfter(src.getNotOnOrAfter());
}
IMPL_XMLOBJECT_CLONE(Conditions);
- IMPL_DATETIME_ATTRIB(NotBefore);
- IMPL_DATETIME_ATTRIB(NotOnOrAfter);
+ IMPL_DATETIME_ATTRIB(NotBefore,0);
+ IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
IMPL_TYPED_CHILDREN(AudienceRestriction, m_children.end());
IMPL_TYPED_CHILDREN(OneTimeUse,m_children.end());
IMPL_TYPED_CHILDREN(ProxyRestriction, m_children.end());
void processAttribute(const DOMAttr* attribute) {
PROC_DATETIME_ATTRIB(NotBefore,NOTBEFORE,NULL);
PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
- class SAML_DLLLOCAL SubjectConfirmationDataImpl
- : public virtual SubjectConfirmationData, public AnyElementImpl, public AbstractValidatingXMLObject
+ class SAML_DLLLOCAL SubjectConfirmationDataImpl : public virtual SubjectConfirmationData, public AnyElementImpl
{
void init() {
m_NotBefore=m_NotOnOrAfter=NULL;
init();
}
- SubjectConfirmationDataImpl(const SubjectConfirmationDataImpl& src)
- : AnyElementImpl(src), AbstractValidatingXMLObject(src) {
+ SubjectConfirmationDataImpl(const SubjectConfirmationDataImpl& src) : AnyElementImpl(src) {
init();
setNotBefore(src.getNotBefore());
setNotOnOrAfter(src.getNotOnOrAfter());
}
IMPL_XMLOBJECT_CLONE(SubjectConfirmationData);
- IMPL_DATETIME_ATTRIB(NotBefore);
- IMPL_DATETIME_ATTRIB(NotOnOrAfter);
+ IMPL_DATETIME_ATTRIB(NotBefore,0);
+ IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
IMPL_STRING_ATTRIB(Recipient);
IMPL_STRING_ATTRIB(InResponseTo);
IMPL_STRING_ATTRIB(Address);
public:
void setAttribute(QName& qualifiedName, const XMLCh* value) {
if (!qualifiedName.hasNamespaceURI()) {
- if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME))
+ if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME)) {
setNotBefore(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME)) {
setNotOnOrAfter(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME)) {
setRecipient(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME)) {
setInResponseTo(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME)) {
setAddress(value);
+ return;
+ }
}
AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value);
}
};
class SAML_DLLLOCAL KeyInfoConfirmationDataTypeImpl : public virtual KeyInfoConfirmationDataType,
- public AbstractDOMCachingXMLObject,
public AbstractComplexElement,
public AbstractAttributeExtensibleXMLObject,
+ public AbstractDOMCachingXMLObject,
public AbstractXMLObjectMarshaller,
- public AbstractXMLObjectUnmarshaller,
- public AbstractValidatingXMLObject
+ public AbstractXMLObjectUnmarshaller
{
void init() {
m_NotBefore=m_NotOnOrAfter=NULL;
}
KeyInfoConfirmationDataTypeImpl(const KeyInfoConfirmationDataTypeImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractAttributeExtensibleXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractAttributeExtensibleXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setNotBefore(src.getNotBefore());
setNotOnOrAfter(src.getNotOnOrAfter());
}
IMPL_XMLOBJECT_CLONE(KeyInfoConfirmationDataType);
- IMPL_DATETIME_ATTRIB(NotBefore);
- IMPL_DATETIME_ATTRIB(NotOnOrAfter);
+ IMPL_DATETIME_ATTRIB(NotBefore,0);
+ IMPL_DATETIME_ATTRIB(NotOnOrAfter,SAMLTIME_MAX);
IMPL_STRING_ATTRIB(Recipient);
IMPL_STRING_ATTRIB(InResponseTo);
IMPL_STRING_ATTRIB(Address);
public:
void setAttribute(QName& qualifiedName, const XMLCh* value) {
if (!qualifiedName.hasNamespaceURI()) {
- if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME))
+ if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME)) {
setNotBefore(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME)) {
setNotOnOrAfter(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME)) {
setRecipient(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME)) {
setInResponseTo(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME)) {
setAddress(value);
+ return;
+ }
}
AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value);
}
class SAML_DLLLOCAL SubjectConfirmationImpl : public virtual SubjectConfirmation,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
m_Method=NULL;
m_BaseID=NULL;
m_NameID=NULL;
- //m_EncryptedID=NULL;
+ m_EncryptedID=NULL;
m_SubjectConfirmationData=NULL;
m_KeyInfoConfirmationDataType=NULL;
m_children.push_back(NULL);
m_pos_BaseID=m_children.begin();
m_pos_NameID=m_pos_BaseID;
++m_pos_NameID;
- m_pos_SubjectConfirmationData=m_pos_NameID;
+ m_pos_EncryptedID=m_pos_NameID;
+ ++m_pos_EncryptedID;
+ m_pos_SubjectConfirmationData=m_pos_EncryptedID;
++m_pos_SubjectConfirmationData;
m_pos_KeyInfoConfirmationDataType=m_pos_SubjectConfirmationData;
++m_pos_KeyInfoConfirmationDataType;
init();
}
- SubjectConfirmationImpl(const SubjectConfirmationImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ SubjectConfirmationImpl(const SubjectConfirmationImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setMethod(src.getMethod());
if (src.getBaseID())
setBaseID(src.getBaseID()->cloneBaseID());
if (src.getNameID())
setNameID(src.getNameID()->cloneNameID());
- //if (src.getEncryptedID())
- //setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
+ if (src.getEncryptedID())
+ setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
if (src.getSubjectConfirmationData())
setSubjectConfirmationData(src.getSubjectConfirmationData()->clone());
if (src.getKeyInfoConfirmationDataType())
IMPL_STRING_ATTRIB(Method);
IMPL_TYPED_CHILD(BaseID);
IMPL_TYPED_CHILD(NameID);
- //IMPL_TYPED_CHILD(EncryptedID);
+ IMPL_TYPED_CHILD(EncryptedID);
IMPL_XMLOBJECT_CHILD(SubjectConfirmationData);
IMPL_TYPED_CHILD(KeyInfoConfirmationDataType);
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
PROC_TYPED_CHILD(BaseID,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILD(NameID,SAMLConstants::SAML20_NS,false);
- //PROC_TYPED_CHILD(EncryptedID,SAMLConstants::SAML20_NS,false);
+ PROC_TYPED_CHILD(EncryptedID,SAMLConstants::SAML20_NS,false);
PROC_XMLOBJECT_CHILD(SubjectConfirmationData,SAMLConstants::SAML20_NS);
PROC_TYPED_CHILD(KeyInfoConfirmationDataType,SAMLConstants::SAML20_NS,false);
AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
void processAttribute(const DOMAttr* attribute) {
PROC_STRING_ATTRIB(Method,METHOD,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
class SAML_DLLLOCAL SubjectImpl : public virtual Subject,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
m_pos_BaseID=m_children.begin();
m_pos_NameID=m_pos_BaseID;
++m_pos_NameID;
- //m_pos_EncryptedID=m_pos_NameID;
- //++m_pos_EncryptedID;
+ m_pos_EncryptedID=m_pos_NameID;
+ ++m_pos_EncryptedID;
}
public:
virtual ~SubjectImpl() {}
init();
}
- SubjectImpl(const SubjectImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ SubjectImpl(const SubjectImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getBaseID())
setBaseID(src.getBaseID()->cloneBaseID());
if (src.getNameID())
setNameID(src.getNameID()->cloneNameID());
- //if (src.getEncryptedID())
- //setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
+ if (src.getEncryptedID())
+ setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
VectorOf(SubjectConfirmation) v=getSubjectConfirmations();
for (vector<SubjectConfirmation*>::const_iterator i=src.m_SubjectConfirmations.begin(); i!=src.m_SubjectConfirmations.end(); i++) {
if (*i) {
IMPL_XMLOBJECT_CLONE(Subject);
IMPL_TYPED_CHILD(NameID);
IMPL_TYPED_CHILD(BaseID);
- //IMPL_TYPED_CHILD(EncryptedID);
+ IMPL_TYPED_CHILD(EncryptedID);
IMPL_TYPED_CHILDREN(SubjectConfirmation,m_children.end());
protected:
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
PROC_TYPED_CHILD(BaseID,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILD(NameID,SAMLConstants::SAML20_NS,false);
- //PROC_TYPED_CHILD(EncryptedID,SAMLConstants::SAML20_NS,false);
+ PROC_TYPED_CHILD(EncryptedID,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILDREN(SubjectConfirmation,SAMLConstants::SAML20_NS,false);
AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
}
class SAML_DLLLOCAL SubjectLocalityImpl : public virtual SubjectLocality,
public AbstractChildlessElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- SubjectLocalityImpl(const SubjectLocalityImpl& src)
- : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) {
+ SubjectLocalityImpl(const SubjectLocalityImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setAddress(src.getAddress());
setDNSName(src.getDNSName());
void processAttribute(const DOMAttr* attribute) {
PROC_STRING_ATTRIB(Address,ADDRESS,NULL);
PROC_STRING_ATTRIB(DNSName,DNSNAME,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
- class SAML_DLLLOCAL AuthnContextDeclImpl
- : public virtual AuthnContextDecl, public AnyElementImpl, public AbstractValidatingXMLObject
+ class SAML_DLLLOCAL AuthnContextDeclImpl : public virtual AuthnContextDecl, public AnyElementImpl
{
public:
virtual ~AuthnContextDeclImpl() {}
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- AuthnContextDeclImpl(const AuthnContextDeclImpl& src) : AnyElementImpl(src), AbstractValidatingXMLObject(src) {}
+ AuthnContextDeclImpl(const AuthnContextDeclImpl& src) : AnyElementImpl(src) {
+ }
IMPL_XMLOBJECT_CLONE(AuthnContextDecl);
};
class SAML_DLLLOCAL AuthnContextImpl : public virtual AuthnContext,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- AuthnContextImpl(const AuthnContextImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ AuthnContextImpl(const AuthnContextImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
if (src.getAuthnContextClassRef())
setAuthnContextClassRef(src.getAuthnContextClassRef()->cloneAuthnContextClassRef());
class SAML_DLLLOCAL AuthnStatementImpl : public virtual AuthnStatement,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
init();
}
- AuthnStatementImpl(const AuthnStatementImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ AuthnStatementImpl(const AuthnStatementImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setAuthnInstant(src.getAuthnInstant());
setSessionIndex(src.getSessionIndex());
Statement* cloneStatement() const {
return cloneAuthnStatement();
}
- IMPL_DATETIME_ATTRIB(AuthnInstant);
+ IMPL_DATETIME_ATTRIB(AuthnInstant,0);
IMPL_STRING_ATTRIB(SessionIndex);
- IMPL_DATETIME_ATTRIB(SessionNotOnOrAfter);
+ IMPL_DATETIME_ATTRIB(SessionNotOnOrAfter,SAMLTIME_MAX);
IMPL_TYPED_CHILD(SubjectLocality);
IMPL_TYPED_CHILD(AuthnContext);
PROC_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT,NULL);
PROC_STRING_ATTRIB(SessionIndex,SESSIONINDEX,NULL);
PROC_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
public AbstractSimpleElement,
public AbstractChildlessElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Namespace(NULL) {
}
- ActionImpl(const ActionImpl& src) : AbstractXMLObject(src),
- AbstractSimpleElement(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ ActionImpl(const ActionImpl& src)
+ : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src) {
setNamespace(src.getNamespace());
}
void processAttribute(const DOMAttr* attribute) {
PROC_STRING_ATTRIB(Namespace,NAMESPACE,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
class SAML_DLLLOCAL EvidenceImpl : public virtual Evidence,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- EvidenceImpl(const EvidenceImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ EvidenceImpl(const EvidenceImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
AssertionIDRef* ref=dynamic_cast<AssertionIDRef*>(*i);
continue;
}
- /*
EncryptedAssertion* enc=dynamic_cast<EncryptedAssertion*>(*i);
if (enc) {
getEncryptedAssertions().push_back(enc->cloneEncryptedAssertion());
continue;
}
- */
}
}
}
IMPL_TYPED_CHILDREN(AssertionIDRef,m_children.end());
IMPL_TYPED_CHILDREN(AssertionURIRef,m_children.end());
IMPL_TYPED_CHILDREN(Assertion,m_children.end());
- //IMPL_TYPED_CHILDREN(EncryptedAssertion,m_children.end());
+ IMPL_TYPED_CHILDREN(EncryptedAssertion,m_children.end());
protected:
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
PROC_TYPED_CHILDREN(AssertionIDRef,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILDREN(AssertionURIRef,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILDREN(Assertion,SAMLConstants::SAML20_NS,false);
- //PROC_TYPED_CHILDREN(EncryptedAssertion,SAMLConstants::SAML20_NS,false);
+ PROC_TYPED_CHILDREN(EncryptedAssertion,SAMLConstants::SAML20_NS,false);
AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
}
};
class SAML_DLLLOCAL AuthzDecisionStatementImpl : public virtual AuthzDecisionStatement,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
}
AuthzDecisionStatementImpl(const AuthzDecisionStatementImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setResource(src.getResource());
setDecision(src.getDecision());
void processAttribute(const DOMAttr* attribute) {
PROC_STRING_ATTRIB(Resource,RESOURCE,NULL);
PROC_STRING_ATTRIB(Decision,DECISION,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
- class SAML_DLLLOCAL AttributeValueImpl
- : public virtual AttributeValue, public AnyElementImpl, public AbstractValidatingXMLObject
+ class SAML_DLLLOCAL AttributeValueImpl : public virtual AttributeValue, public AnyElementImpl
{
public:
virtual ~AttributeValueImpl() {}
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- AttributeValueImpl(const AttributeValueImpl& src) : AnyElementImpl(src), AbstractValidatingXMLObject(src) {}
+ AttributeValueImpl(const AttributeValueImpl& src) : AnyElementImpl(src) {
+ }
IMPL_XMLOBJECT_CLONE(AttributeValue);
};
public AbstractComplexElement,
public AbstractAttributeExtensibleXMLObject,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
}
AttributeImpl(const AttributeImpl& src)
- : AbstractXMLObject(src),
- AbstractAttributeExtensibleXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ : AbstractXMLObject(src), AbstractAttributeExtensibleXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setName(src.getName());
setNameFormat(src.getNameFormat());
void setAttribute(QName& qualifiedName, const XMLCh* value) {
if (!qualifiedName.hasNamespaceURI()) {
- if (XMLString::equals(qualifiedName.getLocalPart(),NAME_ATTRIB_NAME))
+ if (XMLString::equals(qualifiedName.getLocalPart(),NAME_ATTRIB_NAME)) {
setName(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),NAMEFORMAT_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),NAMEFORMAT_ATTRIB_NAME)) {
setNameFormat(value);
- else if (XMLString::equals(qualifiedName.getLocalPart(),FRIENDLYNAME_ATTRIB_NAME))
+ return;
+ }
+ else if (XMLString::equals(qualifiedName.getLocalPart(),FRIENDLYNAME_ATTRIB_NAME)) {
setFriendlyName(value);
+ return;
+ }
}
AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value);
}
}
};
+ class SAML_DLLLOCAL EncryptedAttributeImpl : public virtual EncryptedAttribute, public EncryptedElementTypeImpl
+ {
+ public:
+ virtual ~EncryptedAttributeImpl() {}
+
+ EncryptedAttributeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
+
+ EncryptedAttributeImpl(const EncryptedAttributeImpl& src) : AbstractXMLObject(src), EncryptedElementTypeImpl(src) {}
+
+ IMPL_XMLOBJECT_CLONE(EncryptedAttribute);
+ EncryptedElementType* cloneEncryptedElementType() const {
+ return new EncryptedAttributeImpl(*this);
+ }
+ };
+
class SAML_DLLLOCAL AttributeStatementImpl : public virtual AttributeStatement,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- AttributeStatementImpl(const AttributeStatementImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ AttributeStatementImpl(const AttributeStatementImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
Attribute* attribute=dynamic_cast<Attribute*>(*i);
continue;
}
- /*
EncryptedAttribute* enc=dynamic_cast<EncryptedAttribute*>(*i);
if (enc) {
getEncryptedAttributes().push_back(enc->cloneEncryptedAttribute());
continue;
}
- */
}
}
}
return cloneAttributeStatement();
}
IMPL_TYPED_CHILDREN(Attribute, m_children.end());
- //IMPL_TYPED_CHILDREN(EncryptedAttribute, m_children.end());
+ IMPL_TYPED_CHILDREN(EncryptedAttribute, m_children.end());
protected:
void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
PROC_TYPED_CHILDREN(Attribute,SAMLConstants::SAML20_NS,false);
- //PROC_TYPED_CHILDREN(EncryptedAttribute,SAMLConstants::SAML20_NS,false);
+ PROC_TYPED_CHILDREN(EncryptedAttribute,SAMLConstants::SAML20_NS,false);
AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
}
};
class SAML_DLLLOCAL AdviceImpl : public virtual Advice,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
: AbstractXMLObject(nsURI, localName, prefix, schemaType) {
}
- AdviceImpl(const AdviceImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ AdviceImpl(const AdviceImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
if (*i) {
AssertionIDRef* ref=dynamic_cast<AssertionIDRef*>(*i);
continue;
}
- /*
EncryptedAssertion* enc=dynamic_cast<EncryptedAssertion*>(*i);
if (enc) {
getEncryptedAssertions().push_back(enc->cloneEncryptedAssertion());
continue;
}
- */
+
getOthers().push_back((*i)->clone());
}
}
IMPL_TYPED_CHILDREN(AssertionIDRef,m_children.end());
IMPL_TYPED_CHILDREN(AssertionURIRef,m_children.end());
IMPL_TYPED_CHILDREN(Assertion,m_children.end());
- //IMPL_TYPED_CHILDREN(EncryptedAssertion,m_children.end());
+ IMPL_TYPED_CHILDREN(EncryptedAssertion,m_children.end());
IMPL_XMLOBJECT_CHILDREN(Other,m_children.end());
protected:
PROC_TYPED_CHILDREN(AssertionIDRef,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILDREN(AssertionURIRef,SAMLConstants::SAML20_NS,false);
PROC_TYPED_CHILDREN(Assertion,SAMLConstants::SAML20_NS,false);
- //PROC_TYPED_CHILDREN(EncryptedAssertion,SAMLConstants::SAML20_NS,false);
+ PROC_TYPED_CHILDREN(EncryptedAssertion,SAMLConstants::SAML20_NS,false);
// Unknown child.
const XMLCh* nsURI=root->getNamespaceURI();
- if (!XMLString::equals(nsURI,SAMLConstants::SAML20_NS) && nsURI && *nsURI)
+ if (!XMLString::equals(nsURI,SAMLConstants::SAML20_NS) && nsURI && *nsURI) {
getOthers().push_back(childXMLObject);
+ return;
+ }
AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
}
};
+ class SAML_DLLLOCAL EncryptedAssertionImpl : public virtual EncryptedAssertion, public EncryptedElementTypeImpl
+ {
+ public:
+ virtual ~EncryptedAssertionImpl() {}
+
+ EncryptedAssertionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
+ : AbstractXMLObject(nsURI, localName, prefix, schemaType) {}
+
+ EncryptedAssertionImpl(const EncryptedAssertionImpl& src) : AbstractXMLObject(src), EncryptedElementTypeImpl(src) {}
+
+ IMPL_XMLOBJECT_CLONE(EncryptedAssertion);
+ EncryptedElementType* cloneEncryptedElementType() const {
+ return new EncryptedAssertionImpl(*this);
+ }
+ };
+
class SAML_DLLLOCAL AssertionImpl : public virtual Assertion,
public AbstractComplexElement,
public AbstractDOMCachingXMLObject,
- public AbstractValidatingXMLObject,
public AbstractXMLObjectMarshaller,
public AbstractXMLObjectUnmarshaller
{
void init() {
m_ID=NULL;
+ m_Version=NULL;
m_IssueInstant=NULL;
m_Issuer=NULL;
m_Signature=NULL;
init();
}
- AssertionImpl(const AssertionImpl& src)
- : AbstractXMLObject(src),
- AbstractDOMCachingXMLObject(src),
- AbstractValidatingXMLObject(src) {
+ AssertionImpl(const AssertionImpl& src) : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src) {
init();
setVersion(src.getVersion());
setID(src.getID());
IMPL_XMLOBJECT_CLONE(Assertion);
IMPL_STRING_ATTRIB(Version);
IMPL_STRING_ATTRIB(ID);
- IMPL_DATETIME_ATTRIB(IssueInstant);
+ IMPL_DATETIME_ATTRIB(IssueInstant,0);
IMPL_TYPED_CHILD(Issuer);
IMPL_TYPED_CHILD(Subject);
IMPL_TYPED_CHILD(Conditions);
if (!m_ID)
const_cast<AssertionImpl*>(this)->m_ID=SAMLConfig::getConfig().generateIdentifier();
MARSHALL_ID_ATTRIB(ID,ID,NULL);
- if (!m_IssueInstant)
- const_cast<AssertionImpl*>(this)->m_IssueInstant=new DateTime(time(NULL));
+ if (!m_IssueInstant) {
+ const_cast<AssertionImpl*>(this)->m_IssueInstantEpoch=time(NULL);
+ const_cast<AssertionImpl*>(this)->m_IssueInstant=new DateTime(m_IssueInstantEpoch);
+ }
MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
}
PROC_STRING_ATTRIB(Version,VER,NULL);
PROC_ID_ATTRIB(ID,ID,NULL);
PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
+ AbstractXMLObjectUnmarshaller::processAttribute(attribute);
}
};
IMPL_XMLOBJECTBUILDER(AuthnStatement);
IMPL_XMLOBJECTBUILDER(AuthzDecisionStatement);
IMPL_XMLOBJECTBUILDER(Conditions);
+IMPL_XMLOBJECTBUILDER(EncryptedAssertion);
+IMPL_XMLOBJECTBUILDER(EncryptedAttribute);
+IMPL_XMLOBJECTBUILDER(EncryptedID);
IMPL_XMLOBJECTBUILDER(Evidence);
IMPL_XMLOBJECTBUILDER(Issuer);
IMPL_XMLOBJECTBUILDER(KeyInfoConfirmationDataType);
const XMLCh Conditions::TYPE_NAME[] = UNICODE_LITERAL_14(C,o,n,d,i,t,i,o,n,s,T,y,p,e);
const XMLCh Conditions::NOTBEFORE_ATTRIB_NAME[] = UNICODE_LITERAL_9(N,o,t,B,e,f,o,r,e);
const XMLCh Conditions::NOTONORAFTER_ATTRIB_NAME[] =UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r);
+const XMLCh EncryptedAssertion::LOCAL_NAME[] = UNICODE_LITERAL_18(E,n,c,r,y,p,t,e,d,A,s,s,e,r,t,i,o,n);
+const XMLCh EncryptedAttribute::LOCAL_NAME[] = UNICODE_LITERAL_18(E,n,c,r,y,p,t,e,d,A,t,t,r,i,b,u,t,e);
+const XMLCh EncryptedElementType::LOCAL_NAME[] = {chNull};
+const XMLCh EncryptedElementType::TYPE_NAME[] = UNICODE_LITERAL_20(E,n,c,r,y,p,t,e,d,E,l,e,m,e,n,t,T,y,p,e);
+const XMLCh EncryptedID::LOCAL_NAME[] = UNICODE_LITERAL_11(E,n,c,r,y,p,t,e,d,I,d);
const XMLCh Evidence::LOCAL_NAME[] = UNICODE_LITERAL_8(E,v,i,d,e,n,c,e);
const XMLCh Evidence::TYPE_NAME[] = UNICODE_LITERAL_12(E,v,i,d,e,n,c,e,T,y,p,e);
const XMLCh Issuer::LOCAL_NAME[] = UNICODE_LITERAL_6(I,s,s,u,e,r);
projects / shibboleth / cpp-opensaml.git / blobdiff