From 7ad96e97599881b4fbaf67da4a85155398dd4787 Mon Sep 17 00:00:00 2001 From: Scott Cantor Date: Tue, 30 May 2006 02:56:11 +0000 Subject: [PATCH] Completed 2.0 assertions schema classes. --- .cdtproject | 5 +- saml/Makefile.am | 7 + saml/SAMLConfig.cpp | 4 +- saml/saml.vcproj | 84 ++ saml/saml1/core/Assertions.h | 45 +- saml/saml1/core/Protocols.h | 18 +- saml/saml1/core/impl/AssertionsImpl.cpp | 12 +- saml/saml1/core/impl/ProtocolsImpl.cpp | 13 +- saml/saml1/core/impl/ProtocolsSchemaValidators.cpp | 5 +- saml/saml2/core/Assertions.h | 356 +++++ saml/saml2/core/impl/AssertionsImpl.cpp | 1535 ++++++++++++++++++++ .../saml2/core/impl/AssertionsSchemaValidators.cpp | 226 +++ samltest/saml1/core/impl/ActionTest.h | 6 +- .../saml1/core/impl/AssertionIDReferenceTest.h | 6 +- samltest/saml1/core/impl/AudienceTest.h | 6 +- samltest/signature/SAML1RequestTest.h | 1 + samltest/signature/SAML1ResponseTest.h | 1 + 17 files changed, 2262 insertions(+), 68 deletions(-) create mode 100644 saml/saml2/core/Assertions.h create mode 100644 saml/saml2/core/impl/AssertionsImpl.cpp create mode 100644 saml/saml2/core/impl/AssertionsSchemaValidators.cpp diff --git a/.cdtproject b/.cdtproject index 1acb183..2358662 100644 --- a/.cdtproject +++ b/.cdtproject @@ -58,18 +58,19 @@ - + - + + diff --git a/saml/Makefile.am b/saml/Makefile.am index 9796c35..8b0ffcb 100644 --- a/saml/Makefile.am +++ b/saml/Makefile.am @@ -10,6 +10,8 @@ utilincludedir = $(includedir)/saml/util saml1coreincludedir = $(includedir)/saml/saml1/core +saml2coreincludedir = $(includedir)/saml/saml2/core + libsamlinclude_HEADERS = \ base.h \ exceptions.h \ @@ -28,6 +30,9 @@ saml1coreinclude_HEADERS = \ saml1/core/Assertions.h \ saml1/core/Protocols.h +saml2coreinclude_HEADERS = \ + saml2/core/Assertions.h + noinst_HEADERS = \ internal.h @@ -37,6 +42,8 @@ libsaml_la_SOURCES = \ saml1/core/impl/AssertionsSchemaValidators.cpp \ saml1/core/impl/ProtocolsImpl.cpp \ saml1/core/impl/ProtocolsSchemaValidators.cpp \ + saml2/core/impl/AssertionsImpl.cpp \ + saml2/core/impl/AssertionsSchemaValidators.cpp \ signature/ContentReference.cpp \ signature/SignatureProfileValidator.cpp \ util/SAMLConstants.cpp diff --git a/saml/SAMLConfig.cpp b/saml/SAMLConfig.cpp index ddbf3d5..efd3e1c 100644 --- a/saml/SAMLConfig.cpp +++ b/saml/SAMLConfig.cpp @@ -27,6 +27,7 @@ #include "SAMLConfig.h" #include "saml1/core/Assertions.h" #include "saml1/core/Protocols.h" +#include "saml2/core/Assertions.h" #include "util/SAMLConstants.h" #include @@ -71,7 +72,8 @@ bool SAMLInternalConfig::init() log.debug("XMLTooling library initialized"); saml1::registerAssertionClasses(); - saml1::registerProtocolClasses(); + saml1p::registerProtocolClasses(); + saml2::registerAssertionClasses(); log.info("library initialization complete"); return true; diff --git a/saml/saml.vcproj b/saml/saml.vcproj index 29d3479..2fe8368 100644 --- a/saml/saml.vcproj +++ b/saml/saml.vcproj @@ -233,6 +233,70 @@ > + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + #include #include @@ -43,15 +42,15 @@ namespace opensaml { /** * @namespace saml1 - * SAML 1.x class namespace + * SAML 1.x assertion namespace */ namespace saml1 { // Forward references class SAML_API Assertion; - DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionIDReference,Reference,SAML 1.x AssertionIDReference element); - DECL_XMLOBJECT_SIMPLE(SAML_API,Audience,Uri,SAML 1.x Audience element); + DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionIDReference,AssertionID,SAML 1.x AssertionIDReference element); + DECL_XMLOBJECT_SIMPLE(SAML_API,Audience,AudienceURI,SAML 1.x Audience element); DECL_XMLOBJECT_SIMPLE(SAML_API,ConfirmationMethod,Method,SAML 1.x ConfirmationMethod element); BEGIN_XMLOBJECT(SAML_API,Condition,xmltooling::XMLObject,SAML 1.x Condition element); @@ -69,8 +68,8 @@ namespace opensaml { END_XMLOBJECT; BEGIN_XMLOBJECT(SAML_API,Conditions,xmltooling::XMLObject,SAML 1.x Conditions element); - DECL_XMLOBJECT_ATTRIB(NotBefore,NOTBEFORE,xmltooling::DateTime); - DECL_XMLOBJECT_ATTRIB(NotOnOrAfter,NOTONORAFTER,xmltooling::DateTime); + DECL_DATETIME_ATTRIB(NotBefore,NOTBEFORE); + DECL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER); DECL_TYPED_CHILDREN(AudienceRestrictionCondition); DECL_TYPED_CHILDREN(DoNotCacheCondition); DECL_TYPED_CHILDREN(Condition); @@ -86,20 +85,8 @@ namespace opensaml { static const XMLCh TYPE_NAME[]; END_XMLOBJECT; - /** SAML 1.x SubjectConfirmationData element */ - class SAML_API SubjectConfirmationData : public virtual xmltooling::ElementProxy, - public virtual xmltooling::AttributeExtensibleXMLObject, - public virtual xmltooling::ValidatingXMLObject - { - protected: - SubjectConfirmationData() {} - public: - virtual ~SubjectConfirmationData() {} - /** Type-specific clone method. */ - virtual SubjectConfirmationData* cloneSubjectConfirmationData() const=0; - /** Element local name. */ - static const XMLCh LOCAL_NAME[]; - }; + BEGIN_XMLOBJECT2(SAML_API,SubjectConfirmationData,xmltooling::ElementProxy,xmltooling::AttributeExtensibleXMLObject,SAML 1.x SubjectConfirmationData element); + END_XMLOBJECT; BEGIN_XMLOBJECT(SAML_API,SubjectConfirmation,xmltooling::XMLObject,SAML 1.x SubjectConfirmation element); DECL_TYPED_CHILDREN(ConfirmationMethod); @@ -149,7 +136,7 @@ namespace opensaml { BEGIN_XMLOBJECT(SAML_API,Action,xmltooling::SimpleElement,SAML 1.x Action element); DECL_STRING_ATTRIB(Namespace,NAMESPACE); - DECL_XMLOBJECT_CONTENT(Value); + DECL_XMLOBJECT_CONTENT(Action); /** ActionType local name */ static const XMLCh TYPE_NAME[]; END_XMLOBJECT; @@ -189,20 +176,8 @@ namespace opensaml { static const XMLCh TYPE_NAME[]; END_XMLOBJECT; - /** SAML 1.x AttributeValue element */ - class SAML_API AttributeValue : public virtual xmltooling::ElementProxy, - public virtual xmltooling::AttributeExtensibleXMLObject, - public virtual xmltooling::ValidatingXMLObject - { - protected: - AttributeValue() {} - public: - virtual ~AttributeValue() {} - /** Type-specific clone method. */ - virtual AttributeValue* cloneAttributeValue() const=0; - /** Element local name. */ - static const XMLCh LOCAL_NAME[]; - }; + BEGIN_XMLOBJECT2(SAML_API,AttributeValue,xmltooling::ElementProxy,xmltooling::AttributeExtensibleXMLObject,SAML 1.x AttributeValue element); + END_XMLOBJECT; BEGIN_XMLOBJECT(SAML_API,AttributeStatement,SubjectStatement,SAML 1.x AttributeStatement element); DECL_TYPED_CHILDREN(Attribute); diff --git a/saml/saml1/core/Protocols.h b/saml/saml1/core/Protocols.h index 7d694c5..8b72e45 100644 --- a/saml/saml1/core/Protocols.h +++ b/saml/saml1/core/Protocols.h @@ -30,7 +30,11 @@ namespace opensaml { - namespace saml1 { + /** + * @namespace saml1p + * SAML 1.x protocol namespace + */ + namespace saml1p { DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionArtifact,Artifact,SAML 1.x AssertionArtifact element); DECL_XMLOBJECT_SIMPLE(SAML_API,StatusMessage,Message,SAML 1.x StatusMessage element); @@ -46,7 +50,7 @@ namespace opensaml { END_XMLOBJECT; BEGIN_XMLOBJECT(SAML_API,SubjectQuery,Query,SAML 1.x SubjectQuery element); - DECL_TYPED_CHILD(Subject); + DECL_TYPED_FOREIGN_CHILD(Subject,saml1); END_XMLOBJECT; BEGIN_XMLOBJECT(SAML_API,AuthenticationQuery,SubjectQuery,SAML 1.x AuthenticationQuery element); @@ -57,15 +61,15 @@ namespace opensaml { BEGIN_XMLOBJECT(SAML_API,AttributeQuery,SubjectQuery,SAML 1.x AttributeQuery element); DECL_STRING_ATTRIB(Resource,RESOURCE); - DECL_TYPED_CHILDREN(AttributeDesignator); + DECL_TYPED_FOREIGN_CHILDREN(AttributeDesignator,saml1); /** AttributeQueryType local name */ static const XMLCh TYPE_NAME[]; END_XMLOBJECT; BEGIN_XMLOBJECT(SAML_API,AuthorizationDecisionQuery,SubjectQuery,SAML 1.x AuthorizationDecisionQuery element); DECL_STRING_ATTRIB(Resource,RESOURCE); - DECL_TYPED_CHILDREN(Action); - DECL_TYPED_CHILD(Evidence); + DECL_TYPED_FOREIGN_CHILDREN(Action,saml1); + DECL_TYPED_FOREIGN_CHILD(Evidence,saml1); /** AuthorizationDecisionQueryType local name */ static const XMLCh TYPE_NAME[]; END_XMLOBJECT; @@ -84,7 +88,7 @@ namespace opensaml { DECL_TYPED_CHILD(AuthenticationQuery); DECL_TYPED_CHILD(AttributeQuery); DECL_TYPED_CHILD(AuthorizationDecisionQuery); - DECL_TYPED_CHILDREN(AssertionIDReference); + DECL_TYPED_FOREIGN_CHILDREN(AssertionIDReference,saml1); DECL_TYPED_CHILDREN(AssertionArtifact); /** RequestType local name */ static const XMLCh TYPE_NAME[]; @@ -130,7 +134,7 @@ namespace opensaml { BEGIN_XMLOBJECT(SAML_API,Response,AbstractResponse,SAML 1.x Response element); DECL_TYPED_CHILD(Status); - DECL_TYPED_CHILDREN(Assertion); + DECL_TYPED_FOREIGN_CHILDREN(Assertion,saml1); /** ResponseType local name */ static const XMLCh TYPE_NAME[]; END_XMLOBJECT; diff --git a/saml/saml1/core/impl/AssertionsImpl.cpp b/saml/saml1/core/impl/AssertionsImpl.cpp index f73a271..761b6de 100644 --- a/saml/saml1/core/impl/AssertionsImpl.cpp +++ b/saml/saml1/core/impl/AssertionsImpl.cpp @@ -55,7 +55,7 @@ namespace opensaml { DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,Audience); DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,ConfirmationMethod); - class XMLTOOL_DLLLOCAL AudienceRestrictionConditionImpl : public virtual AudienceRestrictionCondition, + class SAML_DLLLOCAL AudienceRestrictionConditionImpl : public virtual AudienceRestrictionCondition, public AbstractComplexElement, public AbstractDOMCachingXMLObject, public AbstractValidatingXMLObject, @@ -92,7 +92,7 @@ namespace opensaml { } }; - class XMLTOOL_DLLLOCAL DoNotCacheConditionImpl : public virtual DoNotCacheCondition, + class SAML_DLLLOCAL DoNotCacheConditionImpl : public virtual DoNotCacheCondition, public AbstractChildlessElement, public AbstractDOMCachingXMLObject, public AbstractValidatingXMLObject, @@ -537,7 +537,7 @@ namespace opensaml { m_SubjectLocality=NULL; m_children.push_back(NULL); m_pos_SubjectLocality=m_pos_Subject; - m_pos_SubjectLocality++; + ++m_pos_SubjectLocality; } IMPL_XMLOBJECT_CLONE(AuthenticationStatement); @@ -692,7 +692,7 @@ namespace opensaml { m_Evidence=NULL; m_children.push_back(NULL); m_pos_Evidence=m_pos_Subject; - m_pos_Evidence++; + ++m_pos_Evidence; } IMPL_XMLOBJECT_CLONE(AuthorizationDecisionStatement); @@ -958,9 +958,9 @@ namespace opensaml { m_Signature=NULL; m_pos_Conditions=m_children.begin(); m_pos_Advice=m_pos_Conditions; - m_pos_Advice++; + ++m_pos_Advice; m_pos_Signature=m_pos_Advice; - m_pos_Signature++; + ++m_pos_Signature; } public: virtual ~AssertionImpl() { diff --git a/saml/saml1/core/impl/ProtocolsImpl.cpp b/saml/saml1/core/impl/ProtocolsImpl.cpp index fd2b330..b2261f9 100644 --- a/saml/saml1/core/impl/ProtocolsImpl.cpp +++ b/saml/saml1/core/impl/ProtocolsImpl.cpp @@ -37,6 +37,7 @@ #include #include +using namespace opensaml::saml1p; using namespace opensaml::saml1; using namespace opensaml; using namespace xmlsignature; @@ -49,7 +50,7 @@ using namespace std; #endif namespace opensaml { - namespace saml1 { + namespace saml1p { DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AssertionArtifact); DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,StatusMessage); @@ -243,7 +244,7 @@ namespace opensaml { m_Evidence=NULL; m_children.push_back(NULL); m_pos_Evidence=m_pos_Subject; - m_pos_Evidence++; + ++m_pos_Evidence; } public: virtual ~AuthorizationDecisionQueryImpl() { @@ -411,7 +412,7 @@ namespace opensaml { m_children.push_back(NULL); m_Query=NULL; m_pos_Query=m_pos_Signature; - m_pos_Query++; + ++m_pos_Query; } public: virtual ~RequestImpl() {} @@ -582,10 +583,10 @@ namespace opensaml { m_pos_StatusCode=m_children.begin(); m_StatusMessage=NULL; m_pos_StatusMessage=m_pos_StatusCode; - m_pos_StatusMessage++; + ++m_pos_StatusMessage; m_StatusDetail=NULL; m_pos_StatusDetail=m_pos_StatusMessage; - m_pos_StatusDetail++; + ++m_pos_StatusDetail; } public: virtual ~StatusImpl() {} @@ -737,7 +738,7 @@ namespace opensaml { m_children.push_back(NULL); m_Status=NULL; m_pos_Status=m_pos_Signature; - m_pos_Status++; + ++m_pos_Status; } public: virtual ~ResponseImpl() {} diff --git a/saml/saml1/core/impl/ProtocolsSchemaValidators.cpp b/saml/saml1/core/impl/ProtocolsSchemaValidators.cpp index 1fe5041..59942ee 100644 --- a/saml/saml1/core/impl/ProtocolsSchemaValidators.cpp +++ b/saml/saml1/core/impl/ProtocolsSchemaValidators.cpp @@ -24,13 +24,14 @@ #include "exceptions.h" #include "saml1/core/Protocols.h" +using namespace opensaml::saml1p; using namespace opensaml::saml1; using namespace opensaml; using namespace xmltooling; using namespace std; namespace opensaml { - namespace saml1 { + namespace saml1p { XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,AssertionArtifact); XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,StatusMessage); @@ -106,7 +107,7 @@ namespace opensaml { q=QName(SAMLConstants::SAML1P_NS,cname::TYPE_NAME); \ XMLObjectBuilder::registerBuilder(q,new cname##Builder()); -void opensaml::saml1::registerProtocolClasses() { +void opensaml::saml1p::registerProtocolClasses() { QName q; REGISTER_ELEMENT(AssertionArtifact); REGISTER_ELEMENT(AttributeQuery); diff --git a/saml/saml2/core/Assertions.h b/saml/saml2/core/Assertions.h new file mode 100644 index 0000000..1cc75be --- /dev/null +++ b/saml/saml2/core/Assertions.h @@ -0,0 +1,356 @@ +/* + * Copyright 2001-2006 Internet2 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file Assertions.h + * + * XMLObjects representing the SAML 2.0 Assertions schema + */ + +#ifndef __saml2_assertions_h__ +#define __saml2_assertions_h__ + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#define DECL_SAML2OBJECTBUILDER(cname) \ + DECL_XMLOBJECTBUILDER(SAML_API,cname,opensaml::SAMLConstants::SAML20_NS,opensaml::SAMLConstants::SAML20_PREFIX) + +namespace opensaml { + + /** + * @namespace saml2 + * SAML 2.0 assertion namespace + */ + namespace saml2 { + + // Forward references + class SAML_API Assertion; + + DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionIDRef,AssertionID,SAML 2.0 AssertionIDRef element); + DECL_XMLOBJECT_SIMPLE(SAML_API,AssertionURIRef,AssertionURI,SAML 2.0 AssertionURIRef element); + DECL_XMLOBJECT_SIMPLE(SAML_API,Audience,AudienceURI,SAML 2.0 Audience element); + DECL_XMLOBJECT_SIMPLE(SAML_API,AuthnContextClassRef,Reference,SAML 2.0 AuthnContextClassRef element); + DECL_XMLOBJECT_SIMPLE(SAML_API,AuthnContextDeclRef,Reference,SAML 2.0 AuthnContextDeclRef element); + DECL_XMLOBJECT_SIMPLE(SAML_API,AuthenticatingAuthority,ID,SAML 2.0 AuthenticatingAuthority element); + + BEGIN_XMLOBJECT(SAML_API,BaseID,xmltooling::XMLObject,SAML 2.0 BaseIDAbstractType abstract type); + DECL_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER); + DECL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,NameIDType,xmltooling::SimpleElement,SAML 2.0 NameIDType type); + DECL_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER); + DECL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER); + DECL_STRING_ATTRIB(Format,FORMAT); + DECL_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID); + DECL_XMLOBJECT_CONTENT(Name); + /** NameIDType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,NameID,NameIDType,SAML 2.0 NameID element); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Issuer,NameIDType,SAML 2.0 Issuer element); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Condition,xmltooling::XMLObject,SAML 2.0 Condition element); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,AudienceRestriction,Condition,SAML 2.0 AudienceRestriction element); + DECL_TYPED_CHILDREN(Audience); + /** AudienceRestrictionType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,OneTimeUse,Condition,SAML 2.0 OneTimeUse element); + /** OneTimeUseType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,ProxyRestriction,Condition,SAML 2.0 ProxyRestriction element); + DECL_INTEGER_ATTRIB(Count,COUNT); + DECL_TYPED_CHILDREN(Audience); + /** ProxyRestrictionType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Conditions,xmltooling::XMLObject,SAML 2.0 Conditions element); + DECL_DATETIME_ATTRIB(NotBefore,NOTBEFORE); + DECL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER); + DECL_TYPED_CHILDREN(AudienceRestriction); + DECL_TYPED_CHILDREN(OneTimeUse); + DECL_TYPED_CHILDREN(ProxyRestriction); + DECL_TYPED_CHILDREN(Condition); + /** ConditionsType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT2(SAML_API,SubjectConfirmationData,xmltooling::ElementProxy,xmltooling::AttributeExtensibleXMLObject,SAML 2.0 SubjectConfirmationData element); + DECL_DATETIME_ATTRIB(NotBefore,NOTBEFORE); + DECL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER); + DECL_STRING_ATTRIB(Recipient,RECIPIENT); + DECL_STRING_ATTRIB(InResponseTo,INRESPONSETO); + DECL_STRING_ATTRIB(Address,ADDRESS); + DECL_XMLOBJECT_CONTENT(Data); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,KeyInfoConfirmationDataType,xmltooling::AttributeExtensibleXMLObject,SAML 2.0 KeyInfoConfirmationDataType type); + DECL_DATETIME_ATTRIB(NotBefore,NOTBEFORE); + DECL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER); + DECL_STRING_ATTRIB(Recipient,RECIPIENT); + DECL_STRING_ATTRIB(InResponseTo,INRESPONSETO); + DECL_STRING_ATTRIB(Address,ADDRESS); + DECL_TYPED_FOREIGN_CHILDREN(KeyInfo,xmlsignature); + /** KeyInfoConfirmationDataType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,SubjectConfirmation,xmltooling::XMLObject,SAML 2.0 SubjectConfirmation element); + DECL_STRING_ATTRIB(Method,METHOD); + DECL_TYPED_CHILD(BaseID); + DECL_TYPED_CHILD(NameID); + //DECL_TYPED_CHILD(EncryptedID); + DECL_XMLOBJECT_CHILD(SubjectConfirmationData); + DECL_TYPED_CHILD(KeyInfoConfirmationDataType); + /** SubjectConfirmationType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Subject,xmltooling::XMLObject,SAML 2.0 Subject element); + DECL_TYPED_CHILD(BaseID); + DECL_TYPED_CHILD(NameID); + //DECL_TYPED_CHILD(EncryptedID); + DECL_TYPED_CHILDREN(SubjectConfirmation); + /** SubjectType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Statement,xmltooling::XMLObject,SAML 2.0 Statement element); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,SubjectLocality,xmltooling::XMLObject,SAML 2.0 SubjectLocality element); + DECL_STRING_ATTRIB(Address,ADDRESS); + DECL_STRING_ATTRIB(DNSName,DNSNAME); + /** SubjectLocalityType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT2(SAML_API,AuthnContextDecl,xmltooling::ElementProxy,xmltooling::AttributeExtensibleXMLObject,SAML 2.0 AuthnContextDecl element); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,AuthnContext,xmltooling::XMLObject,SAML 2.0 AuthnContext element); + DECL_TYPED_CHILD(AuthnContextClassRef); + DECL_XMLOBJECT_CHILD(AuthnContextDecl); + DECL_TYPED_CHILD(AuthnContextDeclRef); + DECL_TYPED_CHILDREN(AuthenticatingAuthority); + /** AuthnContextType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,AuthnStatement,Statement,SAML 2.0 AuthnStatement element); + DECL_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT); + DECL_STRING_ATTRIB(SessionIndex,SESSIONINDEX); + DECL_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER); + DECL_TYPED_CHILD(SubjectLocality); + DECL_TYPED_CHILD(AuthnContext); + /** AuthnStatementType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Action,xmltooling::SimpleElement,SAML 2.0 Action element); + DECL_STRING_ATTRIB(Namespace,NAMESPACE); + DECL_XMLOBJECT_CONTENT(Action); + /** ActionType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Evidence,xmltooling::XMLObject,SAML 2.0 Evidence element); + DECL_TYPED_CHILDREN(AssertionIDRef); + DECL_TYPED_CHILDREN(AssertionURIRef); + DECL_TYPED_CHILDREN(Assertion); + //DECL_TYPED_CHILDREN(EncryptedAssertion); + /** EvidenceType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,AuthzDecisionStatement,Statement,SAML 2.0 AuthzDecisionStatement element); + DECL_STRING_ATTRIB(Resource,RESOURCE); + DECL_STRING_ATTRIB(Decision,DECISION); + DECL_TYPED_CHILDREN(Action); + DECL_TYPED_CHILD(Evidence); + /** AuthzDecisionStatementType local name */ + static const XMLCh TYPE_NAME[]; + /** Permit Decision */ + static const XMLCh DECISION_PERMIT[]; + /** Deny Decision */ + static const XMLCh DECISION_DENY[]; + /** Indeterminate Decision */ + static const XMLCh DECISION_INDETERMINATE[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT2(SAML_API,AttributeValue,xmltooling::ElementProxy,xmltooling::AttributeExtensibleXMLObject,SAML 2.0 AttributeValue element); + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Attribute,xmltooling::AttributeExtensibleXMLObject,SAML 2.0 Attribute element); + DECL_STRING_ATTRIB(Name,NAME); + DECL_STRING_ATTRIB(NameFormat,NAMEFORMAT); + DECL_STRING_ATTRIB(FriendlyName,FRIENDLYNAME); + DECL_XMLOBJECT_CHILDREN(AttributeValue); + /** AttributeType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,AttributeStatement,Statement,SAML 2.0 AttributeStatement element); + DECL_TYPED_CHILDREN(Attribute); + //DECL_TYPED_CHILDREN(EncryptedAttribute); + /** AttributeStatementType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Advice,xmltooling::XMLObject,SAML 2.0 Advice element); + DECL_TYPED_CHILDREN(AssertionIDRef); + DECL_TYPED_CHILDREN(AssertionURIRef); + DECL_TYPED_CHILDREN(Assertion); + //DECL_TYPED_CHILDREN(EncryptedAssertion); + DECL_XMLOBJECT_CHILDREN(Other); + /** AdviceType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + BEGIN_XMLOBJECT(SAML_API,Assertion,SignableObject,SAML 2.0 Assertion element); + DECL_STRING_ATTRIB(Version,VER); + DECL_STRING_ATTRIB(ID,ID); + DECL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT); + DECL_TYPED_CHILD(Issuer); + DECL_TYPED_FOREIGN_CHILD(Signature,xmlsignature); + DECL_TYPED_CHILD(Subject); + DECL_TYPED_CHILD(Conditions); + DECL_TYPED_CHILD(Advice); + DECL_TYPED_CHILDREN(Statement); + DECL_TYPED_CHILDREN(AuthnStatement); + DECL_TYPED_CHILDREN(AttributeStatement); + DECL_TYPED_CHILDREN(AuthzDecisionStatement); + /** AssertionType local name */ + static const XMLCh TYPE_NAME[]; + END_XMLOBJECT; + + DECL_SAML2OBJECTBUILDER(Action); + DECL_SAML2OBJECTBUILDER(Advice); + DECL_SAML2OBJECTBUILDER(Assertion); + DECL_SAML2OBJECTBUILDER(AssertionIDRef); + DECL_SAML2OBJECTBUILDER(AssertionURIRef); + DECL_SAML2OBJECTBUILDER(Attribute); + DECL_SAML2OBJECTBUILDER(AttributeStatement); + DECL_SAML2OBJECTBUILDER(AttributeValue); + DECL_SAML2OBJECTBUILDER(Audience); + DECL_SAML2OBJECTBUILDER(AudienceRestriction); + DECL_SAML2OBJECTBUILDER(AuthenticatingAuthority); + DECL_SAML2OBJECTBUILDER(AuthnContext); + DECL_SAML2OBJECTBUILDER(AuthnContextClassRef); + DECL_SAML2OBJECTBUILDER(AuthnContextDecl); + DECL_SAML2OBJECTBUILDER(AuthnContextDeclRef); + DECL_SAML2OBJECTBUILDER(AuthnStatement); + DECL_SAML2OBJECTBUILDER(AuthzDecisionStatement); + DECL_SAML2OBJECTBUILDER(Conditions); + DECL_SAML2OBJECTBUILDER(Evidence); + DECL_SAML2OBJECTBUILDER(Issuer); + DECL_SAML2OBJECTBUILDER(NameID); + DECL_SAML2OBJECTBUILDER(OneTimeUse); + DECL_SAML2OBJECTBUILDER(ProxyRestriction); + DECL_SAML2OBJECTBUILDER(Subject); + DECL_SAML2OBJECTBUILDER(SubjectConfirmation); + DECL_SAML2OBJECTBUILDER(SubjectConfirmationData); + DECL_SAML2OBJECTBUILDER(SubjectLocality); + + /** + * Builder for NameIDType objects. + * + * This is customized to force the element name to be specified. + */ + class SAML_API NameIDTypeBuilder : public xmltooling::XMLObjectBuilder { + public: + virtual ~NameIDTypeBuilder() {} + /** Builder that allows element/type override. */ + virtual NameIDType* buildObject( + const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL + ) const; + + /** Singleton builder. */ + static NameIDType* buildNameIDType(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL) { + const NameIDTypeBuilder* b = dynamic_cast( + XMLObjectBuilder::getBuilder(xmltooling::QName(SAMLConstants::SAML20_NS,NameIDType::TYPE_NAME)) + ); + if (b) { + xmltooling::QName schemaType(SAMLConstants::SAML20_NS,NameIDType::TYPE_NAME,SAMLConstants::SAML20_PREFIX); + return b->buildObject(nsURI, localName, prefix, &schemaType); + } + throw xmltooling::XMLObjectException("Unable to obtain typed builder for NameIDType."); + } + }; + + /** + * Builder for KeyInfoConfirmationDataType objects. + * + * This is customized to return a SubjectConfirmationData element with an + * xsi:type of KeyInfoConfirmationDataType. + */ + class SAML_API KeyInfoConfirmationDataTypeBuilder : public xmltooling::XMLObjectBuilder { + public: + virtual ~KeyInfoConfirmationDataTypeBuilder() {} + /** Default builder. */ + virtual KeyInfoConfirmationDataType* buildObject() const { + xmltooling::QName schemaType( + SAMLConstants::SAML20_NS,KeyInfoConfirmationDataType::TYPE_NAME,SAMLConstants::SAML20_PREFIX + ); + return buildObject( + SAMLConstants::SAML20_NS,KeyInfoConfirmationDataType::LOCAL_NAME,SAMLConstants::SAML20_PREFIX,&schemaType + ); + } + /** Builder that allows element/type override. */ + virtual KeyInfoConfirmationDataType* buildObject( + const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix=NULL, const xmltooling::QName* schemaType=NULL + ) const; + + /** Singleton builder. */ + static KeyInfoConfirmationDataType* buildKeyInfoConfirmationDataType() { + const KeyInfoConfirmationDataTypeBuilder* b = dynamic_cast( + XMLObjectBuilder::getBuilder(xmltooling::QName(SAMLConstants::SAML20_NS,KeyInfoConfirmationDataType::TYPE_NAME)) + ); + if (b) + return b->buildObject(); + throw xmltooling::XMLObjectException("Unable to obtain typed builder for KeyInfoConfirmationDataType."); + } + }; + + /** + * Registers builders and validators for Assertion classes into the runtime. + */ + void SAML_API registerAssertionClasses(); + }; +}; + +#endif /* __saml2_assertions_h__ */ diff --git a/saml/saml2/core/impl/AssertionsImpl.cpp b/saml/saml2/core/impl/AssertionsImpl.cpp new file mode 100644 index 0000000..4152362 --- /dev/null +++ b/saml/saml2/core/impl/AssertionsImpl.cpp @@ -0,0 +1,1535 @@ +/* + * Copyright 2001-2006 Internet2 + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * AssertionsImpl.cpp + * + * Implementation classes for SAML 2.0 Assertions schema + */ + +#include "internal.h" +#include "exceptions.h" +#include "saml2/core/Assertions.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +using namespace opensaml::saml2; +using namespace opensaml; +using namespace xmlsignature; +using namespace xmltooling; +using namespace std; + +#if defined (_MSC_VER) + #pragma warning( push ) + #pragma warning( disable : 4250 4251 ) +#endif + +namespace opensaml { + namespace saml2 { + + DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AssertionIDRef); + DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AssertionURIRef); + DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,Audience); + DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AuthnContextClassRef); + DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AuthnContextDeclRef); + DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AuthenticatingAuthority); + + class SAML_DLLLOCAL NameIDTypeImpl : public virtual NameIDType, + public AbstractSimpleElement, + public AbstractChildlessElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_Format=m_SPProvidedID=m_NameQualifier=m_SPNameQualifier=NULL; + } + + protected: + NameIDTypeImpl() { + init(); + } + + public: + virtual ~NameIDTypeImpl() { + XMLString::release(&m_NameQualifier); + XMLString::release(&m_SPNameQualifier); + XMLString::release(&m_Format); + XMLString::release(&m_SPProvidedID); + } + + NameIDTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + NameIDTypeImpl(const NameIDTypeImpl& src) + : AbstractXMLObject(src), AbstractSimpleElement(src), + AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) { + init(); + setNameQualifier(src.getNameQualifier()); + setSPNameQualifier(src.getSPNameQualifier()); + setFormat(src.getFormat()); + setSPProvidedID(src.getSPProvidedID()); + } + + IMPL_XMLOBJECT_CLONE(NameIDType); + IMPL_STRING_ATTRIB(NameQualifier); + IMPL_STRING_ATTRIB(SPNameQualifier); + IMPL_STRING_ATTRIB(Format); + IMPL_STRING_ATTRIB(SPProvidedID); + IMPL_XMLOBJECT_CONTENT; + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER,NULL); + MARSHALL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,NULL); + MARSHALL_STRING_ATTRIB(Format,FORMAT,NULL); + MARSHALL_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID,NULL); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_STRING_ATTRIB(NameQualifier,NAMEQUALIFIER,NULL); + PROC_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,NULL); + PROC_STRING_ATTRIB(Format,FORMAT,NULL); + PROC_STRING_ATTRIB(SPProvidedID,SPPROVIDEDID,NULL); + } + }; + + class SAML_DLLLOCAL NameIDImpl : public virtual NameID, public NameIDTypeImpl + { + public: + virtual ~NameIDImpl() {} + + NameIDImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) {} + + NameIDImpl(const NameIDImpl& src) : AbstractXMLObject(src), NameIDTypeImpl(src) {} + + IMPL_XMLOBJECT_CLONE(NameID); + NameIDType* cloneNameIDType() const { + return new NameIDImpl(*this); + } + }; + + class SAML_DLLLOCAL IssuerImpl : public virtual Issuer, public NameIDTypeImpl + { + public: + virtual ~IssuerImpl() {} + + IssuerImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) {} + + IssuerImpl(const IssuerImpl& src) : AbstractXMLObject(src), NameIDTypeImpl(src) {} + + IMPL_XMLOBJECT_CLONE(Issuer); + NameIDType* cloneNameIDType() const { + return new IssuerImpl(*this); + } + }; + + class SAML_DLLLOCAL AudienceRestrictionImpl : public virtual AudienceRestriction, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~AudienceRestrictionImpl() {} + + AudienceRestrictionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + AudienceRestrictionImpl(const AudienceRestrictionImpl& src) + : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) { + VectorOf(Audience) v=getAudiences(); + for (vector::const_iterator i=src.m_Audiences.begin(); i!=src.m_Audiences.end(); i++) { + if (*i) { + v.push_back((*i)->cloneAudience()); + } + } + } + + IMPL_XMLOBJECT_CLONE(AudienceRestriction); + Condition* cloneCondition() const { + return cloneAudienceRestriction(); + } + IMPL_TYPED_CHILDREN(Audience,m_children.end()); + + protected: + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILDREN(Audience,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + }; + + class SAML_DLLLOCAL OneTimeUseImpl : public virtual OneTimeUse, + public AbstractChildlessElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~OneTimeUseImpl() {} + + OneTimeUseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + OneTimeUseImpl(const OneTimeUseImpl& src) + : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) { + } + + IMPL_XMLOBJECT_CLONE(OneTimeUse); + Condition* cloneCondition() const { + return cloneOneTimeUse(); + } + }; + + class SAML_DLLLOCAL ProxyRestrictionImpl : public virtual ProxyRestriction, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~ProxyRestrictionImpl() {} + + ProxyRestrictionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + ProxyRestrictionImpl(const ProxyRestrictionImpl& src) + : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) { + setCount(src.getCount()); + VectorOf(Audience) v=getAudiences(); + for (vector::const_iterator i=src.m_Audiences.begin(); i!=src.m_Audiences.end(); i++) { + if (*i) { + v.push_back((*i)->cloneAudience()); + } + } + } + + IMPL_XMLOBJECT_CLONE(ProxyRestriction); + Condition* cloneCondition() const { + return cloneProxyRestriction(); + } + IMPL_TYPED_CHILDREN(Audience,m_children.end()); + IMPL_INTEGER_ATTRIB(Count); + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_INTEGER_ATTRIB(Count,COUNT,NULL); + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILDREN(Audience,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_INTEGER_ATTRIB(Count,COUNT,NULL); + } + }; + + + class SAML_DLLLOCAL ConditionsImpl : public virtual Conditions, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_NotBefore=m_NotOnOrAfter=NULL; + } + public: + virtual ~ConditionsImpl() { + delete m_NotBefore; + delete m_NotOnOrAfter; + } + + ConditionsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + ConditionsImpl(const ConditionsImpl& src) + : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) { + init(); + setNotBefore(src.getNotBefore()); + setNotOnOrAfter(src.getNotOnOrAfter()); + + for (list::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) { + if (*i) { + AudienceRestriction* arc=dynamic_cast(*i); + if (arc) { + getAudienceRestrictions().push_back(arc->cloneAudienceRestriction()); + continue; + } + + OneTimeUse* dncc=dynamic_cast(*i); + if (dncc) { + getOneTimeUses().push_back(dncc->cloneOneTimeUse()); + continue; + } + + ProxyRestriction* prc=dynamic_cast(*i); + if (prc) { + getProxyRestrictions().push_back(prc->cloneProxyRestriction()); + continue; + } + + Condition* c=dynamic_cast(*i); + if (c) { + getConditions().push_back(c->cloneCondition()); + continue; + } + } + } + } + + IMPL_XMLOBJECT_CLONE(Conditions); + IMPL_DATETIME_ATTRIB(NotBefore); + IMPL_DATETIME_ATTRIB(NotOnOrAfter); + IMPL_TYPED_CHILDREN(AudienceRestriction, m_children.end()); + IMPL_TYPED_CHILDREN(OneTimeUse,m_children.end()); + IMPL_TYPED_CHILDREN(ProxyRestriction, m_children.end()); + IMPL_TYPED_CHILDREN(Condition,m_children.end()); + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_DATETIME_ATTRIB(NotBefore,NOTBEFORE,NULL); + MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL); + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILDREN(AudienceRestriction,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(OneTimeUse,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(ProxyRestriction,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(Condition,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_DATETIME_ATTRIB(NotBefore,NOTBEFORE,NULL); + PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL); + } + }; + + class SAML_DLLLOCAL SubjectConfirmationDataImpl + : public virtual SubjectConfirmationData, public AnyElementImpl, public AbstractValidatingXMLObject + { + void init() { + m_NotBefore=m_NotOnOrAfter=NULL; + m_Recipient=m_InResponseTo=m_Address=NULL; + } + public: + virtual ~SubjectConfirmationDataImpl() { + delete m_NotBefore; + delete m_NotOnOrAfter; + XMLString::release(&m_Recipient); + XMLString::release(&m_InResponseTo); + XMLString::release(&m_Address); + } + + SubjectConfirmationDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + SubjectConfirmationDataImpl(const SubjectConfirmationDataImpl& src) + : AnyElementImpl(src), AbstractValidatingXMLObject(src) { + init(); + setNotBefore(src.getNotBefore()); + setNotOnOrAfter(src.getNotOnOrAfter()); + setRecipient(src.getRecipient()); + setInResponseTo(src.getInResponseTo()); + setAddress(src.getAddress()); + } + + IMPL_XMLOBJECT_CLONE(SubjectConfirmationData); + IMPL_DATETIME_ATTRIB(NotBefore); + IMPL_DATETIME_ATTRIB(NotOnOrAfter); + 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)) + setNotBefore(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME)) + setNotOnOrAfter(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME)) + setRecipient(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME)) + setInResponseTo(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME)) + setAddress(value); + } + AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value); + } + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_DATETIME_ATTRIB(NotBefore,NOTBEFORE,NULL); + MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL); + MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,NULL); + MARSHALL_STRING_ATTRIB(InResponseTo,INRESPONSETO,NULL); + MARSHALL_STRING_ATTRIB(Address,ADDRESS,NULL); + AnyElementImpl::marshallAttributes(domElement); + } + + // The processAttributes hook is handled by AnyElementImpl + }; + + class SAML_DLLLOCAL KeyInfoConfirmationDataTypeImpl : public virtual KeyInfoConfirmationDataType, + public AbstractDOMCachingXMLObject, + public AbstractComplexElement, + public AbstractAttributeExtensibleXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller, + public AbstractValidatingXMLObject + { + void init() { + m_NotBefore=m_NotOnOrAfter=NULL; + m_Recipient=m_InResponseTo=m_Address=NULL; + } + public: + virtual ~KeyInfoConfirmationDataTypeImpl() { + delete m_NotBefore; + delete m_NotOnOrAfter; + XMLString::release(&m_Recipient); + XMLString::release(&m_InResponseTo); + XMLString::release(&m_Address); + } + + KeyInfoConfirmationDataTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + KeyInfoConfirmationDataTypeImpl(const KeyInfoConfirmationDataTypeImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractAttributeExtensibleXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + setNotBefore(src.getNotBefore()); + setNotOnOrAfter(src.getNotOnOrAfter()); + setRecipient(src.getRecipient()); + setInResponseTo(src.getInResponseTo()); + setAddress(src.getAddress()); + VectorOf(KeyInfo) v=getKeyInfos(); + for (vector::const_iterator i=src.m_KeyInfos.begin(); i!=src.m_KeyInfos.end(); i++) { + if (*i) { + v.push_back((*i)->cloneKeyInfo()); + } + } + } + + IMPL_XMLOBJECT_CLONE(KeyInfoConfirmationDataType); + IMPL_DATETIME_ATTRIB(NotBefore); + IMPL_DATETIME_ATTRIB(NotOnOrAfter); + IMPL_STRING_ATTRIB(Recipient); + IMPL_STRING_ATTRIB(InResponseTo); + IMPL_STRING_ATTRIB(Address); + IMPL_TYPED_CHILDREN(KeyInfo,m_children.end()); + + public: + void setAttribute(QName& qualifiedName, const XMLCh* value) { + if (!qualifiedName.hasNamespaceURI()) { + if (XMLString::equals(qualifiedName.getLocalPart(),NOTBEFORE_ATTRIB_NAME)) + setNotBefore(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),NOTONORAFTER_ATTRIB_NAME)) + setNotOnOrAfter(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),RECIPIENT_ATTRIB_NAME)) + setRecipient(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),INRESPONSETO_ATTRIB_NAME)) + setInResponseTo(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),ADDRESS_ATTRIB_NAME)) + setAddress(value); + } + AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value); + } + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_DATETIME_ATTRIB(NotBefore,NOTBEFORE,NULL); + MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL); + MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,NULL); + MARSHALL_STRING_ATTRIB(InResponseTo,INRESPONSETO,NULL); + MARSHALL_STRING_ATTRIB(Address,ADDRESS,NULL); + + // Take care of wildcard. + for (map::const_iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++) { + DOMAttr* attr=domElement->getOwnerDocument()->createAttributeNS(i->first.getNamespaceURI(),i->first.getLocalPart()); + if (i->first.hasPrefix()) + attr->setPrefix(i->first.getPrefix()); + attr->setNodeValue(i->second); + domElement->setAttributeNode(attr); + } + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILDREN(KeyInfo,XMLConstants::XMLSIG_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + + void processAttribute(const DOMAttr* attribute) { + QName q(attribute->getNamespaceURI(),attribute->getLocalName(),attribute->getPrefix()); + setAttribute(q,attribute->getNodeValue()); + } + }; + + class SAML_DLLLOCAL SubjectConfirmationImpl : public virtual SubjectConfirmation, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_Method=NULL; + m_BaseID=NULL; + m_NameID=NULL; + //m_EncryptedID=NULL; + m_SubjectConfirmationData=NULL; + m_KeyInfoConfirmationDataType=NULL; + m_children.push_back(NULL); + m_children.push_back(NULL); + m_children.push_back(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_SubjectConfirmationData; + m_pos_KeyInfoConfirmationDataType=m_pos_SubjectConfirmationData; + ++m_pos_KeyInfoConfirmationDataType; + } + public: + virtual ~SubjectConfirmationImpl() {} + + SubjectConfirmationImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + SubjectConfirmationImpl(const SubjectConfirmationImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(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.getSubjectConfirmationData()) + setSubjectConfirmationData(src.getSubjectConfirmationData()->clone()); + if (src.getKeyInfoConfirmationDataType()) + setKeyInfoConfirmationDataType(src.getKeyInfoConfirmationDataType()->cloneKeyInfoConfirmationDataType()); + } + + IMPL_XMLOBJECT_CLONE(SubjectConfirmation); + IMPL_STRING_ATTRIB(Method); + IMPL_TYPED_CHILD(BaseID); + IMPL_TYPED_CHILD(NameID); + //IMPL_TYPED_CHILD(EncryptedID); + IMPL_XMLOBJECT_CHILD(SubjectConfirmationData); + IMPL_TYPED_CHILD(KeyInfoConfirmationDataType); + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_STRING_ATTRIB(Method,METHOD,NULL); + } + + 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_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); + } + }; + + class SAML_DLLLOCAL SubjectImpl : public virtual Subject, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_BaseID=NULL; + m_NameID=NULL; + //m_EncryptedID=NULL; + m_children.push_back(NULL); + m_children.push_back(NULL); + m_children.push_back(NULL); + m_pos_BaseID=m_children.begin(); + m_pos_NameID=m_pos_BaseID; + ++m_pos_NameID; + //m_pos_EncryptedID=m_pos_NameID; + //++m_pos_EncryptedID; + } + public: + virtual ~SubjectImpl() {} + + SubjectImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + SubjectImpl(const SubjectImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + if (src.getBaseID()) + setBaseID(src.getBaseID()->cloneBaseID()); + if (src.getNameID()) + setNameID(src.getNameID()->cloneNameID()); + //if (src.getEncryptedID()) + //setEncryptedID(src.getEncryptedID()->cloneEncryptedID()); + VectorOf(SubjectConfirmation) v=getSubjectConfirmations(); + for (vector::const_iterator i=src.m_SubjectConfirmations.begin(); i!=src.m_SubjectConfirmations.end(); i++) { + if (*i) { + v.push_back((*i)->cloneSubjectConfirmation()); + } + } + } + + IMPL_XMLOBJECT_CLONE(Subject); + IMPL_TYPED_CHILD(NameID); + IMPL_TYPED_CHILD(BaseID); + //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_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 + { + void init() { + m_Address=m_DNSName=NULL; + } + public: + virtual ~SubjectLocalityImpl() { + XMLString::release(&m_Address); + XMLString::release(&m_DNSName); + } + + SubjectLocalityImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + SubjectLocalityImpl(const SubjectLocalityImpl& src) + : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src) { + init(); + setAddress(src.getAddress()); + setDNSName(src.getDNSName()); + } + + IMPL_XMLOBJECT_CLONE(SubjectLocality); + IMPL_STRING_ATTRIB(Address); + IMPL_STRING_ATTRIB(DNSName); + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_STRING_ATTRIB(Address,ADDRESS,NULL); + MARSHALL_STRING_ATTRIB(DNSName,DNSNAME,NULL); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_STRING_ATTRIB(Address,ADDRESS,NULL); + PROC_STRING_ATTRIB(DNSName,DNSNAME,NULL); + } + }; + + class SAML_DLLLOCAL AuthnContextDeclImpl + : public virtual AuthnContextDecl, public AnyElementImpl, public AbstractValidatingXMLObject + { + public: + virtual ~AuthnContextDeclImpl() {} + + AuthnContextDeclImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + AuthnContextDeclImpl(const AuthnContextDeclImpl& src) : AnyElementImpl(src), AbstractValidatingXMLObject(src) {} + + IMPL_XMLOBJECT_CLONE(AuthnContextDecl); + }; + + class SAML_DLLLOCAL AuthnContextImpl : public virtual AuthnContext, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_AuthnContextClassRef=NULL; + m_AuthnContextDecl=NULL; + m_AuthnContextDeclRef=NULL; + m_children.push_back(NULL); + m_children.push_back(NULL); + m_children.push_back(NULL); + m_pos_AuthnContextClassRef=m_children.begin(); + m_pos_AuthnContextDecl=m_pos_AuthnContextClassRef; + ++m_pos_AuthnContextDecl; + m_pos_AuthnContextDeclRef=m_pos_AuthnContextDecl; + ++m_pos_AuthnContextDeclRef; + } + public: + virtual ~AuthnContextImpl() {} + + AuthnContextImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + AuthnContextImpl(const AuthnContextImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + if (src.getAuthnContextClassRef()) + setAuthnContextClassRef(src.getAuthnContextClassRef()->cloneAuthnContextClassRef()); + if (src.getAuthnContextDecl()) + setAuthnContextDecl(src.getAuthnContextDecl()->clone()); + if (src.getAuthnContextDeclRef()) + setAuthnContextDeclRef(src.getAuthnContextDeclRef()->cloneAuthnContextDeclRef()); + VectorOf(AuthenticatingAuthority) v=getAuthenticatingAuthoritys(); + for (vector::const_iterator i=src.m_AuthenticatingAuthoritys.begin(); i!=src.m_AuthenticatingAuthoritys.end(); i++) { + if (*i) { + v.push_back((*i)->cloneAuthenticatingAuthority()); + } + } + } + + IMPL_XMLOBJECT_CLONE(AuthnContext); + IMPL_TYPED_CHILD(AuthnContextClassRef); + IMPL_XMLOBJECT_CHILD(AuthnContextDecl); + IMPL_TYPED_CHILD(AuthnContextDeclRef); + IMPL_TYPED_CHILDREN(AuthenticatingAuthority,m_children.end()); + + protected: + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILD(AuthnContextClassRef,SAMLConstants::SAML20_NS,false); + PROC_XMLOBJECT_CHILD(AuthnContextDecl,SAMLConstants::SAML20_NS); + PROC_TYPED_CHILD(AuthnContextDeclRef,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(AuthenticatingAuthority,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + }; + + class SAML_DLLLOCAL AuthnStatementImpl : public virtual AuthnStatement, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_AuthnInstant=NULL; + m_SessionIndex=NULL; + m_SessionNotOnOrAfter=NULL; + m_SubjectLocality=NULL; + m_AuthnContext=NULL; + m_children.push_back(NULL); + m_children.push_back(NULL); + m_pos_SubjectLocality=m_children.begin(); + m_pos_AuthnContext=m_pos_SubjectLocality; + ++m_pos_AuthnContext; + } + public: + virtual ~AuthnStatementImpl() { + delete m_AuthnInstant; + XMLString::release(&m_SessionIndex); + delete m_SessionNotOnOrAfter; + } + + AuthnStatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + AuthnStatementImpl(const AuthnStatementImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + setAuthnInstant(src.getAuthnInstant()); + setSessionIndex(src.getSessionIndex()); + setSessionNotOnOrAfter(src.getSessionNotOnOrAfter()); + if (src.getSubjectLocality()) + setSubjectLocality(src.getSubjectLocality()->cloneSubjectLocality()); + if (src.getAuthnContext()) + setAuthnContext(src.getAuthnContext()->cloneAuthnContext()); + } + + IMPL_XMLOBJECT_CLONE(AuthnStatement); + Statement* cloneStatement() const { + return cloneAuthnStatement(); + } + IMPL_DATETIME_ATTRIB(AuthnInstant); + IMPL_STRING_ATTRIB(SessionIndex); + IMPL_DATETIME_ATTRIB(SessionNotOnOrAfter); + IMPL_TYPED_CHILD(SubjectLocality); + IMPL_TYPED_CHILD(AuthnContext); + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT,NULL); + MARSHALL_STRING_ATTRIB(SessionIndex,SESSIONINDEX,NULL); + MARSHALL_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER,NULL); + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILD(SubjectLocality,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILD(AuthnContext,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_DATETIME_ATTRIB(AuthnInstant,AUTHNINSTANT,NULL); + PROC_STRING_ATTRIB(SessionIndex,SESSIONINDEX,NULL); + PROC_DATETIME_ATTRIB(SessionNotOnOrAfter,SESSIONNOTONORAFTER,NULL); + } + }; + + class SAML_DLLLOCAL ActionImpl : public virtual Action, + public AbstractSimpleElement, + public AbstractChildlessElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~ActionImpl() { + XMLString::release(&m_Namespace); + } + + ActionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Namespace(NULL) { + } + + ActionImpl(const ActionImpl& src) : AbstractXMLObject(src), + AbstractSimpleElement(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + setNamespace(src.getNamespace()); + } + + IMPL_XMLOBJECT_CLONE(Action); + IMPL_STRING_ATTRIB(Namespace); + IMPL_XMLOBJECT_CONTENT; + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_STRING_ATTRIB(Namespace,NAMESPACE,NULL); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_STRING_ATTRIB(Namespace,NAMESPACE,NULL); + } + }; + + class SAML_DLLLOCAL EvidenceImpl : public virtual Evidence, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~EvidenceImpl() {} + + EvidenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + EvidenceImpl(const EvidenceImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + for (list::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) { + if (*i) { + AssertionIDRef* ref=dynamic_cast(*i); + if (ref) { + getAssertionIDRefs().push_back(ref->cloneAssertionIDRef()); + continue; + } + + AssertionURIRef* uri=dynamic_cast(*i); + if (uri) { + getAssertionURIRefs().push_back(uri->cloneAssertionURIRef()); + continue; + } + + Assertion* assertion=dynamic_cast(*i); + if (assertion) { + getAssertions().push_back(assertion->cloneAssertion()); + continue; + } + + /* + EncryptedAssertion* enc=dynamic_cast(*i); + if (enc) { + getEncryptedAssertions().push_back(enc->cloneEncryptedAssertion()); + continue; + } + */ + } + } + } + + IMPL_XMLOBJECT_CLONE(Evidence); + 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()); + + 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); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + }; + + class SAML_DLLLOCAL AuthzDecisionStatementImpl : public virtual AuthzDecisionStatement, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_Resource=NULL; + m_Decision=NULL; + m_Evidence=NULL; + m_children.push_back(NULL); + m_pos_Evidence=m_children.begin(); + } + public: + virtual ~AuthzDecisionStatementImpl() { + XMLString::release(&m_Resource); + XMLString::release(&m_Decision); + } + + AuthzDecisionStatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + AuthzDecisionStatementImpl(const AuthzDecisionStatementImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + setResource(src.getResource()); + setDecision(src.getDecision()); + if (src.getEvidence()) + setEvidence(src.getEvidence()->cloneEvidence()); + VectorOf(Action) v=getActions(); + for (vector::const_iterator i=src.m_Actions.begin(); i!=src.m_Actions.end(); i++) { + if (*i) { + v.push_back((*i)->cloneAction()); + } + } + } + + IMPL_XMLOBJECT_CLONE(AuthzDecisionStatement); + Statement* cloneStatement() const { + return cloneAuthzDecisionStatement(); + } + IMPL_STRING_ATTRIB(Resource); + IMPL_STRING_ATTRIB(Decision); + IMPL_TYPED_CHILD(Evidence); + IMPL_TYPED_CHILDREN(Action, m_pos_Evidence); + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_STRING_ATTRIB(Resource,RESOURCE,NULL); + MARSHALL_STRING_ATTRIB(Decision,DECISION,NULL); + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILD(Evidence,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(Action,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_STRING_ATTRIB(Resource,RESOURCE,NULL); + PROC_STRING_ATTRIB(Decision,DECISION,NULL); + } + }; + + class SAML_DLLLOCAL AttributeValueImpl + : public virtual AttributeValue, public AnyElementImpl, public AbstractValidatingXMLObject + { + public: + virtual ~AttributeValueImpl() {} + + AttributeValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + AttributeValueImpl(const AttributeValueImpl& src) : AnyElementImpl(src), AbstractValidatingXMLObject(src) {} + + IMPL_XMLOBJECT_CLONE(AttributeValue); + }; + + + class SAML_DLLLOCAL AttributeImpl : public virtual Attribute, + public AbstractComplexElement, + public AbstractAttributeExtensibleXMLObject, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_Name=m_NameFormat=m_FriendlyName=NULL; + } + public: + virtual ~AttributeImpl() { + XMLString::release(&m_Name); + XMLString::release(&m_NameFormat); + XMLString::release(&m_FriendlyName); + } + + AttributeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + AttributeImpl(const AttributeImpl& src) + : AbstractXMLObject(src), + AbstractAttributeExtensibleXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + setName(src.getName()); + setNameFormat(src.getNameFormat()); + setFriendlyName(src.getFriendlyName()); + VectorOf(XMLObject) v=getAttributeValues(); + for (vector::const_iterator i=src.m_AttributeValues.begin(); i!=src.m_AttributeValues.end(); i++) { + if (*i) { + v.push_back((*i)->clone()); + } + } + } + + IMPL_XMLOBJECT_CLONE(Attribute); + IMPL_STRING_ATTRIB(Name); + IMPL_STRING_ATTRIB(NameFormat); + IMPL_STRING_ATTRIB(FriendlyName); + IMPL_XMLOBJECT_CHILDREN(AttributeValue,m_children.end()); + + void setAttribute(QName& qualifiedName, const XMLCh* value) { + if (!qualifiedName.hasNamespaceURI()) { + if (XMLString::equals(qualifiedName.getLocalPart(),NAME_ATTRIB_NAME)) + setName(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),NAMEFORMAT_ATTRIB_NAME)) + setNameFormat(value); + else if (XMLString::equals(qualifiedName.getLocalPart(),FRIENDLYNAME_ATTRIB_NAME)) + setFriendlyName(value); + } + AbstractAttributeExtensibleXMLObject::setAttribute(qualifiedName, value); + } + + protected: + void marshallAttributes(DOMElement* domElement) const { + MARSHALL_STRING_ATTRIB(Name,NAME,NULL); + MARSHALL_STRING_ATTRIB(NameFormat,NAMEFORMAT,NULL); + MARSHALL_STRING_ATTRIB(FriendlyName,FRIENDLYNAME,NULL); + + // Take care of wildcard. + for (map::const_iterator i=m_attributeMap.begin(); i!=m_attributeMap.end(); i++) { + DOMAttr* attr=domElement->getOwnerDocument()->createAttributeNS(i->first.getNamespaceURI(),i->first.getLocalPart()); + if (i->first.hasPrefix()) + attr->setPrefix(i->first.getPrefix()); + attr->setNodeValue(i->second); + domElement->setAttributeNode(attr); + } + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + getAttributeValues().push_back(childXMLObject); + } + + void processAttribute(const DOMAttr* attribute) { + QName q(attribute->getNamespaceURI(),attribute->getLocalName(),attribute->getPrefix()); + setAttribute(q,attribute->getNodeValue()); + } + }; + + class SAML_DLLLOCAL AttributeStatementImpl : public virtual AttributeStatement, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~AttributeStatementImpl() {} + + AttributeStatementImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + AttributeStatementImpl(const AttributeStatementImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + for (list::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) { + if (*i) { + Attribute* attribute=dynamic_cast(*i); + if (attribute) { + getAttributes().push_back(attribute->cloneAttribute()); + continue; + } + + /* + EncryptedAttribute* enc=dynamic_cast(*i); + if (enc) { + getEncryptedAttributes().push_back(enc->cloneEncryptedAttribute()); + continue; + } + */ + } + } + } + + IMPL_XMLOBJECT_CLONE(AttributeStatement); + Statement* cloneStatement() const { + return cloneAttributeStatement(); + } + IMPL_TYPED_CHILDREN(Attribute, 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); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + }; + + class SAML_DLLLOCAL AdviceImpl : public virtual Advice, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + public: + virtual ~AdviceImpl() {} + + AdviceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + } + + AdviceImpl(const AdviceImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + for (list::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) { + if (*i) { + AssertionIDRef* ref=dynamic_cast(*i); + if (ref) { + getAssertionIDRefs().push_back(ref->cloneAssertionIDRef()); + continue; + } + + AssertionURIRef* uri=dynamic_cast(*i); + if (uri) { + getAssertionURIRefs().push_back(uri->cloneAssertionURIRef()); + continue; + } + + Assertion* assertion=dynamic_cast(*i); + if (assertion) { + getAssertions().push_back(assertion->cloneAssertion()); + continue; + } + + /* + EncryptedAssertion* enc=dynamic_cast(*i); + if (enc) { + getEncryptedAssertions().push_back(enc->cloneEncryptedAssertion()); + continue; + } + */ + getOthers().push_back((*i)->clone()); + } + } + } + + IMPL_XMLOBJECT_CLONE(Advice); + 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_XMLOBJECT_CHILDREN(Other,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); + + // Unknown child. + const XMLCh* nsURI=root->getNamespaceURI(); + if (!XMLString::equals(nsURI,SAMLConstants::SAML20_NS) && nsURI && *nsURI) + getOthers().push_back(childXMLObject); + + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + }; + + class SAML_DLLLOCAL AssertionImpl : public virtual Assertion, + public AbstractComplexElement, + public AbstractDOMCachingXMLObject, + public AbstractValidatingXMLObject, + public AbstractXMLObjectMarshaller, + public AbstractXMLObjectUnmarshaller + { + void init() { + m_ID=NULL; + m_IssueInstant=NULL; + m_Issuer=NULL; + m_Signature=NULL; + m_Subject=NULL; + m_Conditions=NULL; + m_Advice=NULL; + m_children.push_back(NULL); + m_children.push_back(NULL); + m_children.push_back(NULL); + m_children.push_back(NULL); + m_children.push_back(NULL); + m_pos_Issuer=m_children.begin(); + m_pos_Signature=m_pos_Issuer; + ++m_pos_Signature; + m_pos_Subject=m_pos_Signature; + ++m_pos_Subject; + m_pos_Conditions=m_pos_Subject; + ++m_pos_Conditions; + m_pos_Advice=m_pos_Conditions; + ++m_pos_Advice; + } + public: + virtual ~AssertionImpl() { + XMLString::release(&m_ID); + XMLString::release(&m_Version); + delete m_IssueInstant; + } + + AssertionImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType) + : AbstractXMLObject(nsURI, localName, prefix, schemaType) { + init(); + } + + AssertionImpl(const AssertionImpl& src) + : AbstractXMLObject(src), + AbstractDOMCachingXMLObject(src), + AbstractValidatingXMLObject(src) { + init(); + setVersion(src.getVersion()); + setID(src.getID()); + setIssueInstant(src.getIssueInstant()); + if (src.getIssuer()) + setIssuer(src.getIssuer()->cloneIssuer()); + if (src.getSignature()) + setSignature(src.getSignature()->cloneSignature()); + if (src.getSubject()) + setSubject(src.getSubject()->cloneSubject()); + if (src.getConditions()) + setConditions(src.getConditions()->cloneConditions()); + if (src.getAdvice()) + setAdvice(src.getAdvice()->cloneAdvice()); + for (list::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) { + if (*i) { + AuthnStatement* authst=dynamic_cast(*i); + if (authst) { + getAuthnStatements().push_back(authst->cloneAuthnStatement()); + continue; + } + + AttributeStatement* attst=dynamic_cast(*i); + if (attst) { + getAttributeStatements().push_back(attst->cloneAttributeStatement()); + continue; + } + + AuthzDecisionStatement* authzst=dynamic_cast(*i); + if (authzst) { + getAuthzDecisionStatements().push_back(authzst->cloneAuthzDecisionStatement()); + continue; + } + + Statement* st=dynamic_cast(*i); + if (st) { + getStatements().push_back(st->cloneStatement()); + continue; + } + } + } + } + + const XMLCh* getId() const { + return getID(); + } + + //IMPL_TYPED_CHILD(Signature); + // Need customized setter. + protected: + Signature* m_Signature; + list::iterator m_pos_Signature; + public: + Signature* getSignature() const { + return m_Signature; + } + + void setSignature(Signature* sig) { + prepareForAssignment(m_Signature,sig); + *m_pos_Signature=m_Signature=sig; + // Sync content reference back up. + if (m_Signature) + m_Signature->setContentReference(new opensaml::ContentReference(*this)); + } + + IMPL_XMLOBJECT_CLONE(Assertion); + IMPL_STRING_ATTRIB(Version); + IMPL_STRING_ATTRIB(ID); + IMPL_DATETIME_ATTRIB(IssueInstant); + IMPL_TYPED_CHILD(Issuer); + IMPL_TYPED_CHILD(Subject); + IMPL_TYPED_CHILD(Conditions); + IMPL_TYPED_CHILD(Advice); + IMPL_TYPED_CHILDREN(Statement, m_children.end()); + IMPL_TYPED_CHILDREN(AuthnStatement, m_children.end()); + IMPL_TYPED_CHILDREN(AttributeStatement, m_children.end()); + IMPL_TYPED_CHILDREN(AuthzDecisionStatement, m_children.end()); + + protected: + void marshallAttributes(DOMElement* domElement) const { + if (!m_Version) + const_cast(this)->m_Version=XMLString::transcode("2.0"); + MARSHALL_STRING_ATTRIB(Version,VER,NULL); + if (!m_ID) + const_cast(this)->m_ID=SAMLConfig::getConfig().generateIdentifier(); + MARSHALL_ID_ATTRIB(ID,ID,NULL); + if (!m_IssueInstant) + const_cast(this)->m_IssueInstant=new DateTime(time(NULL)); + MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL); + } + + void processChildElement(XMLObject* childXMLObject, const DOMElement* root) { + PROC_TYPED_CHILD(Issuer,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILD(Signature,XMLConstants::XMLSIG_NS,false); + PROC_TYPED_CHILD(Subject,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILD(Conditions,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILD(Advice,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(AuthnStatement,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(AttributeStatement,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(AuthzDecisionStatement,SAMLConstants::SAML20_NS,false); + PROC_TYPED_CHILDREN(Statement,SAMLConstants::SAML20_NS,false); + AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root); + } + + void processAttribute(const DOMAttr* attribute) { + PROC_STRING_ATTRIB(Version,VER,NULL); + PROC_ID_ATTRIB(ID,ID,NULL); + PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL); + } + }; + + }; +}; + +#if defined (_MSC_VER) + #pragma warning( pop ) +#endif + +// Builder Implementations + +IMPL_XMLOBJECTBUILDER(Action); +IMPL_XMLOBJECTBUILDER(Advice); +IMPL_XMLOBJECTBUILDER(Assertion); +IMPL_XMLOBJECTBUILDER(AssertionIDRef); +IMPL_XMLOBJECTBUILDER(AssertionURIRef); +IMPL_XMLOBJECTBUILDER(Attribute); +IMPL_XMLOBJECTBUILDER(AttributeStatement); +IMPL_XMLOBJECTBUILDER(AttributeValue); +IMPL_XMLOBJECTBUILDER(Audience); +IMPL_XMLOBJECTBUILDER(AudienceRestriction); +IMPL_XMLOBJECTBUILDER(AuthenticatingAuthority); +IMPL_XMLOBJECTBUILDER(AuthnContext); +IMPL_XMLOBJECTBUILDER(AuthnContextClassRef); +IMPL_XMLOBJECTBUILDER(AuthnContextDecl); +IMPL_XMLOBJECTBUILDER(AuthnContextDeclRef); +IMPL_XMLOBJECTBUILDER(AuthnStatement); +IMPL_XMLOBJECTBUILDER(AuthzDecisionStatement); +IMPL_XMLOBJECTBUILDER(Conditions); +IMPL_XMLOBJECTBUILDER(Evidence); +IMPL_XMLOBJECTBUILDER(Issuer); +IMPL_XMLOBJECTBUILDER(KeyInfoConfirmationDataType); +IMPL_XMLOBJECTBUILDER(NameID); +IMPL_XMLOBJECTBUILDER(NameIDType); +IMPL_XMLOBJECTBUILDER(OneTimeUse); +IMPL_XMLOBJECTBUILDER(ProxyRestriction); +IMPL_XMLOBJECTBUILDER(Subject); +IMPL_XMLOBJECTBUILDER(SubjectConfirmation); +IMPL_XMLOBJECTBUILDER(SubjectConfirmationData); +IMPL_XMLOBJECTBUILDER(SubjectLocality); + +// Unicode literals +const XMLCh Action::LOCAL_NAME[] = UNICODE_LITERAL_6(A,c,t,i,o,n); +const XMLCh Action::TYPE_NAME[] = UNICODE_LITERAL_10(A,c,t,i,o,n,T,y,p,e); +const XMLCh Action::NAMESPACE_ATTRIB_NAME[] = UNICODE_LITERAL_9(N,a,m,e,s,p,a,c,e); +const XMLCh Advice::LOCAL_NAME[] = UNICODE_LITERAL_6(A,d,v,i,c,e); +const XMLCh Advice::TYPE_NAME[] = UNICODE_LITERAL_10(A,d,v,i,c,e,T,y,p,e); +const XMLCh Assertion::LOCAL_NAME[] = UNICODE_LITERAL_9(A,s,s,e,r,t,i,o,n); +const XMLCh Assertion::TYPE_NAME[] = UNICODE_LITERAL_13(A,s,s,e,r,t,i,o,n,T,y,p,e); +const XMLCh Assertion::VER_ATTRIB_NAME[] = UNICODE_LITERAL_7(V,e,r,s,i,o,n); +const XMLCh Assertion::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,D); +const XMLCh Assertion::ISSUEINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t); +const XMLCh AssertionIDRef::LOCAL_NAME[] = UNICODE_LITERAL_14(A,s,s,e,r,t,i,o,n,I,D,R,e,f); +const XMLCh AssertionURIRef::LOCAL_NAME[] = UNICODE_LITERAL_15(A,s,s,e,r,t,i,o,n,U,R,I,R,e,f); +const XMLCh Attribute::LOCAL_NAME[] = UNICODE_LITERAL_9(A,t,t,r,i,b,u,t,e); +const XMLCh Attribute::TYPE_NAME[] = UNICODE_LITERAL_13(A,t,t,r,i,b,u,t,e,T,y,p,e); +const XMLCh Attribute::NAME_ATTRIB_NAME[] = UNICODE_LITERAL_4(N,a,m,e); +const XMLCh Attribute::NAMEFORMAT_ATTRIB_NAME[] = UNICODE_LITERAL_10(N,a,m,e,F,o,r,m,a,t); +const XMLCh Attribute::FRIENDLYNAME_ATTRIB_NAME[] = UNICODE_LITERAL_12(F,r,i,e,n,d,l,y,N,a,m,e); +const XMLCh AttributeStatement::LOCAL_NAME[] = UNICODE_LITERAL_18(A,t,t,r,i,b,u,t,e,S,t,a,t,e,m,e,n,t); +const XMLCh AttributeStatement::TYPE_NAME[] = UNICODE_LITERAL_22(A,t,t,r,i,b,u,t,e,S,t,a,t,e,m,e,n,t,T,y,p,e); +const XMLCh AttributeValue::LOCAL_NAME[] = UNICODE_LITERAL_14(A,t,t,r,i,b,u,t,e,V,a,l,u,e); +const XMLCh Audience::LOCAL_NAME[] = UNICODE_LITERAL_8(A,u,d,i,e,n,c,e); +const XMLCh AudienceRestriction::LOCAL_NAME[] = UNICODE_LITERAL_19(A,u,d,i,e,n,c,e,R,e,s,t,r,i,c,t,i,o,n); +const XMLCh AudienceRestriction::TYPE_NAME[] = UNICODE_LITERAL_23(A,u,d,i,e,n,c,e,R,e,s,t,r,i,c,t,i,o,n,T,y,p,e); +const XMLCh AuthenticatingAuthority::LOCAL_NAME[] = UNICODE_LITERAL_23(A,u,t,h,e,n,t,i,c,a,t,i,n,g,A,u,t,h,o,r,i,t,y); +const XMLCh AuthnContext::LOCAL_NAME[] = UNICODE_LITERAL_12(A,u,t,h,n,C,o,n,t,e,x,t); +const XMLCh AuthnContext::TYPE_NAME[] = UNICODE_LITERAL_16(A,u,t,h,n,C,o,n,t,e,x,t,T,y,p,e); +const XMLCh AuthnContextClassRef::LOCAL_NAME[] = UNICODE_LITERAL_20(A,u,t,h,n,C,o,n,t,e,x,t,C,l,a,s,s,R,e,f); +const XMLCh AuthnContextDecl::LOCAL_NAME[] = UNICODE_LITERAL_16(A,u,t,h,n,C,o,n,t,e,x,t,D,e,c,l); +const XMLCh AuthnContextDeclRef::LOCAL_NAME[] = UNICODE_LITERAL_19(A,u,t,h,n,C,o,n,t,e,x,t,D,e,c,l,R,e,f); +const XMLCh AuthnStatement::LOCAL_NAME[] = UNICODE_LITERAL_14(A,u,t,h,n,S,t,a,t,e,m,e,n,t); +const XMLCh AuthnStatement::TYPE_NAME[] = UNICODE_LITERAL_18(A,u,t,h,n,S,t,a,t,e,m,e,n,t,T,y,p,e); +const XMLCh AuthnStatement::AUTHNINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(A,u,t,h,n,I,n,s,t,a,n,t); +const XMLCh AuthnStatement::SESSIONINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_12(S,e,s,s,i,o,n,I,n,d,e,x); +const XMLCh AuthnStatement::SESSIONNOTONORAFTER_ATTRIB_NAME[] = UNICODE_LITERAL_19(S,e,s,s,i,o,n,N,o,t,O,n,O,r,A,f,t,e,r); +const XMLCh AuthzDecisionStatement::LOCAL_NAME[] = UNICODE_LITERAL_22(A,u,t,h,z,D,e,c,i,s,i,o,n,S,t,a,t,e,m,e,n,t); +const XMLCh AuthzDecisionStatement::TYPE_NAME[] = UNICODE_LITERAL_26(A,u,t,h,z,D,e,c,i,s,i,o,n,S,t,a,t,e,m,e,n,t,T,y,p,e); +const XMLCh AuthzDecisionStatement::RESOURCE_ATTRIB_NAME[] = UNICODE_LITERAL_8(R,e,s,o,u,r,c,e); +const XMLCh AuthzDecisionStatement::DECISION_ATTRIB_NAME[] = UNICODE_LITERAL_8(D,e,c,i,s,i,o,n); +const XMLCh AuthzDecisionStatement::DECISION_PERMIT[] = UNICODE_LITERAL_6(P,e,r,m,i,t); +const XMLCh AuthzDecisionStatement::DECISION_DENY[] = UNICODE_LITERAL_4(D,e,n,y); +const XMLCh AuthzDecisionStatement::DECISION_INDETERMINATE[] = UNICODE_LITERAL_13(I,n,d,e,t,e,r,m,i,n,a,t,e); +const XMLCh BaseID::LOCAL_NAME[] = UNICODE_LITERAL_6(B,a,s,e,I,D); +const XMLCh BaseID::NAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_13(N,a,m,e,Q,u,a,l,i,f,i,e,r); +const XMLCh BaseID::SPNAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_15(S,P,N,a,m,e,Q,u,a,l,i,f,i,e,r); +const XMLCh Condition::LOCAL_NAME[] = UNICODE_LITERAL_9(C,o,n,d,i,t,i,o,n); +const XMLCh Conditions::LOCAL_NAME[] = UNICODE_LITERAL_10(C,o,n,d,i,t,i,o,n,s); +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 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); +const XMLCh KeyInfoConfirmationDataType::LOCAL_NAME[] = UNICODE_LITERAL_23(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n,D,a,t,a); +const XMLCh KeyInfoConfirmationDataType::TYPE_NAME[] = UNICODE_LITERAL_27(K,e,y,I,n,f,o,C,o,n,f,i,r,m,a,t,i,o,n,D,a,t,a,T,y,p,e); +const XMLCh KeyInfoConfirmationDataType::NOTBEFORE_ATTRIB_NAME[] = UNICODE_LITERAL_9(N,o,t,B,e,f,o,r,e); +const XMLCh KeyInfoConfirmationDataType::NOTONORAFTER_ATTRIB_NAME[] = UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r); +const XMLCh KeyInfoConfirmationDataType::INRESPONSETO_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,n,R,e,s,p,o,n,s,e,T,o); +const XMLCh KeyInfoConfirmationDataType::RECIPIENT_ATTRIB_NAME[] = UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t); +const XMLCh KeyInfoConfirmationDataType::ADDRESS_ATTRIB_NAME[] = UNICODE_LITERAL_7(A,d,d,r,e,s,s); +const XMLCh NameID::LOCAL_NAME[] = UNICODE_LITERAL_6(N,a,m,e,I,D); +const XMLCh NameIDType::LOCAL_NAME[] = {chNull}; +const XMLCh NameIDType::TYPE_NAME[] = UNICODE_LITERAL_10(N,a,m,e,I,D,T,y,p,e); +const XMLCh NameIDType::NAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_13(N,a,m,e,Q,u,a,l,i,f,i,e,r); +const XMLCh NameIDType::SPNAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_15(S,P,N,a,m,e,Q,u,a,l,i,f,i,e,r); +const XMLCh NameIDType::FORMAT_ATTRIB_NAME[] = UNICODE_LITERAL_6(F,o,r,m,a,t); +const XMLCh NameIDType::SPPROVIDEDID_ATTRIB_NAME[] = UNICODE_LITERAL_12(S,P,P,r,o,v,i,d,e,d,I,D); +const XMLCh OneTimeUse::LOCAL_NAME[] = UNICODE_LITERAL_10(O,n,e,T,i,m,e,U,s,e); +const XMLCh OneTimeUse::TYPE_NAME[] = UNICODE_LITERAL_14(O,n,e,T,i,m,e,U,s,e,T,y,p,e); +const XMLCh ProxyRestriction::LOCAL_NAME[] = UNICODE_LITERAL_16(P,r,o,x,y,R,e,s,t,r,i,c,t,i,o,n); +const XMLCh ProxyRestriction::TYPE_NAME[] = UNICODE_LITERAL_20(P,r,o,x,y,R,e,s,t,r,i,c,t,i,o,n,T,y,p,e); +const XMLCh ProxyRestriction::COUNT_ATTRIB_NAME[] = UNICODE_LITERAL_5(C,o,u,n,t); +const XMLCh Statement::LOCAL_NAME[] = UNICODE_LITERAL_9(S,t,a,t,e,m,e,n,t); +const XMLCh Subject::LOCAL_NAME[] = UNICODE_LITERAL_7(S,u,b,j,e,c,t); +const XMLCh Subject::TYPE_NAME[] = UNICODE_LITERAL_11(S,u,b,j,e,c,t,T,y,p,e); +const XMLCh SubjectConfirmation::LOCAL_NAME[] = UNICODE_LITERAL_19(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n); +const XMLCh SubjectConfirmation::TYPE_NAME[] = UNICODE_LITERAL_23(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n,T,y,p,e); +const XMLCh SubjectConfirmation::METHOD_ATTRIB_NAME[] = UNICODE_LITERAL_6(M,e,t,h,o,d); +const XMLCh SubjectConfirmationData::LOCAL_NAME[] = UNICODE_LITERAL_23(S,u,b,j,e,c,t,C,o,n,f,i,r,m,a,t,i,o,n,D,a,t,a); +const XMLCh SubjectConfirmationData::NOTBEFORE_ATTRIB_NAME[] = UNICODE_LITERAL_9(N,o,t,B,e,f,o,r,e); +const XMLCh SubjectConfirmationData::NOTONORAFTER_ATTRIB_NAME[] = UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r); +const XMLCh SubjectConfirmationData::INRESPONSETO_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,n,R,e,s,p,o,n,s,e,T,o); +const XMLCh SubjectConfirmationData::RECIPIENT_ATTRIB_NAME[] = UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t); +const XMLCh SubjectConfirmationData::ADDRESS_ATTRIB_NAME[] = UNICODE_LITERAL_7(A,d,d,r,e,s,s); +const XMLCh SubjectLocality::LOCAL_NAME[] = UNICODE_LITERAL_15(S,u,b,j,e,c,t,L,o,c,a,l,i,t,y); +const XMLCh SubjectLocality::TYPE_NAME[] = UNICODE_LITERAL_19(S,u,b,j,e,c,t,L,o,c,a,l,i,t,y,T,y,p,e); +const XMLCh SubjectLocality::ADDRESS_ATTRIB_NAME[] =UNICODE_LITERAL_7(A,d,d,r,e,s,s); +const XMLCh SubjectLocality::DNSNAME_ATTRIB_NAME[] =UNICODE_LITERAL_7(D,N,S,N,a,m,e); diff --git a/saml/saml2/core/impl/AssertionsSchemaValidators.cpp b/saml/saml2/core/impl/AssertionsSchemaValidators.cpp new file mode 100644 index 0000000..e839e69 --- /dev/null +++ b/saml/saml2/core/impl/AssertionsSchemaValidators.cpp @@ -0,0 +1,226 @@ +/* +* Copyright 2001-2006 Internet2 + * +* Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * AssertionsSchemaValidators.cpp + * + * Schema-based validators for SAML 2.0 Assertions classes + */ + +#include "internal.h" +#include "exceptions.h" +#include "saml2/core/Assertions.h" + +using namespace opensaml::saml2; +using namespace opensaml; +using namespace xmltooling; +using namespace std; + +namespace opensaml { + namespace saml2 { + + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,Action); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,AssertionIDRef); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,AssertionURIRef); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,Audience); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,AuthnContextClassRef); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,AuthnContextDeclRef); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,AuthenticatingAuthority); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,NameIDType); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,NameID); + XMLOBJECTVALIDATOR_SIMPLE(SAML_DLLLOCAL,Issuer); + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,AudienceRestriction); + XMLOBJECTVALIDATOR_NONEMPTY(AudienceRestriction,Audience); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,ProxyRestriction); + if (ptr->getAudiences().empty()) { + XMLOBJECTVALIDATOR_REQUIRE(ProxyRestriction,Count); + } + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,Conditions); + if (!ptr->hasChildren()) { + XMLOBJECTVALIDATOR_ONEOF(Conditions,NotBefore,NotOnOrAfter); + } + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,KeyInfoConfirmationDataType); + XMLOBJECTVALIDATOR_NONEMPTY(KeyInfoConfirmationDataType,KeyInfo); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,SubjectConfirmation); + XMLOBJECTVALIDATOR_REQUIRE(SubjectConfirmation,Method); + int count=0; + if (ptr->getBaseID()) + count++; + if (ptr->getNameID()) + count++; + //if (ptr->getEncryptedID()) + //count++; + if (count > 1) + throw ValidationException("SubjectConfirmation cannot contain multiple identifier elements."); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,Subject); + int count=0; + if (ptr->getBaseID()) + count++; + if (ptr->getNameID()) + count++; + //if (ptr->getEncryptedID()) + //count++; + if (count > 1) + throw ValidationException("Subject cannot contain multiple identifier elements."); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,SubjectLocality); + XMLOBJECTVALIDATOR_ONEOF(SubjectLocality,Address,DNSName); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,AuthnContext); + if (!ptr->getAuthnContextClassRef()) { + XMLOBJECTVALIDATOR_ONLYONEOF(AuthnContext,AuthnContextDeclRef,AuthnContextDecl); + } + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,AuthnStatement); + XMLOBJECTVALIDATOR_REQUIRE(AuthnStatement,AuthnInstant); + XMLOBJECTVALIDATOR_REQUIRE(AuthnStatement,AuthnContext); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,Evidence); + if (!ptr->hasChildren()) + throw ValidationException("Evidence must have at least one child element."); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,AuthzDecisionStatement); + XMLOBJECTVALIDATOR_REQUIRE(AuthzDecisionStatement,Resource); + XMLOBJECTVALIDATOR_REQUIRE(AuthzDecisionStatement,Decision); + if (!XMLString::equals(ptr->getDecision(),AuthzDecisionStatement::DECISION_PERMIT) && + !XMLString::equals(ptr->getDecision(),AuthzDecisionStatement::DECISION_DENY) && + !XMLString::equals(ptr->getDecision(),AuthzDecisionStatement::DECISION_INDETERMINATE)) + throw ValidationException("Decision must be one of Deny, Permit, or Indeterminate."); + XMLOBJECTVALIDATOR_NONEMPTY(AuthzDecisionStatement,Action); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,Attribute); + XMLOBJECTVALIDATOR_REQUIRE(Attribute,Name); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,AttributeStatement); + XMLOBJECTVALIDATOR_NONEMPTY(AttributeStatement,Attribute); + END_XMLOBJECTVALIDATOR; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,Assertion); + XMLOBJECTVALIDATOR_REQUIRE(Assertion,Version); + XMLOBJECTVALIDATOR_REQUIRE(Assertion,ID); + XMLOBJECTVALIDATOR_REQUIRE(Assertion,IssueInstant); + XMLOBJECTVALIDATOR_REQUIRE(Assertion,Issuer); + if ((!ptr->getAuthnStatements().empty() || + !ptr->getAttributeStatements().empty() || + !ptr->getAuthzDecisionStatements().empty()) && !ptr->getSubject()) + throw ValidationException("Assertion with standard statements must have a Subject."); + END_XMLOBJECTVALIDATOR; + + class SAML_DLLLOCAL checkWildcardNS { + public: + void operator()(const XMLObject* xmlObject) const { + const XMLCh* ns=xmlObject->getElementQName().getNamespaceURI(); + if (XMLString::equals(ns,SAMLConstants::SAML20_NS) || !ns || !*ns) { + throw ValidationException( + "Object contains an illegal extension child element ($1).", + params(1,xmlObject->getElementQName().toString().c_str()) + ); + } + } + }; + + BEGIN_XMLOBJECTVALIDATOR(SAML_DLLLOCAL,Advice); + const vector& anys=ptr->getOthers(); + for_each(anys.begin(),anys.end(),checkWildcardNS()); + END_XMLOBJECTVALIDATOR; + + }; +}; + +#define REGISTER_ELEMENT(cname) \ + q=QName(SAMLConstants::SAML20_NS,cname::LOCAL_NAME); \ + XMLObjectBuilder::registerBuilder(q,new cname##Builder()); \ + Validator::registerValidator(q,new cname##SchemaValidator()) + +#define REGISTER_TYPE(cname) \ + q=QName(SAMLConstants::SAML20_NS,cname::TYPE_NAME); \ + XMLObjectBuilder::registerBuilder(q,new cname##Builder()); \ + Validator::registerValidator(q,new cname##SchemaValidator()) + +#define REGISTER_ELEMENT_NOVAL(cname) \ + q=QName(SAMLConstants::SAML20_NS,cname::LOCAL_NAME); \ + XMLObjectBuilder::registerBuilder(q,new cname##Builder()); + +#define REGISTER_TYPE_NOVAL(cname) \ + q=QName(SAMLConstants::SAML20_NS,cname::TYPE_NAME); \ + XMLObjectBuilder::registerBuilder(q,new cname##Builder()); + +void opensaml::saml2::registerAssertionClasses() { + QName q; + REGISTER_ELEMENT(Action); + REGISTER_ELEMENT(Advice); + REGISTER_ELEMENT(Assertion); + REGISTER_ELEMENT(AssertionIDRef); + REGISTER_ELEMENT(AssertionURIRef); + REGISTER_ELEMENT(Attribute); + REGISTER_ELEMENT(AttributeStatement); + REGISTER_ELEMENT_NOVAL(AttributeValue); + REGISTER_ELEMENT(Audience); + REGISTER_ELEMENT(AudienceRestriction); + REGISTER_ELEMENT(AuthenticatingAuthority); + REGISTER_ELEMENT(AuthnContext); + REGISTER_ELEMENT(AuthnContextClassRef); + REGISTER_ELEMENT_NOVAL(AuthnContextDecl); + REGISTER_ELEMENT(AuthnContextDeclRef); + REGISTER_ELEMENT(AuthnStatement); + REGISTER_ELEMENT(AuthzDecisionStatement); + REGISTER_ELEMENT(Conditions); + REGISTER_ELEMENT(Evidence); + REGISTER_ELEMENT(Issuer); + REGISTER_ELEMENT(NameID); + REGISTER_ELEMENT_NOVAL(OneTimeUse); + REGISTER_ELEMENT(ProxyRestriction); + REGISTER_ELEMENT(Subject); + REGISTER_ELEMENT(SubjectConfirmation); + REGISTER_ELEMENT_NOVAL(SubjectConfirmationData); + REGISTER_ELEMENT(SubjectLocality); + REGISTER_TYPE(Action); + REGISTER_TYPE(Advice); + REGISTER_TYPE(Assertion); + REGISTER_TYPE(Attribute); + REGISTER_TYPE(AttributeStatement); + REGISTER_TYPE(AudienceRestriction); + REGISTER_TYPE(AuthnContext); + REGISTER_TYPE(AuthnStatement); + REGISTER_TYPE(AuthzDecisionStatement); + REGISTER_TYPE(Conditions); + REGISTER_TYPE(Evidence); + REGISTER_TYPE(KeyInfoConfirmationDataType); + REGISTER_TYPE(NameIDType); + REGISTER_TYPE_NOVAL(OneTimeUse); + REGISTER_TYPE(ProxyRestriction); + REGISTER_TYPE(Subject); + REGISTER_TYPE(SubjectConfirmation); + REGISTER_TYPE(SubjectLocality); +} diff --git a/samltest/saml1/core/impl/ActionTest.h b/samltest/saml1/core/impl/ActionTest.h index 65c5fc1..f2f92bc 100644 --- a/samltest/saml1/core/impl/ActionTest.h +++ b/samltest/saml1/core/impl/ActionTest.h @@ -43,14 +43,14 @@ public: Action* action = dynamic_cast(xo.get()); TS_ASSERT(action!=NULL); TSM_ASSERT("namespace attribute present", action->getNamespace()==NULL); - TSM_ASSERT("Contents present", action->getValue()==NULL); + TSM_ASSERT("Contents present", action->getAction()==NULL); } void testSingleElementOptionalAttributesUnmarshall() { auto_ptr xo(unmarshallElement(singleElementOptionalAttributesFile)); Action* action = dynamic_cast(xo.get()); TSM_ASSERT_SAME_DATA("namespace attribute ", expectedNamespace, action->getNamespace(), XMLString::stringLen(expectedNamespace)); - TSM_ASSERT_SAME_DATA("Contents ", expectedContents, action->getValue(), XMLString::stringLen(expectedContents)); + TSM_ASSERT_SAME_DATA("Contents ", expectedContents, action->getAction(), XMLString::stringLen(expectedContents)); } void testSingleElementMarshall() { @@ -60,7 +60,7 @@ public: void testSingleElementOptionalAttributesMarshall() { Action* action=ActionBuilder::buildAction(); action->setNamespace(expectedNamespace); - action->setValue(expectedContents); + action->setAction(expectedContents); assertEquals(expectedOptionalAttributesDOM, action); } diff --git a/samltest/saml1/core/impl/AssertionIDReferenceTest.h b/samltest/saml1/core/impl/AssertionIDReferenceTest.h index e7ca8c5..a2b9846 100644 --- a/samltest/saml1/core/impl/AssertionIDReferenceTest.h +++ b/samltest/saml1/core/impl/AssertionIDReferenceTest.h @@ -39,13 +39,13 @@ public: auto_ptr xo(unmarshallElement(singleElementFile)); AssertionIDReference* assertionIDReference = dynamic_cast(xo.get()); TS_ASSERT(assertionIDReference!=NULL); - TSM_ASSERT("NCName present", assertionIDReference->getReference()==NULL); + TSM_ASSERT("NCName present", assertionIDReference->getAssertionID()==NULL); } void testSingleElementOptionalAttributesUnmarshall() { auto_ptr xo(unmarshallElement(singleElementOptionalAttributesFile)); AssertionIDReference* assertionIDReference = dynamic_cast(xo.get()); - TSM_ASSERT_SAME_DATA("NCName ", expectedNCName, assertionIDReference->getReference(), XMLString::stringLen(expectedNCName)); + TSM_ASSERT_SAME_DATA("NCName ", expectedNCName, assertionIDReference->getAssertionID(), XMLString::stringLen(expectedNCName)); } void testSingleElementMarshall() { @@ -54,7 +54,7 @@ public: void testSingleElementOptionalAttributesMarshall() { AssertionIDReference* assertionIDReference=AssertionIDReferenceBuilder::buildAssertionIDReference(); - assertionIDReference->setReference(expectedNCName); + assertionIDReference->setAssertionID(expectedNCName); assertEquals(expectedOptionalAttributesDOM, assertionIDReference); } diff --git a/samltest/saml1/core/impl/AudienceTest.h b/samltest/saml1/core/impl/AudienceTest.h index aa281c2..4b45d4f 100644 --- a/samltest/saml1/core/impl/AudienceTest.h +++ b/samltest/saml1/core/impl/AudienceTest.h @@ -38,13 +38,13 @@ public: void testSingleElementUnmarshall() { auto_ptr xo(unmarshallElement(singleElementFile)); Audience& a = dynamic_cast(*xo.get()); - TSM_ASSERT("Uri is non-null", a.getUri()==NULL); + TSM_ASSERT("Uri is non-null", a.getAudienceURI()==NULL); } void testSingleElementOptionalAttributesUnmarshall() { auto_ptr xo(unmarshallElement(singleElementOptionalAttributesFile)); Audience& a = dynamic_cast(*xo.get()); - TSM_ASSERT_SAME_DATA("Uri", expectedUri, a.getUri(), XMLString::stringLen(expectedUri)); + TSM_ASSERT_SAME_DATA("Uri", expectedUri, a.getAudienceURI(), XMLString::stringLen(expectedUri)); } void testSingleElementMarshall() { @@ -53,7 +53,7 @@ public: void testSingleElementOptionalAttributesMarshall() { Audience* a=AudienceBuilder::buildAudience(); - a->setUri(expectedUri); + a->setAudienceURI(expectedUri); assertEquals(expectedOptionalAttributesDOM, a); } diff --git a/samltest/signature/SAML1RequestTest.h b/samltest/signature/SAML1RequestTest.h index 7396d83..5cd2778 100644 --- a/samltest/signature/SAML1RequestTest.h +++ b/samltest/signature/SAML1RequestTest.h @@ -29,6 +29,7 @@ #include #include +using namespace opensaml::saml1p; using namespace opensaml::saml1; using namespace xmlsignature; diff --git a/samltest/signature/SAML1ResponseTest.h b/samltest/signature/SAML1ResponseTest.h index 89e679a..ac26175 100644 --- a/samltest/signature/SAML1ResponseTest.h +++ b/samltest/signature/SAML1ResponseTest.h @@ -28,6 +28,7 @@ #include #include +using namespace opensaml::saml1p; using namespace opensaml::saml1; using namespace xmlsignature; -- 2.1.4