xmltooling/signature/impl/KeyInfoImpl.cpp

   1 /*
   2  *  Copyright 2001-2010 Internet2
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /**
  18  * KeyInfoImpl.cpp
  19  *
  20  * Implementation classes for KeyInfo schema.
  21  */
  22
  23 #include "internal.h"
  24 #include "AbstractComplexElement.h"
  25 #include "AbstractSimpleElement.h"
  26 #include "exceptions.h"
  27 #include "io/AbstractXMLObjectMarshaller.h"
  28 #include "io/AbstractXMLObjectUnmarshaller.h"
  29 #include "signature/KeyInfo.h"
  30 #include "util/XMLHelper.h"
  31
  32 #include <xercesc/util/XMLUniDefs.hpp>
  33
  34 using namespace xmlsignature;
  35 using namespace xmltooling;
  36 using namespace xercesc;
  37 using namespace std;
  38 using xmlconstants::XMLSIG_NS;
  39 using xmlconstants::XMLSIG11_NS;
  40
  41 #if defined (_MSC_VER)
  42     #pragma warning( push )
  43     #pragma warning( disable : 4250 4251 )
  44 #endif
  45
  46 namespace xmlsignature {
  47
  48     class XMLTOOL_DLLLOCAL DSAKeyValueImpl : public virtual DSAKeyValue,
  49         public AbstractComplexElement,
  50         public AbstractDOMCachingXMLObject,
  51         public AbstractXMLObjectMarshaller,
  52         public AbstractXMLObjectUnmarshaller
  53     {
  54     public:
  55         virtual ~DSAKeyValueImpl() {}
  56
  57         DSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  58             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  59             init();
  60         }
  61
  62         DSAKeyValueImpl(const DSAKeyValueImpl& src)
  63                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  64             init();
  65             if (src.getP())
  66                 setP(src.getP()->cloneP());
  67             if (src.getQ())
  68                 setQ(src.getQ()->cloneQ());
  69             if (src.getG())
  70                 setG(src.getG()->cloneG());
  71             if (src.getY())
  72                 setY(src.getY()->cloneY());
  73             if (src.getJ())
  74                 setJ(src.getJ()->cloneJ());
  75             if (src.getSeed())
  76                 setSeed(src.getSeed()->cloneSeed());
  77             if (src.getPgenCounter())
  78                 setPgenCounter(src.getPgenCounter()->clonePgenCounter());
  79         }
  80
  81         void init() {
  82             m_P=nullptr;
  83             m_Q=nullptr;
  84             m_G=nullptr;
  85             m_Y=nullptr;
  86             m_J=nullptr;
  87             m_Seed=nullptr;
  88             m_PgenCounter=nullptr;
  89             m_children.push_back(nullptr);
  90             m_children.push_back(nullptr);
  91             m_children.push_back(nullptr);
  92             m_children.push_back(nullptr);
  93             m_children.push_back(nullptr);
  94             m_children.push_back(nullptr);
  95             m_children.push_back(nullptr);
  96             m_pos_P=m_children.begin();
  97             m_pos_Q=m_pos_P;
  98             ++m_pos_Q;
  99             m_pos_G=m_pos_Q;
 100             ++m_pos_G;
 101             m_pos_Y=m_pos_G;
 102             ++m_pos_Y;
 103             m_pos_J=m_pos_Y;
 104             ++m_pos_J;
 105             m_pos_Seed=m_pos_J;
 106             ++m_pos_Seed;
 107             m_pos_PgenCounter=m_pos_Seed;
 108             ++m_pos_PgenCounter;
 109         }
 110
 111         IMPL_XMLOBJECT_CLONE(DSAKeyValue);
 112         IMPL_TYPED_CHILD(P);
 113         IMPL_TYPED_CHILD(Q);
 114         IMPL_TYPED_CHILD(G);
 115         IMPL_TYPED_CHILD(Y);
 116         IMPL_TYPED_CHILD(J);
 117         IMPL_TYPED_CHILD(Seed);
 118         IMPL_TYPED_CHILD(PgenCounter);
 119
 120     protected:
 121         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 122             PROC_TYPED_CHILD(P,XMLSIG_NS,false);
 123             PROC_TYPED_CHILD(Q,XMLSIG_NS,false);
 124             PROC_TYPED_CHILD(G,XMLSIG_NS,false);
 125             PROC_TYPED_CHILD(Y,XMLSIG_NS,false);
 126             PROC_TYPED_CHILD(J,XMLSIG_NS,false);
 127             PROC_TYPED_CHILD(Seed,XMLSIG_NS,false);
 128             PROC_TYPED_CHILD(PgenCounter,XMLSIG_NS,false);
 129             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 130         }
 131     };
 132
 133     class XMLTOOL_DLLLOCAL RSAKeyValueImpl : public virtual RSAKeyValue,
 134         public AbstractComplexElement,
 135         public AbstractDOMCachingXMLObject,
 136         public AbstractXMLObjectMarshaller,
 137         public AbstractXMLObjectUnmarshaller
 138     {
 139     public:
 140         virtual ~RSAKeyValueImpl() {}
 141
 142         RSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 143                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 144             init();
 145         }
 146
 147         RSAKeyValueImpl(const RSAKeyValueImpl& src)
 148                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 149             init();
 150             if (src.getModulus())
 151                 setModulus(src.getModulus()->cloneModulus());
 152             if (src.getExponent())
 153                 setExponent(src.getExponent()->cloneExponent());
 154         }
 155
 156         void init() {
 157             m_Modulus=nullptr;
 158             m_Exponent=nullptr;
 159             m_children.push_back(nullptr);
 160             m_children.push_back(nullptr);
 161             m_pos_Modulus=m_children.begin();
 162             m_pos_Exponent=m_pos_Modulus;
 163             ++m_pos_Exponent;
 164         }
 165
 166         IMPL_XMLOBJECT_CLONE(RSAKeyValue);
 167         IMPL_TYPED_CHILD(Modulus);
 168         IMPL_TYPED_CHILD(Exponent);
 169
 170     protected:
 171         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 172             PROC_TYPED_CHILD(Modulus,XMLSIG_NS,false);
 173             PROC_TYPED_CHILD(Exponent,XMLSIG_NS,false);
 174             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 175         }
 176     };
 177
 178     class XMLTOOL_DLLLOCAL NamedCurveImpl : public virtual NamedCurve,
 179         public AbstractComplexElement,
 180         public AbstractDOMCachingXMLObject,
 181         public AbstractXMLObjectMarshaller,
 182         public AbstractXMLObjectUnmarshaller
 183     {
 184     public:
 185         virtual ~NamedCurveImpl() {
 186             XMLString::release(&m_URI);
 187         }
 188
 189         NamedCurveImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 190             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 191             m_URI=nullptr;
 192         }
 193
 194         NamedCurveImpl(const NamedCurveImpl& src)
 195                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 196             m_URI=nullptr;
 197             setURI(getURI());
 198         }
 199
 200         IMPL_XMLOBJECT_CLONE(NamedCurve);
 201         IMPL_STRING_ATTRIB(URI);
 202
 203     protected:
 204         void marshallAttributes(DOMElement* domElement) const {
 205             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 206         }
 207
 208         void processAttribute(const DOMAttr* attribute) {
 209             PROC_STRING_ATTRIB(URI,URI,nullptr);
 210             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 211         }
 212     };
 213
 214     class XMLTOOL_DLLLOCAL ECKeyValueImpl : public virtual ECKeyValue,
 215         public AbstractComplexElement,
 216         public AbstractDOMCachingXMLObject,
 217         public AbstractXMLObjectMarshaller,
 218         public AbstractXMLObjectUnmarshaller
 219     {
 220     public:
 221         virtual ~ECKeyValueImpl() {
 222             XMLString::release(&m_Id);
 223         }
 224
 225         ECKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 226                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 227             init();
 228         }
 229
 230         ECKeyValueImpl(const ECKeyValueImpl& src)
 231                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 232             init();
 233             m_Id=XMLString::replicate(src.m_Id);
 234             if (src.getECParameters())
 235                 setECParameters(src.getECParameters()->clone());
 236             if (src.getNamedCurve())
 237                 setNamedCurve(src.getNamedCurve()->cloneNamedCurve());
 238             if (src.getPublicKey())
 239                 setPublicKey(src.getPublicKey()->clonePublicKey());
 240         }
 241
 242         void init() {
 243             m_Id=nullptr;
 244             m_ECParameters=nullptr;
 245             m_NamedCurve=nullptr;
 246             m_PublicKey=nullptr;
 247             m_children.push_back(nullptr);
 248             m_children.push_back(nullptr);
 249             m_children.push_back(nullptr);
 250             m_pos_ECParameters=m_children.begin();
 251             m_pos_NamedCurve=m_pos_ECParameters;
 252             ++m_pos_NamedCurve;
 253             m_pos_PublicKey=m_pos_NamedCurve;
 254             ++m_pos_PublicKey;
 255         }
 256
 257         IMPL_XMLOBJECT_CLONE(ECKeyValue);
 258         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 259         IMPL_XMLOBJECT_CHILD(ECParameters);
 260         IMPL_TYPED_CHILD(NamedCurve);
 261         IMPL_TYPED_CHILD(PublicKey);
 262
 263     protected:
 264         void marshallAttributes(DOMElement* domElement) const {
 265             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 266         }
 267
 268         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 269             PROC_TYPED_CHILD(NamedCurve,XMLSIG11_NS,false);
 270             PROC_TYPED_CHILD(PublicKey,XMLSIG11_NS,false);
 271
 272             // Not really "unknown", but currently unwrapped.
 273             static const XMLCh _ECParameters[] = UNICODE_LITERAL_12(E,C,P,a,r,a,m,e,t,e,r,s);
 274             if (XMLString::equals(root->getLocalName(), _ECParameters) && XMLString::equals(root->getNamespaceURI(), XMLSIG11_NS)) {
 275                 setECParameters(childXMLObject);
 276                 return;
 277             }
 278
 279             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 280         }
 281
 282         void processAttribute(const DOMAttr* attribute) {
 283             PROC_ID_ATTRIB(Id,ID,nullptr);
 284             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 285         }
 286     };
 287
 288     class XMLTOOL_DLLLOCAL KeyValueImpl : public virtual KeyValue,
 289         public AbstractComplexElement,
 290         public AbstractDOMCachingXMLObject,
 291         public AbstractXMLObjectMarshaller,
 292         public AbstractXMLObjectUnmarshaller
 293     {
 294     public:
 295         virtual ~KeyValueImpl() {}
 296
 297         KeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 298                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 299             init();
 300         }
 301
 302         KeyValueImpl(const KeyValueImpl& src)
 303                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 304             init();
 305             if (src.getDSAKeyValue())
 306                 setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
 307             if (src.getRSAKeyValue())
 308                 setRSAKeyValue(src.getRSAKeyValue()->cloneRSAKeyValue());
 309             if (src.getECKeyValue())
 310                 setECKeyValue(src.getECKeyValue()->cloneECKeyValue());
 311             if (src.getUnknownXMLObject())
 312                 setUnknownXMLObject(src.getUnknownXMLObject()->clone());
 313         }
 314
 315         void init() {
 316             m_DSAKeyValue=nullptr;
 317             m_RSAKeyValue=nullptr;
 318             m_ECKeyValue=nullptr;
 319             m_UnknownXMLObject=nullptr;
 320             m_children.push_back(nullptr);
 321             m_children.push_back(nullptr);
 322             m_children.push_back(nullptr);
 323             m_children.push_back(nullptr);
 324             m_pos_DSAKeyValue=m_children.begin();
 325             m_pos_RSAKeyValue=m_pos_DSAKeyValue;
 326             ++m_pos_RSAKeyValue;
 327             m_pos_ECKeyValue=m_pos_RSAKeyValue;
 328             ++m_pos_ECKeyValue;
 329             m_pos_UnknownXMLObject=m_pos_ECKeyValue;
 330             ++m_pos_UnknownXMLObject;
 331         }
 332
 333         IMPL_XMLOBJECT_CLONE(KeyValue);
 334         IMPL_TYPED_CHILD(DSAKeyValue);
 335         IMPL_TYPED_CHILD(RSAKeyValue);
 336         IMPL_TYPED_CHILD(ECKeyValue);
 337         IMPL_XMLOBJECT_CHILD(UnknownXMLObject);
 338
 339     protected:
 340         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 341             PROC_TYPED_CHILD(DSAKeyValue,XMLSIG_NS,false);
 342             PROC_TYPED_CHILD(RSAKeyValue,XMLSIG_NS,false);
 343             PROC_TYPED_CHILD(ECKeyValue,XMLSIG11_NS,false);
 344
 345             // Unknown child.
 346             const XMLCh* nsURI=root->getNamespaceURI();
 347             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 348                 setUnknownXMLObject(childXMLObject);
 349                 return;
 350             }
 351
 352             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 353         }
 354     };
 355
 356     class XMLTOOL_DLLLOCAL DEREncodedKeyValueImpl : public virtual DEREncodedKeyValue,
 357         public AbstractSimpleElement,
 358         public AbstractDOMCachingXMLObject,
 359         public AbstractXMLObjectMarshaller,
 360         public AbstractXMLObjectUnmarshaller
 361     {
 362     public:
 363         virtual ~DEREncodedKeyValueImpl() {
 364             XMLString::release(&m_Id);
 365         }
 366
 367         DEREncodedKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 368                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 369         }
 370
 371         DEREncodedKeyValueImpl(const DEREncodedKeyValueImpl& src)
 372                 : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Id(nullptr) {
 373             setId(src.getId());
 374         }
 375
 376         IMPL_XMLOBJECT_CLONE(DEREncodedKeyValue);
 377         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 378
 379     protected:
 380         void marshallAttributes(DOMElement* domElement) const {
 381             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 382         }
 383
 384         void processAttribute(const DOMAttr* attribute) {
 385             PROC_ID_ATTRIB(Id,ID,nullptr);
 386             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 387         }
 388     };
 389
 390     class XMLTOOL_DLLLOCAL TransformImpl : public virtual Transform,
 391         public AbstractComplexElement,
 392         public AbstractDOMCachingXMLObject,
 393         public AbstractXMLObjectMarshaller,
 394         public AbstractXMLObjectUnmarshaller
 395     {
 396     public:
 397         virtual ~TransformImpl() {
 398             XMLString::release(&m_Algorithm);
 399         }
 400
 401         TransformImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 402             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
 403         }
 404
 405         TransformImpl(const TransformImpl& src)
 406                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 407                     m_Algorithm(XMLString::replicate(src.m_Algorithm)) {
 408             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 409                 if (*i) {
 410                     XPath* x=dynamic_cast<XPath*>(*i);
 411                     if (x) {
 412                         getXPaths().push_back(x->cloneXPath());
 413                         continue;
 414                     }
 415                     getUnknownXMLObjects().push_back((*i)->clone());
 416                 }
 417             }
 418         }
 419
 420         IMPL_XMLOBJECT_CLONE(Transform);
 421         IMPL_STRING_ATTRIB(Algorithm);
 422         IMPL_TYPED_CHILDREN(XPath,m_children.end());
 423         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 424
 425     protected:
 426         void marshallAttributes(DOMElement* domElement) const {
 427             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 428         }
 429
 430         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 431             PROC_TYPED_CHILDREN(XPath,XMLSIG_NS,false);
 432
 433             // Unknown child.
 434             const XMLCh* nsURI=root->getNamespaceURI();
 435             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 436                 getUnknownXMLObjects().push_back(childXMLObject);
 437                 return;
 438             }
 439
 440             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 441         }
 442
 443         void processAttribute(const DOMAttr* attribute) {
 444             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 445             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 446         }
 447     };
 448
 449     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 450         public AbstractComplexElement,
 451         public AbstractDOMCachingXMLObject,
 452         public AbstractXMLObjectMarshaller,
 453         public AbstractXMLObjectUnmarshaller
 454     {
 455     public:
 456         virtual ~TransformsImpl() {}
 457
 458         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 459             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 460         }
 461
 462         TransformsImpl(const TransformsImpl& src)
 463                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 464             VectorOf(Transform) v=getTransforms();
 465             for (vector<Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 466                 if (*i) {
 467                     v.push_back((*i)->cloneTransform());
 468                 }
 469             }
 470         }
 471
 472         IMPL_XMLOBJECT_CLONE(Transforms);
 473         IMPL_TYPED_CHILDREN(Transform,m_children.end());
 474
 475     protected:
 476         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 477             PROC_TYPED_CHILDREN(Transform,XMLSIG_NS,false);
 478             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 479         }
 480     };
 481
 482     class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public virtual RetrievalMethod,
 483         public AbstractComplexElement,
 484         public AbstractDOMCachingXMLObject,
 485         public AbstractXMLObjectMarshaller,
 486         public AbstractXMLObjectUnmarshaller
 487     {
 488     public:
 489         virtual ~RetrievalMethodImpl() {
 490             XMLString::release(&m_URI);
 491             XMLString::release(&m_Type);
 492         }
 493
 494         RetrievalMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 495             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 496             init();
 497         }
 498
 499         RetrievalMethodImpl(const RetrievalMethodImpl& src)
 500                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 501             init();
 502             setURI(getURI());
 503             setType(getType());
 504             if (src.getTransforms())
 505                 setTransforms(src.getTransforms()->cloneTransforms());
 506         }
 507
 508         void init() {
 509             m_URI=m_Type=nullptr;
 510             m_Transforms=nullptr;
 511             m_children.push_back(nullptr);
 512             m_pos_Transforms=m_children.begin();
 513         }
 514
 515         IMPL_XMLOBJECT_CLONE(RetrievalMethod);
 516         IMPL_STRING_ATTRIB(URI);
 517         IMPL_STRING_ATTRIB(Type);
 518         IMPL_TYPED_CHILD(Transforms);
 519
 520     protected:
 521         void marshallAttributes(DOMElement* domElement) const {
 522             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 523             MARSHALL_STRING_ATTRIB(Type,TYPE,nullptr);
 524         }
 525
 526         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 527             PROC_TYPED_CHILD(Transforms,XMLSIG_NS,false);
 528             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 529         }
 530
 531         void processAttribute(const DOMAttr* attribute) {
 532             PROC_STRING_ATTRIB(URI,URI,nullptr);
 533             PROC_STRING_ATTRIB(Type,TYPE,nullptr);
 534             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 535         }
 536     };
 537
 538     class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public virtual X509IssuerSerial,
 539         public AbstractComplexElement,
 540         public AbstractDOMCachingXMLObject,
 541         public AbstractXMLObjectMarshaller,
 542         public AbstractXMLObjectUnmarshaller
 543     {
 544     public:
 545         virtual ~X509IssuerSerialImpl() {}
 546
 547         X509IssuerSerialImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 548                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 549             init();
 550         }
 551
 552         X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
 553                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 554             init();
 555             if (src.getX509IssuerName())
 556                 setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
 557             if (src.getX509SerialNumber())
 558                 setX509SerialNumber(src.getX509SerialNumber()->cloneX509SerialNumber());
 559         }
 560
 561         void init() {
 562             m_X509IssuerName=nullptr;
 563             m_X509SerialNumber=nullptr;
 564             m_children.push_back(nullptr);
 565             m_children.push_back(nullptr);
 566             m_pos_X509IssuerName=m_children.begin();
 567             m_pos_X509SerialNumber=m_pos_X509IssuerName;
 568             ++m_pos_X509SerialNumber;
 569         }
 570
 571         IMPL_XMLOBJECT_CLONE(X509IssuerSerial);
 572         IMPL_TYPED_CHILD(X509IssuerName);
 573         IMPL_TYPED_CHILD(X509SerialNumber);
 574
 575     protected:
 576         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 577             PROC_TYPED_CHILD(X509IssuerName,XMLSIG_NS,false);
 578             PROC_TYPED_CHILD(X509SerialNumber,XMLSIG_NS,false);
 579             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 580         }
 581     };
 582
 583     class XMLTOOL_DLLLOCAL X509DigestImpl : public virtual X509Digest,
 584         public AbstractComplexElement,
 585         public AbstractDOMCachingXMLObject,
 586         public AbstractXMLObjectMarshaller,
 587         public AbstractXMLObjectUnmarshaller
 588     {
 589     public:
 590         virtual ~X509DigestImpl() {
 591             XMLString::release(&m_Algorithm);
 592         }
 593
 594         X509DigestImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 595             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
 596         }
 597
 598         X509DigestImpl(const X509DigestImpl& src)
 599                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src), m_Algorithm(nullptr) {
 600             setAlgorithm(src.getAlgorithm());
 601         }
 602
 603         IMPL_XMLOBJECT_CLONE(X509Digest);
 604         IMPL_STRING_ATTRIB(Algorithm);
 605
 606     protected:
 607         void marshallAttributes(DOMElement* domElement) const {
 608             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 609         }
 610
 611         void processAttribute(const DOMAttr* attribute) {
 612             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 613             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 614         }
 615     };
 616
 617
 618     class XMLTOOL_DLLLOCAL X509DataImpl : public virtual X509Data,
 619         public AbstractComplexElement,
 620         public AbstractDOMCachingXMLObject,
 621         public AbstractXMLObjectMarshaller,
 622         public AbstractXMLObjectUnmarshaller
 623     {
 624     public:
 625         virtual ~X509DataImpl() {}
 626
 627         X509DataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 628             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 629         }
 630
 631         X509DataImpl(const X509DataImpl& src)
 632                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 633             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 634                 if (*i) {
 635                     X509Certificate* xcert=dynamic_cast<X509Certificate*>(*i);
 636                     if (xcert) {
 637                         getX509Certificates().push_back(xcert->cloneX509Certificate());
 638                         continue;
 639                     }
 640
 641                     X509CRL* xcrl=dynamic_cast<X509CRL*>(*i);
 642                     if (xcrl) {
 643                         getX509CRLs().push_back(xcrl->cloneX509CRL());
 644                         continue;
 645                     }
 646
 647                     X509SubjectName* xsn=dynamic_cast<X509SubjectName*>(*i);
 648                     if (xsn) {
 649                         getX509SubjectNames().push_back(xsn->cloneX509SubjectName());
 650                         continue;
 651                     }
 652
 653                     X509IssuerSerial* xis=dynamic_cast<X509IssuerSerial*>(*i);
 654                     if (xis) {
 655                         getX509IssuerSerials().push_back(xis->cloneX509IssuerSerial());
 656                         continue;
 657                     }
 658
 659                     X509SKI* xski=dynamic_cast<X509SKI*>(*i);
 660                     if (xski) {
 661                         getX509SKIs().push_back(xski->cloneX509SKI());
 662                         continue;
 663                     }
 664
 665                     X509Digest* xdig=dynamic_cast<X509Digest*>(*i);
 666                     if (xdig) {
 667                         getX509Digests().push_back(xdig->cloneX509Digest());
 668                         continue;
 669                     }
 670
 671                     OCSPResponse* ocsp=dynamic_cast<OCSPResponse*>(*i);
 672                     if (ocsp) {
 673                         getOCSPResponses().push_back(ocsp->cloneOCSPResponse());
 674                         continue;
 675                     }
 676
 677                     getUnknownXMLObjects().push_back((*i)->clone());
 678                 }
 679             }
 680         }
 681
 682         IMPL_XMLOBJECT_CLONE(X509Data);
 683         IMPL_TYPED_CHILDREN(X509IssuerSerial,m_children.end());
 684         IMPL_TYPED_CHILDREN(X509SKI,m_children.end());
 685         IMPL_TYPED_CHILDREN(X509SubjectName,m_children.end());
 686         IMPL_TYPED_CHILDREN(X509Certificate,m_children.end());
 687         IMPL_TYPED_CHILDREN(X509CRL,m_children.end());
 688         IMPL_TYPED_CHILDREN(X509Digest,m_children.end());
 689         IMPL_TYPED_CHILDREN(OCSPResponse,m_children.end());
 690         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 691
 692     protected:
 693         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 694             PROC_TYPED_CHILDREN(X509IssuerSerial,XMLSIG_NS,false);
 695             PROC_TYPED_CHILDREN(X509SKI,XMLSIG_NS,false);
 696             PROC_TYPED_CHILDREN(X509SubjectName,XMLSIG_NS,false);
 697             PROC_TYPED_CHILDREN(X509Certificate,XMLSIG_NS,false);
 698             PROC_TYPED_CHILDREN(X509CRL,XMLSIG_NS,false);
 699             PROC_TYPED_CHILDREN(X509Digest,XMLSIG11_NS,false);
 700             PROC_TYPED_CHILDREN(OCSPResponse,XMLSIG11_NS,false);
 701
 702             // Unknown child.
 703             const XMLCh* nsURI=root->getNamespaceURI();
 704             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 705                 getUnknownXMLObjects().push_back(childXMLObject);
 706                 return;
 707             }
 708
 709             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 710         }
 711     };
 712
 713     class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
 714         public AbstractComplexElement,
 715         public AbstractDOMCachingXMLObject,
 716         public AbstractXMLObjectMarshaller,
 717         public AbstractXMLObjectUnmarshaller
 718     {
 719     public:
 720         virtual ~SPKIDataImpl() {}
 721
 722         SPKIDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 723             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 724         }
 725
 726         SPKIDataImpl(const SPKIDataImpl& src)
 727                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 728             VectorOfPairs(SPKISexp,XMLObject) v=getSPKISexps();
 729             for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
 730                 if (i->first) {
 731                     v.push_back(make_pair(i->first->cloneSPKISexp(),(i->second ? i->second->clone() : (XMLObject*)nullptr)));
 732                 }
 733             }
 734         }
 735
 736         IMPL_XMLOBJECT_CLONE(SPKIData);
 737
 738     private:
 739         vector< pair<SPKISexp*,XMLObject*> > m_SPKISexps;
 740
 741     public:
 742         VectorOfPairs(SPKISexp,XMLObject) getSPKISexps() {
 743             return VectorOfPairs(SPKISexp,XMLObject)(this, m_SPKISexps, &m_children, m_children.end());
 744         }
 745
 746         const vector< pair<SPKISexp*,XMLObject*> >& getSPKISexps() const {
 747             return m_SPKISexps;
 748         }
 749
 750     protected:
 751         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 752             if (XMLHelper::isNodeNamed(root,XMLSIG_NS,SPKISexp::LOCAL_NAME)) {
 753                 SPKISexp* typesafe=dynamic_cast<SPKISexp*>(childXMLObject);
 754                 if (typesafe) {
 755                     getSPKISexps().push_back(make_pair(typesafe,(XMLObject*)nullptr));
 756                     return;
 757                 }
 758             }
 759
 760             // Unknown child (has to be paired with the last SPKISexp processed.
 761             const XMLCh* nsURI=root->getNamespaceURI();
 762             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 763                 // Update second half of pair in vector, and in master list.
 764                 if (!m_SPKISexps.empty() && m_SPKISexps.back().second==nullptr) {
 765                     m_SPKISexps.back().second=childXMLObject;
 766                     m_children.back()=childXMLObject;
 767                     return;
 768                 }
 769                 else
 770                     throw UnmarshallingException("Extension element must follow ds:SPKISexp element.");
 771             }
 772
 773             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 774         }
 775     };
 776
 777     class XMLTOOL_DLLLOCAL PGPDataImpl : public virtual PGPData,
 778         public AbstractComplexElement,
 779         public AbstractDOMCachingXMLObject,
 780         public AbstractXMLObjectMarshaller,
 781         public AbstractXMLObjectUnmarshaller
 782     {
 783     public:
 784         virtual ~PGPDataImpl() {}
 785
 786         PGPDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 787                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 788             init();
 789         }
 790
 791         PGPDataImpl(const PGPDataImpl& src)
 792                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 793             init();
 794             if (src.getPGPKeyID())
 795                 setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
 796             if (src.getPGPKeyPacket())
 797                 setPGPKeyPacket(src.getPGPKeyPacket()->clonePGPKeyPacket());
 798             VectorOf(XMLObject) v=getUnknownXMLObjects();
 799             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 800                 v.push_back((*i)->clone());
 801         }
 802
 803         void init() {
 804             m_PGPKeyID=nullptr;
 805             m_PGPKeyPacket=nullptr;
 806             m_children.push_back(nullptr);
 807             m_children.push_back(nullptr);
 808             m_pos_PGPKeyID=m_children.begin();
 809             m_pos_PGPKeyPacket=m_pos_PGPKeyID;
 810             ++m_pos_PGPKeyPacket;
 811         }
 812
 813         IMPL_XMLOBJECT_CLONE(PGPData);
 814         IMPL_TYPED_CHILD(PGPKeyID);
 815         IMPL_TYPED_CHILD(PGPKeyPacket);
 816         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 817
 818     protected:
 819         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 820             PROC_TYPED_CHILD(PGPKeyID,XMLSIG_NS,false);
 821             PROC_TYPED_CHILD(PGPKeyPacket,XMLSIG_NS,false);
 822
 823             // Unknown child.
 824             const XMLCh* nsURI=root->getNamespaceURI();
 825             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 826                 getUnknownXMLObjects().push_back(childXMLObject);
 827                 return;
 828             }
 829
 830             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 831         }
 832     };
 833
 834     class XMLTOOL_DLLLOCAL KeyInfoReferenceImpl : public virtual KeyInfoReference,
 835         public AbstractComplexElement,
 836         public AbstractDOMCachingXMLObject,
 837         public AbstractXMLObjectMarshaller,
 838         public AbstractXMLObjectUnmarshaller
 839     {
 840     public:
 841         virtual ~KeyInfoReferenceImpl() {
 842             XMLString::release(&m_Id);
 843             XMLString::release(&m_URI);
 844         }
 845
 846         KeyInfoReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 847             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 848             init();
 849         }
 850
 851         KeyInfoReferenceImpl(const KeyInfoReferenceImpl& src)
 852                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 853             init();
 854             setId(getId());
 855             setURI(getURI());
 856         }
 857
 858         void init() {
 859             m_Id=m_URI=nullptr;
 860         }
 861
 862         IMPL_XMLOBJECT_CLONE(KeyInfoReference);
 863         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 864         IMPL_STRING_ATTRIB(URI);
 865
 866     protected:
 867         void marshallAttributes(DOMElement* domElement) const {
 868             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 869             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 870         }
 871
 872         void processAttribute(const DOMAttr* attribute) {
 873             PROC_ID_ATTRIB(Id,ID,nullptr);
 874             PROC_STRING_ATTRIB(URI,URI,nullptr);
 875             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 876         }
 877     };
 878
 879     class XMLTOOL_DLLLOCAL KeyInfoImpl : public virtual KeyInfo,
 880         public AbstractComplexElement,
 881         public AbstractDOMCachingXMLObject,
 882         public AbstractXMLObjectMarshaller,
 883         public AbstractXMLObjectUnmarshaller
 884     {
 885     public:
 886         virtual ~KeyInfoImpl() {
 887             XMLString::release(&m_Id);
 888         }
 889
 890         KeyInfoImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 891             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 892         }
 893
 894         KeyInfoImpl(const KeyInfoImpl& src)
 895                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 896                     m_Id(XMLString::replicate(src.m_Id)) {
 897
 898             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 899                 if (*i) {
 900                     X509Data* xd=dynamic_cast<X509Data*>(*i);
 901                     if (xd) {
 902                         getX509Datas().push_back(xd->cloneX509Data());
 903                         continue;
 904                     }
 905
 906                     KeyName* kn=dynamic_cast<KeyName*>(*i);
 907                     if (kn) {
 908                         getKeyNames().push_back(kn->cloneKeyName());
 909                         continue;
 910                     }
 911
 912                     KeyValue* kv=dynamic_cast<KeyValue*>(*i);
 913                     if (kv) {
 914                         getKeyValues().push_back(kv->cloneKeyValue());
 915                         continue;
 916                     }
 917
 918                     DEREncodedKeyValue* ekv=dynamic_cast<DEREncodedKeyValue*>(*i);
 919                     if (ekv) {
 920                         getDEREncodedKeyValues().push_back(ekv->cloneDEREncodedKeyValue());
 921                         continue;
 922                     }
 923
 924                     RetrievalMethod* rm=dynamic_cast<RetrievalMethod*>(*i);
 925                     if (rm) {
 926                         getRetrievalMethods().push_back(rm->cloneRetrievalMethod());
 927                         continue;
 928                     }
 929
 930                     MgmtData* md=dynamic_cast<MgmtData*>(*i);
 931                     if (md) {
 932                         getMgmtDatas().push_back(md->cloneMgmtData());
 933                         continue;
 934                     }
 935
 936                     SPKIData* sd=dynamic_cast<SPKIData*>(*i);
 937                     if (sd) {
 938                         getSPKIDatas().push_back(sd->cloneSPKIData());
 939                         continue;
 940                     }
 941
 942                     PGPData* pd=dynamic_cast<PGPData*>(*i);
 943                     if (pd) {
 944                         getPGPDatas().push_back(pd->clonePGPData());
 945                         continue;
 946                     }
 947
 948                     KeyInfoReference* kref=dynamic_cast<KeyInfoReference*>(*i);
 949                     if (kref) {
 950                         getKeyInfoReferences().push_back(kref->cloneKeyInfoReference());
 951                         continue;
 952                     }
 953
 954                     getUnknownXMLObjects().push_back((*i)->clone());
 955                 }
 956             }
 957         }
 958
 959         IMPL_XMLOBJECT_CLONE(KeyInfo);
 960         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 961         IMPL_TYPED_CHILDREN(KeyName,m_children.end());
 962         IMPL_TYPED_CHILDREN(KeyValue,m_children.end());
 963         IMPL_TYPED_CHILDREN(DEREncodedKeyValue,m_children.end());
 964         IMPL_TYPED_CHILDREN(RetrievalMethod,m_children.end());
 965         IMPL_TYPED_CHILDREN(X509Data,m_children.end());
 966         IMPL_TYPED_CHILDREN(MgmtData,m_children.end());
 967         IMPL_TYPED_CHILDREN(SPKIData,m_children.end());
 968         IMPL_TYPED_CHILDREN(PGPData,m_children.end());
 969         IMPL_TYPED_CHILDREN(KeyInfoReference,m_children.end());
 970         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 971
 972     protected:
 973         void marshallAttributes(DOMElement* domElement) const {
 974             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 975         }
 976
 977         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 978             PROC_TYPED_CHILDREN(X509Data,XMLSIG_NS,false);
 979             PROC_TYPED_CHILDREN(KeyName,XMLSIG_NS,false);
 980             PROC_TYPED_CHILDREN(KeyValue,XMLSIG_NS,false);
 981             PROC_TYPED_CHILDREN(DEREncodedKeyValue,XMLSIG11_NS,false);
 982             PROC_TYPED_CHILDREN(RetrievalMethod,XMLSIG_NS,false);
 983             PROC_TYPED_CHILDREN(MgmtData,XMLSIG_NS,false);
 984             PROC_TYPED_CHILDREN(SPKIData,XMLSIG_NS,false);
 985             PROC_TYPED_CHILDREN(PGPData,XMLSIG_NS,false);
 986             PROC_TYPED_CHILDREN(KeyInfoReference,XMLSIG11_NS,false);
 987
 988             // Unknown child.
 989             const XMLCh* nsURI=root->getNamespaceURI();
 990             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 991                 getUnknownXMLObjects().push_back(childXMLObject);
 992                 return;
 993             }
 994
 995             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 996         }
 997
 998         void processAttribute(const DOMAttr* attribute) {
 999             PROC_ID_ATTRIB(Id,ID,nullptr);
1000             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
1001         }
1002     };
1003
1004     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
1005     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
1006     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
1007     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
1008     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
1009     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
1010     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P);
1011     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q);
1012     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G);
1013     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y);
1014     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J);
1015     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
1016     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
1017     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
1018     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
1019     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
1020     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
1021     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
1022     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
1023     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
1024     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
1025
1026     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,OCSPResponse);
1027     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PublicKey);
1028 };
1029
1030 #if defined (_MSC_VER)
1031     #pragma warning( pop )
1032 #endif
1033
1034 // Builder Implementations
1035
1036 IMPL_XMLOBJECTBUILDER(X509IssuerSerial);
1037 IMPL_XMLOBJECTBUILDER(X509IssuerName);
1038 IMPL_XMLOBJECTBUILDER(X509SerialNumber);
1039 IMPL_XMLOBJECTBUILDER(X509SKI);
1040 IMPL_XMLOBJECTBUILDER(X509SubjectName);
1041 IMPL_XMLOBJECTBUILDER(X509Certificate);
1042 IMPL_XMLOBJECTBUILDER(X509CRL);
1043 IMPL_XMLOBJECTBUILDER(X509Data);
1044 IMPL_XMLOBJECTBUILDER(XPath);
1045 IMPL_XMLOBJECTBUILDER(Transform);
1046 IMPL_XMLOBJECTBUILDER(Transforms);
1047 IMPL_XMLOBJECTBUILDER(RetrievalMethod);
1048 IMPL_XMLOBJECTBUILDER(KeyName);
1049 IMPL_XMLOBJECTBUILDER(MgmtData);
1050 IMPL_XMLOBJECTBUILDER(Modulus);
1051 IMPL_XMLOBJECTBUILDER(Exponent);
1052 IMPL_XMLOBJECTBUILDER(Seed);
1053 IMPL_XMLOBJECTBUILDER(PgenCounter);
1054 IMPL_XMLOBJECTBUILDER(P);
1055 IMPL_XMLOBJECTBUILDER(Q);
1056 IMPL_XMLOBJECTBUILDER(G);
1057 IMPL_XMLOBJECTBUILDER(Y);
1058 IMPL_XMLOBJECTBUILDER(J);
1059 IMPL_XMLOBJECTBUILDER(DSAKeyValue);
1060 IMPL_XMLOBJECTBUILDER(RSAKeyValue);
1061 IMPL_XMLOBJECTBUILDER(KeyValue);
1062 IMPL_XMLOBJECTBUILDER(KeyInfo);
1063 IMPL_XMLOBJECTBUILDER(SPKISexp);
1064 IMPL_XMLOBJECTBUILDER(SPKIData);
1065 IMPL_XMLOBJECTBUILDER(PGPKeyID);
1066 IMPL_XMLOBJECTBUILDER(PGPKeyPacket);
1067 IMPL_XMLOBJECTBUILDER(PGPData);
1068
1069 IMPL_XMLOBJECTBUILDER(DEREncodedKeyValue);
1070 IMPL_XMLOBJECTBUILDER(ECKeyValue);
1071 IMPL_XMLOBJECTBUILDER(KeyInfoReference);
1072 IMPL_XMLOBJECTBUILDER(NamedCurve);
1073 IMPL_XMLOBJECTBUILDER(OCSPResponse);
1074 IMPL_XMLOBJECTBUILDER(PublicKey);
1075 IMPL_XMLOBJECTBUILDER(X509Digest);
1076
1077 // Unicode literals
1078
1079 const XMLCh KeyInfo::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,I,n,f,o);
1080 const XMLCh KeyInfo::TYPE_NAME[] =                  UNICODE_LITERAL_11(K,e,y,I,n,f,o,T,y,p,e);
1081 const XMLCh KeyInfo::ID_ATTRIB_NAME[] =             UNICODE_LITERAL_2(I,d);
1082 const XMLCh KeyValue::LOCAL_NAME[] =                UNICODE_LITERAL_8(K,e,y,V,a,l,u,e);
1083 const XMLCh KeyValue::TYPE_NAME[] =                 UNICODE_LITERAL_12(K,e,y,V,a,l,u,e,T,y,p,e);
1084 const XMLCh DSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(D,S,A,K,e,y,V,a,l,u,e);
1085 const XMLCh DSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(D,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
1086 const XMLCh RSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(R,S,A,K,e,y,V,a,l,u,e);
1087 const XMLCh RSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(R,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
1088 const XMLCh MgmtData::LOCAL_NAME[] =                UNICODE_LITERAL_8(M,g,m,t,D,a,t,a);
1089 const XMLCh KeyName::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,N,a,m,e);
1090 const XMLCh Modulus::LOCAL_NAME[] =                 UNICODE_LITERAL_7(M,o,d,u,l,u,s);
1091 const XMLCh Exponent::LOCAL_NAME[] =                UNICODE_LITERAL_8(E,x,p,o,n,e,n,t);
1092 const XMLCh Seed::LOCAL_NAME[] =                    UNICODE_LITERAL_4(S,e,e,d);
1093 const XMLCh PgenCounter::LOCAL_NAME[] =             UNICODE_LITERAL_11(P,g,e,n,C,o,u,n,t,e,r);
1094 const XMLCh P::LOCAL_NAME[] =                       UNICODE_LITERAL_1(P);
1095 const XMLCh Q::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Q);
1096 const XMLCh G::LOCAL_NAME[] =                       UNICODE_LITERAL_1(G);
1097 const XMLCh Y::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Y);
1098 const XMLCh J::LOCAL_NAME[] =                       UNICODE_LITERAL_1(J);
1099 const XMLCh XPath::LOCAL_NAME[] =                   UNICODE_LITERAL_5(X,P,a,t,h);
1100 const XMLCh Transform::LOCAL_NAME[] =               UNICODE_LITERAL_9(T,r,a,n,s,f,o,r,m);
1101 const XMLCh Transform::TYPE_NAME[] =                UNICODE_LITERAL_13(T,r,a,n,s,f,o,r,m,T,y,p,e);
1102 const XMLCh Transform::ALGORITHM_ATTRIB_NAME[] =    UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
1103 const XMLCh Transforms::LOCAL_NAME[] =              UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
1104 const XMLCh Transforms::TYPE_NAME[] =               UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);
1105 const XMLCh RetrievalMethod::LOCAL_NAME[] =         UNICODE_LITERAL_15(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d);
1106 const XMLCh RetrievalMethod::TYPE_NAME[] =          UNICODE_LITERAL_19(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d,T,y,p,e);
1107 const XMLCh RetrievalMethod::URI_ATTRIB_NAME[] =    UNICODE_LITERAL_3(U,R,I);
1108 const XMLCh RetrievalMethod::TYPE_ATTRIB_NAME[] =   UNICODE_LITERAL_4(T,y,p,e);
1109 const XMLCh SPKISexp::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,S,e,x,p);
1110 const XMLCh SPKIData::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,D,a,t,a);
1111 const XMLCh SPKIData::TYPE_NAME[] =                 UNICODE_LITERAL_12(S,P,K,I,D,a,t,a,T,y,p,e);
1112 const XMLCh PGPKeyID::LOCAL_NAME[] =                UNICODE_LITERAL_8(P,G,P,K,e,y,I,D);
1113 const XMLCh PGPKeyPacket::LOCAL_NAME[] =            UNICODE_LITERAL_12(P,G,P,K,e,y,P,a,c,k,e,t);
1114 const XMLCh PGPData::LOCAL_NAME[] =                 UNICODE_LITERAL_7(P,G,P,D,a,t,a);
1115 const XMLCh PGPData::TYPE_NAME[] =                  UNICODE_LITERAL_11(P,G,P,D,a,t,a,T,y,p,e);
1116
1117 const XMLCh DEREncodedKeyValue::LOCAL_NAME[] =      UNICODE_LITERAL_18(D,E,R,E,n,c,o,d,e,d,K,e,y,V,a,l,u,e);
1118 const XMLCh DEREncodedKeyValue::TYPE_NAME[] =       UNICODE_LITERAL_22(D,E,R,E,n,c,o,d,e,d,K,e,y,V,a,l,u,e,T,y,p,e);
1119 const XMLCh DEREncodedKeyValue::ID_ATTRIB_NAME[] =  UNICODE_LITERAL_2(I,d);
1120 const XMLCh ECKeyValue::LOCAL_NAME[] =              UNICODE_LITERAL_10(E,C,K,e,y,V,a,l,u,e);
1121 const XMLCh ECKeyValue::TYPE_NAME[] =               UNICODE_LITERAL_14(E,C,K,e,y,V,a,l,u,e,T,y,p,e);
1122 const XMLCh ECKeyValue::ID_ATTRIB_NAME[] =          UNICODE_LITERAL_2(I,d);
1123 const XMLCh KeyInfoReference::LOCAL_NAME[] =        UNICODE_LITERAL_16(K,e,y,I,n,f,o,R,e,f,e,r,e,n,c,e);
1124 const XMLCh KeyInfoReference::TYPE_NAME[] =         UNICODE_LITERAL_20(K,e,y,I,n,f,o,R,e,f,e,r,e,n,c,e,T,y,p,e);
1125 const XMLCh KeyInfoReference::ID_ATTRIB_NAME[] =    UNICODE_LITERAL_2(I,d);
1126 const XMLCh KeyInfoReference::URI_ATTRIB_NAME[] =   UNICODE_LITERAL_3(U,R,I);
1127 const XMLCh NamedCurve::LOCAL_NAME[] =              UNICODE_LITERAL_10(N,a,m,e,d,C,u,r,v,e);
1128 const XMLCh NamedCurve::TYPE_NAME[] =               UNICODE_LITERAL_14(N,a,m,e,d,C,u,r,v,e,T,y,p,e);
1129 const XMLCh NamedCurve::URI_ATTRIB_NAME[] =         UNICODE_LITERAL_3(U,R,I);
1130 const XMLCh OCSPResponse::LOCAL_NAME[] =            UNICODE_LITERAL_12(O,C,S,P,R,e,s,p,o,n,s,e);
1131 const XMLCh PublicKey::LOCAL_NAME[] =               UNICODE_LITERAL_9(P,u,b,l,i,c,K,e,y);
1132 const XMLCh X509Digest::ALGORITHM_ATTRIB_NAME[] =   UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
1133
1134 #define XCH(ch) chLatin_##ch
1135 #define XNUM(d) chDigit_##d
1136
1137 const XMLCh X509Data::LOCAL_NAME[] = {
1138     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), chNull
1139     };
1140 const XMLCh X509Data::TYPE_NAME[] = {
1141     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1142     };
1143 const XMLCh X509IssuerSerial::LOCAL_NAME[] = {
1144     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1145     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), chNull
1146     };
1147 const XMLCh X509IssuerSerial::TYPE_NAME[] = {
1148     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1149     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1150     };
1151 const XMLCh X509IssuerName::LOCAL_NAME[] = {
1152     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
1153     XCH(N), XCH(a), XCH(m), XCH(e), chNull
1154     };
1155 const XMLCh X509SerialNumber::LOCAL_NAME[] = {
1156     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l),
1157     XCH(N), XCH(u), XCH(m), XCH(b), XCH(e), XCH(r), chNull
1158     };
1159 const XMLCh X509SKI::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(K), XCH(I), chNull };
1160 const XMLCh X509SubjectName::LOCAL_NAME[] = {
1161     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(u), XCH(b), XCH(j), XCH(e), XCH(c), XCH(t),
1162     XCH(N), XCH(a), XCH(m), XCH(e), chNull
1163     };
1164 const XMLCh X509Certificate::LOCAL_NAME[] = {
1165     XCH(X), XNUM(5), XNUM(0), XNUM(9),
1166     XCH(C), XCH(e), XCH(r), XCH(t), XCH(i), XCH(f), XCH(i), XCH(c), XCH(a), XCH(t), XCH(e), chNull
1167     };
1168 const XMLCh X509CRL::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(C), XCH(R), XCH(L), chNull };
1169 const XMLCh X509Digest::LOCAL_NAME[] = {
1170     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(i), XCH(g), XCH(e), XCH(s), XCH(t), chNull
1171     };
1172 const XMLCh X509Digest::TYPE_NAME[] = {
1173     XCH(X), XNUM(5), XNUM(0), XNUM(9),  XCH(D), XCH(i), XCH(g), XCH(e), XCH(s), XCH(t), XCH(T), XCH(y), XCH(p), XCH(e), chNull
1174     };
1175
1176 const XMLCh RetrievalMethod::TYPE_DSAKEYVALUE[] = {
1177     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1178     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1179     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1180     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1181     chLatin_D, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1182     };
1183
1184 const XMLCh RetrievalMethod::TYPE_RSAKEYVALUE[] = {
1185     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1186     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1187     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1188     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1189     chLatin_R, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
1190     };
1191
1192 const XMLCh RetrievalMethod::TYPE_X509DATA[] = {
1193     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
1194     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
1195     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
1196     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
1197     chLatin_X, chDigit_5, chDigit_0, chDigit_9, chLatin_D, chLatin_a, chLatin_t, chLatin_a, chNull
1198     };