xmltooling/signature/impl/KeyInfoImpl.cpp

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