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