saml/saml2/core/impl/Protocols20Impl.cpp

   1 /*
   2  *  Copyright 2001-2006 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * Protocols20Impl.cpp
  19  *
  20  * Implementation classes for SAML 2.0 Protocols schema
  21  */
  22
  23 #include "internal.h"
  24 #include "exceptions.h"
  25 #include "saml/encryption/EncryptedKeyResolver.h"
  26 #include "saml2/core/Protocols.h"
  27
  28 #include <xmltooling/AbstractChildlessElement.h>
  29 #include <xmltooling/AbstractComplexElement.h>
  30 #include <xmltooling/AbstractElementProxy.h>
  31 #include <xmltooling/AbstractSimpleElement.h>
  32 #include <xmltooling/encryption/Decrypter.h>
  33 #include <xmltooling/impl/AnyElement.h>
  34 #include <xmltooling/io/AbstractXMLObjectMarshaller.h>
  35 #include <xmltooling/io/AbstractXMLObjectUnmarshaller.h>
  36 #include <xmltooling/util/XMLHelper.h>
  37 #include <xmltooling/validation/AbstractValidatingXMLObject.h>
  38
  39 #include <ctime>
  40 #include <xercesc/util/XMLUniDefs.hpp>
  41
  42 using namespace opensaml::saml2p;
  43 using namespace opensaml::saml2;
  44 using namespace opensaml;
  45 using namespace xmlsignature;
  46 using namespace xmlencryption;
  47 using namespace xmltooling;
  48 using namespace std;
  49
  50 #if defined (_MSC_VER)
  51     #pragma warning( push )
  52     #pragma warning( disable : 4250 4251 )
  53 #endif
  54
  55 namespace opensaml {
  56     namespace saml2p {
  57
  58         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,Artifact);
  59         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,GetComplete);
  60         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,NewID);
  61         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,RequesterID);
  62         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,SessionIndex);
  63         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,StatusMessage);
  64
  65
  66         //TODO need unit test for this, using objects from another namespace
  67         class SAML_DLLLOCAL ExtensionsImpl : public virtual Extensions,
  68                                              public AbstractDOMCachingXMLObject,
  69                                              public AbstractElementProxy,
  70                                              public AbstractValidatingXMLObject,
  71                                              public AbstractXMLObjectMarshaller,
  72                                              public AbstractXMLObjectUnmarshaller
  73         {
  74         public:
  75             virtual ~ExtensionsImpl() {}
  76
  77             ExtensionsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
  78                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  79             }
  80
  81             ExtensionsImpl(const ExtensionsImpl& src)
  82                     : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractElementProxy(src),
  83                         AbstractValidatingXMLObject(src) {
  84                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
  85                     if (*i) {
  86                         getXMLObjects().push_back((*i)->clone());
  87                     }
  88                 }
  89             }
  90
  91             IMPL_XMLOBJECT_CLONE(Extensions);
  92
  93         protected:
  94             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
  95                 // Unknown child.
  96                 const XMLCh* nsURI=root->getNamespaceURI();
  97                 if (!XMLString::equals(nsURI,SAMLConstants::SAML20P_NS) && nsURI && *nsURI) {
  98                     getXMLObjects().push_back(childXMLObject);
  99                     return;
 100                 }
 101
 102                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 103             }
 104         };
 105
 106         class SAML_DLLLOCAL StatusCodeImpl : public virtual StatusCode,
 107                                              public AbstractComplexElement,
 108                                              public AbstractDOMCachingXMLObject,
 109                                              public AbstractValidatingXMLObject,
 110                                              public AbstractXMLObjectMarshaller,
 111                                              public AbstractXMLObjectUnmarshaller
 112         {
 113             void init() {
 114                 m_Value=NULL;
 115                 m_StatusCode=NULL;
 116                 m_children.push_back(NULL);
 117                 m_pos_StatusCode=m_children.begin();
 118             }
 119             public:
 120                 virtual ~StatusCodeImpl() {}
 121
 122                 StatusCodeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 123                     : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 124                 {
 125                         init();
 126                 }
 127
 128                 StatusCodeImpl(const StatusCodeImpl& src) : AbstractXMLObject(src),
 129                                                             AbstractDOMCachingXMLObject(src),
 130                                                             AbstractValidatingXMLObject(src)
 131                 {
 132                     init();
 133                     setValue(src.getValue());
 134                     if (src.getStatusCode())
 135                         setStatusCode(src.getStatusCode()->cloneStatusCode());
 136                 }
 137
 138                 IMPL_XMLOBJECT_CLONE(StatusCode);
 139                 IMPL_STRING_ATTRIB(Value);
 140                 IMPL_TYPED_CHILD(StatusCode);
 141
 142             protected:
 143                 void marshallAttributes(DOMElement* domElement) const {
 144                     MARSHALL_STRING_ATTRIB(Value,VALUE,NULL);
 145                 }
 146
 147                 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 148                     PROC_TYPED_CHILD(StatusCode,SAMLConstants::SAML20P_NS,false);
 149                     AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 150                 }
 151
 152                 void processAttribute(const DOMAttr* attribute) {
 153                     PROC_STRING_ATTRIB(Value,VALUE,NULL);
 154                     AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 155                 }
 156         };
 157
 158         //TODO need unit tests for non-SAML namespace children
 159         class SAML_DLLLOCAL StatusDetailImpl : public virtual StatusDetail,
 160                                                public AbstractComplexElement,
 161                                                public AbstractDOMCachingXMLObject,
 162                                                public AbstractValidatingXMLObject,
 163                                                public AbstractXMLObjectMarshaller,
 164                                                public AbstractXMLObjectUnmarshaller
 165         {
 166             public:
 167                 virtual ~StatusDetailImpl() {}
 168
 169                 StatusDetailImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 170                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
 171
 172                 StatusDetailImpl(const StatusDetailImpl& src) : AbstractXMLObject(src),
 173                                                                 AbstractDOMCachingXMLObject(src),
 174                                                                 AbstractValidatingXMLObject(src)
 175                 {
 176                         VectorOf(XMLObject) v=getDetails();
 177                         for (vector<XMLObject*>::const_iterator i=src.m_Details.begin(); i!=src.m_Details.end(); i++) {
 178                             if (*i) {
 179                                 v.push_back((*i)->clone());
 180                             }
 181                         }
 182                     }
 183
 184                 IMPL_XMLOBJECT_CLONE(StatusDetail);
 185                 IMPL_XMLOBJECT_CHILDREN(Detail,m_children.end());
 186
 187             protected:
 188                 void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 189                     getDetails().push_back(childXMLObject);
 190                     AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 191                 }
 192         };
 193
 194
 195         class SAML_DLLLOCAL StatusImpl : public virtual Status,
 196                                          public AbstractComplexElement,
 197                                          public AbstractDOMCachingXMLObject,
 198                                          public AbstractValidatingXMLObject,
 199                                          public AbstractXMLObjectMarshaller,
 200                                          public AbstractXMLObjectUnmarshaller
 201         {
 202             void init() {
 203                 m_StatusCode=NULL;
 204                 m_StatusMessage=NULL;
 205                 m_StatusDetail=NULL;
 206                 m_children.push_back(NULL);
 207                 m_children.push_back(NULL);
 208                 m_children.push_back(NULL);
 209                 m_pos_StatusCode=m_children.begin();
 210                 m_pos_StatusMessage=m_pos_StatusCode;
 211                 ++m_pos_StatusMessage;
 212                 m_pos_StatusDetail=m_pos_StatusMessage;
 213                 ++m_pos_StatusDetail;
 214             }
 215         public:
 216             virtual ~StatusImpl() { }
 217
 218             StatusImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 219                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 220             {
 221                     init();
 222             }
 223
 224             StatusImpl(const StatusImpl& src) : AbstractXMLObject(src),
 225                                                 AbstractDOMCachingXMLObject(src),
 226                                                 AbstractValidatingXMLObject(src)
 227             {
 228                 init();
 229                 if (src.getStatusCode())
 230                     setStatusCode(src.getStatusCode()->cloneStatusCode());
 231                 if (src.getStatusMessage())
 232                     setStatusMessage(src.getStatusMessage()->cloneStatusMessage());
 233                 if (src.getStatusDetail())
 234                     setStatusDetail(src.getStatusDetail()->cloneStatusDetail());
 235             }
 236
 237             IMPL_XMLOBJECT_CLONE(Status);
 238             IMPL_TYPED_CHILD(StatusCode);
 239             IMPL_TYPED_CHILD(StatusMessage);
 240             IMPL_TYPED_CHILD(StatusDetail);
 241
 242         protected:
 243
 244             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 245                 PROC_TYPED_CHILD(StatusCode,SAMLConstants::SAML20P_NS,false);
 246                 PROC_TYPED_CHILD(StatusMessage,SAMLConstants::SAML20P_NS,false);
 247                 PROC_TYPED_CHILD(StatusDetail,SAMLConstants::SAML20P_NS,false);
 248                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 249             }
 250
 251         };
 252
 253
 254         class SAML_DLLLOCAL RequestImpl : public virtual Request,
 255                                           public AbstractComplexElement,
 256                                           public AbstractDOMCachingXMLObject,
 257                                           public AbstractValidatingXMLObject,
 258                                           public AbstractXMLObjectMarshaller,
 259                                           public AbstractXMLObjectUnmarshaller
 260         {
 261             void init() {
 262                 m_ID=NULL;
 263                 m_Version=NULL;
 264                 m_IssueInstant=NULL;
 265                 m_Destination=NULL;
 266                 m_Consent=NULL;
 267                 m_Issuer=NULL;
 268                 m_Signature=NULL;
 269                 m_Extensions=NULL;
 270                 m_children.push_back(NULL);
 271                 m_children.push_back(NULL);
 272                 m_children.push_back(NULL);
 273                 m_pos_Issuer=m_children.begin();
 274                 m_pos_Signature=m_pos_Issuer;
 275                 ++m_pos_Signature;
 276                 m_pos_Extensions=m_pos_Signature;
 277                 ++m_pos_Extensions;
 278             }
 279         protected:
 280             RequestImpl() {
 281                 init();
 282             }
 283         public:
 284             virtual ~RequestImpl() {
 285                 XMLString::release(&m_ID);
 286                 XMLString::release(&m_Version);
 287                 XMLString::release(&m_Destination);
 288                 XMLString::release(&m_Consent);
 289                 delete m_IssueInstant;
 290             }
 291
 292             RequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 293                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 294             {
 295                 init();
 296             }
 297
 298             RequestImpl(const RequestImpl& src) : AbstractXMLObject(src),
 299                                                   AbstractDOMCachingXMLObject(src),
 300                                                   AbstractValidatingXMLObject(src)
 301             {
 302                 init();
 303                 setID(src.getID());
 304                 setVersion(src.getVersion());
 305                 setIssueInstant(src.getIssueInstant());
 306                 setDestination(src.getDestination());
 307                 setConsent(src.getConsent());
 308                 if (src.getIssuer())
 309                     setIssuer(src.getIssuer()->cloneIssuer());
 310                 if (src.getSignature())
 311                     setSignature(src.getSignature()->cloneSignature());
 312                 if (src.getExtensions())
 313                     setExtensions(src.getExtensions()->cloneExtensions());
 314             }
 315
 316             const XMLCh* getId() const {
 317                 return getID();
 318             }
 319
 320             //IMPL_TYPED_CHILD(Signature);
 321             // Need customized setter.
 322         protected:
 323             Signature* m_Signature;
 324             list<XMLObject*>::iterator m_pos_Signature;
 325         public:
 326             Signature* getSignature() const {
 327                 return m_Signature;
 328             }
 329
 330             void setSignature(Signature* sig) {
 331                 prepareForAssignment(m_Signature,sig);
 332                 *m_pos_Signature=m_Signature=sig;
 333                 // Sync content reference back up.
 334                 if (m_Signature)
 335                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
 336             }
 337
 338             IMPL_XMLOBJECT_CLONE(Request);
 339             IMPL_STRING_ATTRIB(Version);
 340             IMPL_STRING_ATTRIB(ID);
 341             IMPL_DATETIME_ATTRIB(IssueInstant);
 342             IMPL_STRING_ATTRIB(Destination);
 343             IMPL_STRING_ATTRIB(Consent);
 344             IMPL_TYPED_FOREIGN_CHILD(Issuer,saml2);
 345             IMPL_TYPED_CHILD(Extensions);
 346
 347         protected:
 348             void marshallAttributes(DOMElement* domElement) const {
 349                 if (!m_Version)
 350                     const_cast<RequestImpl*>(this)->m_Version=XMLString::transcode("2.0");
 351                 MARSHALL_STRING_ATTRIB(Version,VER,NULL);
 352                 if (!m_ID)
 353                     const_cast<RequestImpl*>(this)->m_ID=SAMLConfig::getConfig().generateIdentifier();
 354                 MARSHALL_ID_ATTRIB(ID,ID,NULL);
 355                 if (!m_IssueInstant)
 356                     const_cast<RequestImpl*>(this)->m_IssueInstant=new DateTime(time(NULL));
 357                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
 358                 MARSHALL_STRING_ATTRIB(Destination,DESTINATION,NULL);
 359                 MARSHALL_STRING_ATTRIB(Consent,CONSENT,NULL);
 360             }
 361
 362             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 363                 PROC_TYPED_FOREIGN_CHILD(Issuer,saml2,SAMLConstants::SAML20_NS,false);
 364                 PROC_TYPED_FOREIGN_CHILD(Signature,xmlsignature,XMLConstants::XMLSIG_NS,false);
 365                 PROC_TYPED_CHILD(Extensions,SAMLConstants::SAML20P_NS,false);
 366                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 367             }
 368
 369             void processAttribute(const DOMAttr* attribute) {
 370                 PROC_ID_ATTRIB(ID,ID,NULL);
 371                 PROC_STRING_ATTRIB(Version,VER,NULL);
 372                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
 373                 PROC_STRING_ATTRIB(Destination,DESTINATION,NULL);
 374                 PROC_STRING_ATTRIB(Consent,CONSENT,NULL);
 375                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 376             }
 377         };
 378
 379
 380         class SAML_DLLLOCAL AssertionIDRequestImpl : public virtual AssertionIDRequest, public RequestImpl
 381         {
 382         public:
 383             virtual ~AssertionIDRequestImpl() { }
 384
 385             AssertionIDRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 386                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
 387
 388             AssertionIDRequestImpl(const AssertionIDRequestImpl& src) : AbstractXMLObject(src),
 389                                                                         RequestImpl(src)
 390             {
 391                 VectorOf(AssertionIDRef) v=getAssertionIDRefs();
 392                 for (vector<AssertionIDRef*>::const_iterator i=src.m_AssertionIDRefs.begin(); i!=src.m_AssertionIDRefs.end(); i++) {
 393                     if (*i) {
 394                         v.push_back((*i)->cloneAssertionIDRef());
 395                     }
 396                 }
 397
 398             }
 399
 400             IMPL_XMLOBJECT_CLONE(AssertionIDRequest);
 401             IMPL_TYPED_FOREIGN_CHILDREN(AssertionIDRef,saml2,m_children.end());
 402
 403         protected:
 404             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 405                 PROC_TYPED_FOREIGN_CHILDREN(AssertionIDRef,saml2,SAMLConstants::SAML20_NS,false);
 406                 RequestImpl::processChildElement(childXMLObject,root);
 407             }
 408         };
 409
 410         class SAML_DLLLOCAL SubjectQueryImpl : public virtual SubjectQuery, public RequestImpl
 411         {
 412             void init()
 413             {
 414                 m_Subject = NULL;
 415                 m_children.push_back(NULL);
 416                 m_pos_Subject = m_pos_Extensions;
 417                 ++m_pos_Subject;
 418             }
 419         protected:
 420             SubjectQueryImpl() {
 421                 init();
 422             }
 423         public:
 424             virtual ~SubjectQueryImpl() { }
 425
 426             SubjectQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 427                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 428             {
 429                 init();
 430             }
 431
 432             SubjectQueryImpl(const SubjectQueryImpl& src) : AbstractXMLObject(src),
 433                                                             RequestImpl(src)
 434             {
 435                 init();
 436                 if (src.getSubject())
 437                     setSubject(src.getSubject()->cloneSubject());
 438             }
 439
 440             IMPL_XMLOBJECT_CLONE(SubjectQuery);
 441             IMPL_TYPED_FOREIGN_CHILD(Subject,saml2);
 442
 443         protected:
 444             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 445                 PROC_TYPED_FOREIGN_CHILD(Subject,saml2,SAMLConstants::SAML20_NS,false);
 446                 RequestImpl::processChildElement(childXMLObject,root);
 447             }
 448         };
 449
 450
 451         class SAML_DLLLOCAL RequestedAuthnContextImpl : public virtual RequestedAuthnContext,
 452                                                         public AbstractComplexElement,
 453                                                         public AbstractDOMCachingXMLObject,
 454                                                         public AbstractValidatingXMLObject,
 455                                                         public AbstractXMLObjectMarshaller,
 456                                                         public AbstractXMLObjectUnmarshaller
 457         {
 458             void init() {
 459                 m_Comparison=NULL;
 460             }
 461         public:
 462             virtual ~RequestedAuthnContextImpl() {
 463                 XMLString::release(&m_Comparison);
 464             }
 465
 466             RequestedAuthnContextImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 467                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 468             {
 469                 init();
 470             }
 471
 472             RequestedAuthnContextImpl(const RequestedAuthnContextImpl& src) : AbstractXMLObject(src),
 473                                                                               AbstractDOMCachingXMLObject(src),
 474                                                                               AbstractValidatingXMLObject(src)
 475             {
 476                 init();
 477                 setComparison(src.getComparison());
 478                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 479                     if (*i) {
 480                         AuthnContextClassRef* classref=dynamic_cast<AuthnContextClassRef*>(*i);
 481                         if (classref) {
 482                             getAuthnContextClassRefs().push_back(classref->cloneAuthnContextClassRef());
 483                             continue;
 484                         }
 485
 486                         AuthnContextDeclRef* declref=dynamic_cast<AuthnContextDeclRef*>(*i);
 487                         if (declref) {
 488                             getAuthnContextDeclRefs().push_back(declref->cloneAuthnContextDeclRef());
 489                             continue;
 490                         }
 491                     }
 492                 }
 493             }
 494
 495             IMPL_XMLOBJECT_CLONE(RequestedAuthnContext);
 496             IMPL_STRING_ATTRIB(Comparison);
 497             IMPL_TYPED_FOREIGN_CHILDREN(AuthnContextClassRef,saml2,m_children.end());
 498             IMPL_TYPED_FOREIGN_CHILDREN(AuthnContextDeclRef,saml2,m_children.end());
 499
 500         protected:
 501             void marshallAttributes(DOMElement* domElement) const {
 502                 MARSHALL_STRING_ATTRIB(Comparison,COMPARISON,NULL);
 503             }
 504
 505             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 506                 PROC_TYPED_FOREIGN_CHILDREN(AuthnContextClassRef,saml2,SAMLConstants::SAML20_NS,false);
 507                 PROC_TYPED_FOREIGN_CHILDREN(AuthnContextDeclRef,saml2,SAMLConstants::SAML20_NS,false);
 508                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 509             }
 510
 511             void processAttribute(const DOMAttr* attribute) {
 512                 PROC_STRING_ATTRIB(Comparison,COMPARISON,NULL);
 513                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 514             }
 515         };
 516
 517
 518         class SAML_DLLLOCAL AuthnQueryImpl : public virtual AuthnQuery, public SubjectQueryImpl
 519         {
 520             void init() {
 521                 m_SessionIndex=NULL;
 522                 m_RequestedAuthnContext=NULL;
 523                 m_children.push_back(NULL);
 524                 m_pos_RequestedAuthnContext = m_pos_Subject;
 525                 ++m_pos_RequestedAuthnContext;
 526
 527             }
 528         public:
 529             virtual ~AuthnQueryImpl() {
 530                 XMLString::release(&m_SessionIndex);
 531             }
 532
 533             AuthnQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 534                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 535             {
 536                 init();
 537             }
 538
 539             AuthnQueryImpl(const AuthnQueryImpl& src) : AbstractXMLObject(src),
 540                                                         SubjectQueryImpl(src)
 541             {
 542                 init();
 543                 setSessionIndex(src.getSessionIndex());
 544                 if (src.getRequestedAuthnContext())
 545                     setRequestedAuthnContext(src.getRequestedAuthnContext()->cloneRequestedAuthnContext());
 546             }
 547
 548             IMPL_XMLOBJECT_CLONE(AuthnQuery);
 549             IMPL_STRING_ATTRIB(SessionIndex);
 550             IMPL_TYPED_CHILD(RequestedAuthnContext);
 551
 552         protected:
 553             void marshallAttributes(DOMElement* domElement) const {
 554                 MARSHALL_STRING_ATTRIB(SessionIndex,SESSIONINDEX,NULL);
 555                 SubjectQueryImpl::marshallAttributes(domElement);
 556             }
 557
 558             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 559                 PROC_TYPED_CHILD(RequestedAuthnContext,SAMLConstants::SAML20P_NS,false);
 560                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 561             }
 562             void processAttribute(const DOMAttr* attribute) {
 563                 PROC_STRING_ATTRIB(SessionIndex,SESSIONINDEX,NULL);
 564                 SubjectQueryImpl::processAttribute(attribute);
 565             }
 566         };
 567
 568         class SAML_DLLLOCAL AttributeQueryImpl : public virtual AttributeQuery, public SubjectQueryImpl
 569         {
 570         public:
 571             virtual ~AttributeQueryImpl() { }
 572
 573             AttributeQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 574                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
 575
 576             AttributeQueryImpl(const AttributeQueryImpl& src) : AbstractXMLObject(src),
 577                                                                 SubjectQueryImpl(src)
 578             {
 579                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 580                     if (*i) {
 581                         Attribute* attrib=dynamic_cast<Attribute*>(*i);
 582                         if (attrib) {
 583                             getAttributes().push_back(attrib->cloneAttribute());
 584                             continue;
 585                         }
 586                     }
 587                 }
 588
 589             }
 590
 591             IMPL_XMLOBJECT_CLONE(AttributeQuery);
 592             IMPL_TYPED_FOREIGN_CHILDREN(Attribute,saml2,m_children.end());
 593
 594         protected:
 595             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 596                 PROC_TYPED_FOREIGN_CHILDREN(Attribute,saml2,SAMLConstants::SAML20_NS,false);
 597                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 598             }
 599         };
 600
 601         class SAML_DLLLOCAL AuthzDecisionQueryImpl : public virtual AuthzDecisionQuery, public SubjectQueryImpl
 602         {
 603             void init() {
 604                 m_Resource=NULL;
 605                 m_Evidence=NULL;
 606                 m_children.push_back(NULL);
 607                 m_pos_Evidence=m_pos_Subject;
 608                 ++m_pos_Evidence;
 609
 610             }
 611         public:
 612             virtual ~AuthzDecisionQueryImpl() {
 613                 XMLString::release(&m_Resource);
 614             }
 615
 616             AuthzDecisionQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 617                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 618             {
 619                 init();
 620             }
 621
 622             AuthzDecisionQueryImpl(const AuthzDecisionQueryImpl& src) : AbstractXMLObject(src),
 623                                                         SubjectQueryImpl(src)
 624             {
 625                 init();
 626                 setResource(src.getResource());
 627                 if (src.getEvidence())
 628                     setEvidence(src.getEvidence()->cloneEvidence());
 629                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 630                     if (*i) {
 631                         Action* action=dynamic_cast<Action*>(*i);
 632                         if (action) {
 633                             getActions().push_back(action->cloneAction());
 634                             continue;
 635                         }
 636                     }
 637                 }
 638             }
 639
 640             IMPL_XMLOBJECT_CLONE(AuthzDecisionQuery);
 641             IMPL_STRING_ATTRIB(Resource);
 642             IMPL_TYPED_FOREIGN_CHILDREN(Action,saml2,m_pos_Evidence);
 643             IMPL_TYPED_FOREIGN_CHILD(Evidence,saml2);
 644
 645         protected:
 646             void marshallAttributes(DOMElement* domElement) const {
 647                 MARSHALL_STRING_ATTRIB(Resource,RESOURCE,NULL);
 648                 SubjectQueryImpl::marshallAttributes(domElement);
 649             }
 650
 651             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 652                 PROC_TYPED_FOREIGN_CHILD(Evidence,saml2,SAMLConstants::SAML20_NS,false);
 653                 PROC_TYPED_FOREIGN_CHILDREN(Action,saml2,SAMLConstants::SAML20_NS,false);
 654                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 655             }
 656             void processAttribute(const DOMAttr* attribute) {
 657                 PROC_STRING_ATTRIB(Resource,RESOURCE,NULL);
 658                 SubjectQueryImpl::processAttribute(attribute);
 659             }
 660         };
 661
 662         class SAML_DLLLOCAL NameIDPolicyImpl : public virtual NameIDPolicy,
 663                                                public AbstractChildlessElement,
 664                                                public AbstractDOMCachingXMLObject,
 665                                                public AbstractValidatingXMLObject,
 666                                                public AbstractXMLObjectMarshaller,
 667                                                public AbstractXMLObjectUnmarshaller
 668         {
 669             void init() {
 670                 m_Format=NULL;
 671                 m_SPNameQualifier=NULL;
 672                 m_AllowCreate=XMLConstants::XML_BOOL_NULL;
 673             }
 674             public:
 675                 virtual ~NameIDPolicyImpl()
 676                 {
 677                     XMLString::release(&m_Format);
 678                     XMLString::release(&m_SPNameQualifier);
 679                 }
 680
 681                 NameIDPolicyImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 682                     : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 683                 {
 684                         init();
 685                 }
 686
 687                 NameIDPolicyImpl(const NameIDPolicyImpl& src) : AbstractXMLObject(src),
 688                                                                 AbstractDOMCachingXMLObject(src),
 689                                                                 AbstractValidatingXMLObject(src)
 690                 {
 691                     init();
 692                     setFormat(src.getFormat());
 693                     setSPNameQualifier(src.getSPNameQualifier());
 694                     AllowCreate(m_AllowCreate);
 695                 }
 696
 697                 IMPL_XMLOBJECT_CLONE(NameIDPolicy);
 698                 IMPL_STRING_ATTRIB(Format);
 699                 IMPL_STRING_ATTRIB(SPNameQualifier);
 700                 IMPL_BOOLEAN_ATTRIB(AllowCreate);
 701
 702             protected:
 703                 void marshallAttributes(DOMElement* domElement) const {
 704                     MARSHALL_STRING_ATTRIB(Format,FORMAT,NULL);
 705                     MARSHALL_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,NULL);
 706                     MARSHALL_BOOLEAN_ATTRIB(AllowCreate,ALLOWCREATE,NULL);
 707                 }
 708
 709                 void processAttribute(const DOMAttr* attribute) {
 710                     PROC_STRING_ATTRIB(Format,FORMAT,NULL);
 711                     PROC_STRING_ATTRIB(SPNameQualifier,SPNAMEQUALIFIER,NULL);
 712                     PROC_BOOLEAN_ATTRIB(AllowCreate,ALLOWCREATE,NULL);
 713                     AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 714                 }
 715         };
 716
 717         class SAML_DLLLOCAL IDPEntryImpl : public virtual IDPEntry,
 718                                            public AbstractChildlessElement,
 719                                            public AbstractDOMCachingXMLObject,
 720                                            public AbstractValidatingXMLObject,
 721                                            public AbstractXMLObjectMarshaller,
 722                                            public AbstractXMLObjectUnmarshaller
 723         {
 724             void init() {
 725                 m_ProviderID=NULL;
 726                 m_Name=NULL;
 727                 m_Loc=NULL;
 728             }
 729             public:
 730                 virtual ~IDPEntryImpl()
 731                 {
 732                     XMLString::release(&m_ProviderID);
 733                     XMLString::release(&m_Name);
 734                     XMLString::release(&m_Loc);
 735                 }
 736
 737                 IDPEntryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 738                     : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 739                 {
 740                         init();
 741                 }
 742
 743                 IDPEntryImpl(const IDPEntryImpl& src) : AbstractXMLObject(src),
 744                                                                 AbstractDOMCachingXMLObject(src),
 745                                                                 AbstractValidatingXMLObject(src)
 746                 {
 747                     init();
 748                     setProviderID(src.getProviderID());
 749                     setName(src.getName());
 750                     setLoc(src.getLoc());
 751                 }
 752
 753                 IMPL_XMLOBJECT_CLONE(IDPEntry);
 754                 IMPL_STRING_ATTRIB(ProviderID);
 755                 IMPL_STRING_ATTRIB(Name);
 756                 IMPL_STRING_ATTRIB(Loc);
 757
 758             protected:
 759                 void marshallAttributes(DOMElement* domElement) const {
 760                     MARSHALL_STRING_ATTRIB(ProviderID,PROVIDERID,NULL);
 761                     MARSHALL_STRING_ATTRIB(Name,NAME,NULL);
 762                     MARSHALL_STRING_ATTRIB(Loc,LOC,NULL);
 763                 }
 764
 765                 void processAttribute(const DOMAttr* attribute) {
 766                     PROC_STRING_ATTRIB(ProviderID,PROVIDERID,NULL);
 767                     PROC_STRING_ATTRIB(Name,NAME,NULL);
 768                     PROC_STRING_ATTRIB(Loc,LOC,NULL);
 769                     AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 770                 }
 771         };
 772
 773         class SAML_DLLLOCAL IDPListImpl : public virtual IDPList,
 774                                           public AbstractComplexElement,
 775                                           public AbstractDOMCachingXMLObject,
 776                                           public AbstractValidatingXMLObject,
 777                                           public AbstractXMLObjectMarshaller,
 778                                           public AbstractXMLObjectUnmarshaller
 779         {
 780             void init() {
 781                 m_GetComplete=NULL;
 782                 m_children.push_back(NULL);
 783                 m_pos_GetComplete=m_children.begin();
 784
 785             }
 786         public:
 787             virtual ~IDPListImpl() { }
 788
 789             IDPListImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 790                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 791             {
 792                 init();
 793             }
 794
 795             IDPListImpl(const IDPListImpl& src) : AbstractXMLObject(src),
 796                                                   AbstractComplexElement(src),
 797                                                   AbstractDOMCachingXMLObject(src),
 798                                                   AbstractValidatingXMLObject(src)
 799             {
 800                 init();
 801                 if (src.getGetComplete())
 802                     setGetComplete(src.getGetComplete()->cloneGetComplete());
 803                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 804                     if (*i) {
 805                         IDPEntry* entry=dynamic_cast<IDPEntry*>(*i);
 806                         if (entry) {
 807                             getIDPEntrys().push_back(entry->cloneIDPEntry());
 808                             continue;
 809                         }
 810                     }
 811                 }
 812             }
 813
 814             IMPL_XMLOBJECT_CLONE(IDPList);
 815             IMPL_TYPED_CHILDREN(IDPEntry,m_pos_GetComplete);
 816             IMPL_TYPED_CHILD(GetComplete);
 817
 818         protected:
 819             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 820                 PROC_TYPED_CHILDREN(IDPEntry,SAMLConstants::SAML20P_NS,false);
 821                 PROC_TYPED_CHILD(GetComplete,SAMLConstants::SAML20P_NS,false);
 822                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 823             }
 824         };
 825
 826
 827         class SAML_DLLLOCAL ScopingImpl : public virtual Scoping,
 828                                           public AbstractComplexElement,
 829                                           public AbstractDOMCachingXMLObject,
 830                                           public AbstractValidatingXMLObject,
 831                                           public AbstractXMLObjectMarshaller,
 832                                           public AbstractXMLObjectUnmarshaller
 833         {
 834             void init() {
 835                 m_ProxyCount=NULL;
 836                 m_IDPList=NULL;
 837                 m_children.push_back(NULL);
 838                 m_pos_IDPList=m_children.begin();
 839
 840             }
 841         public:
 842             virtual ~ScopingImpl() {
 843                 XMLString::release(&m_ProxyCount);
 844             }
 845
 846             ScopingImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 847                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 848             {
 849                 init();
 850             }
 851
 852             ScopingImpl(const ScopingImpl& src) : AbstractXMLObject(src),
 853                                                   AbstractComplexElement(src),
 854                                                   AbstractDOMCachingXMLObject(src),
 855                                                   AbstractValidatingXMLObject(src)
 856             {
 857                 init();
 858                 setProxyCount(m_ProxyCount);
 859                 if (src.getIDPList())
 860                     setIDPList(src.getIDPList()->cloneIDPList());
 861                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 862                     if (*i) {
 863                         RequesterID* reqid =dynamic_cast<RequesterID*>(*i);
 864                         if (reqid) {
 865                             getRequesterIDs().push_back(reqid->cloneRequesterID());
 866                             continue;
 867                         }
 868                     }
 869                 }
 870             }
 871
 872             IMPL_XMLOBJECT_CLONE(Scoping);
 873             IMPL_INTEGER_ATTRIB(ProxyCount);
 874             IMPL_TYPED_CHILD(IDPList);
 875             IMPL_TYPED_CHILDREN(RequesterID,m_children.end());
 876
 877         protected:
 878             void marshallAttributes(DOMElement* domElement) const {
 879                     MARSHALL_INTEGER_ATTRIB(ProxyCount,PROXYCOUNT,NULL);
 880             }
 881
 882             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 883                 PROC_TYPED_CHILD(IDPList,SAMLConstants::SAML20P_NS,false);
 884                 PROC_TYPED_CHILDREN(RequesterID,SAMLConstants::SAML20P_NS,false);
 885                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 886             }
 887
 888             void processAttribute(const DOMAttr* attribute) {
 889                 PROC_INTEGER_ATTRIB(ProxyCount,PROXYCOUNT,NULL);
 890                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 891             }
 892         };
 893
 894         class SAML_DLLLOCAL AuthnRequestImpl : public virtual AuthnRequest, public RequestImpl
 895         {
 896             void init() {
 897                 m_ForceAuthn=XMLConstants::XML_BOOL_NULL;
 898                 m_IsPassive=XMLConstants::XML_BOOL_NULL;
 899                 m_ProtocolBinding=NULL;
 900                 m_AssertionConsumerServiceIndex=NULL;
 901                 m_AssertionConsumerServiceURL=NULL;
 902                 m_AttributeConsumingServiceIndex=NULL;
 903                 m_ProviderName=NULL;
 904
 905                 m_Subject=NULL;
 906                 m_NameIDPolicy=NULL;
 907                 m_Conditions=NULL;
 908                 m_RequestedAuthnContext=NULL;
 909                 m_Scoping=NULL;
 910                 m_children.push_back(NULL);
 911                 m_children.push_back(NULL);
 912                 m_children.push_back(NULL);
 913                 m_children.push_back(NULL);
 914                 m_children.push_back(NULL);
 915                 m_pos_Subject=m_pos_Extensions;
 916                 ++m_pos_Subject;
 917                 m_pos_NameIDPolicy=m_pos_Subject;
 918                 ++m_pos_NameIDPolicy;
 919                 m_pos_Conditions=m_pos_NameIDPolicy;
 920                 ++m_pos_Conditions;
 921                 m_pos_RequestedAuthnContext=m_pos_Conditions;
 922                 ++m_pos_RequestedAuthnContext;
 923                 m_pos_Scoping=m_pos_RequestedAuthnContext;
 924                 ++m_pos_Scoping;
 925
 926             }
 927         public:
 928             virtual ~AuthnRequestImpl() {
 929                 XMLString::release(&m_ProtocolBinding);
 930                 XMLString::release(&m_AssertionConsumerServiceURL);
 931                 XMLString::release(&m_ProviderName);
 932                 XMLString::release(&m_AssertionConsumerServiceIndex);
 933                 XMLString::release(&m_AttributeConsumingServiceIndex);
 934             }
 935
 936             AuthnRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 937                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
 938             {
 939                 init();
 940             }
 941
 942             AuthnRequestImpl(const AuthnRequestImpl& src) : AbstractXMLObject(src),
 943                                                             RequestImpl(src)
 944             {
 945                 init();
 946
 947                 ForceAuthn(m_ForceAuthn);
 948                 IsPassive(m_IsPassive);
 949                 setProtocolBinding(src.getProtocolBinding());
 950                 setAssertionConsumerServiceIndex(m_AssertionConsumerServiceIndex);
 951                 setAssertionConsumerServiceURL(src.getAssertionConsumerServiceURL());
 952                 setAttributeConsumingServiceIndex(m_AttributeConsumingServiceIndex);
 953                 setProviderName(src.getProviderName());
 954
 955                 if (src.getSubject())
 956                     setSubject(src.getSubject()->cloneSubject());
 957                 if (src.getNameIDPolicy())
 958                     setNameIDPolicy(src.getNameIDPolicy()->cloneNameIDPolicy());
 959                 if (src.getConditions())
 960                     setConditions(src.getConditions()->cloneConditions());
 961                 if (src.getRequestedAuthnContext())
 962                     setRequestedAuthnContext(src.getRequestedAuthnContext()->cloneRequestedAuthnContext());
 963                 if (src.getScoping())
 964                     setScoping(src.getScoping()->cloneScoping());
 965             }
 966
 967             IMPL_XMLOBJECT_CLONE(AuthnRequest);
 968
 969             IMPL_BOOLEAN_ATTRIB(ForceAuthn);
 970             IMPL_BOOLEAN_ATTRIB(IsPassive);
 971             IMPL_STRING_ATTRIB(ProtocolBinding);
 972             IMPL_INTEGER_ATTRIB(AssertionConsumerServiceIndex);
 973             IMPL_STRING_ATTRIB(AssertionConsumerServiceURL);
 974             IMPL_INTEGER_ATTRIB(AttributeConsumingServiceIndex);
 975             IMPL_STRING_ATTRIB(ProviderName);
 976
 977             IMPL_TYPED_FOREIGN_CHILD(Subject,saml2);
 978             IMPL_TYPED_CHILD(NameIDPolicy);
 979             IMPL_TYPED_FOREIGN_CHILD(Conditions,saml2);
 980             IMPL_TYPED_CHILD(RequestedAuthnContext);
 981             IMPL_TYPED_CHILD(Scoping);
 982
 983         protected:
 984             void marshallAttributes(DOMElement* domElement) const {
 985                 MARSHALL_BOOLEAN_ATTRIB(ForceAuthn,FORCEAUTHN,NULL);
 986                 MARSHALL_BOOLEAN_ATTRIB(IsPassive,ISPASSIVE,NULL);
 987                 MARSHALL_STRING_ATTRIB(ProtocolBinding,PROTOCOLBINDING,NULL);
 988                 MARSHALL_INTEGER_ATTRIB(AssertionConsumerServiceIndex,ASSERTIONCONSUMERSERVICEINDEX,NULL);
 989                 MARSHALL_STRING_ATTRIB(AssertionConsumerServiceURL,ASSERTIONCONSUMERSERVICEURL,NULL);
 990                 MARSHALL_INTEGER_ATTRIB(AttributeConsumingServiceIndex,ATTRIBUTECONSUMINGSERVICEINDEX,NULL);
 991                 MARSHALL_STRING_ATTRIB(ProviderName,PROVIDERNAME,NULL);
 992                 RequestImpl::marshallAttributes(domElement);
 993             }
 994
 995             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 996                 PROC_TYPED_FOREIGN_CHILD(Subject,saml2,SAMLConstants::SAML20_NS,false);
 997                 PROC_TYPED_CHILD(NameIDPolicy,SAMLConstants::SAML20P_NS,false);
 998                 PROC_TYPED_FOREIGN_CHILD(Conditions,saml2,SAMLConstants::SAML20_NS,false);
 999                 PROC_TYPED_CHILD(RequestedAuthnContext,SAMLConstants::SAML20P_NS,false);
1000                 PROC_TYPED_CHILD(Scoping,SAMLConstants::SAML20P_NS,false);
1001                 RequestImpl::processChildElement(childXMLObject,root);
1002             }
1003             void processAttribute(const DOMAttr* attribute) {
1004                 PROC_BOOLEAN_ATTRIB(ForceAuthn,FORCEAUTHN,NULL);
1005                 PROC_BOOLEAN_ATTRIB(IsPassive,ISPASSIVE,NULL);
1006                 PROC_STRING_ATTRIB(ProtocolBinding,PROTOCOLBINDING,NULL);
1007                 PROC_INTEGER_ATTRIB(AssertionConsumerServiceIndex,ASSERTIONCONSUMERSERVICEINDEX,NULL);
1008                 PROC_STRING_ATTRIB(AssertionConsumerServiceURL,ASSERTIONCONSUMERSERVICEURL,NULL);
1009                 PROC_INTEGER_ATTRIB(AttributeConsumingServiceIndex,ATTRIBUTECONSUMINGSERVICEINDEX,NULL);
1010                 PROC_STRING_ATTRIB(ProviderName,PROVIDERNAME,NULL);
1011                 RequestImpl::processAttribute(attribute);
1012             }
1013         };
1014
1015         class SAML_DLLLOCAL StatusResponseImpl : public virtual StatusResponse,
1016                                                  public AbstractComplexElement,
1017                                                  public AbstractDOMCachingXMLObject,
1018                                                  public AbstractValidatingXMLObject,
1019                                                  public AbstractXMLObjectMarshaller,
1020                                                  public AbstractXMLObjectUnmarshaller
1021         {
1022             void init() {
1023                 m_ID=NULL;
1024                 m_InResponseTo=NULL;
1025                 m_Version=NULL;
1026                 m_IssueInstant=NULL;
1027                 m_Destination=NULL;
1028                 m_Consent=NULL;
1029                 m_Issuer=NULL;
1030                 m_Signature=NULL;
1031                 m_Extensions=NULL;
1032                 m_Status=NULL;
1033                 m_children.push_back(NULL);
1034                 m_children.push_back(NULL);
1035                 m_children.push_back(NULL);
1036                 m_children.push_back(NULL);
1037                 m_pos_Issuer=m_children.begin();
1038                 m_pos_Signature=m_pos_Issuer;
1039                 ++m_pos_Signature;
1040                 m_pos_Extensions=m_pos_Signature;
1041                 ++m_pos_Extensions;
1042                 m_pos_Status=m_pos_Extensions;
1043                 ++m_pos_Status;
1044             }
1045         protected:
1046             StatusResponseImpl() {
1047                 init();
1048             }
1049         public:
1050             virtual ~StatusResponseImpl() {
1051                 XMLString::release(&m_ID);
1052                 XMLString::release(&m_InResponseTo);
1053                 XMLString::release(&m_Version);
1054                 XMLString::release(&m_Destination);
1055                 XMLString::release(&m_Consent);
1056                 delete m_IssueInstant;
1057             }
1058
1059             StatusResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1060                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1061             {
1062                 init();
1063             }
1064
1065             StatusResponseImpl(const StatusResponseImpl& src) : AbstractXMLObject(src),
1066                                                                 AbstractDOMCachingXMLObject(src),
1067                                                                 AbstractValidatingXMLObject(src)
1068             {
1069                 init();
1070                 setID(src.getID());
1071                 setInResponseTo(src.getInResponseTo());
1072                 setVersion(src.getVersion());
1073                 setIssueInstant(src.getIssueInstant());
1074                 setDestination(src.getDestination());
1075                 setConsent(src.getConsent());
1076                 if (src.getIssuer())
1077                     setIssuer(src.getIssuer()->cloneIssuer());
1078                 if (src.getSignature())
1079                     setSignature(src.getSignature()->cloneSignature());
1080                 if (src.getExtensions())
1081                     setExtensions(src.getExtensions()->cloneExtensions());
1082                 if (src.getStatus())
1083                     setStatus(src.getStatus()->cloneStatus());
1084             }
1085
1086             const XMLCh* getId() const {
1087                 return getID();
1088             }
1089
1090             //IMPL_TYPED_CHILD(Signature);
1091             // Need customized setter.
1092         protected:
1093             Signature* m_Signature;
1094             list<XMLObject*>::iterator m_pos_Signature;
1095         public:
1096             Signature* getSignature() const {
1097                 return m_Signature;
1098             }
1099
1100             void setSignature(Signature* sig) {
1101                 prepareForAssignment(m_Signature,sig);
1102                 *m_pos_Signature=m_Signature=sig;
1103                 // Sync content reference back up.
1104                 if (m_Signature)
1105                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
1106             }
1107
1108             IMPL_XMLOBJECT_CLONE(StatusResponse);
1109             IMPL_STRING_ATTRIB(Version);
1110             IMPL_STRING_ATTRIB(ID);
1111             IMPL_STRING_ATTRIB(InResponseTo);
1112             IMPL_DATETIME_ATTRIB(IssueInstant);
1113             IMPL_STRING_ATTRIB(Destination);
1114             IMPL_STRING_ATTRIB(Consent);
1115             IMPL_TYPED_FOREIGN_CHILD(Issuer,saml2);
1116             IMPL_TYPED_CHILD(Extensions);
1117             IMPL_TYPED_CHILD(Status);
1118
1119         protected:
1120             void marshallAttributes(DOMElement* domElement) const {
1121                 if (!m_Version)
1122                     const_cast<StatusResponseImpl*>(this)->m_Version=XMLString::transcode("2.0");
1123                 MARSHALL_STRING_ATTRIB(Version,VER,NULL);
1124                 if (!m_ID)
1125                     const_cast<StatusResponseImpl*>(this)->m_ID=SAMLConfig::getConfig().generateIdentifier();
1126                 MARSHALL_ID_ATTRIB(ID,ID,NULL);
1127                 if (!m_IssueInstant)
1128                     const_cast<StatusResponseImpl*>(this)->m_IssueInstant=new DateTime(time(NULL));
1129                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
1130                 MARSHALL_STRING_ATTRIB(Destination,DESTINATION,NULL);
1131                 MARSHALL_STRING_ATTRIB(Consent,CONSENT,NULL);
1132                 MARSHALL_STRING_ATTRIB(InResponseTo,INRESPONSETO,NULL);
1133             }
1134
1135             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1136                 PROC_TYPED_FOREIGN_CHILD(Issuer,saml2,SAMLConstants::SAML20_NS,false);
1137                 PROC_TYPED_FOREIGN_CHILD(Signature,xmlsignature,XMLConstants::XMLSIG_NS,false);
1138                 PROC_TYPED_CHILD(Extensions,SAMLConstants::SAML20P_NS,false);
1139                 PROC_TYPED_CHILD(Status,SAMLConstants::SAML20P_NS,false);
1140                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1141             }
1142
1143             void processAttribute(const DOMAttr* attribute) {
1144                 PROC_ID_ATTRIB(ID,ID,NULL);
1145                 PROC_STRING_ATTRIB(Version,VER,NULL);
1146                 PROC_STRING_ATTRIB(InResponseTo,INRESPONSETO,NULL);
1147                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
1148                 PROC_STRING_ATTRIB(Destination,DESTINATION,NULL);
1149                 PROC_STRING_ATTRIB(Consent,CONSENT,NULL);
1150                 AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1151             }
1152         };
1153
1154         class SAML_DLLLOCAL ResponseImpl : public virtual Response, public StatusResponseImpl
1155         {
1156         public:
1157             virtual ~ResponseImpl() { }
1158
1159             ResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1160                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1161
1162             ResponseImpl(const ResponseImpl& src) : AbstractXMLObject(src),
1163                                                     StatusResponseImpl(src)
1164             {
1165                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
1166                     if (*i) {
1167                         Assertion* assertion=dynamic_cast<Assertion*>(*i);
1168                         if (assertion) {
1169                             getAssertions().push_back(assertion->cloneAssertion());
1170                             continue;
1171                         }
1172                         EncryptedAssertion* encAssertion=dynamic_cast<EncryptedAssertion*>(*i);
1173                         if (encAssertion) {
1174                             getEncryptedAssertions().push_back(encAssertion->cloneEncryptedAssertion());
1175                             continue;
1176                         }
1177                     }
1178                 }
1179
1180             }
1181
1182             IMPL_XMLOBJECT_CLONE(Response);
1183             IMPL_TYPED_FOREIGN_CHILDREN(Assertion,saml2,m_children.end());
1184             IMPL_TYPED_FOREIGN_CHILDREN(EncryptedAssertion,saml2,m_children.end());
1185
1186         protected:
1187             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1188                 PROC_TYPED_FOREIGN_CHILDREN(Assertion,saml2,SAMLConstants::SAML20_NS,false);
1189                 PROC_TYPED_FOREIGN_CHILDREN(EncryptedAssertion,saml2,SAMLConstants::SAML20_NS,false);
1190                 StatusResponseImpl::processChildElement(childXMLObject,root);
1191             }
1192         };
1193
1194         class SAML_DLLLOCAL ArtifactResolveImpl : public virtual ArtifactResolve, public RequestImpl
1195         {
1196             void init() {
1197                 m_Artifact=NULL;
1198                 m_children.push_back(NULL);
1199                 m_pos_Artifact=m_pos_Extensions;
1200                 ++m_pos_Artifact;
1201             }
1202         public:
1203             virtual ~ArtifactResolveImpl() { }
1204
1205             ArtifactResolveImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1206                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1207             {
1208                 init();
1209             }
1210
1211             ArtifactResolveImpl(const ArtifactResolveImpl& src) : AbstractXMLObject(src),
1212                                                                   RequestImpl(src)
1213             {
1214                 init();
1215                 if(src.getArtifact())
1216                     setArtifact(src.getArtifact()->cloneArtifact());
1217             }
1218
1219             IMPL_XMLOBJECT_CLONE(ArtifactResolve);
1220             IMPL_TYPED_CHILD(Artifact);
1221
1222         protected:
1223             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1224                 PROC_TYPED_CHILD(Artifact,SAMLConstants::SAML20P_NS,false);
1225                 RequestImpl::processChildElement(childXMLObject,root);
1226             }
1227         };
1228
1229         class SAML_DLLLOCAL ArtifactResponseImpl : public virtual ArtifactResponse, public StatusResponseImpl
1230         {
1231             void init() {
1232                 m_Payload=NULL;
1233                 m_children.push_back(NULL);
1234                 m_pos_Payload=m_pos_Status;
1235                 ++m_pos_Payload;
1236             }
1237         public:
1238             virtual ~ArtifactResponseImpl() { }
1239
1240             ArtifactResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1241                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1242             {
1243                 init();
1244             }
1245
1246             ArtifactResponseImpl(const ArtifactResponseImpl& src) : AbstractXMLObject(src),
1247                                                                     StatusResponseImpl(src)
1248             {
1249                 init();
1250                 if (src.getPayload())
1251                     setPayload(getPayload()->clone());
1252
1253             }
1254
1255             IMPL_XMLOBJECT_CLONE(ArtifactResponse);
1256             IMPL_XMLOBJECT_CHILD(Payload);
1257
1258         protected:
1259             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1260                 // These are valid elements for the parent StatusResponse, so don't process these.
1261                 // If not one of these, then it must be the payload.
1262                 if (
1263                     ! XMLHelper::isNodeNamed(root,SAMLConstants::SAML20_NS,saml2::Issuer::LOCAL_NAME) &&
1264                     ! XMLHelper::isNodeNamed(root,XMLConstants::XMLSIG_NS,xmlsignature::Signature::LOCAL_NAME) &&
1265                     ! XMLHelper::isNodeNamed(root,SAMLConstants::SAML20P_NS,saml2p::Extensions::LOCAL_NAME) &&
1266                     ! XMLHelper::isNodeNamed(root,SAMLConstants::SAML20P_NS,saml2p::Status::LOCAL_NAME)
1267                    )
1268                 {
1269                     setPayload(childXMLObject);
1270                     return;
1271                 }
1272
1273                 StatusResponseImpl::processChildElement(childXMLObject,root);
1274             }
1275         };
1276
1277         class SAML_DLLLOCAL NewEncryptedIDImpl : public virtual NewEncryptedID,
1278                                                  public AbstractComplexElement,
1279                                                  public AbstractDOMCachingXMLObject,
1280                                                  public AbstractValidatingXMLObject,
1281                                                  public AbstractXMLObjectMarshaller,
1282                                                  public AbstractXMLObjectUnmarshaller
1283         {
1284             void init() {
1285                 m_EncryptedData=NULL;
1286                 m_children.push_back(NULL);
1287                 m_pos_EncryptedData=m_children.begin();
1288             }
1289
1290         protected:
1291             NewEncryptedIDImpl()
1292             {
1293                 init();
1294             }
1295
1296         public:
1297             virtual ~NewEncryptedIDImpl() {}
1298
1299             NewEncryptedIDImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1300                     : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1301             {
1302                 init();
1303             }
1304
1305             NewEncryptedIDImpl(const NewEncryptedIDImpl& src)
1306                 : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractValidatingXMLObject(src)
1307             {
1308                 init();
1309                 if (src.getEncryptedData())
1310                     setEncryptedData(src.getEncryptedData()->cloneEncryptedData());
1311                 VectorOf(xmlencryption::EncryptedKey) v=getEncryptedKeys();
1312                 for (vector<xmlencryption::EncryptedKey*>::const_iterator i=src.m_EncryptedKeys.begin(); i!=src.m_EncryptedKeys.end(); i++) {
1313                     if (*i) {
1314                         v.push_back((*i)->cloneEncryptedKey());
1315                     }
1316                 }
1317             }
1318
1319             XMLObject* decrypt(KeyResolver* KEKresolver, const XMLCh* recipient) const
1320             {
1321                 if (!m_EncryptedData)
1322                     throw DecryptionException("No encrypted data present.");
1323                 Decrypter decrypter(KEKresolver, new EncryptedKeyResolver(*this, recipient));
1324                 DOMDocumentFragment* frag = decrypter.decryptData(m_EncryptedData);
1325                 if (frag->hasChildNodes() && frag->getFirstChild()==frag->getLastChild()) {
1326                     DOMNode* plaintext=frag->getFirstChild();
1327                     if (plaintext->getNodeType()==DOMNode::ELEMENT_NODE) {
1328                         auto_ptr<XMLObject> ret(XMLObjectBuilder::buildOneFromElement(static_cast<DOMElement*>(plaintext)));
1329                         ret->releaseThisAndChildrenDOM();
1330                         return ret.release();
1331                     }
1332                 }
1333                 frag->release();
1334                 throw DecryptionException("Decryption did not result in a single element.");
1335             }
1336
1337             IMPL_XMLOBJECT_CLONE(NewEncryptedID);
1338             EncryptedElementType* cloneEncryptedElementType() const {
1339                 return new NewEncryptedIDImpl(*this);
1340             }
1341
1342             IMPL_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption);
1343             IMPL_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,m_children.end());
1344
1345         protected:
1346             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1347                 PROC_TYPED_FOREIGN_CHILD(EncryptedData,xmlencryption,XMLConstants::XMLENC_NS,false);
1348                 PROC_TYPED_FOREIGN_CHILDREN(EncryptedKey,xmlencryption,XMLConstants::XMLENC_NS,false);
1349                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
1350             }
1351         };
1352
1353         class SAML_DLLLOCAL TerminateImpl : public virtual Terminate,
1354                                             public AbstractChildlessElement,
1355                                             public AbstractDOMCachingXMLObject,
1356                                             public AbstractValidatingXMLObject,
1357                                             public AbstractXMLObjectMarshaller,
1358                                             public AbstractXMLObjectUnmarshaller
1359         {
1360             public:
1361                 virtual ~TerminateImpl() { }
1362
1363                 TerminateImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1364                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1365
1366                 TerminateImpl(const TerminateImpl& src) : AbstractXMLObject(src),
1367                                                           AbstractDOMCachingXMLObject(src),
1368                                                           AbstractValidatingXMLObject(src) { }
1369
1370                 IMPL_XMLOBJECT_CLONE(Terminate);
1371
1372             protected:
1373                 // has no attributes or children
1374         };
1375
1376         class SAML_DLLLOCAL ManageNameIDRequestImpl : public virtual ManageNameIDRequest, public RequestImpl
1377         {
1378             void init() {
1379                 m_NameID=NULL;
1380                 m_EncryptedID=NULL;
1381                 m_NewID=NULL;
1382                 m_NewEncryptedID=NULL;
1383                 m_Terminate=NULL;
1384                 m_children.push_back(NULL);
1385                 m_children.push_back(NULL);
1386                 m_children.push_back(NULL);
1387                 m_children.push_back(NULL);
1388                 m_children.push_back(NULL);
1389                 m_pos_NameID=m_pos_Extensions;
1390                 ++m_pos_NameID;
1391                 m_pos_EncryptedID=m_pos_NameID;
1392                 ++m_pos_EncryptedID;
1393                 m_pos_NewID=m_pos_EncryptedID;
1394                 ++m_pos_NewID;
1395                 m_pos_NewEncryptedID=m_pos_NewID;
1396                 ++m_pos_NewEncryptedID;
1397                 m_pos_Terminate=m_pos_NewEncryptedID;
1398                 ++m_pos_Terminate;
1399
1400             }
1401         public:
1402             virtual ~ManageNameIDRequestImpl() { }
1403
1404             ManageNameIDRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1405                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1406             {
1407                 init();
1408             }
1409
1410             ManageNameIDRequestImpl(const ManageNameIDRequestImpl& src) : AbstractXMLObject(src),
1411                                                                             RequestImpl(src)
1412             {
1413                 init();
1414
1415                 if (src.getNameID())
1416                     setNameID(src.getNameID()->cloneNameID());
1417                 if (src.getEncryptedID())
1418                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1419                 if (src.getNewID())
1420                     setNewID(src.getNewID()->cloneNewID());
1421                 if (src.getNewEncryptedID())
1422                     setNewEncryptedID(src.getNewEncryptedID()->cloneNewEncryptedID());
1423                 if (src.getTerminate())
1424                     setTerminate(src.getTerminate()->cloneTerminate());
1425
1426             }
1427
1428             IMPL_XMLOBJECT_CLONE(ManageNameIDRequest);
1429
1430             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1431             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1432             IMPL_TYPED_CHILD(NewID);
1433             IMPL_TYPED_CHILD(NewEncryptedID);
1434             IMPL_TYPED_CHILD(Terminate);
1435
1436         protected:
1437             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1438                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAMLConstants::SAML20_NS,false);
1439                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAMLConstants::SAML20_NS,false);
1440                 PROC_TYPED_CHILD(NewID,SAMLConstants::SAML20P_NS,false);
1441                 PROC_TYPED_CHILD(NewEncryptedID,SAMLConstants::SAML20P_NS,false);
1442                 PROC_TYPED_CHILD(Terminate,SAMLConstants::SAML20P_NS,false);
1443                 RequestImpl::processChildElement(childXMLObject,root);
1444             }
1445         };
1446
1447         class SAML_DLLLOCAL ManageNameIDResponseImpl : public virtual ManageNameIDResponse, public StatusResponseImpl
1448         {
1449             public:
1450                 virtual ~ManageNameIDResponseImpl() { }
1451
1452                 ManageNameIDResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1453                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1454
1455                 ManageNameIDResponseImpl(const ManageNameIDResponseImpl& src) : AbstractXMLObject(src),
1456                                                                                 StatusResponseImpl(src) { }
1457
1458                 IMPL_XMLOBJECT_CLONE(ManageNameIDResponse);
1459         };
1460
1461         class SAML_DLLLOCAL LogoutRequestImpl : public virtual LogoutRequest, public RequestImpl
1462         {
1463             void init() {
1464                 m_Reason=NULL;
1465                 m_NotOnOrAfter=NULL;
1466
1467                 m_BaseID=NULL;
1468                 m_NameID=NULL;
1469                 m_EncryptedID=NULL;
1470                 m_children.push_back(NULL);
1471                 m_children.push_back(NULL);
1472                 m_children.push_back(NULL);
1473                 m_pos_BaseID=m_pos_Extensions;
1474                 ++m_pos_BaseID;
1475                 m_pos_NameID=m_pos_BaseID;
1476                 ++m_pos_NameID;
1477                 m_pos_EncryptedID=m_pos_NameID;
1478                 ++m_pos_EncryptedID;
1479
1480             }
1481         public:
1482             virtual ~LogoutRequestImpl() {
1483                 XMLString::release(&m_Reason);
1484                 delete m_NotOnOrAfter;
1485             }
1486
1487             LogoutRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1488                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1489             {
1490                 init();
1491             }
1492
1493             LogoutRequestImpl(const LogoutRequestImpl& src) : AbstractXMLObject(src),
1494                                                               RequestImpl(src)
1495             {
1496                 init();
1497
1498                 setReason(src.getReason());
1499                 setNotOnOrAfter(src.getNotOnOrAfter());
1500
1501                 if (src.getBaseID())
1502                     setBaseID(src.getBaseID()->cloneBaseID());
1503                 if (src.getNameID())
1504                     setNameID(src.getNameID()->cloneNameID());
1505                 if (src.getEncryptedID())
1506                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1507
1508                 for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
1509                     if (*i) {
1510                         SessionIndex* si = dynamic_cast<SessionIndex*>(*i);
1511                         if (si) {
1512                             getSessionIndexs().push_back(si->cloneSessionIndex());
1513                             continue;
1514                         }
1515                     }
1516                 }
1517             }
1518
1519             IMPL_XMLOBJECT_CLONE(LogoutRequest);
1520
1521             IMPL_STRING_ATTRIB(Reason);
1522             IMPL_DATETIME_ATTRIB(NotOnOrAfter);
1523             IMPL_TYPED_FOREIGN_CHILD(BaseID,saml2);
1524             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1525             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1526             IMPL_TYPED_CHILDREN(SessionIndex,m_children.end());
1527
1528         protected:
1529             void marshallAttributes(DOMElement* domElement) const {
1530                 MARSHALL_STRING_ATTRIB(Reason,REASON,NULL);
1531                 MARSHALL_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL);
1532                 RequestImpl::marshallAttributes(domElement);
1533             }
1534
1535             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1536                 PROC_TYPED_FOREIGN_CHILD(BaseID,saml2,SAMLConstants::SAML20_NS,false);
1537                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAMLConstants::SAML20_NS,false);
1538                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAMLConstants::SAML20_NS,false);
1539                 PROC_TYPED_CHILDREN(SessionIndex,SAMLConstants::SAML20P_NS,false);
1540                 RequestImpl::processChildElement(childXMLObject,root);
1541             }
1542             void processAttribute(const DOMAttr* attribute) {
1543                 PROC_STRING_ATTRIB(Reason,REASON,NULL);
1544                 PROC_DATETIME_ATTRIB(NotOnOrAfter,NOTONORAFTER,NULL);
1545                 RequestImpl::processAttribute(attribute);
1546             }
1547         };
1548
1549         class SAML_DLLLOCAL LogoutResponseImpl : public virtual LogoutResponse, public StatusResponseImpl
1550         {
1551             public:
1552                 virtual ~LogoutResponseImpl() { }
1553
1554                 LogoutResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1555                     : AbstractXMLObject(nsURI, localName, prefix, schemaType) { }
1556
1557                 LogoutResponseImpl(const LogoutResponseImpl& src) : AbstractXMLObject(src),
1558                                                                     StatusResponseImpl(src) { }
1559
1560                 IMPL_XMLOBJECT_CLONE(LogoutResponse);
1561         };
1562
1563
1564         class SAML_DLLLOCAL NameIDMappingRequestImpl : public virtual NameIDMappingRequest, public RequestImpl
1565         {
1566             void init() {
1567                 m_BaseID=NULL;
1568                 m_NameID=NULL;
1569                 m_EncryptedID=NULL;
1570                 m_NameIDPolicy=NULL;
1571                 m_children.push_back(NULL);
1572                 m_children.push_back(NULL);
1573                 m_children.push_back(NULL);
1574                 m_children.push_back(NULL);
1575                 m_pos_BaseID=m_pos_Extensions;
1576                 ++m_pos_BaseID;
1577                 m_pos_NameID=m_pos_BaseID;
1578                 ++m_pos_NameID;
1579                 m_pos_EncryptedID=m_pos_NameID;
1580                 ++m_pos_EncryptedID;
1581                 m_pos_NameIDPolicy=m_pos_EncryptedID;
1582                 ++m_pos_NameIDPolicy;
1583
1584             }
1585         public:
1586             virtual ~NameIDMappingRequestImpl() { }
1587
1588             NameIDMappingRequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1589                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1590             {
1591                 init();
1592             }
1593
1594             NameIDMappingRequestImpl(const NameIDMappingRequestImpl& src) : AbstractXMLObject(src),
1595                                                                             RequestImpl(src)
1596             {
1597                 init();
1598
1599                 if (src.getBaseID())
1600                     setBaseID(src.getBaseID()->cloneBaseID());
1601                 if (src.getNameID())
1602                     setNameID(src.getNameID()->cloneNameID());
1603                 if (src.getEncryptedID())
1604                     setEncryptedID(src.getEncryptedID()->cloneEncryptedID());
1605                 if (src.getNameIDPolicy())
1606                     setNameIDPolicy(src.getNameIDPolicy()->cloneNameIDPolicy());
1607
1608             }
1609
1610             IMPL_XMLOBJECT_CLONE(NameIDMappingRequest);
1611
1612             IMPL_TYPED_FOREIGN_CHILD(BaseID,saml2);
1613             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1614             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1615             IMPL_TYPED_CHILD(NameIDPolicy);
1616
1617         protected:
1618             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1619                 PROC_TYPED_FOREIGN_CHILD(BaseID,saml2,SAMLConstants::SAML20_NS,false);
1620                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAMLConstants::SAML20_NS,false);
1621                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAMLConstants::SAML20_NS,false);
1622                 PROC_TYPED_CHILD(NameIDPolicy,SAMLConstants::SAML20P_NS,false);
1623                 RequestImpl::processChildElement(childXMLObject,root);
1624             }
1625         };
1626
1627         class SAML_DLLLOCAL NameIDMappingResponseImpl : public virtual NameIDMappingResponse, public StatusResponseImpl
1628         {
1629             void init() {
1630                 m_NameID=NULL;
1631                 m_EncryptedID=NULL;
1632                 m_children.push_back(NULL);
1633                 m_children.push_back(NULL);
1634                 m_pos_NameID=m_pos_Status;
1635                 ++m_pos_NameID;
1636                 m_pos_EncryptedID=m_pos_NameID;
1637                 ++m_pos_EncryptedID;
1638             }
1639         public:
1640             virtual ~NameIDMappingResponseImpl() { }
1641
1642             NameIDMappingResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
1643                 : AbstractXMLObject(nsURI, localName, prefix, schemaType)
1644             {
1645                 init();
1646             }
1647
1648             NameIDMappingResponseImpl(const NameIDMappingResponseImpl& src) : AbstractXMLObject(src),
1649                                                                               StatusResponseImpl(src)
1650             {
1651                 init();
1652
1653                 if (src.getNameID())
1654                     setNameID(getNameID()->cloneNameID());
1655                 if (src.getEncryptedID())
1656                     setEncryptedID(getEncryptedID()->cloneEncryptedID());
1657
1658             }
1659
1660             IMPL_XMLOBJECT_CLONE(NameIDMappingResponse);
1661             IMPL_TYPED_FOREIGN_CHILD(NameID,saml2);
1662             IMPL_TYPED_FOREIGN_CHILD(EncryptedID,saml2);
1663
1664         protected:
1665             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
1666                 PROC_TYPED_FOREIGN_CHILD(NameID,saml2,SAMLConstants::SAML20_NS,false);
1667                 PROC_TYPED_FOREIGN_CHILD(EncryptedID,saml2,SAMLConstants::SAML20_NS,false);
1668                 StatusResponseImpl::processChildElement(childXMLObject,root);
1669             }
1670         };
1671     };
1672 };
1673
1674 #if defined (_MSC_VER)
1675     #pragma warning( pop )
1676 #endif
1677
1678 // Builder Implementations
1679 IMPL_XMLOBJECTBUILDER(Artifact);
1680 IMPL_XMLOBJECTBUILDER(ArtifactResolve);
1681 IMPL_XMLOBJECTBUILDER(ArtifactResponse);
1682 IMPL_XMLOBJECTBUILDER(AssertionIDRequest);
1683 IMPL_XMLOBJECTBUILDER(AttributeQuery);
1684 IMPL_XMLOBJECTBUILDER(AuthnQuery);
1685 IMPL_XMLOBJECTBUILDER(AuthnRequest);
1686 IMPL_XMLOBJECTBUILDER(AuthzDecisionQuery);
1687 IMPL_XMLOBJECTBUILDER(Extensions);
1688 IMPL_XMLOBJECTBUILDER(GetComplete);
1689 IMPL_XMLOBJECTBUILDER(IDPEntry);
1690 IMPL_XMLOBJECTBUILDER(IDPList);
1691 IMPL_XMLOBJECTBUILDER(LogoutRequest);
1692 IMPL_XMLOBJECTBUILDER(LogoutResponse);
1693 IMPL_XMLOBJECTBUILDER(ManageNameIDRequest);
1694 IMPL_XMLOBJECTBUILDER(ManageNameIDResponse);
1695 IMPL_XMLOBJECTBUILDER(NameIDMappingRequest);
1696 IMPL_XMLOBJECTBUILDER(NameIDMappingResponse);
1697 IMPL_XMLOBJECTBUILDER(NameIDPolicy);
1698 IMPL_XMLOBJECTBUILDER(NewEncryptedID);
1699 IMPL_XMLOBJECTBUILDER(NewID);
1700 IMPL_XMLOBJECTBUILDER(RequestedAuthnContext);
1701 IMPL_XMLOBJECTBUILDER(RequesterID);
1702 IMPL_XMLOBJECTBUILDER(Response);
1703 IMPL_XMLOBJECTBUILDER(Scoping);
1704 IMPL_XMLOBJECTBUILDER(SessionIndex);
1705 IMPL_XMLOBJECTBUILDER(Status);
1706 IMPL_XMLOBJECTBUILDER(StatusCode);
1707 IMPL_XMLOBJECTBUILDER(StatusDetail);
1708 IMPL_XMLOBJECTBUILDER(StatusMessage);
1709 IMPL_XMLOBJECTBUILDER(StatusResponse);
1710 IMPL_XMLOBJECTBUILDER(Terminate);
1711
1712
1713 // Unicode literals
1714 const XMLCh Artifact::LOCAL_NAME[] = UNICODE_LITERAL_8(A,r,t,i,f,a,c,t);
1715 const XMLCh ArtifactResolve::LOCAL_NAME[] = UNICODE_LITERAL_15(A,r,t,i,f,a,c,t,R,e,s,o,l,v,e);
1716 const XMLCh ArtifactResolve::TYPE_NAME[] = UNICODE_LITERAL_19(A,r,t,i,f,a,c,t,R,e,s,o,l,v,e,T,y,p,e);
1717 const XMLCh ArtifactResponse::LOCAL_NAME[] = UNICODE_LITERAL_16(A,r,t,i,f,a,c,t,R,e,s,p,o,n,s,e);
1718 const XMLCh ArtifactResponse::TYPE_NAME[] = UNICODE_LITERAL_20(A,r,t,i,f,a,c,t,R,e,s,p,o,n,s,e,T,y,p,e);
1719 const XMLCh AssertionIDRequest::LOCAL_NAME[] = UNICODE_LITERAL_18(A,s,s,e,r,t,i,o,n,I,D,R,e,q,u,e,s,t);
1720 const XMLCh AssertionIDRequest::TYPE_NAME[] = UNICODE_LITERAL_22(A,s,s,e,r,t,i,o,n,I,D,R,e,q,u,e,s,t,T,y,p,e);
1721 const XMLCh AttributeQuery::LOCAL_NAME[] = UNICODE_LITERAL_14(A,t,t,r,i,b,u,t,e,Q,u,e,r,y);
1722 const XMLCh AttributeQuery::TYPE_NAME[] = UNICODE_LITERAL_18(A,t,t,r,i,b,u,t,e,Q,u,e,r,y,T,y,p,e);
1723 const XMLCh AuthnQuery::LOCAL_NAME[] = UNICODE_LITERAL_10(A,u,t,h,n,Q,u,e,r,y);
1724 const XMLCh AuthnQuery::TYPE_NAME[] = UNICODE_LITERAL_14(A,u,t,h,n,Q,u,e,r,y,T,y,p,e);
1725 const XMLCh AuthnQuery::SESSIONINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_12(S,e,s,s,i,o,n,I,n,d,e,x);
1726 const XMLCh AuthnRequest::LOCAL_NAME[] = UNICODE_LITERAL_12(A,u,t,h,n,R,e,q,u,e,s,t);
1727 const XMLCh AuthnRequest::TYPE_NAME[] = UNICODE_LITERAL_16(A,u,t,h,n,R,e,q,u,e,s,t,T,y,p,e);
1728 const XMLCh AuthnRequest::FORCEAUTHN_ATTRIB_NAME[] = UNICODE_LITERAL_10(F,o,r,c,e,A,u,t,h,n);
1729 const XMLCh AuthnRequest::ISPASSIVE_ATTRIB_NAME[] = UNICODE_LITERAL_9(I,s,P,a,s,s,i,v,e);
1730 const XMLCh AuthnRequest::PROTOCOLBINDING_ATTRIB_NAME[] = UNICODE_LITERAL_15(P,r,o,t,o,c,o,l,B,i,n,d,i,n,g);
1731 const XMLCh AuthnRequest::ASSERTIONCONSUMERSERVICEINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_29(A,s,s,e,r,t,i,o,n,C,o,n,s,u,m,e,r,S,e,r,v,i,c,e,I,n,d,e,x);
1732 const XMLCh AuthnRequest::ASSERTIONCONSUMERSERVICEURL_ATTRIB_NAME[] = UNICODE_LITERAL_27(A,s,s,e,r,t,i,o,n,C,o,n,s,u,m,e,r,S,e,r,v,i,c,e,U,R,L);
1733 const XMLCh AuthnRequest::ATTRIBUTECONSUMINGSERVICEINDEX_ATTRIB_NAME[] = UNICODE_LITERAL_30(A,t,t,r,i,b,u,t,e,C,o,n,s,u,m,i,n,g,S,e,r,v,i,c,e,I,n,d,e,x);
1734 const XMLCh AuthnRequest::PROVIDERNAME_ATTRIB_NAME[] = UNICODE_LITERAL_12(P,r,o,v,i,d,e,r,N,a,m,e);
1735 const XMLCh AuthzDecisionQuery::LOCAL_NAME[] = UNICODE_LITERAL_18(A,u,t,h,z,D,e,c,i,s,i,o,n,Q,u,e,r,y);
1736 const XMLCh AuthzDecisionQuery::TYPE_NAME[] = UNICODE_LITERAL_22(A,u,t,h,z,D,e,c,i,s,i,o,n,Q,u,e,r,y,T,y,p,e);
1737 const XMLCh AuthzDecisionQuery::RESOURCE_ATTRIB_NAME[] = UNICODE_LITERAL_8(R,e,s,o,u,r,c,e);
1738 const XMLCh Extensions::LOCAL_NAME[] = UNICODE_LITERAL_10(E,x,t,e,n,s,i,o,n,s);
1739 const XMLCh Extensions::TYPE_NAME[] = UNICODE_LITERAL_14(E,x,t,e,n,s,i,o,n,s,T,y,p,e);
1740 const XMLCh GetComplete::LOCAL_NAME[] = UNICODE_LITERAL_11(G,e,t,C,o,m,p,l,e,t,e);
1741 const XMLCh IDPEntry::LOCAL_NAME[] = UNICODE_LITERAL_8(I,D,P,E,n,t,r,y);
1742 const XMLCh IDPEntry::TYPE_NAME[] = UNICODE_LITERAL_12(I,D,P,E,n,t,r,y,T,y,p,e);
1743 const XMLCh IDPEntry::PROVIDERID_ATTRIB_NAME[] = UNICODE_LITERAL_10(P,r,o,v,i,d,e,r,I,D);
1744 const XMLCh IDPEntry::NAME_ATTRIB_NAME[] = UNICODE_LITERAL_4(N,a,m,e);
1745 const XMLCh IDPEntry::LOC_ATTRIB_NAME[] = UNICODE_LITERAL_3(L,o,c);
1746 const XMLCh IDPList::LOCAL_NAME[] = UNICODE_LITERAL_7(I,D,P,L,i,s,t);
1747 const XMLCh IDPList::TYPE_NAME[] = UNICODE_LITERAL_11(I,D,P,L,i,s,t,T,y,p,e);
1748 const XMLCh LogoutRequest::LOCAL_NAME[] = UNICODE_LITERAL_13(L,o,g,o,u,t,R,e,q,u,e,s,t);
1749 const XMLCh LogoutRequest::TYPE_NAME[] = UNICODE_LITERAL_17(L,o,g,o,u,t,R,e,q,u,e,s,t,T,y,p,e);
1750 const XMLCh LogoutRequest::REASON_ATTRIB_NAME[] = UNICODE_LITERAL_6(R,e,a,s,o,n);
1751 const XMLCh LogoutRequest::NOTONORAFTER_ATTRIB_NAME[] = UNICODE_LITERAL_12(N,o,t,O,n,O,r,A,f,t,e,r);
1752 const XMLCh LogoutResponse::LOCAL_NAME[] = UNICODE_LITERAL_14(L,o,g,o,u,t,R,e,s,p,o,n,s,e);
1753 const XMLCh ManageNameIDRequest::LOCAL_NAME[] = UNICODE_LITERAL_19(M,a,n,a,g,e,N,a,m,e,I,D,R,e,q,u,e,s,t);
1754 const XMLCh ManageNameIDRequest::TYPE_NAME[] = UNICODE_LITERAL_23(M,a,n,a,g,e,N,a,m,e,I,D,R,e,q,u,e,s,t,T,y,p,e);
1755 const XMLCh ManageNameIDResponse::LOCAL_NAME[] = UNICODE_LITERAL_20(M,a,n,a,g,e,N,a,m,e,I,D,R,e,s,p,o,n,s,e);
1756 const XMLCh NameIDMappingRequest::LOCAL_NAME[] = UNICODE_LITERAL_20(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,q,u,e,s,t);
1757 const XMLCh NameIDMappingRequest::TYPE_NAME[] = UNICODE_LITERAL_24(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,q,u,e,s,t,T,y,p,e);
1758 const XMLCh NameIDMappingResponse::LOCAL_NAME[] = UNICODE_LITERAL_21(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,s,p,o,n,s,e);
1759 const XMLCh NameIDMappingResponse::TYPE_NAME[] = UNICODE_LITERAL_25(N,a,m,e,I,D,M,a,p,p,i,n,g,R,e,s,p,o,n,s,e,T,y,p,e);
1760 const XMLCh NameIDPolicy::LOCAL_NAME[] = UNICODE_LITERAL_12(N,a,m,e,I,D,P,o,l,i,c,y);
1761 const XMLCh NameIDPolicy::TYPE_NAME[] = UNICODE_LITERAL_16(N,a,m,e,I,D,P,o,l,i,c,y,T,y,p,e);
1762 const XMLCh NameIDPolicy::FORMAT_ATTRIB_NAME[] = UNICODE_LITERAL_6(F,o,r,m,a,t);
1763 const XMLCh NameIDPolicy::SPNAMEQUALIFIER_ATTRIB_NAME[] = UNICODE_LITERAL_15(S,P,N,a,m,e,Q,u,a,l,i,f,i,e,r);
1764 const XMLCh NameIDPolicy::ALLOWCREATE_ATTRIB_NAME[] = UNICODE_LITERAL_11(A,l,l,o,w,C,r,e,a,t,e);
1765 const XMLCh NewEncryptedID::LOCAL_NAME[] = UNICODE_LITERAL_14(N,e,w,E,n,c,r,y,p,t,e,d,I,D);
1766 const XMLCh NewID::LOCAL_NAME[] = UNICODE_LITERAL_5(N,e,w,I,D);
1767 const XMLCh RequesterID::LOCAL_NAME[] = UNICODE_LITERAL_11(R,e,q,u,e,s,t,e,r,I,D);
1768 const XMLCh RequestedAuthnContext::LOCAL_NAME[] = UNICODE_LITERAL_21(R,e,q,u,e,s,t,e,d,A,u,t,h,n,C,o,n,t,e,x,t);
1769 const XMLCh RequestedAuthnContext::TYPE_NAME[] = UNICODE_LITERAL_25(R,e,q,u,e,s,t,e,d,A,u,t,h,n,C,o,n,t,e,x,t,T,y,p,e);
1770 const XMLCh RequestedAuthnContext::COMPARISON_ATTRIB_NAME[] = UNICODE_LITERAL_10(C,o,m,p,a,r,i,s,o,n);
1771 const XMLCh RequestedAuthnContext::COMPARISON_EXACT[] = UNICODE_LITERAL_5(e,x,a,c,t);
1772 const XMLCh RequestedAuthnContext::COMPARISON_MINIMUM[] = UNICODE_LITERAL_7(m,i,n,i,m,u,m);
1773 const XMLCh RequestedAuthnContext::COMPARISON_MAXIMUM[] = UNICODE_LITERAL_7(m,a,x,i,m,u,m);
1774 const XMLCh RequestedAuthnContext::COMPARISON_BETTER[] = UNICODE_LITERAL_6(b,e,t,t,e,r);
1775 const XMLCh Request::LOCAL_NAME[] = {chNull};
1776 const XMLCh Request::TYPE_NAME[] = UNICODE_LITERAL_19(R,e,q,u,e,s,t,A,b,s,t,r,a,c,t,T,y,p,e);
1777 const XMLCh Request::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,D);
1778 const XMLCh Request::VER_ATTRIB_NAME[] = UNICODE_LITERAL_7(V,e,r,s,i,o,n);
1779 const XMLCh Request::ISSUEINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
1780 const XMLCh Request::DESTINATION_ATTRIB_NAME[] = UNICODE_LITERAL_11(D,e,s,t,i,n,a,t,i,o,n);
1781 const XMLCh Request::CONSENT_ATTRIB_NAME[] = UNICODE_LITERAL_7(C,o,n,s,e,n,t);
1782 const XMLCh Response::LOCAL_NAME[] = UNICODE_LITERAL_8(R,e,s,p,o,n,s,e);
1783 const XMLCh Response::TYPE_NAME[] = UNICODE_LITERAL_12(R,e,s,p,o,n,s,e,T,y,p,e);
1784 const XMLCh Scoping::LOCAL_NAME[] = UNICODE_LITERAL_7(S,c,o,p,i,n,g);
1785 const XMLCh Scoping::TYPE_NAME[] = UNICODE_LITERAL_11(S,c,o,p,i,n,g,T,y,p,e);
1786 const XMLCh Scoping::PROXYCOUNT_ATTRIB_NAME[] = UNICODE_LITERAL_10(P,r,o,x,y,C,o,u,n,t);
1787 const XMLCh SessionIndex::LOCAL_NAME[] = UNICODE_LITERAL_12(S,e,s,s,i,o,n,I,n,d,e,x);
1788 const XMLCh Status::LOCAL_NAME[] = UNICODE_LITERAL_6(S,t,a,t,u,s);
1789 const XMLCh Status::TYPE_NAME[] = UNICODE_LITERAL_10(S,t,a,t,u,s,T,y,p,e);
1790 const XMLCh StatusCode::LOCAL_NAME[] = UNICODE_LITERAL_10(S,t,a,t,u,s,C,o,d,e);
1791 const XMLCh StatusCode::TYPE_NAME[] = UNICODE_LITERAL_14(S,t,a,t,u,s,C,o,d,e,T,y,p,e);
1792 const XMLCh StatusCode::VALUE_ATTRIB_NAME[] = UNICODE_LITERAL_5(V,a,l,u,e);
1793 const XMLCh StatusDetail::LOCAL_NAME[] = UNICODE_LITERAL_12(S,t,a,t,u,s,D,e,t,a,i,l);
1794 const XMLCh StatusDetail::TYPE_NAME[] = UNICODE_LITERAL_16(S,t,a,t,u,s,D,e,t,a,i,l,T,y,p,e);
1795 const XMLCh StatusMessage::LOCAL_NAME[] = UNICODE_LITERAL_13(S,t,a,t,u,s,M,e,s,s,a,g,e);
1796 const XMLCh StatusResponse::LOCAL_NAME[] = {chNull};
1797 const XMLCh StatusResponse::TYPE_NAME[] = UNICODE_LITERAL_18(S,t,a,t,u,s,R,e,s,p,o,n,s,e,T,y,p,e);
1798 const XMLCh StatusResponse::ID_ATTRIB_NAME[] = UNICODE_LITERAL_2(I,D);
1799 const XMLCh StatusResponse::INRESPONSETO_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,n,R,e,s,p,o,n,s,e,T,o);
1800 const XMLCh StatusResponse::VER_ATTRIB_NAME[] = UNICODE_LITERAL_7(V,e,r,s,i,o,n);
1801 const XMLCh StatusResponse::ISSUEINSTANT_ATTRIB_NAME[] = UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
1802 const XMLCh StatusResponse::DESTINATION_ATTRIB_NAME[] = UNICODE_LITERAL_11(D,e,s,t,i,n,a,t,i,o,n);
1803 const XMLCh StatusResponse::CONSENT_ATTRIB_NAME[] = UNICODE_LITERAL_7(C,o,n,s,e,n,t);
1804 const XMLCh SubjectQuery::LOCAL_NAME[] = {chNull};
1805 const XMLCh SubjectQuery::TYPE_NAME[] = UNICODE_LITERAL_16(S,u,b,j,e,c,t,Q,u,e,r,y,T,y,p,e);
1806 const XMLCh Terminate::LOCAL_NAME[] = UNICODE_LITERAL_9(T,e,r,m,i,n,a,t,e);
1807 const XMLCh Terminate::TYPE_NAME[] = UNICODE_LITERAL_13(T,e,r,m,i,n,a,t,e,T,y,p,e);