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