saml/saml2/core/impl/Protocols20Impl.cpp

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