saml/saml1/core/impl/ProtocolsImpl.cpp

   1 /*
   2  *  Copyright 2001-2007 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  * ProtocolsImpl.cpp
  19  *
  20  * Implementation classes for SAML 1.x Protocols schema
  21  */
  22
  23 #include "internal.h"
  24 #include "exceptions.h"
  25 #include "saml1/core/Assertions.h"
  26 #include "saml1/core/Protocols.h"
  27
  28 #include <xmltooling/AbstractComplexElement.h>
  29 #include <xmltooling/AbstractSimpleElement.h>
  30 #include <xmltooling/impl/AnyElement.h>
  31 #include <xmltooling/io/AbstractXMLObjectMarshaller.h>
  32 #include <xmltooling/io/AbstractXMLObjectUnmarshaller.h>
  33 #include <xmltooling/util/XMLHelper.h>
  34
  35 #include <ctime>
  36 #include <xercesc/util/XMLUniDefs.hpp>
  37
  38 using namespace opensaml::saml1p;
  39 using namespace opensaml::saml1;
  40 using namespace xmlsignature;
  41 using namespace xmltooling;
  42 using namespace std;
  43 using xmlconstants::XMLSIG_NS;
  44 using xmlconstants::XML_ONE;
  45 using samlconstants::SAML1P_NS;
  46 using samlconstants::SAML1_NS;
  47 using samlconstants::SAML1P_PREFIX;
  48
  49 #if defined (_MSC_VER)
  50     #pragma warning( push )
  51     #pragma warning( disable : 4250 4251 )
  52 #endif
  53
  54 namespace opensaml {
  55     namespace saml1p {
  56
  57         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,AssertionArtifact);
  58         DECL_XMLOBJECTIMPL_SIMPLE(SAML_DLLLOCAL,StatusMessage);
  59
  60         class SAML_DLLLOCAL RespondWithImpl : public virtual RespondWith,
  61             public AbstractSimpleElement,
  62             public AbstractDOMCachingXMLObject,
  63             public AbstractXMLObjectMarshaller,
  64             public AbstractXMLObjectUnmarshaller
  65         {
  66             QName* m_qname;
  67         public:
  68             virtual ~RespondWithImpl() {
  69                 delete m_qname;
  70             }
  71
  72             RespondWithImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
  73                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_qname(NULL) {
  74             }
  75
  76             RespondWithImpl(const RespondWithImpl& src)
  77                     : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_qname(NULL) {
  78                 setQName(src.getQName());
  79             }
  80
  81             QName* getQName() const {
  82                 return m_qname;
  83             }
  84
  85             void setQName(const QName* qname) {
  86                 m_qname=prepareForAssignment(m_qname,qname);
  87                 if (m_qname) {
  88                     auto_ptr_XMLCh temp(m_qname->toString().c_str());
  89                     setTextContent(temp.get());
  90                 }
  91                 else
  92                     setTextContent(NULL);
  93             }
  94
  95             IMPL_XMLOBJECT_CLONE(RespondWith);
  96         };
  97
  98         class SAML_DLLLOCAL QueryImpl : public virtual Query, public AnyElementImpl
  99         {
 100         public:
 101             virtual ~QueryImpl() {}
 102
 103             QueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 104                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 105             }
 106
 107             QueryImpl(const QueryImpl& src) : AnyElementImpl(src) {}
 108
 109             IMPL_XMLOBJECT_CLONE(Query);
 110         };
 111
 112         class SAML_DLLLOCAL SubjectQueryImpl : public virtual SubjectQuery,
 113             public AbstractComplexElement,
 114             public AbstractDOMCachingXMLObject,
 115             public AbstractXMLObjectMarshaller,
 116             public AbstractXMLObjectUnmarshaller
 117         {
 118             void init() {
 119                 m_Subject=NULL;
 120                 m_children.push_back(NULL);
 121                 m_pos_Subject=m_children.begin();
 122             }
 123         protected:
 124             SubjectQueryImpl() {
 125                 init();
 126             }
 127         public:
 128             virtual ~SubjectQueryImpl() {}
 129
 130             SubjectQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 131                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 132                 init();
 133             }
 134
 135             SubjectQueryImpl(const SubjectQueryImpl& src)
 136                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 137                 init();
 138                 if (src.getSubject())
 139                     setSubject(src.getSubject()->cloneSubject());
 140             }
 141
 142             IMPL_TYPED_CHILD(Subject);
 143
 144         protected:
 145             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 146                 PROC_TYPED_CHILD(Subject,SAML1_NS,true);
 147                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 148             }
 149         };
 150
 151         class SAML_DLLLOCAL AuthenticationQueryImpl : public virtual AuthenticationQuery, public SubjectQueryImpl
 152         {
 153             void init() {
 154                 m_AuthenticationMethod=NULL;
 155             }
 156         public:
 157             virtual ~AuthenticationQueryImpl() {
 158                 XMLString::release(&m_AuthenticationMethod);
 159             }
 160
 161             AuthenticationQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 162                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 163                 init();
 164             }
 165
 166             AuthenticationQueryImpl(const AuthenticationQueryImpl& src) : AbstractXMLObject(src), SubjectQueryImpl(src) {
 167                 init();
 168                 setAuthenticationMethod(src.getAuthenticationMethod());
 169             }
 170
 171             IMPL_XMLOBJECT_CLONE(AuthenticationQuery);
 172             SubjectQuery* cloneSubjectQuery() const {
 173                 return cloneAuthenticationQuery();
 174             }
 175             Query* cloneQuery() const {
 176                 return cloneAuthenticationQuery();
 177             }
 178             IMPL_STRING_ATTRIB(AuthenticationMethod);
 179
 180         protected:
 181             void marshallAttributes(DOMElement* domElement) const {
 182                 MARSHALL_STRING_ATTRIB(AuthenticationMethod,AUTHENTICATIONMETHOD,NULL);
 183                 SubjectQueryImpl::marshallAttributes(domElement);
 184             }
 185
 186             void processAttribute(const DOMAttr* attribute) {
 187                 PROC_STRING_ATTRIB(AuthenticationMethod,AUTHENTICATIONMETHOD,NULL);
 188                 SubjectQueryImpl::processAttribute(attribute);
 189             }
 190         };
 191
 192         class SAML_DLLLOCAL AttributeQueryImpl : public virtual AttributeQuery, public SubjectQueryImpl
 193         {
 194             void init() {
 195                 m_Resource=NULL;
 196             }
 197         public:
 198             virtual ~AttributeQueryImpl() {
 199                 XMLString::release(&m_Resource);
 200             }
 201
 202             AttributeQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 203                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 204                 init();
 205             }
 206
 207             AttributeQueryImpl(const AttributeQueryImpl& src) : AbstractXMLObject(src), SubjectQueryImpl(src) {
 208                 init();
 209                 setResource(src.getResource());
 210                 VectorOf(AttributeDesignator) v=getAttributeDesignators();
 211                 for (vector<AttributeDesignator*>::const_iterator i=src.m_AttributeDesignators.begin(); i!=src.m_AttributeDesignators.end(); i++) {
 212                     if (*i) {
 213                         v.push_back((*i)->cloneAttributeDesignator());
 214                     }
 215                 }
 216             }
 217
 218             IMPL_XMLOBJECT_CLONE(AttributeQuery);
 219             SubjectQuery* cloneSubjectQuery() const {
 220                 return cloneAttributeQuery();
 221             }
 222             Query* cloneQuery() const {
 223                 return cloneAttributeQuery();
 224             }
 225             IMPL_STRING_ATTRIB(Resource);
 226             IMPL_TYPED_CHILDREN(AttributeDesignator,m_children.end());
 227
 228         protected:
 229             void marshallAttributes(DOMElement* domElement) const {
 230                 MARSHALL_STRING_ATTRIB(Resource,RESOURCE,NULL);
 231                 SubjectQueryImpl::marshallAttributes(domElement);
 232             }
 233
 234             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 235                 PROC_TYPED_CHILDREN(AttributeDesignator,SAML1_NS,true);
 236                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 237             }
 238
 239             void processAttribute(const DOMAttr* attribute) {
 240                 PROC_STRING_ATTRIB(Resource,RESOURCE,NULL);
 241                 SubjectQueryImpl::processAttribute(attribute);
 242             }
 243         };
 244
 245         class SAML_DLLLOCAL AuthorizationDecisionQueryImpl : public virtual AuthorizationDecisionQuery, public SubjectQueryImpl
 246         {
 247             void init() {
 248                 m_Resource=NULL;
 249                 m_Evidence=NULL;
 250                 m_children.push_back(NULL);
 251                 m_pos_Evidence=m_pos_Subject;
 252                 ++m_pos_Evidence;
 253             }
 254         public:
 255             virtual ~AuthorizationDecisionQueryImpl() {
 256                 XMLString::release(&m_Resource);
 257             }
 258
 259             AuthorizationDecisionQueryImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 260                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 261                 init();
 262             }
 263
 264             AuthorizationDecisionQueryImpl(const AuthorizationDecisionQueryImpl& src) : AbstractXMLObject(src), SubjectQueryImpl(src) {
 265                 init();
 266                 setResource(src.getResource());
 267                 if (src.getEvidence())
 268                     setEvidence(src.getEvidence()->cloneEvidence());
 269                 VectorOf(Action) v=getActions();
 270                 for (vector<Action*>::const_iterator i=src.m_Actions.begin(); i!=src.m_Actions.end(); i++) {
 271                     if (*i) {
 272                         v.push_back((*i)->cloneAction());
 273                     }
 274                 }
 275             }
 276
 277             IMPL_XMLOBJECT_CLONE(AuthorizationDecisionQuery);
 278             SubjectQuery* cloneSubjectQuery() const {
 279                 return cloneAuthorizationDecisionQuery();
 280             }
 281             Query* cloneQuery() const {
 282                 return cloneAuthorizationDecisionQuery();
 283             }
 284             IMPL_STRING_ATTRIB(Resource);
 285             IMPL_TYPED_CHILD(Evidence);
 286             IMPL_TYPED_CHILDREN(Action, m_pos_Evidence);
 287
 288         protected:
 289             void marshallAttributes(DOMElement* domElement) const {
 290                 MARSHALL_STRING_ATTRIB(Resource,RESOURCE,NULL);
 291                 SubjectQueryImpl::marshallAttributes(domElement);
 292             }
 293
 294             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 295                 PROC_TYPED_CHILD(Evidence,SAML1_NS,false);
 296                 PROC_TYPED_CHILDREN(Action,SAML1_NS,false);
 297                 SubjectQueryImpl::processChildElement(childXMLObject,root);
 298             }
 299
 300             void processAttribute(const DOMAttr* attribute) {
 301                 PROC_STRING_ATTRIB(Resource,RESOURCE,NULL);
 302                 SubjectQueryImpl::processAttribute(attribute);
 303             }
 304         };
 305
 306         class SAML_DLLLOCAL RequestAbstractTypeImpl : public virtual RequestAbstractType,
 307             public AbstractComplexElement,
 308             public AbstractDOMCachingXMLObject,
 309             public AbstractXMLObjectMarshaller,
 310             public AbstractXMLObjectUnmarshaller
 311         {
 312             void init() {
 313                 m_MinorVersion=NULL;
 314                 m_RequestID=NULL;
 315                 m_IssueInstant=NULL;
 316                 m_children.push_back(NULL);
 317                 m_Signature=NULL;
 318                 m_pos_Signature=m_children.begin();
 319             }
 320         protected:
 321             RequestAbstractTypeImpl() {
 322                 init();
 323             }
 324         public:
 325             virtual ~RequestAbstractTypeImpl() {
 326                 XMLString::release(&m_MinorVersion);
 327                 XMLString::release(&m_RequestID);
 328                 delete m_IssueInstant;
 329             }
 330
 331             RequestAbstractTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 332                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 333                 init();
 334             }
 335
 336             RequestAbstractTypeImpl(const RequestAbstractTypeImpl& src)
 337                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 338                 init();
 339                 setMinorVersion(src.m_MinorVersion);
 340                 setRequestID(src.getRequestID());
 341                 setIssueInstant(src.getIssueInstant());
 342                 if (src.getSignature())
 343                     setSignature(src.getSignature()->cloneSignature());
 344                 VectorOf(RespondWith) v=getRespondWiths();
 345                 for (vector<RespondWith*>::const_iterator i=src.m_RespondWiths.begin(); i!=src.m_RespondWiths.end(); i++) {
 346                     if (*i) {
 347                         v.push_back((*i)->cloneRespondWith());
 348                     }
 349                 }
 350             }
 351
 352             //IMPL_TYPED_CHILD(Signature);
 353             // Need customized setter.
 354         protected:
 355             Signature* m_Signature;
 356             list<XMLObject*>::iterator m_pos_Signature;
 357         public:
 358             Signature* getSignature() const {
 359                 return m_Signature;
 360             }
 361
 362             void setSignature(Signature* sig) {
 363                 prepareForAssignment(m_Signature,sig);
 364                 *m_pos_Signature=m_Signature=sig;
 365                 // Sync content reference back up.
 366                 if (m_Signature)
 367                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
 368             }
 369
 370             IMPL_INTEGER_ATTRIB(MinorVersion);
 371             IMPL_STRING_ATTRIB(RequestID);    // have to special-case getXMLID
 372             const XMLCh* getXMLID() const {
 373                 pair<bool,int> v = getMinorVersion();
 374                 return (!v.first || v.second > 0) ? m_RequestID : NULL;
 375             }
 376             const XMLCh* getID() const {
 377                 return getRequestID();
 378             }
 379             IMPL_DATETIME_ATTRIB(IssueInstant,0);
 380             IMPL_TYPED_CHILDREN(RespondWith,m_pos_Signature);
 381
 382         protected:
 383             void marshallAttributes(DOMElement* domElement) const {
 384                 static const XMLCh MAJORVERSION[] = UNICODE_LITERAL_12(M,a,j,o,r,V,e,r,s,i,o,n);
 385                 domElement->setAttributeNS(NULL,MAJORVERSION,XML_ONE);
 386                 if (!m_MinorVersion)
 387                     const_cast<RequestAbstractTypeImpl*>(this)->m_MinorVersion=XMLString::replicate(XML_ONE);
 388                 MARSHALL_INTEGER_ATTRIB(MinorVersion,MINORVERSION,NULL);
 389                 if (!m_RequestID)
 390                     const_cast<RequestAbstractTypeImpl*>(this)->m_RequestID=SAMLConfig::getConfig().generateIdentifier();
 391                 domElement->setAttributeNS(NULL, REQUESTID_ATTRIB_NAME, m_RequestID);
 392                 if (*m_MinorVersion!=chDigit_0)
 393                     domElement->setIdAttributeNS(NULL, REQUESTID_ATTRIB_NAME);
 394                 if (!m_IssueInstant) {
 395                     const_cast<RequestAbstractTypeImpl*>(this)->m_IssueInstantEpoch=time(NULL);
 396                     const_cast<RequestAbstractTypeImpl*>(this)->m_IssueInstant=new DateTime(m_IssueInstantEpoch);
 397                 }
 398                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
 399             }
 400
 401             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 402                 PROC_TYPED_CHILDREN(RespondWith,SAML1P_NS,false);
 403                 PROC_TYPED_CHILD(Signature,XMLSIG_NS,false);
 404                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 405             }
 406
 407             void unmarshallAttributes(const DOMElement* domElement) {
 408                 // Standard processing, but then we check IDness.
 409                 AbstractXMLObjectUnmarshaller::unmarshallAttributes(domElement);
 410                 if (m_RequestID && (!m_MinorVersion || *m_MinorVersion!=chDigit_0))
 411                     const_cast<DOMElement*>(domElement)->setIdAttributeNS(NULL, REQUESTID_ATTRIB_NAME);
 412             }
 413
 414             void processAttribute(const DOMAttr* attribute) {
 415                 static const XMLCh MAJORVERSION[] = UNICODE_LITERAL_12(M,a,j,o,r,V,e,r,s,i,o,n);
 416                 if (XMLHelper::isNodeNamed(attribute,NULL,MAJORVERSION)) {
 417                     if (!XMLString::equals(attribute->getValue(),XML_ONE))
 418                         throw UnmarshallingException("Request has invalid major version.");
 419                 }
 420                 PROC_INTEGER_ATTRIB(MinorVersion,MINORVERSION,NULL);
 421                 PROC_STRING_ATTRIB(RequestID,REQUESTID,NULL);
 422                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
 423             }
 424         };
 425
 426         class SAML_DLLLOCAL RequestImpl : public virtual Request, public RequestAbstractTypeImpl
 427         {
 428             void init() {
 429                 m_children.push_back(NULL);
 430                 m_Query=NULL;
 431                 m_pos_Query=m_pos_Signature;
 432                 ++m_pos_Query;
 433             }
 434         public:
 435             virtual ~RequestImpl() {}
 436
 437             RequestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 438                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 439                 init();
 440             }
 441
 442             RequestImpl(const RequestImpl& src) : AbstractXMLObject(src), RequestAbstractTypeImpl(src) {
 443                 init();
 444                 if (src.getQuery())
 445                     setQuery(src.getQuery()->cloneQuery());
 446                 VectorOf(AssertionIDReference) v=getAssertionIDReferences();
 447                 for (vector<AssertionIDReference*>::const_iterator i=src.m_AssertionIDReferences.begin(); i!=src.m_AssertionIDReferences.end(); i++) {
 448                     if (*i) {
 449                         v.push_back((*i)->cloneAssertionIDReference());
 450                     }
 451                 }
 452                 VectorOf(AssertionArtifact) v2=getAssertionArtifacts();
 453                 for (vector<AssertionArtifact*>::const_iterator i=src.m_AssertionArtifacts.begin(); i!=src.m_AssertionArtifacts.end(); i++) {
 454                     if (*i) {
 455                         v2.push_back((*i)->cloneAssertionArtifact());
 456                     }
 457                 }
 458             }
 459
 460             IMPL_XMLOBJECT_CLONE(Request);
 461             RequestAbstractType* cloneRequestAbstractType() const {
 462                 return cloneRequest();
 463             }
 464             IMPL_TYPED_CHILD(Query);
 465
 466             SubjectQuery* getSubjectQuery() const {
 467                 return dynamic_cast<SubjectQuery*>(getQuery());
 468             }
 469             AuthenticationQuery* getAuthenticationQuery() const {
 470                 return dynamic_cast<AuthenticationQuery*>(getQuery());
 471             }
 472             AttributeQuery* getAttributeQuery() const {
 473                 return dynamic_cast<AttributeQuery*>(getQuery());
 474             }
 475             AuthorizationDecisionQuery* getAuthorizationDecisionQuery() const {
 476                 return dynamic_cast<AuthorizationDecisionQuery*>(getQuery());
 477             }
 478
 479             void setSubjectQuery(SubjectQuery* q) {
 480                 setQuery(q);
 481             }
 482             void setAuthenticationQuery(AuthenticationQuery* q) {
 483                 setQuery(q);
 484             }
 485             void setAttributeQuery(AttributeQuery* q) {
 486                 setQuery(q);
 487             }
 488             void setAuthorizationDecisionQuery(AuthorizationDecisionQuery* q) {
 489                 setQuery(q);
 490             }
 491
 492             IMPL_TYPED_CHILDREN(AssertionIDReference, m_children.end());
 493             IMPL_TYPED_CHILDREN(AssertionArtifact, m_children.end());
 494
 495         protected:
 496             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 497                 PROC_TYPED_CHILD(Query,SAML1P_NS,true);
 498                 PROC_TYPED_CHILDREN(AssertionIDReference,SAML1_NS,false);
 499                 PROC_TYPED_CHILDREN(AssertionArtifact,SAML1P_NS,false);
 500                 RequestAbstractTypeImpl::processChildElement(childXMLObject,root);
 501             }
 502         };
 503
 504         class SAML_DLLLOCAL StatusCodeImpl : public virtual StatusCode,
 505             public AbstractComplexElement,
 506             public AbstractDOMCachingXMLObject,
 507             public AbstractXMLObjectMarshaller,
 508             public AbstractXMLObjectUnmarshaller
 509         {
 510             void init() {
 511                 m_Value=NULL;
 512                 m_children.push_back(NULL);
 513                 m_StatusCode=NULL;
 514                 m_pos_StatusCode=m_children.begin();
 515             }
 516         public:
 517             virtual ~StatusCodeImpl() {
 518                 delete m_Value;
 519             }
 520
 521             StatusCodeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 522                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 523                 init();
 524             }
 525
 526             StatusCodeImpl(const StatusCodeImpl& src)
 527                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 528                 init();
 529                 setValue(src.getValue());
 530                 if (src.getStatusCode())
 531                     setStatusCode(src.getStatusCode()->cloneStatusCode());
 532             }
 533
 534             IMPL_XMLOBJECT_CLONE(StatusCode);
 535             IMPL_XMLOBJECT_ATTRIB(Value,QName);
 536             IMPL_TYPED_CHILD(StatusCode);
 537
 538         protected:
 539             void marshallAttributes(DOMElement* domElement) const {
 540                 MARSHALL_QNAME_ATTRIB(Value,VALUE,NULL);
 541             }
 542
 543             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 544                 PROC_TYPED_CHILD(StatusCode,SAML1P_NS,true);
 545                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 546             }
 547
 548             void processAttribute(const DOMAttr* attribute) {
 549                 PROC_QNAME_ATTRIB(Value,VALUE,NULL);
 550             }
 551         };
 552
 553         class SAML_DLLLOCAL StatusDetailImpl : public virtual StatusDetail,
 554             public AbstractComplexElement,
 555             public AbstractDOMCachingXMLObject,
 556             public AbstractXMLObjectMarshaller,
 557             public AbstractXMLObjectUnmarshaller
 558         {
 559         public:
 560             virtual ~StatusDetailImpl() {}
 561
 562             StatusDetailImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 563                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 564             }
 565
 566             StatusDetailImpl(const StatusDetailImpl& src)
 567                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 568                 VectorOf(XMLObject) v=getUnknownXMLObjects();
 569                 for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 570                     v.push_back((*i)->clone());
 571             }
 572
 573             IMPL_XMLOBJECT_CLONE(StatusDetail);
 574             IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 575
 576         protected:
 577             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 578                 getUnknownXMLObjects().push_back(childXMLObject);
 579             }
 580         };
 581
 582         class SAML_DLLLOCAL StatusImpl : public virtual Status,
 583             public AbstractComplexElement,
 584             public AbstractDOMCachingXMLObject,
 585             public AbstractXMLObjectMarshaller,
 586             public AbstractXMLObjectUnmarshaller
 587         {
 588             void init() {
 589                 m_children.push_back(NULL);
 590                 m_children.push_back(NULL);
 591                 m_children.push_back(NULL);
 592                 m_StatusCode=NULL;
 593                 m_pos_StatusCode=m_children.begin();
 594                 m_StatusMessage=NULL;
 595                 m_pos_StatusMessage=m_pos_StatusCode;
 596                 ++m_pos_StatusMessage;
 597                 m_StatusDetail=NULL;
 598                 m_pos_StatusDetail=m_pos_StatusMessage;
 599                 ++m_pos_StatusDetail;
 600             }
 601         public:
 602             virtual ~StatusImpl() {}
 603
 604             StatusImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 605                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 606                 init();
 607             }
 608
 609             StatusImpl(const StatusImpl& src)
 610                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 611                 init();
 612                 if (src.getStatusCode())
 613                     setStatusCode(src.getStatusCode()->cloneStatusCode());
 614                 if (src.getStatusMessage())
 615                     setStatusMessage(src.getStatusMessage()->cloneStatusMessage());
 616                 if (src.getStatusDetail())
 617                     setStatusDetail(src.getStatusDetail()->cloneStatusDetail());
 618             }
 619
 620             IMPL_XMLOBJECT_CLONE(Status);
 621             IMPL_TYPED_CHILD(StatusCode);
 622             IMPL_TYPED_CHILD(StatusMessage);
 623             IMPL_TYPED_CHILD(StatusDetail);
 624
 625         protected:
 626             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 627                 PROC_TYPED_CHILD(StatusCode,SAML1P_NS,false);
 628                 PROC_TYPED_CHILD(StatusMessage,SAML1P_NS,false);
 629                 PROC_TYPED_CHILD(StatusDetail,SAML1P_NS,false);
 630                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 631             }
 632         };
 633
 634         class SAML_DLLLOCAL ResponseAbstractTypeImpl : public virtual ResponseAbstractType,
 635             public AbstractComplexElement,
 636             public AbstractDOMCachingXMLObject,
 637             public AbstractXMLObjectMarshaller,
 638             public AbstractXMLObjectUnmarshaller
 639         {
 640             void init() {
 641                 m_MinorVersion=NULL;
 642                 m_ResponseID=NULL;
 643                 m_InResponseTo=NULL;
 644                 m_IssueInstant=NULL;
 645                 m_Recipient=NULL;
 646                 m_children.push_back(NULL);
 647                 m_Signature=NULL;
 648                 m_pos_Signature=m_children.begin();
 649             }
 650         protected:
 651             ResponseAbstractTypeImpl() {
 652                 init();
 653             }
 654         public:
 655             virtual ~ResponseAbstractTypeImpl() {
 656                 XMLString::release(&m_MinorVersion);
 657                 XMLString::release(&m_ResponseID);
 658                 XMLString::release(&m_InResponseTo);
 659                 XMLString::release(&m_Recipient);
 660                 delete m_IssueInstant;
 661             }
 662
 663             ResponseAbstractTypeImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 664                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 665                 init();
 666             }
 667
 668             ResponseAbstractTypeImpl(const ResponseAbstractTypeImpl& src)
 669                     : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 670                 init();
 671                 setMinorVersion(src.m_MinorVersion);
 672                 setResponseID(src.getResponseID());
 673                 setInResponseTo(src.getInResponseTo());
 674                 setIssueInstant(src.getIssueInstant());
 675                 setRecipient(src.getRecipient());
 676                 if (src.getSignature())
 677                     setSignature(src.getSignature()->cloneSignature());
 678             }
 679
 680             //IMPL_TYPED_CHILD(Signature);
 681             // Need customized setter.
 682         protected:
 683             Signature* m_Signature;
 684             list<XMLObject*>::iterator m_pos_Signature;
 685         public:
 686             Signature* getSignature() const {
 687                 return m_Signature;
 688             }
 689
 690             void setSignature(Signature* sig) {
 691                 prepareForAssignment(m_Signature,sig);
 692                 *m_pos_Signature=m_Signature=sig;
 693                 // Sync content reference back up.
 694                 if (m_Signature)
 695                     m_Signature->setContentReference(new opensaml::ContentReference(*this));
 696             }
 697
 698             IMPL_INTEGER_ATTRIB(MinorVersion);
 699             IMPL_STRING_ATTRIB(ResponseID);    // have to special-case getXMLID
 700             const XMLCh* getXMLID() const {
 701                 pair<bool,int> v = getMinorVersion();
 702                 return (!v.first || v.second > 0) ? m_ResponseID : NULL;
 703             }
 704             const XMLCh* getID() const {
 705                 return getResponseID();
 706             }
 707             IMPL_STRING_ATTRIB(InResponseTo);
 708             IMPL_DATETIME_ATTRIB(IssueInstant,0);
 709             IMPL_STRING_ATTRIB(Recipient);
 710
 711         protected:
 712             void marshallAttributes(DOMElement* domElement) const {
 713                 static const XMLCh MAJORVERSION[] = UNICODE_LITERAL_12(M,a,j,o,r,V,e,r,s,i,o,n);
 714                 domElement->setAttributeNS(NULL,MAJORVERSION,XML_ONE);
 715                 if (!m_MinorVersion)
 716                     const_cast<ResponseAbstractTypeImpl*>(this)->m_MinorVersion=XMLString::replicate(XML_ONE);
 717                 MARSHALL_INTEGER_ATTRIB(MinorVersion,MINORVERSION,NULL);
 718                 if (!m_ResponseID)
 719                     const_cast<ResponseAbstractTypeImpl*>(this)->m_ResponseID=SAMLConfig::getConfig().generateIdentifier();
 720                 domElement->setAttributeNS(NULL, RESPONSEID_ATTRIB_NAME, m_ResponseID);
 721                 if (*m_MinorVersion!=chDigit_0)
 722                     domElement->setIdAttributeNS(NULL, RESPONSEID_ATTRIB_NAME);
 723                 MARSHALL_STRING_ATTRIB(InResponseTo,INRESPONSETO,NULL);
 724                 if (!m_IssueInstant) {
 725                     const_cast<ResponseAbstractTypeImpl*>(this)->m_IssueInstantEpoch=time(NULL);
 726                     const_cast<ResponseAbstractTypeImpl*>(this)->m_IssueInstant=new DateTime(m_IssueInstantEpoch);
 727                 }
 728                 MARSHALL_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
 729                 MARSHALL_STRING_ATTRIB(Recipient,RECIPIENT,NULL);
 730             }
 731
 732             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 733                 PROC_TYPED_CHILD(Signature,XMLSIG_NS,false);
 734                 AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 735             }
 736
 737             void unmarshallAttributes(const DOMElement* domElement) {
 738                 // Standard processing, but then we check IDness.
 739                 AbstractXMLObjectUnmarshaller::unmarshallAttributes(domElement);
 740                 if (m_ResponseID && (!m_MinorVersion || *m_MinorVersion!=chDigit_0))
 741                     const_cast<DOMElement*>(domElement)->setIdAttributeNS(NULL, RESPONSEID_ATTRIB_NAME);
 742             }
 743
 744             void processAttribute(const DOMAttr* attribute) {
 745                 static const XMLCh MAJORVERSION[] = UNICODE_LITERAL_12(M,a,j,o,r,V,e,r,s,i,o,n);
 746                 if (XMLHelper::isNodeNamed(attribute,NULL,MAJORVERSION)) {
 747                     if (!XMLString::equals(attribute->getValue(),XML_ONE))
 748                         throw UnmarshallingException("Response has invalid major version.");
 749                 }
 750                 PROC_INTEGER_ATTRIB(MinorVersion,MINORVERSION,NULL);
 751                 PROC_STRING_ATTRIB(ResponseID,RESPONSEID,NULL);
 752                 PROC_STRING_ATTRIB(InResponseTo,INRESPONSETO,NULL);
 753                 PROC_DATETIME_ATTRIB(IssueInstant,ISSUEINSTANT,NULL);
 754                 PROC_STRING_ATTRIB(Recipient,RECIPIENT,NULL);
 755             }
 756         };
 757
 758         class SAML_DLLLOCAL ResponseImpl : public virtual Response, public ResponseAbstractTypeImpl
 759         {
 760             void init() {
 761                 m_children.push_back(NULL);
 762                 m_Status=NULL;
 763                 m_pos_Status=m_pos_Signature;
 764                 ++m_pos_Status;
 765             }
 766         public:
 767             virtual ~ResponseImpl() {}
 768
 769             ResponseImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 770                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 771                 init();
 772             }
 773
 774             ResponseImpl(const ResponseImpl& src) : AbstractXMLObject(src), ResponseAbstractTypeImpl(src) {
 775                 init();
 776                 if (src.getStatus())
 777                     setStatus(src.getStatus()->cloneStatus());
 778                 VectorOf(saml1::Assertion) v=getAssertions();
 779                 for (vector<saml1::Assertion*>::const_iterator i=src.m_Assertions.begin(); i!=src.m_Assertions.end(); i++) {
 780                     if (*i) {
 781                         v.push_back((*i)->cloneAssertion());
 782                     }
 783                 }
 784             }
 785
 786             IMPL_XMLOBJECT_CLONE(Response);
 787             ResponseAbstractType* cloneResponseAbstractType() const {
 788                 return cloneResponse();
 789             }
 790             IMPL_TYPED_CHILD(Status);
 791             IMPL_TYPED_FOREIGN_CHILDREN(Assertion,saml1,m_children.end());
 792
 793         protected:
 794             void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 795                 PROC_TYPED_CHILD(Status,SAML1P_NS,false);
 796                 PROC_TYPED_FOREIGN_CHILDREN(Assertion,saml1,SAML1_NS,true);
 797                 ResponseAbstractTypeImpl::processChildElement(childXMLObject,root);
 798             }
 799         };
 800
 801     };
 802 };
 803
 804 #if defined (_MSC_VER)
 805     #pragma warning( pop )
 806 #endif
 807
 808 // Builder Implementations
 809
 810 IMPL_XMLOBJECTBUILDER(AssertionArtifact);
 811 IMPL_XMLOBJECTBUILDER(AttributeQuery);
 812 IMPL_XMLOBJECTBUILDER(AuthenticationQuery);
 813 IMPL_XMLOBJECTBUILDER(AuthorizationDecisionQuery);
 814 IMPL_XMLOBJECTBUILDER(Query);
 815 IMPL_XMLOBJECTBUILDER(Request);
 816 IMPL_XMLOBJECTBUILDER(RespondWith);
 817 IMPL_XMLOBJECTBUILDER(Response);
 818 IMPL_XMLOBJECTBUILDER(Status);
 819 IMPL_XMLOBJECTBUILDER(StatusCode);
 820 IMPL_XMLOBJECTBUILDER(StatusDetail);
 821 IMPL_XMLOBJECTBUILDER(StatusMessage);
 822
 823 // Unicode literals
 824 const XMLCh RequestAbstractType::LOCAL_NAME[] =             {chNull};
 825 const XMLCh RequestAbstractType::TYPE_NAME[] =              UNICODE_LITERAL_19(R,e,q,u,e,s,t,A,b,s,t,r,a,c,t,T,y,p,e);
 826 const XMLCh RequestAbstractType::MINORVERSION_ATTRIB_NAME[] =   UNICODE_LITERAL_12(M,i,n,o,r,V,e,r,s,i,o,n);
 827 const XMLCh RequestAbstractType::REQUESTID_ATTRIB_NAME[] =      UNICODE_LITERAL_9(R,e,q,u,e,s,t,I,D);
 828 const XMLCh RequestAbstractType::ISSUEINSTANT_ATTRIB_NAME[] =   UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
 829 const XMLCh ResponseAbstractType::LOCAL_NAME[] =            {chNull};
 830 const XMLCh ResponseAbstractType::TYPE_NAME[] =             UNICODE_LITERAL_20(R,e,s,p,o,n,s,e,A,b,s,t,r,a,c,t,T,y,p,e);
 831 const XMLCh ResponseAbstractType::MINORVERSION_ATTRIB_NAME[] =  UNICODE_LITERAL_12(M,i,n,o,r,V,e,r,s,i,o,n);
 832 const XMLCh ResponseAbstractType::RESPONSEID_ATTRIB_NAME[] =    UNICODE_LITERAL_10(R,e,s,p,o,n,s,e,I,D);
 833 const XMLCh ResponseAbstractType::ISSUEINSTANT_ATTRIB_NAME[] =  UNICODE_LITERAL_12(I,s,s,u,e,I,n,s,t,a,n,t);
 834 const XMLCh ResponseAbstractType::INRESPONSETO_ATTRIB_NAME[] =  UNICODE_LITERAL_12(I,n,R,e,s,p,o,n,s,e,T,o);
 835 const XMLCh ResponseAbstractType::RECIPIENT_ATTRIB_NAME[] =     UNICODE_LITERAL_9(R,e,c,i,p,i,e,n,t);
 836 const XMLCh AssertionArtifact::LOCAL_NAME[] =               UNICODE_LITERAL_17(A,s,s,e,r,t,i,o,n,A,r,t,i,f,a,c,t);
 837 const XMLCh AttributeQuery::LOCAL_NAME[] =                  UNICODE_LITERAL_14(A,t,t,r,i,b,u,t,e,Q,u,e,r,y);
 838 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);
 839 const XMLCh AttributeQuery::RESOURCE_ATTRIB_NAME[] =        UNICODE_LITERAL_8(R,e,s,o,u,r,c,e);
 840 const XMLCh AuthenticationQuery::LOCAL_NAME[] =             UNICODE_LITERAL_19(A,u,t,h,e,n,t,i,c,a,t,i,o,n,Q,u,e,r,y);
 841 const XMLCh AuthenticationQuery::TYPE_NAME[] =              UNICODE_LITERAL_23(A,u,t,h,e,n,t,i,c,a,t,i,o,n,Q,u,e,r,y,T,y,p,e);
 842 const XMLCh AuthenticationQuery::AUTHENTICATIONMETHOD_ATTRIB_NAME[] =   UNICODE_LITERAL_20(A,u,t,h,e,n,t,i,c,a,t,i,o,n,M,e,t,h,o,d);
 843 const XMLCh AuthorizationDecisionQuery::LOCAL_NAME[] =      UNICODE_LITERAL_26(A,u,t,h,o,r,i,z,a,t,i,o,n,D,e,c,i,s,i,o,n,Q,u,e,r,y);
 844 const XMLCh AuthorizationDecisionQuery::TYPE_NAME[] =       UNICODE_LITERAL_30(A,u,t,h,o,r,i,z,a,t,i,o,n,D,e,c,i,s,i,o,n,Q,u,e,r,y,T,y,p,e);
 845 const XMLCh AuthorizationDecisionQuery::RESOURCE_ATTRIB_NAME[] =        UNICODE_LITERAL_8(R,e,s,o,u,r,c,e);
 846 const XMLCh Query::LOCAL_NAME[] =                           UNICODE_LITERAL_5(Q,u,e,r,y);
 847 const XMLCh Request::LOCAL_NAME[] =                         UNICODE_LITERAL_7(R,e,q,u,e,s,t);
 848 const XMLCh Request::TYPE_NAME[] =                          UNICODE_LITERAL_11(R,e,q,u,e,s,t,T,y,p,e);
 849 const XMLCh RespondWith::LOCAL_NAME[] =                     UNICODE_LITERAL_11(R,e,s,p,o,n,d,W,i,t,h);
 850 const XMLCh Response::LOCAL_NAME[] =                        UNICODE_LITERAL_8(R,e,s,p,o,n,s,e);
 851 const XMLCh Response::TYPE_NAME[] =                         UNICODE_LITERAL_12(R,e,s,p,o,n,s,e,T,y,p,e);
 852 const XMLCh Status::LOCAL_NAME[] =                          UNICODE_LITERAL_6(S,t,a,t,u,s);
 853 const XMLCh Status::TYPE_NAME[] =                           UNICODE_LITERAL_10(S,t,a,t,u,s,T,y,p,e);
 854 const XMLCh StatusCode::LOCAL_NAME[] =                      UNICODE_LITERAL_10(S,t,a,t,u,s,C,o,d,e);
 855 const XMLCh StatusCode::TYPE_NAME[] =                       UNICODE_LITERAL_14(S,t,a,t,u,s,C,o,d,e,T,y,p,e);
 856 const XMLCh StatusCode::VALUE_ATTRIB_NAME[] =               UNICODE_LITERAL_5(V,a,l,u,e);
 857 const XMLCh StatusDetail::LOCAL_NAME[] =                    UNICODE_LITERAL_12(S,t,a,t,u,s,D,e,t,a,i,l);
 858 const XMLCh StatusDetail::TYPE_NAME[] =                     UNICODE_LITERAL_16(S,t,a,t,u,s,D,e,t,a,i,l,T,y,p,e);
 859 const XMLCh StatusMessage::LOCAL_NAME[] =                   UNICODE_LITERAL_13(S,t,a,t,u,s,M,e,s,s,a,g,e);
 860 const XMLCh SubjectQuery::LOCAL_NAME[] =                    UNICODE_LITERAL_12(S,u,b,j,e,c,t,Q,u,e,r,y);
 861
 862 #define XCH(ch) chLatin_##ch
 863 #define XNUM(d) chDigit_##d
 864
 865 const XMLCh _SUCCESS[] =                                    UNICODE_LITERAL_7(S,u,c,c,e,s,s);
 866 const XMLCh _REQUESTER[] =                                  UNICODE_LITERAL_9(R,e,q,u,e,s,t,e,r);
 867 const XMLCh _RESPONDER[] =                                  UNICODE_LITERAL_9(R,e,s,p,o,n,d,e,r);
 868 const XMLCh _VERSIONMISMATCH[] =                            UNICODE_LITERAL_15(V,e,r,s,i,o,n,M,i,s,m,a,t,c,h);
 869
 870 QName StatusCode::SUCCESS(SAML1P_NS,_SUCCESS,SAML1P_PREFIX);
 871 QName StatusCode::REQUESTER(SAML1P_NS,_REQUESTER,SAML1P_PREFIX);
 872 QName StatusCode::RESPONDER(SAML1P_NS,_RESPONDER,SAML1P_PREFIX);
 873 QName StatusCode::VERSIONMISMATCH(SAML1P_NS,_VERSIONMISMATCH,SAML1P_PREFIX);