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