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
  40 #if defined (_MSC_VER)
  41     #pragma warning( push )
  42     #pragma warning( disable : 4250 4251 )
  43 #endif
  44
  45 namespace xmlsignature {
  46
  47     class XMLTOOL_DLLLOCAL DSAKeyValueImpl : public virtual DSAKeyValue,
  48         public AbstractComplexElement,
  49         public AbstractDOMCachingXMLObject,
  50         public AbstractXMLObjectMarshaller,
  51         public AbstractXMLObjectUnmarshaller
  52     {
  53     public:
  54         virtual ~DSAKeyValueImpl() {}
  55
  56         DSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
  57             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
  58             init();
  59         }
  60
  61         DSAKeyValueImpl(const DSAKeyValueImpl& src)
  62                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
  63             init();
  64             if (src.getP())
  65                 setP(src.getP()->cloneP());
  66             if (src.getQ())
  67                 setQ(src.getQ()->cloneQ());
  68             if (src.getG())
  69                 setG(src.getG()->cloneG());
  70             if (src.getY())
  71                 setY(src.getY()->cloneY());
  72             if (src.getJ())
  73                 setJ(src.getJ()->cloneJ());
  74             if (src.getSeed())
  75                 setSeed(src.getSeed()->cloneSeed());
  76             if (src.getPgenCounter())
  77                 setPgenCounter(src.getPgenCounter()->clonePgenCounter());
  78         }
  79
  80         void init() {
  81             m_P=nullptr;
  82             m_Q=nullptr;
  83             m_G=nullptr;
  84             m_Y=nullptr;
  85             m_J=nullptr;
  86             m_Seed=nullptr;
  87             m_PgenCounter=nullptr;
  88             m_children.push_back(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_pos_P=m_children.begin();
  96             m_pos_Q=m_pos_P;
  97             ++m_pos_Q;
  98             m_pos_G=m_pos_Q;
  99             ++m_pos_G;
 100             m_pos_Y=m_pos_G;
 101             ++m_pos_Y;
 102             m_pos_J=m_pos_Y;
 103             ++m_pos_J;
 104             m_pos_Seed=m_pos_J;
 105             ++m_pos_Seed;
 106             m_pos_PgenCounter=m_pos_Seed;
 107             ++m_pos_PgenCounter;
 108         }
 109
 110         IMPL_XMLOBJECT_CLONE(DSAKeyValue);
 111         IMPL_TYPED_CHILD(P);
 112         IMPL_TYPED_CHILD(Q);
 113         IMPL_TYPED_CHILD(G);
 114         IMPL_TYPED_CHILD(Y);
 115         IMPL_TYPED_CHILD(J);
 116         IMPL_TYPED_CHILD(Seed);
 117         IMPL_TYPED_CHILD(PgenCounter);
 118
 119     protected:
 120         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 121             PROC_TYPED_CHILD(P,XMLSIG_NS,false);
 122             PROC_TYPED_CHILD(Q,XMLSIG_NS,false);
 123             PROC_TYPED_CHILD(G,XMLSIG_NS,false);
 124             PROC_TYPED_CHILD(Y,XMLSIG_NS,false);
 125             PROC_TYPED_CHILD(J,XMLSIG_NS,false);
 126             PROC_TYPED_CHILD(Seed,XMLSIG_NS,false);
 127             PROC_TYPED_CHILD(PgenCounter,XMLSIG_NS,false);
 128             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 129         }
 130     };
 131
 132     class XMLTOOL_DLLLOCAL RSAKeyValueImpl : public virtual RSAKeyValue,
 133         public AbstractComplexElement,
 134         public AbstractDOMCachingXMLObject,
 135         public AbstractXMLObjectMarshaller,
 136         public AbstractXMLObjectUnmarshaller
 137     {
 138     public:
 139         virtual ~RSAKeyValueImpl() {}
 140
 141         RSAKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 142                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 143             init();
 144         }
 145
 146         RSAKeyValueImpl(const RSAKeyValueImpl& src)
 147                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 148             init();
 149             if (src.getModulus())
 150                 setModulus(src.getModulus()->cloneModulus());
 151             if (src.getExponent())
 152                 setExponent(src.getExponent()->cloneExponent());
 153         }
 154
 155         void init() {
 156             m_Modulus=nullptr;
 157             m_Exponent=nullptr;
 158             m_children.push_back(nullptr);
 159             m_children.push_back(nullptr);
 160             m_pos_Modulus=m_children.begin();
 161             m_pos_Exponent=m_pos_Modulus;
 162             ++m_pos_Exponent;
 163         }
 164
 165         IMPL_XMLOBJECT_CLONE(RSAKeyValue);
 166         IMPL_TYPED_CHILD(Modulus);
 167         IMPL_TYPED_CHILD(Exponent);
 168
 169     protected:
 170         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 171             PROC_TYPED_CHILD(Modulus,XMLSIG_NS,false);
 172             PROC_TYPED_CHILD(Exponent,XMLSIG_NS,false);
 173             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 174         }
 175     };
 176
 177     class XMLTOOL_DLLLOCAL KeyValueImpl : public virtual KeyValue,
 178         public AbstractComplexElement,
 179         public AbstractDOMCachingXMLObject,
 180         public AbstractXMLObjectMarshaller,
 181         public AbstractXMLObjectUnmarshaller
 182     {
 183     public:
 184         virtual ~KeyValueImpl() {}
 185
 186         KeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 187                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 188             init();
 189         }
 190
 191         KeyValueImpl(const KeyValueImpl& src)
 192                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 193             init();
 194             if (src.getDSAKeyValue())
 195                 setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
 196             if (src.getRSAKeyValue())
 197                 setRSAKeyValue(src.getRSAKeyValue()->cloneRSAKeyValue());
 198             if (src.getUnknownXMLObject())
 199                 setUnknownXMLObject(src.getUnknownXMLObject()->clone());
 200         }
 201
 202         void init() {
 203             m_DSAKeyValue=nullptr;
 204             m_RSAKeyValue=nullptr;
 205             m_UnknownXMLObject=nullptr;
 206             m_children.push_back(nullptr);
 207             m_children.push_back(nullptr);
 208             m_children.push_back(nullptr);
 209             m_pos_DSAKeyValue=m_children.begin();
 210             m_pos_RSAKeyValue=m_pos_DSAKeyValue;
 211             ++m_pos_RSAKeyValue;
 212             m_pos_UnknownXMLObject=m_pos_RSAKeyValue;
 213             ++m_pos_UnknownXMLObject;
 214         }
 215
 216         IMPL_XMLOBJECT_CLONE(KeyValue);
 217         IMPL_TYPED_CHILD(DSAKeyValue);
 218         IMPL_TYPED_CHILD(RSAKeyValue);
 219         IMPL_XMLOBJECT_CHILD(UnknownXMLObject);
 220
 221     protected:
 222         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 223             PROC_TYPED_CHILD(DSAKeyValue,XMLSIG_NS,false);
 224             PROC_TYPED_CHILD(RSAKeyValue,XMLSIG_NS,false);
 225
 226             // Unknown child.
 227             const XMLCh* nsURI=root->getNamespaceURI();
 228             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 229                 setUnknownXMLObject(childXMLObject);
 230                 return;
 231             }
 232
 233             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 234         }
 235     };
 236
 237     class XMLTOOL_DLLLOCAL DEREncodedKeyValueImpl : public virtual DEREncodedKeyValue,
 238         public AbstractSimpleElement,
 239         public AbstractDOMCachingXMLObject,
 240         public AbstractXMLObjectMarshaller,
 241         public AbstractXMLObjectUnmarshaller
 242     {
 243     public:
 244         virtual ~DEREncodedKeyValueImpl() {
 245             XMLString::release(&m_Id);
 246         }
 247
 248         DEREncodedKeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 249                 : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 250         }
 251
 252         DEREncodedKeyValueImpl(const DEREncodedKeyValueImpl& src)
 253                 : AbstractXMLObject(src), AbstractSimpleElement(src), AbstractDOMCachingXMLObject(src), m_Id(nullptr) {
 254             setId(src.getId());
 255         }
 256
 257         IMPL_XMLOBJECT_CLONE(DEREncodedKeyValue);
 258         IMPL_ID_ATTRIB(Id);
 259
 260     protected:
 261         void marshallAttributes(DOMElement* domElement) const {
 262             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 263         }
 264
 265         void processAttribute(const DOMAttr* attribute) {
 266             PROC_ID_ATTRIB(Id,ID,nullptr);
 267             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 268         }
 269     };
 270
 271     class XMLTOOL_DLLLOCAL TransformImpl : public virtual Transform,
 272         public AbstractComplexElement,
 273         public AbstractDOMCachingXMLObject,
 274         public AbstractXMLObjectMarshaller,
 275         public AbstractXMLObjectUnmarshaller
 276     {
 277     public:
 278         virtual ~TransformImpl() {
 279             XMLString::release(&m_Algorithm);
 280         }
 281
 282         TransformImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 283             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(nullptr) {
 284         }
 285
 286         TransformImpl(const TransformImpl& src)
 287                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 288                     m_Algorithm(XMLString::replicate(src.m_Algorithm)) {
 289             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 290                 if (*i) {
 291                     XPath* x=dynamic_cast<XPath*>(*i);
 292                     if (x) {
 293                         getXPaths().push_back(x->cloneXPath());
 294                         continue;
 295                     }
 296                     getUnknownXMLObjects().push_back((*i)->clone());
 297                 }
 298             }
 299         }
 300
 301         IMPL_XMLOBJECT_CLONE(Transform);
 302         IMPL_STRING_ATTRIB(Algorithm);
 303         IMPL_TYPED_CHILDREN(XPath,m_children.end());
 304         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 305
 306     protected:
 307         void marshallAttributes(DOMElement* domElement) const {
 308             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 309         }
 310
 311         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 312             PROC_TYPED_CHILDREN(XPath,XMLSIG_NS,false);
 313
 314             // Unknown child.
 315             const XMLCh* nsURI=root->getNamespaceURI();
 316             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 317                 getUnknownXMLObjects().push_back(childXMLObject);
 318                 return;
 319             }
 320
 321             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 322         }
 323
 324         void processAttribute(const DOMAttr* attribute) {
 325             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,nullptr);
 326             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 327         }
 328     };
 329
 330     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 331         public AbstractComplexElement,
 332         public AbstractDOMCachingXMLObject,
 333         public AbstractXMLObjectMarshaller,
 334         public AbstractXMLObjectUnmarshaller
 335     {
 336     public:
 337         virtual ~TransformsImpl() {}
 338
 339         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 340             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 341         }
 342
 343         TransformsImpl(const TransformsImpl& src)
 344                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 345             VectorOf(Transform) v=getTransforms();
 346             for (vector<Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 347                 if (*i) {
 348                     v.push_back((*i)->cloneTransform());
 349                 }
 350             }
 351         }
 352
 353         IMPL_XMLOBJECT_CLONE(Transforms);
 354         IMPL_TYPED_CHILDREN(Transform,m_children.end());
 355
 356     protected:
 357         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 358             PROC_TYPED_CHILDREN(Transform,XMLSIG_NS,false);
 359             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 360         }
 361     };
 362
 363     class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public virtual RetrievalMethod,
 364         public AbstractComplexElement,
 365         public AbstractDOMCachingXMLObject,
 366         public AbstractXMLObjectMarshaller,
 367         public AbstractXMLObjectUnmarshaller
 368     {
 369     public:
 370         virtual ~RetrievalMethodImpl() {
 371             XMLString::release(&m_URI);
 372             XMLString::release(&m_Type);
 373         }
 374
 375         RetrievalMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 376             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 377             init();
 378         }
 379
 380         RetrievalMethodImpl(const RetrievalMethodImpl& src)
 381                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 382             init();
 383             setURI(getURI());
 384             setType(getType());
 385             if (src.getTransforms())
 386                 setTransforms(src.getTransforms()->cloneTransforms());
 387         }
 388
 389         void init() {
 390             m_URI=m_Type=nullptr;
 391             m_Transforms=nullptr;
 392             m_children.push_back(nullptr);
 393             m_pos_Transforms=m_children.begin();
 394         }
 395
 396         IMPL_XMLOBJECT_CLONE(RetrievalMethod);
 397         IMPL_STRING_ATTRIB(URI);
 398         IMPL_STRING_ATTRIB(Type);
 399         IMPL_TYPED_CHILD(Transforms);
 400
 401     protected:
 402         void marshallAttributes(DOMElement* domElement) const {
 403             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 404             MARSHALL_STRING_ATTRIB(Type,TYPE,nullptr);
 405         }
 406
 407         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 408             PROC_TYPED_CHILD(Transforms,XMLSIG_NS,false);
 409             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 410         }
 411
 412         void processAttribute(const DOMAttr* attribute) {
 413             PROC_STRING_ATTRIB(URI,URI,nullptr);
 414             PROC_STRING_ATTRIB(Type,TYPE,nullptr);
 415             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 416         }
 417     };
 418
 419     class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public virtual X509IssuerSerial,
 420         public AbstractComplexElement,
 421         public AbstractDOMCachingXMLObject,
 422         public AbstractXMLObjectMarshaller,
 423         public AbstractXMLObjectUnmarshaller
 424     {
 425     public:
 426         virtual ~X509IssuerSerialImpl() {}
 427
 428         X509IssuerSerialImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 429                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 430             init();
 431         }
 432
 433         X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
 434                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 435             init();
 436             if (src.getX509IssuerName())
 437                 setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
 438             if (src.getX509SerialNumber())
 439                 setX509SerialNumber(src.getX509SerialNumber()->cloneX509SerialNumber());
 440         }
 441
 442         void init() {
 443             m_X509IssuerName=nullptr;
 444             m_X509SerialNumber=nullptr;
 445             m_children.push_back(nullptr);
 446             m_children.push_back(nullptr);
 447             m_pos_X509IssuerName=m_children.begin();
 448             m_pos_X509SerialNumber=m_pos_X509IssuerName;
 449             ++m_pos_X509SerialNumber;
 450         }
 451
 452         IMPL_XMLOBJECT_CLONE(X509IssuerSerial);
 453         IMPL_TYPED_CHILD(X509IssuerName);
 454         IMPL_TYPED_CHILD(X509SerialNumber);
 455
 456     protected:
 457         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 458             PROC_TYPED_CHILD(X509IssuerName,XMLSIG_NS,false);
 459             PROC_TYPED_CHILD(X509SerialNumber,XMLSIG_NS,false);
 460             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 461         }
 462     };
 463
 464     class XMLTOOL_DLLLOCAL X509DataImpl : public virtual X509Data,
 465         public AbstractComplexElement,
 466         public AbstractDOMCachingXMLObject,
 467         public AbstractXMLObjectMarshaller,
 468         public AbstractXMLObjectUnmarshaller
 469     {
 470     public:
 471         virtual ~X509DataImpl() {}
 472
 473         X509DataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 474             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 475         }
 476
 477         X509DataImpl(const X509DataImpl& src)
 478                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 479             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 480                 if (*i) {
 481                     X509Certificate* xcert=dynamic_cast<X509Certificate*>(*i);
 482                     if (xcert) {
 483                         getX509Certificates().push_back(xcert->cloneX509Certificate());
 484                         continue;
 485                     }
 486
 487                     X509CRL* xcrl=dynamic_cast<X509CRL*>(*i);
 488                     if (xcrl) {
 489                         getX509CRLs().push_back(xcrl->cloneX509CRL());
 490                         continue;
 491                     }
 492
 493                     X509SubjectName* xsn=dynamic_cast<X509SubjectName*>(*i);
 494                     if (xsn) {
 495                         getX509SubjectNames().push_back(xsn->cloneX509SubjectName());
 496                         continue;
 497                     }
 498
 499                     X509IssuerSerial* xis=dynamic_cast<X509IssuerSerial*>(*i);
 500                     if (xis) {
 501                         getX509IssuerSerials().push_back(xis->cloneX509IssuerSerial());
 502                         continue;
 503                     }
 504
 505                     X509SKI* xski=dynamic_cast<X509SKI*>(*i);
 506                     if (xski) {
 507                         getX509SKIs().push_back(xski->cloneX509SKI());
 508                         continue;
 509                     }
 510
 511                     getUnknownXMLObjects().push_back((*i)->clone());
 512                 }
 513             }
 514         }
 515
 516         IMPL_XMLOBJECT_CLONE(X509Data);
 517         IMPL_TYPED_CHILDREN(X509IssuerSerial,m_children.end());
 518         IMPL_TYPED_CHILDREN(X509SKI,m_children.end());
 519         IMPL_TYPED_CHILDREN(X509SubjectName,m_children.end());
 520         IMPL_TYPED_CHILDREN(X509Certificate,m_children.end());
 521         IMPL_TYPED_CHILDREN(X509CRL,m_children.end());
 522         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 523
 524     protected:
 525         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 526             PROC_TYPED_CHILDREN(X509IssuerSerial,XMLSIG_NS,false);
 527             PROC_TYPED_CHILDREN(X509SKI,XMLSIG_NS,false);
 528             PROC_TYPED_CHILDREN(X509SubjectName,XMLSIG_NS,false);
 529             PROC_TYPED_CHILDREN(X509Certificate,XMLSIG_NS,false);
 530             PROC_TYPED_CHILDREN(X509CRL,XMLSIG_NS,false);
 531
 532             // Unknown child.
 533             const XMLCh* nsURI=root->getNamespaceURI();
 534             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 535                 getUnknownXMLObjects().push_back(childXMLObject);
 536                 return;
 537             }
 538
 539             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 540         }
 541     };
 542
 543     class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
 544         public AbstractComplexElement,
 545         public AbstractDOMCachingXMLObject,
 546         public AbstractXMLObjectMarshaller,
 547         public AbstractXMLObjectUnmarshaller
 548     {
 549     public:
 550         virtual ~SPKIDataImpl() {}
 551
 552         SPKIDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 553             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 554         }
 555
 556         SPKIDataImpl(const SPKIDataImpl& src)
 557                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 558             VectorOfPairs(SPKISexp,XMLObject) v=getSPKISexps();
 559             for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
 560                 if (i->first) {
 561                     v.push_back(make_pair(i->first->cloneSPKISexp(),(i->second ? i->second->clone() : (XMLObject*)nullptr)));
 562                 }
 563             }
 564         }
 565
 566         IMPL_XMLOBJECT_CLONE(SPKIData);
 567
 568     private:
 569         vector< pair<SPKISexp*,XMLObject*> > m_SPKISexps;
 570
 571     public:
 572         VectorOfPairs(SPKISexp,XMLObject) getSPKISexps() {
 573             return VectorOfPairs(SPKISexp,XMLObject)(this, m_SPKISexps, &m_children, m_children.end());
 574         }
 575
 576         const vector< pair<SPKISexp*,XMLObject*> >& getSPKISexps() const {
 577             return m_SPKISexps;
 578         }
 579
 580     protected:
 581         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 582             if (XMLHelper::isNodeNamed(root,XMLSIG_NS,SPKISexp::LOCAL_NAME)) {
 583                 SPKISexp* typesafe=dynamic_cast<SPKISexp*>(childXMLObject);
 584                 if (typesafe) {
 585                     getSPKISexps().push_back(make_pair(typesafe,(XMLObject*)nullptr));
 586                     return;
 587                 }
 588             }
 589
 590             // Unknown child (has to be paired with the last SPKISexp processed.
 591             const XMLCh* nsURI=root->getNamespaceURI();
 592             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 593                 // Update second half of pair in vector, and in master list.
 594                 if (!m_SPKISexps.empty() && m_SPKISexps.back().second==nullptr) {
 595                     m_SPKISexps.back().second=childXMLObject;
 596                     m_children.back()=childXMLObject;
 597                     return;
 598                 }
 599                 else
 600                     throw UnmarshallingException("Extension element must follow ds:SPKISexp element.");
 601             }
 602
 603             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 604         }
 605     };
 606
 607     class XMLTOOL_DLLLOCAL PGPDataImpl : public virtual PGPData,
 608         public AbstractComplexElement,
 609         public AbstractDOMCachingXMLObject,
 610         public AbstractXMLObjectMarshaller,
 611         public AbstractXMLObjectUnmarshaller
 612     {
 613     public:
 614         virtual ~PGPDataImpl() {}
 615
 616         PGPDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 617                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 618             init();
 619         }
 620
 621         PGPDataImpl(const PGPDataImpl& src)
 622                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 623             init();
 624             if (src.getPGPKeyID())
 625                 setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
 626             if (src.getPGPKeyPacket())
 627                 setPGPKeyPacket(src.getPGPKeyPacket()->clonePGPKeyPacket());
 628             VectorOf(XMLObject) v=getUnknownXMLObjects();
 629             for (vector<XMLObject*>::const_iterator i=src.m_UnknownXMLObjects.begin(); i!=src.m_UnknownXMLObjects.end(); ++i)
 630                 v.push_back((*i)->clone());
 631         }
 632
 633         void init() {
 634             m_PGPKeyID=nullptr;
 635             m_PGPKeyPacket=nullptr;
 636             m_children.push_back(nullptr);
 637             m_children.push_back(nullptr);
 638             m_pos_PGPKeyID=m_children.begin();
 639             m_pos_PGPKeyPacket=m_pos_PGPKeyID;
 640             ++m_pos_PGPKeyPacket;
 641         }
 642
 643         IMPL_XMLOBJECT_CLONE(PGPData);
 644         IMPL_TYPED_CHILD(PGPKeyID);
 645         IMPL_TYPED_CHILD(PGPKeyPacket);
 646         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 647
 648     protected:
 649         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 650             PROC_TYPED_CHILD(PGPKeyID,XMLSIG_NS,false);
 651             PROC_TYPED_CHILD(PGPKeyPacket,XMLSIG_NS,false);
 652
 653             // Unknown child.
 654             const XMLCh* nsURI=root->getNamespaceURI();
 655             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 656                 getUnknownXMLObjects().push_back(childXMLObject);
 657                 return;
 658             }
 659
 660             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 661         }
 662     };
 663
 664     class XMLTOOL_DLLLOCAL KeyInfoImpl : public virtual KeyInfo,
 665         public AbstractComplexElement,
 666         public AbstractDOMCachingXMLObject,
 667         public AbstractXMLObjectMarshaller,
 668         public AbstractXMLObjectUnmarshaller
 669     {
 670     public:
 671         virtual ~KeyInfoImpl() {
 672             XMLString::release(&m_Id);
 673         }
 674
 675         KeyInfoImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 676             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(nullptr) {
 677         }
 678
 679         KeyInfoImpl(const KeyInfoImpl& src)
 680                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 681                     m_Id(XMLString::replicate(src.m_Id)) {
 682
 683             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 684                 if (*i) {
 685                     X509Data* xd=dynamic_cast<X509Data*>(*i);
 686                     if (xd) {
 687                         getX509Datas().push_back(xd->cloneX509Data());
 688                         continue;
 689                     }
 690
 691                     KeyName* kn=dynamic_cast<KeyName*>(*i);
 692                     if (kn) {
 693                         getKeyNames().push_back(kn->cloneKeyName());
 694                         continue;
 695                     }
 696
 697                     KeyValue* kv=dynamic_cast<KeyValue*>(*i);
 698                     if (kv) {
 699                         getKeyValues().push_back(kv->cloneKeyValue());
 700                         continue;
 701                     }
 702
 703                     RetrievalMethod* rm=dynamic_cast<RetrievalMethod*>(*i);
 704                     if (rm) {
 705                         getRetrievalMethods().push_back(rm->cloneRetrievalMethod());
 706                         continue;
 707                     }
 708
 709                     MgmtData* md=dynamic_cast<MgmtData*>(*i);
 710                     if (md) {
 711                         getMgmtDatas().push_back(md->cloneMgmtData());
 712                         continue;
 713                     }
 714
 715                     SPKIData* sd=dynamic_cast<SPKIData*>(*i);
 716                     if (sd) {
 717                         getSPKIDatas().push_back(sd->cloneSPKIData());
 718                         continue;
 719                     }
 720
 721                     PGPData* pd=dynamic_cast<PGPData*>(*i);
 722                     if (pd) {
 723                         getPGPDatas().push_back(pd->clonePGPData());
 724                         continue;
 725                     }
 726
 727                     getUnknownXMLObjects().push_back((*i)->clone());
 728                 }
 729             }
 730         }
 731
 732         IMPL_XMLOBJECT_CLONE(KeyInfo);
 733         IMPL_ID_ATTRIB_EX(Id,ID,nullptr);
 734         IMPL_TYPED_CHILDREN(KeyName,m_children.end());
 735         IMPL_TYPED_CHILDREN(KeyValue,m_children.end());
 736         IMPL_TYPED_CHILDREN(RetrievalMethod,m_children.end());
 737         IMPL_TYPED_CHILDREN(X509Data,m_children.end());
 738         IMPL_TYPED_CHILDREN(MgmtData,m_children.end());
 739         IMPL_TYPED_CHILDREN(SPKIData,m_children.end());
 740         IMPL_TYPED_CHILDREN(PGPData,m_children.end());
 741         IMPL_XMLOBJECT_CHILDREN(UnknownXMLObject,m_children.end());
 742
 743     protected:
 744         void marshallAttributes(DOMElement* domElement) const {
 745             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 746         }
 747
 748         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 749             PROC_TYPED_CHILDREN(X509Data,XMLSIG_NS,false);
 750             PROC_TYPED_CHILDREN(KeyName,XMLSIG_NS,false);
 751             PROC_TYPED_CHILDREN(KeyValue,XMLSIG_NS,false);
 752             PROC_TYPED_CHILDREN(RetrievalMethod,XMLSIG_NS,false);
 753             PROC_TYPED_CHILDREN(MgmtData,XMLSIG_NS,false);
 754             PROC_TYPED_CHILDREN(SPKIData,XMLSIG_NS,false);
 755             PROC_TYPED_CHILDREN(PGPData,XMLSIG_NS,false);
 756
 757             // Unknown child.
 758             const XMLCh* nsURI=root->getNamespaceURI();
 759             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 760                 getUnknownXMLObjects().push_back(childXMLObject);
 761                 return;
 762             }
 763
 764             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 765         }
 766
 767         void processAttribute(const DOMAttr* attribute) {
 768             PROC_ID_ATTRIB(Id,ID,nullptr);
 769             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 770         }
 771     };
 772
 773     class XMLTOOL_DLLLOCAL KeyInfoReferenceImpl : public virtual KeyInfoReference,
 774         public AbstractComplexElement,
 775         public AbstractDOMCachingXMLObject,
 776         public AbstractXMLObjectMarshaller,
 777         public AbstractXMLObjectUnmarshaller
 778     {
 779     public:
 780         virtual ~KeyInfoReferenceImpl() {
 781             XMLString::release(&m_Id);
 782             XMLString::release(&m_URI);
 783         }
 784
 785         KeyInfoReferenceImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const xmltooling::QName* schemaType)
 786             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 787             init();
 788         }
 789
 790         KeyInfoReferenceImpl(const KeyInfoReferenceImpl& src)
 791                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 792             init();
 793             setId(getId());
 794             setURI(getURI());
 795         }
 796
 797         void init() {
 798             m_Id=m_URI=nullptr;
 799         }
 800
 801         IMPL_XMLOBJECT_CLONE(KeyInfoReference);
 802         IMPL_ID_ATTRIB(Id);
 803         IMPL_STRING_ATTRIB(URI);
 804
 805     protected:
 806         void marshallAttributes(DOMElement* domElement) const {
 807             MARSHALL_ID_ATTRIB(Id,ID,nullptr);
 808             MARSHALL_STRING_ATTRIB(URI,URI,nullptr);
 809         }
 810
 811         void processAttribute(const DOMAttr* attribute) {
 812             PROC_ID_ATTRIB(Id,ID,nullptr);
 813             PROC_STRING_ATTRIB(URI,URI,nullptr);
 814             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 815         }
 816     };
 817
 818
 819     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
 820     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
 821     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
 822     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
 823     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
 824     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
 825     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P);
 826     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q);
 827     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G);
 828     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y);
 829     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J);
 830     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
 831     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
 832     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
 833     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
 834     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
 835     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
 836     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
 837     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,OCSPResponse);
 838     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
 839     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
 840     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
 841 };
 842
 843 #if defined (_MSC_VER)
 844     #pragma warning( pop )
 845 #endif
 846
 847 // Builder Implementations
 848
 849 IMPL_XMLOBJECTBUILDER(OCSPResponse);
 850 IMPL_XMLOBJECTBUILDER(X509IssuerSerial);
 851 IMPL_XMLOBJECTBUILDER(X509IssuerName);
 852 IMPL_XMLOBJECTBUILDER(X509SerialNumber);
 853 IMPL_XMLOBJECTBUILDER(X509SKI);
 854 IMPL_XMLOBJECTBUILDER(X509SubjectName);
 855 IMPL_XMLOBJECTBUILDER(X509Certificate);
 856 IMPL_XMLOBJECTBUILDER(X509CRL);
 857 IMPL_XMLOBJECTBUILDER(X509Data);
 858 IMPL_XMLOBJECTBUILDER(XPath);
 859 IMPL_XMLOBJECTBUILDER(Transform);
 860 IMPL_XMLOBJECTBUILDER(Transforms);
 861 IMPL_XMLOBJECTBUILDER(RetrievalMethod);
 862 IMPL_XMLOBJECTBUILDER(KeyName);
 863 IMPL_XMLOBJECTBUILDER(MgmtData);
 864 IMPL_XMLOBJECTBUILDER(Modulus);
 865 IMPL_XMLOBJECTBUILDER(Exponent);
 866 IMPL_XMLOBJECTBUILDER(Seed);
 867 IMPL_XMLOBJECTBUILDER(PgenCounter);
 868 IMPL_XMLOBJECTBUILDER(P);
 869 IMPL_XMLOBJECTBUILDER(Q);
 870 IMPL_XMLOBJECTBUILDER(G);
 871 IMPL_XMLOBJECTBUILDER(Y);
 872 IMPL_XMLOBJECTBUILDER(J);
 873 IMPL_XMLOBJECTBUILDER(DSAKeyValue);
 874 IMPL_XMLOBJECTBUILDER(RSAKeyValue);
 875 IMPL_XMLOBJECTBUILDER(KeyValue);
 876 IMPL_XMLOBJECTBUILDER(DEREncodedKeyValue);
 877 IMPL_XMLOBJECTBUILDER(KeyInfo);
 878 IMPL_XMLOBJECTBUILDER(KeyInfoReference);
 879 IMPL_XMLOBJECTBUILDER(SPKISexp);
 880 IMPL_XMLOBJECTBUILDER(SPKIData);
 881 IMPL_XMLOBJECTBUILDER(PGPKeyID);
 882 IMPL_XMLOBJECTBUILDER(PGPKeyPacket);
 883 IMPL_XMLOBJECTBUILDER(PGPData);
 884
 885 // Unicode literals
 886
 887 const XMLCh KeyInfo::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,I,n,f,o);
 888 const XMLCh KeyInfo::TYPE_NAME[] =                  UNICODE_LITERAL_11(K,e,y,I,n,f,o,T,y,p,e);
 889 const XMLCh KeyInfo::ID_ATTRIB_NAME[] =             UNICODE_LITERAL_2(I,d);
 890 const XMLCh KeyInfoReference::LOCAL_NAME[] =        UNICODE_LITERAL_16(K,e,y,I,n,f,o,R,e,f,e,r,e,n,c,e);
 891 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);
 892 const XMLCh KeyInfoReference::ID_ATTRIB_NAME[] =    UNICODE_LITERAL_2(I,d);
 893 const XMLCh KeyInfoReference::URI_ATTRIB_NAME[] =   UNICODE_LITERAL_3(U,R,I);
 894 const XMLCh KeyValue::LOCAL_NAME[] =                UNICODE_LITERAL_8(K,e,y,V,a,l,u,e);
 895 const XMLCh KeyValue::TYPE_NAME[] =                 UNICODE_LITERAL_12(K,e,y,V,a,l,u,e,T,y,p,e);
 896 const XMLCh DSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(D,S,A,K,e,y,V,a,l,u,e);
 897 const XMLCh DSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(D,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
 898 const XMLCh RSAKeyValue::LOCAL_NAME[] =             UNICODE_LITERAL_11(R,S,A,K,e,y,V,a,l,u,e);
 899 const XMLCh RSAKeyValue::TYPE_NAME[] =              UNICODE_LITERAL_15(R,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
 900 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);
 901 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);
 902 const XMLCh DEREncodedKeyValue::ID_ATTRIB_NAME[] =  UNICODE_LITERAL_2(I,d);
 903 const XMLCh MgmtData::LOCAL_NAME[] =                UNICODE_LITERAL_8(M,g,m,t,D,a,t,a);
 904 const XMLCh KeyName::LOCAL_NAME[] =                 UNICODE_LITERAL_7(K,e,y,N,a,m,e);
 905 const XMLCh Modulus::LOCAL_NAME[] =                 UNICODE_LITERAL_7(M,o,d,u,l,u,s);
 906 const XMLCh Exponent::LOCAL_NAME[] =                UNICODE_LITERAL_8(E,x,p,o,n,e,n,t);
 907 const XMLCh Seed::LOCAL_NAME[] =                    UNICODE_LITERAL_4(S,e,e,d);
 908 const XMLCh PgenCounter::LOCAL_NAME[] =             UNICODE_LITERAL_11(P,g,e,n,C,o,u,n,t,e,r);
 909 const XMLCh P::LOCAL_NAME[] =                       UNICODE_LITERAL_1(P);
 910 const XMLCh Q::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Q);
 911 const XMLCh G::LOCAL_NAME[] =                       UNICODE_LITERAL_1(G);
 912 const XMLCh Y::LOCAL_NAME[] =                       UNICODE_LITERAL_1(Y);
 913 const XMLCh J::LOCAL_NAME[] =                       UNICODE_LITERAL_1(J);
 914 const XMLCh XPath::LOCAL_NAME[] =                   UNICODE_LITERAL_5(X,P,a,t,h);
 915 const XMLCh Transform::LOCAL_NAME[] =               UNICODE_LITERAL_9(T,r,a,n,s,f,o,r,m);
 916 const XMLCh Transform::TYPE_NAME[] =                UNICODE_LITERAL_13(T,r,a,n,s,f,o,r,m,T,y,p,e);
 917 const XMLCh Transform::ALGORITHM_ATTRIB_NAME[] =    UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
 918 const XMLCh Transforms::LOCAL_NAME[] =              UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
 919 const XMLCh Transforms::TYPE_NAME[] =               UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);
 920 const XMLCh RetrievalMethod::LOCAL_NAME[] =         UNICODE_LITERAL_15(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d);
 921 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);
 922 const XMLCh RetrievalMethod::URI_ATTRIB_NAME[] =    UNICODE_LITERAL_3(U,R,I);
 923 const XMLCh RetrievalMethod::TYPE_ATTRIB_NAME[] =   UNICODE_LITERAL_4(T,y,p,e);
 924 const XMLCh SPKISexp::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,S,e,x,p);
 925 const XMLCh SPKIData::LOCAL_NAME[] =                UNICODE_LITERAL_8(S,P,K,I,D,a,t,a);
 926 const XMLCh SPKIData::TYPE_NAME[] =                 UNICODE_LITERAL_12(S,P,K,I,D,a,t,a,T,y,p,e);
 927 const XMLCh PGPKeyID::LOCAL_NAME[] =                UNICODE_LITERAL_8(P,G,P,K,e,y,I,D);
 928 const XMLCh PGPKeyPacket::LOCAL_NAME[] =            UNICODE_LITERAL_12(P,G,P,K,e,y,P,a,c,k,e,t);
 929 const XMLCh PGPData::LOCAL_NAME[] =                 UNICODE_LITERAL_7(P,G,P,D,a,t,a);
 930 const XMLCh PGPData::TYPE_NAME[] =                  UNICODE_LITERAL_11(P,G,P,D,a,t,a,T,y,p,e);
 931 const XMLCh OCSPResponse::LOCAL_NAME[] =            UNICODE_LITERAL_12(O,C,S,P,R,e,s,p,o,n,s,e);
 932
 933 #define XCH(ch) chLatin_##ch
 934 #define XNUM(d) chDigit_##d
 935
 936 const XMLCh X509Data::LOCAL_NAME[] = {
 937     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), chNull
 938     };
 939 const XMLCh X509Data::TYPE_NAME[] = {
 940     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
 941     };
 942 const XMLCh X509IssuerSerial::LOCAL_NAME[] = {
 943     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
 944     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), chNull
 945     };
 946 const XMLCh X509IssuerSerial::TYPE_NAME[] = {
 947     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
 948     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), XCH(T), XCH(y), XCH(p), XCH(e), chNull
 949     };
 950 const XMLCh X509IssuerName::LOCAL_NAME[] = {
 951     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
 952     XCH(N), XCH(a), XCH(m), XCH(e), chNull
 953     };
 954 const XMLCh X509SerialNumber::LOCAL_NAME[] = {
 955     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l),
 956     XCH(N), XCH(u), XCH(m), XCH(b), XCH(e), XCH(r), chNull
 957     };
 958 const XMLCh X509SKI::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(K), XCH(I), chNull };
 959 const XMLCh X509SubjectName::LOCAL_NAME[] = {
 960     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(u), XCH(b), XCH(j), XCH(e), XCH(c), XCH(t),
 961     XCH(N), XCH(a), XCH(m), XCH(e), chNull
 962     };
 963 const XMLCh X509Certificate::LOCAL_NAME[] = {
 964     XCH(X), XNUM(5), XNUM(0), XNUM(9),
 965     XCH(C), XCH(e), XCH(r), XCH(t), XCH(i), XCH(f), XCH(i), XCH(c), XCH(a), XCH(t), XCH(e), chNull
 966     };
 967 const XMLCh X509CRL::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(C), XCH(R), XCH(L), chNull };
 968
 969 const XMLCh RetrievalMethod::TYPE_DSAKEYVALUE[] = {
 970     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
 971     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
 972     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
 973     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
 974     chLatin_D, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
 975     };
 976
 977 const XMLCh RetrievalMethod::TYPE_RSAKEYVALUE[] = {
 978     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
 979     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
 980     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
 981     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
 982     chLatin_R, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
 983     };
 984
 985 const XMLCh RetrievalMethod::TYPE_X509DATA[] = {
 986     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
 987     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
 988     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
 989     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
 990     chLatin_X, chDigit_5, chDigit_0, chDigit_9, chLatin_D, chLatin_a, chLatin_t, chLatin_a, chNull
 991     };
 992