xmltooling/signature/impl/KeyInfoImpl.cpp

   1 /*
   2  *  Copyright 2001-2006 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 "AbstractSimpleElement.h"
  25 #include "AbstractComplexElement.h"
  26 #include "AbstractElementProxy.h"
  27 #include "AbstractSimpleElement.h"
  28 #include "exceptions.h"
  29 #include "io/AbstractXMLObjectMarshaller.h"
  30 #include "io/AbstractXMLObjectUnmarshaller.h"
  31 #include "signature/KeyInfo.h"
  32 #include "util/XMLHelper.h"
  33
  34 #include <xercesc/util/XMLUniDefs.hpp>
  35
  36 using namespace xmlsignature;
  37 using namespace xmltooling;
  38 using namespace std;
  39 using xmlconstants::XMLSIG_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 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=NULL;
  83             m_Q=NULL;
  84             m_G=NULL;
  85             m_Y=NULL;
  86             m_J=NULL;
  87             m_Seed=NULL;
  88             m_PgenCounter=NULL;
  89             m_children.push_back(NULL);
  90             m_children.push_back(NULL);
  91             m_children.push_back(NULL);
  92             m_children.push_back(NULL);
  93             m_children.push_back(NULL);
  94             m_children.push_back(NULL);
  95             m_children.push_back(NULL);
  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 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=NULL;
 158             m_Exponent=NULL;
 159             m_children.push_back(NULL);
 160             m_children.push_back(NULL);
 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 KeyValueImpl : public virtual KeyValue,
 179         public AbstractComplexElement,
 180         public AbstractDOMCachingXMLObject,
 181         public AbstractXMLObjectMarshaller,
 182         public AbstractXMLObjectUnmarshaller
 183     {
 184     public:
 185         virtual ~KeyValueImpl() {}
 186
 187         KeyValueImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 188                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 189             init();
 190         }
 191
 192         KeyValueImpl(const KeyValueImpl& src)
 193                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 194             init();
 195             if (src.getDSAKeyValue())
 196                 setDSAKeyValue(src.getDSAKeyValue()->cloneDSAKeyValue());
 197             if (src.getRSAKeyValue())
 198                 setRSAKeyValue(src.getRSAKeyValue()->cloneRSAKeyValue());
 199             if (src.getOtherKeyValue())
 200                 setOtherKeyValue(src.getOtherKeyValue()->clone());
 201         }
 202
 203         void init() {
 204             m_DSAKeyValue=NULL;
 205             m_RSAKeyValue=NULL;
 206             m_OtherKeyValue=NULL;
 207             m_children.push_back(NULL);
 208             m_children.push_back(NULL);
 209             m_children.push_back(NULL);
 210             m_pos_DSAKeyValue=m_children.begin();
 211             m_pos_RSAKeyValue=m_pos_DSAKeyValue;
 212             ++m_pos_RSAKeyValue;
 213             m_pos_OtherKeyValue=m_pos_RSAKeyValue;
 214             ++m_pos_OtherKeyValue;
 215         }
 216
 217         IMPL_XMLOBJECT_CLONE(KeyValue);
 218         IMPL_TYPED_CHILD(DSAKeyValue);
 219         IMPL_TYPED_CHILD(RSAKeyValue);
 220         IMPL_XMLOBJECT_CHILD(OtherKeyValue);
 221
 222     protected:
 223         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 224             PROC_TYPED_CHILD(DSAKeyValue,XMLSIG_NS,false);
 225             PROC_TYPED_CHILD(RSAKeyValue,XMLSIG_NS,false);
 226
 227             // Unknown child.
 228             const XMLCh* nsURI=root->getNamespaceURI();
 229             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 230                 setOtherKeyValue(childXMLObject);
 231                 return;
 232             }
 233
 234             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 235         }
 236     };
 237
 238     class XMLTOOL_DLLLOCAL TransformImpl : public virtual Transform,
 239         public AbstractDOMCachingXMLObject,
 240         public AbstractElementProxy,
 241         public AbstractXMLObjectMarshaller,
 242         public AbstractXMLObjectUnmarshaller
 243     {
 244     public:
 245         virtual ~TransformImpl() {
 246             XMLString::release(&m_Algorithm);
 247         }
 248
 249         TransformImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 250             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Algorithm(NULL) {
 251         }
 252
 253         TransformImpl(const TransformImpl& src)
 254                 : AbstractXMLObject(src), AbstractDOMCachingXMLObject(src), AbstractElementProxy(src),
 255                     m_Algorithm(XMLString::replicate(src.m_Algorithm)) {
 256             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 257                 if (*i) {
 258                     XPath* x=dynamic_cast<XPath*>(*i);
 259                     if (x) {
 260                         getXPaths().push_back(x->cloneXPath());
 261                         continue;
 262                     }
 263                     getXMLObjects().push_back((*i)->clone());
 264                 }
 265             }
 266         }
 267
 268         IMPL_XMLOBJECT_CLONE(Transform);
 269         IMPL_STRING_ATTRIB(Algorithm);
 270         IMPL_TYPED_CHILDREN(XPath,m_children.end());
 271
 272     protected:
 273         void marshallAttributes(DOMElement* domElement) const {
 274             MARSHALL_STRING_ATTRIB(Algorithm,ALGORITHM,NULL);
 275         }
 276
 277         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 278             PROC_TYPED_CHILDREN(XPath,XMLSIG_NS,false);
 279
 280             // Unknown child.
 281             const XMLCh* nsURI=root->getNamespaceURI();
 282             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 283                 getXMLObjects().push_back(childXMLObject);
 284                 return;
 285             }
 286
 287             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 288         }
 289
 290         void processAttribute(const DOMAttr* attribute) {
 291             PROC_STRING_ATTRIB(Algorithm,ALGORITHM,NULL);
 292             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 293         }
 294     };
 295
 296     class XMLTOOL_DLLLOCAL TransformsImpl : public virtual Transforms,
 297         public AbstractComplexElement,
 298         public AbstractDOMCachingXMLObject,
 299         public AbstractXMLObjectMarshaller,
 300         public AbstractXMLObjectUnmarshaller
 301     {
 302     public:
 303         virtual ~TransformsImpl() {}
 304
 305         TransformsImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 306             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 307         }
 308
 309         TransformsImpl(const TransformsImpl& src)
 310                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 311             VectorOf(Transform) v=getTransforms();
 312             for (vector<Transform*>::const_iterator i=src.m_Transforms.begin(); i!=src.m_Transforms.end(); i++) {
 313                 if (*i) {
 314                     v.push_back((*i)->cloneTransform());
 315                 }
 316             }
 317         }
 318
 319         IMPL_XMLOBJECT_CLONE(Transforms);
 320         IMPL_TYPED_CHILDREN(Transform,m_children.end());
 321
 322     protected:
 323         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 324             PROC_TYPED_CHILDREN(Transform,XMLSIG_NS,false);
 325             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 326         }
 327     };
 328
 329     class XMLTOOL_DLLLOCAL RetrievalMethodImpl : public virtual RetrievalMethod,
 330         public AbstractComplexElement,
 331         public AbstractDOMCachingXMLObject,
 332         public AbstractXMLObjectMarshaller,
 333         public AbstractXMLObjectUnmarshaller
 334     {
 335     public:
 336         virtual ~RetrievalMethodImpl() {
 337             XMLString::release(&m_URI);
 338             XMLString::release(&m_Type);
 339         }
 340
 341         RetrievalMethodImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 342             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 343             init();
 344         }
 345
 346         RetrievalMethodImpl(const RetrievalMethodImpl& src)
 347                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 348             init();
 349             setURI(getURI());
 350             setType(getType());
 351             if (src.getTransforms())
 352                 setTransforms(src.getTransforms()->cloneTransforms());
 353         }
 354
 355         void init() {
 356             m_URI=m_Type=NULL;
 357             m_Transforms=NULL;
 358             m_children.push_back(NULL);
 359             m_pos_Transforms=m_children.begin();
 360         }
 361
 362         IMPL_XMLOBJECT_CLONE(RetrievalMethod);
 363         IMPL_STRING_ATTRIB(URI);
 364         IMPL_STRING_ATTRIB(Type);
 365         IMPL_TYPED_CHILD(Transforms);
 366
 367     protected:
 368         void marshallAttributes(DOMElement* domElement) const {
 369             MARSHALL_STRING_ATTRIB(URI,URI,NULL);
 370             MARSHALL_STRING_ATTRIB(Type,TYPE,NULL);
 371         }
 372
 373         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 374             PROC_TYPED_CHILD(Transforms,XMLSIG_NS,false);
 375             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 376         }
 377
 378         void processAttribute(const DOMAttr* attribute) {
 379             PROC_STRING_ATTRIB(URI,URI,NULL);
 380             PROC_STRING_ATTRIB(Type,TYPE,NULL);
 381             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 382         }
 383     };
 384
 385     class XMLTOOL_DLLLOCAL X509IssuerSerialImpl : public virtual X509IssuerSerial,
 386         public AbstractComplexElement,
 387         public AbstractDOMCachingXMLObject,
 388         public AbstractXMLObjectMarshaller,
 389         public AbstractXMLObjectUnmarshaller
 390     {
 391     public:
 392         virtual ~X509IssuerSerialImpl() {}
 393
 394         X509IssuerSerialImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 395                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 396             init();
 397         }
 398
 399         X509IssuerSerialImpl(const X509IssuerSerialImpl& src)
 400                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 401             init();
 402             if (src.getX509IssuerName())
 403                 setX509IssuerName(src.getX509IssuerName()->cloneX509IssuerName());
 404             if (src.getX509SerialNumber())
 405                 setX509SerialNumber(src.getX509SerialNumber()->cloneX509SerialNumber());
 406         }
 407
 408         void init() {
 409             m_X509IssuerName=NULL;
 410             m_X509SerialNumber=NULL;
 411             m_children.push_back(NULL);
 412             m_children.push_back(NULL);
 413             m_pos_X509IssuerName=m_children.begin();
 414             m_pos_X509SerialNumber=m_pos_X509IssuerName;
 415             ++m_pos_X509SerialNumber;
 416         }
 417
 418         IMPL_XMLOBJECT_CLONE(X509IssuerSerial);
 419         IMPL_TYPED_CHILD(X509IssuerName);
 420         IMPL_TYPED_CHILD(X509SerialNumber);
 421
 422     protected:
 423         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 424             PROC_TYPED_CHILD(X509IssuerName,XMLSIG_NS,false);
 425             PROC_TYPED_CHILD(X509SerialNumber,XMLSIG_NS,false);
 426             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 427         }
 428     };
 429
 430     class XMLTOOL_DLLLOCAL X509DataImpl : public virtual X509Data,
 431         public AbstractComplexElement,
 432         public AbstractDOMCachingXMLObject,
 433         public AbstractXMLObjectMarshaller,
 434         public AbstractXMLObjectUnmarshaller
 435     {
 436     public:
 437         virtual ~X509DataImpl() {}
 438
 439         X509DataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 440             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 441         }
 442
 443         X509DataImpl(const X509DataImpl& src)
 444                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 445             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 446                 if (*i) {
 447                     X509Certificate* xcert=dynamic_cast<X509Certificate*>(*i);
 448                     if (xcert) {
 449                         getX509Certificates().push_back(xcert->cloneX509Certificate());
 450                         continue;
 451                     }
 452
 453                     X509CRL* xcrl=dynamic_cast<X509CRL*>(*i);
 454                     if (xcrl) {
 455                         getX509CRLs().push_back(xcrl->cloneX509CRL());
 456                         continue;
 457                     }
 458
 459                     X509SubjectName* xsn=dynamic_cast<X509SubjectName*>(*i);
 460                     if (xsn) {
 461                         getX509SubjectNames().push_back(xsn->cloneX509SubjectName());
 462                         continue;
 463                     }
 464
 465                     X509IssuerSerial* xis=dynamic_cast<X509IssuerSerial*>(*i);
 466                     if (xis) {
 467                         getX509IssuerSerials().push_back(xis->cloneX509IssuerSerial());
 468                         continue;
 469                     }
 470
 471                     X509SKI* xski=dynamic_cast<X509SKI*>(*i);
 472                     if (xski) {
 473                         getX509SKIs().push_back(xski->cloneX509SKI());
 474                         continue;
 475                     }
 476
 477                     getOtherX509Datas().push_back((*i)->clone());
 478                 }
 479             }
 480         }
 481
 482         IMPL_XMLOBJECT_CLONE(X509Data);
 483         IMPL_TYPED_CHILDREN(X509IssuerSerial,m_children.end());
 484         IMPL_TYPED_CHILDREN(X509SKI,m_children.end());
 485         IMPL_TYPED_CHILDREN(X509SubjectName,m_children.end());
 486         IMPL_TYPED_CHILDREN(X509Certificate,m_children.end());
 487         IMPL_TYPED_CHILDREN(X509CRL,m_children.end());
 488         IMPL_XMLOBJECT_CHILDREN(OtherX509Data,m_children.end());
 489
 490     protected:
 491         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 492             PROC_TYPED_CHILDREN(X509IssuerSerial,XMLSIG_NS,false);
 493             PROC_TYPED_CHILDREN(X509SKI,XMLSIG_NS,false);
 494             PROC_TYPED_CHILDREN(X509SubjectName,XMLSIG_NS,false);
 495             PROC_TYPED_CHILDREN(X509Certificate,XMLSIG_NS,false);
 496             PROC_TYPED_CHILDREN(X509CRL,XMLSIG_NS,false);
 497
 498             // Unknown child.
 499             const XMLCh* nsURI=root->getNamespaceURI();
 500             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 501                 getOtherX509Datas().push_back(childXMLObject);
 502                 return;
 503             }
 504
 505             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 506         }
 507     };
 508
 509     class XMLTOOL_DLLLOCAL SPKIDataImpl : public virtual SPKIData,
 510         public AbstractComplexElement,
 511         public AbstractDOMCachingXMLObject,
 512         public AbstractXMLObjectMarshaller,
 513         public AbstractXMLObjectUnmarshaller
 514     {
 515     public:
 516         virtual ~SPKIDataImpl() {}
 517
 518         SPKIDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 519             : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 520         }
 521
 522         SPKIDataImpl(const SPKIDataImpl& src)
 523                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 524             VectorOfPairs(SPKISexp,XMLObject) v=getSPKISexps();
 525             for (vector< pair<SPKISexp*,XMLObject*> >::const_iterator i=src.m_SPKISexps.begin(); i!=src.m_SPKISexps.end(); i++) {
 526                 if (i->first) {
 527                     v.push_back(make_pair(i->first->cloneSPKISexp(),(i->second ? i->second->clone() : (XMLObject*)NULL)));
 528                 }
 529             }
 530         }
 531
 532         IMPL_XMLOBJECT_CLONE(SPKIData);
 533
 534     private:
 535         vector< pair<SPKISexp*,XMLObject*> > m_SPKISexps;
 536
 537     public:
 538         VectorOfPairs(SPKISexp,XMLObject) getSPKISexps() {
 539             return VectorOfPairs(SPKISexp,XMLObject)(this, m_SPKISexps, &m_children, m_children.end());
 540         }
 541
 542         const vector< pair<SPKISexp*,XMLObject*> >& getSPKISexps() const {
 543             return m_SPKISexps;
 544         }
 545
 546     protected:
 547         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 548             if (XMLHelper::isNodeNamed(root,XMLSIG_NS,SPKISexp::LOCAL_NAME)) {
 549                 SPKISexp* typesafe=dynamic_cast<SPKISexp*>(childXMLObject);
 550                 if (typesafe) {
 551                     getSPKISexps().push_back(make_pair(typesafe,(XMLObject*)NULL));
 552                     return;
 553                 }
 554             }
 555
 556             // Unknown child (has to be paired with the last SPKISexp processed.
 557             const XMLCh* nsURI=root->getNamespaceURI();
 558             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 559                 // Update second half of pair in vector, and in master list.
 560                 if (!m_SPKISexps.empty() && m_SPKISexps.back().second==NULL) {
 561                     m_SPKISexps.back().second=childXMLObject;
 562                     m_children.back()=childXMLObject;
 563                     return;
 564                 }
 565                 else
 566                     throw UnmarshallingException("Extension element must follow ds:SPKISexp element.");
 567             }
 568
 569             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 570         }
 571     };
 572
 573     class XMLTOOL_DLLLOCAL PGPDataImpl : public virtual PGPData,
 574         public AbstractComplexElement,
 575         public AbstractDOMCachingXMLObject,
 576         public AbstractXMLObjectMarshaller,
 577         public AbstractXMLObjectUnmarshaller
 578     {
 579     public:
 580         virtual ~PGPDataImpl() {}
 581
 582         PGPDataImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 583                 : AbstractXMLObject(nsURI, localName, prefix, schemaType) {
 584             init();
 585         }
 586
 587         PGPDataImpl(const PGPDataImpl& src)
 588                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src) {
 589             init();
 590             if (src.getPGPKeyID())
 591                 setPGPKeyID(src.getPGPKeyID()->clonePGPKeyID());
 592             if (src.getPGPKeyPacket())
 593                 setPGPKeyPacket(src.getPGPKeyPacket()->clonePGPKeyPacket());
 594             VectorOf(XMLObject) v=getPGPDataExtensions();
 595             for (vector<XMLObject*>::const_iterator i=src.m_PGPDataExtensions.begin(); i!=src.m_PGPDataExtensions.end(); i++) {
 596                 if (*i) {
 597                     v.push_back((*i)->clone());
 598                 }
 599             }
 600         }
 601
 602         void init() {
 603             m_PGPKeyID=NULL;
 604             m_PGPKeyPacket=NULL;
 605             m_children.push_back(NULL);
 606             m_children.push_back(NULL);
 607             m_pos_PGPKeyID=m_children.begin();
 608             m_pos_PGPKeyPacket=m_pos_PGPKeyID;
 609             ++m_pos_PGPKeyPacket;
 610         }
 611
 612         IMPL_XMLOBJECT_CLONE(PGPData);
 613         IMPL_TYPED_CHILD(PGPKeyID);
 614         IMPL_TYPED_CHILD(PGPKeyPacket);
 615         IMPL_XMLOBJECT_CHILDREN(PGPDataExtension,m_children.end());
 616
 617     protected:
 618         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 619             PROC_TYPED_CHILD(PGPKeyID,XMLSIG_NS,false);
 620             PROC_TYPED_CHILD(PGPKeyPacket,XMLSIG_NS,false);
 621
 622             // Unknown child.
 623             const XMLCh* nsURI=root->getNamespaceURI();
 624             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 625                 getPGPDataExtensions().push_back(childXMLObject);
 626                 return;
 627             }
 628
 629             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 630         }
 631     };
 632
 633     class XMLTOOL_DLLLOCAL KeyInfoImpl : public virtual KeyInfo,
 634         public AbstractComplexElement,
 635         public AbstractDOMCachingXMLObject,
 636         public AbstractXMLObjectMarshaller,
 637         public AbstractXMLObjectUnmarshaller
 638     {
 639     public:
 640         virtual ~KeyInfoImpl() {
 641             XMLString::release(&m_Id);
 642         }
 643
 644         KeyInfoImpl(const XMLCh* nsURI, const XMLCh* localName, const XMLCh* prefix, const QName* schemaType)
 645             : AbstractXMLObject(nsURI, localName, prefix, schemaType), m_Id(NULL) {
 646         }
 647
 648         KeyInfoImpl(const KeyInfoImpl& src)
 649                 : AbstractXMLObject(src), AbstractComplexElement(src), AbstractDOMCachingXMLObject(src),
 650                     m_Id(XMLString::replicate(src.m_Id)) {
 651
 652             for (list<XMLObject*>::const_iterator i=src.m_children.begin(); i!=src.m_children.end(); i++) {
 653                 if (*i) {
 654                     X509Data* xd=dynamic_cast<X509Data*>(*i);
 655                     if (xd) {
 656                         getX509Datas().push_back(xd->cloneX509Data());
 657                         continue;
 658                     }
 659
 660                     KeyName* kn=dynamic_cast<KeyName*>(*i);
 661                     if (kn) {
 662                         getKeyNames().push_back(kn->cloneKeyName());
 663                         continue;
 664                     }
 665
 666                     KeyValue* kv=dynamic_cast<KeyValue*>(*i);
 667                     if (kv) {
 668                         getKeyValues().push_back(kv->cloneKeyValue());
 669                         continue;
 670                     }
 671
 672                     RetrievalMethod* rm=dynamic_cast<RetrievalMethod*>(*i);
 673                     if (rm) {
 674                         getRetrievalMethods().push_back(rm->cloneRetrievalMethod());
 675                         continue;
 676                     }
 677
 678                     MgmtData* md=dynamic_cast<MgmtData*>(*i);
 679                     if (md) {
 680                         getMgmtDatas().push_back(md->cloneMgmtData());
 681                         continue;
 682                     }
 683
 684                     SPKIData* sd=dynamic_cast<SPKIData*>(*i);
 685                     if (sd) {
 686                         getSPKIDatas().push_back(sd->cloneSPKIData());
 687                         continue;
 688                     }
 689
 690                     PGPData* pd=dynamic_cast<PGPData*>(*i);
 691                     if (pd) {
 692                         getPGPDatas().push_back(pd->clonePGPData());
 693                         continue;
 694                     }
 695
 696                     getOthers().push_back((*i)->clone());
 697                 }
 698             }
 699         }
 700
 701         IMPL_XMLOBJECT_CLONE(KeyInfo);
 702         IMPL_ID_ATTRIB(Id);
 703         IMPL_TYPED_CHILDREN(KeyName,m_children.end());
 704         IMPL_TYPED_CHILDREN(KeyValue,m_children.end());
 705         IMPL_TYPED_CHILDREN(RetrievalMethod,m_children.end());
 706         IMPL_TYPED_CHILDREN(X509Data,m_children.end());
 707         IMPL_TYPED_CHILDREN(MgmtData,m_children.end());
 708         IMPL_TYPED_CHILDREN(SPKIData,m_children.end());
 709         IMPL_TYPED_CHILDREN(PGPData,m_children.end());
 710         IMPL_XMLOBJECT_CHILDREN(Other,m_children.end());
 711
 712     protected:
 713         void marshallAttributes(DOMElement* domElement) const {
 714             MARSHALL_ID_ATTRIB(Id,ID,NULL);
 715         }
 716
 717         void processChildElement(XMLObject* childXMLObject, const DOMElement* root) {
 718             PROC_TYPED_CHILDREN(X509Data,XMLSIG_NS,false);
 719             PROC_TYPED_CHILDREN(KeyName,XMLSIG_NS,false);
 720             PROC_TYPED_CHILDREN(KeyValue,XMLSIG_NS,false);
 721             PROC_TYPED_CHILDREN(RetrievalMethod,XMLSIG_NS,false);
 722             PROC_TYPED_CHILDREN(MgmtData,XMLSIG_NS,false);
 723             PROC_TYPED_CHILDREN(SPKIData,XMLSIG_NS,false);
 724             PROC_TYPED_CHILDREN(PGPData,XMLSIG_NS,false);
 725
 726             // Unknown child.
 727             const XMLCh* nsURI=root->getNamespaceURI();
 728             if (!XMLString::equals(nsURI,XMLSIG_NS) && nsURI && *nsURI) {
 729                 getOthers().push_back(childXMLObject);
 730                 return;
 731             }
 732
 733             AbstractXMLObjectUnmarshaller::processChildElement(childXMLObject,root);
 734         }
 735
 736         void processAttribute(const DOMAttr* attribute) {
 737             PROC_ID_ATTRIB(Id,ID,NULL);
 738             AbstractXMLObjectUnmarshaller::processAttribute(attribute);
 739         }
 740     };
 741
 742     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,KeyName);
 743     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,MgmtData);
 744     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Modulus);
 745     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Exponent);
 746     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Seed);
 747     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PgenCounter);
 748     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,P);
 749     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Q);
 750     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,G);
 751     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,Y);
 752     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,J);
 753     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,XPath);
 754     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509IssuerName);
 755     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SerialNumber);
 756     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SKI);
 757     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509SubjectName);
 758     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509Certificate);
 759     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,X509CRL);
 760     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,SPKISexp);
 761     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyID);
 762     DECL_XMLOBJECTIMPL_SIMPLE(XMLTOOL_DLLLOCAL,PGPKeyPacket);
 763 };
 764
 765 #if defined (_MSC_VER)
 766     #pragma warning( pop )
 767 #endif
 768
 769 // Builder Implementations
 770
 771 IMPL_XMLOBJECTBUILDER(X509IssuerSerial);
 772 IMPL_XMLOBJECTBUILDER(X509IssuerName);
 773 IMPL_XMLOBJECTBUILDER(X509SerialNumber);
 774 IMPL_XMLOBJECTBUILDER(X509SKI);
 775 IMPL_XMLOBJECTBUILDER(X509SubjectName);
 776 IMPL_XMLOBJECTBUILDER(X509Certificate);
 777 IMPL_XMLOBJECTBUILDER(X509CRL);
 778 IMPL_XMLOBJECTBUILDER(X509Data);
 779 IMPL_XMLOBJECTBUILDER(XPath);
 780 IMPL_XMLOBJECTBUILDER(Transform);
 781 IMPL_XMLOBJECTBUILDER(Transforms);
 782 IMPL_XMLOBJECTBUILDER(RetrievalMethod);
 783 IMPL_XMLOBJECTBUILDER(KeyName);
 784 IMPL_XMLOBJECTBUILDER(MgmtData);
 785 IMPL_XMLOBJECTBUILDER(Modulus);
 786 IMPL_XMLOBJECTBUILDER(Exponent);
 787 IMPL_XMLOBJECTBUILDER(Seed);
 788 IMPL_XMLOBJECTBUILDER(PgenCounter);
 789 IMPL_XMLOBJECTBUILDER(P);
 790 IMPL_XMLOBJECTBUILDER(Q);
 791 IMPL_XMLOBJECTBUILDER(G);
 792 IMPL_XMLOBJECTBUILDER(Y);
 793 IMPL_XMLOBJECTBUILDER(J);
 794 IMPL_XMLOBJECTBUILDER(DSAKeyValue);
 795 IMPL_XMLOBJECTBUILDER(RSAKeyValue);
 796 IMPL_XMLOBJECTBUILDER(KeyValue);
 797 IMPL_XMLOBJECTBUILDER(KeyInfo);
 798 IMPL_XMLOBJECTBUILDER(SPKISexp);
 799 IMPL_XMLOBJECTBUILDER(SPKIData);
 800 IMPL_XMLOBJECTBUILDER(PGPKeyID);
 801 IMPL_XMLOBJECTBUILDER(PGPKeyPacket);
 802 IMPL_XMLOBJECTBUILDER(PGPData);
 803
 804 // Unicode literals
 805
 806 const XMLCh KeyInfo::LOCAL_NAME[] =             UNICODE_LITERAL_7(K,e,y,I,n,f,o);
 807 const XMLCh KeyInfo::TYPE_NAME[] =              UNICODE_LITERAL_11(K,e,y,I,n,f,o,T,y,p,e);
 808 const XMLCh KeyInfo::ID_ATTRIB_NAME[] =         UNICODE_LITERAL_2(I,d);
 809 const XMLCh KeyValue::LOCAL_NAME[] =            UNICODE_LITERAL_8(K,e,y,V,a,l,u,e);
 810 const XMLCh KeyValue::TYPE_NAME[] =             UNICODE_LITERAL_12(K,e,y,V,a,l,u,e,T,y,p,e);
 811 const XMLCh DSAKeyValue::LOCAL_NAME[] =         UNICODE_LITERAL_11(D,S,A,K,e,y,V,a,l,u,e);
 812 const XMLCh DSAKeyValue::TYPE_NAME[] =          UNICODE_LITERAL_15(D,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
 813 const XMLCh RSAKeyValue::LOCAL_NAME[] =         UNICODE_LITERAL_11(R,S,A,K,e,y,V,a,l,u,e);
 814 const XMLCh RSAKeyValue::TYPE_NAME[] =          UNICODE_LITERAL_15(R,S,A,K,e,y,V,a,l,u,e,T,y,p,e);
 815 const XMLCh MgmtData::LOCAL_NAME[] =            UNICODE_LITERAL_8(M,g,m,t,D,a,t,a);
 816 const XMLCh KeyName::LOCAL_NAME[] =             UNICODE_LITERAL_7(K,e,y,N,a,m,e);
 817 const XMLCh Modulus::LOCAL_NAME[] =             UNICODE_LITERAL_7(M,o,d,u,l,u,s);
 818 const XMLCh Exponent::LOCAL_NAME[] =            UNICODE_LITERAL_8(E,x,p,o,n,e,n,t);
 819 const XMLCh Seed::LOCAL_NAME[] =                UNICODE_LITERAL_4(S,e,e,d);
 820 const XMLCh PgenCounter::LOCAL_NAME[] =         UNICODE_LITERAL_11(P,g,e,n,C,o,u,n,t,e,r);
 821 const XMLCh P::LOCAL_NAME[] =                   UNICODE_LITERAL_1(P);
 822 const XMLCh Q::LOCAL_NAME[] =                   UNICODE_LITERAL_1(Q);
 823 const XMLCh G::LOCAL_NAME[] =                   UNICODE_LITERAL_1(G);
 824 const XMLCh Y::LOCAL_NAME[] =                   UNICODE_LITERAL_1(Y);
 825 const XMLCh J::LOCAL_NAME[] =                   UNICODE_LITERAL_1(J);
 826 const XMLCh XPath::LOCAL_NAME[] =               UNICODE_LITERAL_5(X,P,a,t,h);
 827 const XMLCh Transform::LOCAL_NAME[] =           UNICODE_LITERAL_9(T,r,a,n,s,f,o,r,m);
 828 const XMLCh Transform::TYPE_NAME[] =            UNICODE_LITERAL_13(T,r,a,n,s,f,o,r,m,T,y,p,e);
 829 const XMLCh Transform::ALGORITHM_ATTRIB_NAME[] = UNICODE_LITERAL_9(A,l,g,o,r,i,t,h,m);
 830 const XMLCh Transforms::LOCAL_NAME[] =          UNICODE_LITERAL_10(T,r,a,n,s,f,o,r,m,s);
 831 const XMLCh Transforms::TYPE_NAME[] =           UNICODE_LITERAL_14(T,r,a,n,s,f,o,r,m,s,T,y,p,e);
 832 const XMLCh RetrievalMethod::LOCAL_NAME[] =     UNICODE_LITERAL_15(R,e,t,r,i,e,v,a,l,M,e,t,h,o,d);
 833 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);
 834 const XMLCh RetrievalMethod::URI_ATTRIB_NAME[] = UNICODE_LITERAL_3(U,R,I);
 835 const XMLCh RetrievalMethod::TYPE_ATTRIB_NAME[] = UNICODE_LITERAL_4(T,y,p,e);
 836 const XMLCh SPKISexp::LOCAL_NAME[] =            UNICODE_LITERAL_8(S,P,K,I,S,e,x,p);
 837 const XMLCh SPKIData::LOCAL_NAME[] =            UNICODE_LITERAL_8(S,P,K,I,D,a,t,a);
 838 const XMLCh SPKIData::TYPE_NAME[] =             UNICODE_LITERAL_12(S,P,K,I,D,a,t,a,T,y,p,e);
 839 const XMLCh PGPKeyID::LOCAL_NAME[] =            UNICODE_LITERAL_8(P,G,P,K,e,y,I,D);
 840 const XMLCh PGPKeyPacket::LOCAL_NAME[] =        UNICODE_LITERAL_12(P,G,P,K,e,y,P,a,c,k,e,t);
 841 const XMLCh PGPData::LOCAL_NAME[] =             UNICODE_LITERAL_7(P,G,P,D,a,t,a);
 842 const XMLCh PGPData::TYPE_NAME[] =              UNICODE_LITERAL_11(P,G,P,D,a,t,a,T,y,p,e);
 843
 844 #define XCH(ch) chLatin_##ch
 845 #define XNUM(d) chDigit_##d
 846
 847 const XMLCh X509Data::LOCAL_NAME[] = {
 848     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(D), XCH(a), XCH(t), XCH(a), chNull
 849     };
 850 const XMLCh X509Data::TYPE_NAME[] = {
 851     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
 852     };
 853 const XMLCh X509IssuerSerial::LOCAL_NAME[] = {
 854     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
 855     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), chNull
 856     };
 857 const XMLCh X509IssuerSerial::TYPE_NAME[] = {
 858     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
 859     XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l), XCH(T), XCH(y), XCH(p), XCH(e), chNull
 860     };
 861 const XMLCh X509IssuerName::LOCAL_NAME[] = {
 862     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(I), XCH(s), XCH(s), XCH(u), XCH(e), XCH(r),
 863     XCH(N), XCH(a), XCH(m), XCH(e), chNull
 864     };
 865 const XMLCh X509SerialNumber::LOCAL_NAME[] = {
 866     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(e), XCH(r), XCH(i), XCH(a), XCH(l),
 867     XCH(N), XCH(u), XCH(m), XCH(b), XCH(e), XCH(r), chNull
 868     };
 869 const XMLCh X509SKI::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(K), XCH(I), chNull };
 870 const XMLCh X509SubjectName::LOCAL_NAME[] = {
 871     XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(S), XCH(u), XCH(b), XCH(j), XCH(e), XCH(c), XCH(t),
 872     XCH(N), XCH(a), XCH(m), XCH(e), chNull
 873     };
 874 const XMLCh X509Certificate::LOCAL_NAME[] = {
 875     XCH(X), XNUM(5), XNUM(0), XNUM(9),
 876     XCH(C), XCH(e), XCH(r), XCH(t), XCH(i), XCH(f), XCH(i), XCH(c), XCH(a), XCH(t), XCH(e), chNull
 877     };
 878 const XMLCh X509CRL::LOCAL_NAME[] = { XCH(X), XNUM(5), XNUM(0), XNUM(9), XCH(C), XCH(R), XCH(L), chNull };
 879
 880 const XMLCh RetrievalMethod::TYPE_DSAKEYVALUE[] = {
 881     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
 882     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
 883     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
 884     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
 885     chLatin_D, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
 886     };
 887
 888 const XMLCh RetrievalMethod::TYPE_RSAKEYVALUE[] = {
 889     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
 890     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
 891     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
 892     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
 893     chLatin_R, chLatin_S, chLatin_A, chLatin_K, chLatin_e, chLatin_y, chLatin_V, chLatin_a, chLatin_l, chLatin_u, chLatin_e, chNull
 894     };
 895
 896 const XMLCh RetrievalMethod::TYPE_X509DATA[] = {
 897     chLatin_h, chLatin_t, chLatin_t, chLatin_p, chColon, chForwardSlash, chForwardSlash,
 898     chLatin_w, chLatin_w, chLatin_w, chPeriod, chLatin_w, chDigit_3, chPeriod, chLatin_o, chLatin_r, chLatin_g, chForwardSlash,
 899     chDigit_2, chDigit_0, chDigit_0, chDigit_0, chForwardSlash, chDigit_0, chDigit_9, chForwardSlash,
 900     chLatin_x, chLatin_m, chLatin_l, chLatin_d, chLatin_s, chLatin_i, chLatin_g, chPound,
 901     chLatin_X, chDigit_5, chDigit_0, chDigit_9, chLatin_D, chLatin_a, chLatin_t, chLatin_a, chNull
 902     };
 903