entities.c

   1 /*
   2  * entities.c : implementation for the XML entities handling
   3  *
   4  * See Copyright for the status of this software.
   5  *
   6  * daniel@veillard.com
   7  */
   8
   9 /* To avoid EBCDIC trouble when parsing on zOS */
  10 #if defined(__MVS__)
  11 #pragma convert("ISO8859-1")
  12 #endif
  13
  14 #define IN_LIBXML
  15 #include "libxml.h"
  16
  17 #include <string.h>
  18 #ifdef HAVE_STDLIB_H
  19 #include <stdlib.h>
  20 #endif
  21 #include <libxml/xmlmemory.h>
  22 #include <libxml/hash.h>
  23 #include <libxml/entities.h>
  24 #include <libxml/parser.h>
  25 #include <libxml/parserInternals.h>
  26 #include <libxml/xmlerror.h>
  27 #include <libxml/globals.h>
  28 #include <libxml/dict.h>
  29
  30 #include "save.h"
  31
  32 /*
  33  * The XML predefined entities.
  34  */
  35
  36 static xmlEntity xmlEntityLt = {
  37     NULL, XML_ENTITY_DECL, BAD_CAST "lt",
  38     NULL, NULL, NULL, NULL, NULL, NULL,
  39     BAD_CAST "<", BAD_CAST "<", 1,
  40     XML_INTERNAL_PREDEFINED_ENTITY,
  41     NULL, NULL, NULL, NULL, 0, 1
  42 };
  43 static xmlEntity xmlEntityGt = {
  44     NULL, XML_ENTITY_DECL, BAD_CAST "gt",
  45     NULL, NULL, NULL, NULL, NULL, NULL,
  46     BAD_CAST ">", BAD_CAST ">", 1,
  47     XML_INTERNAL_PREDEFINED_ENTITY,
  48     NULL, NULL, NULL, NULL, 0, 1
  49 };
  50 static xmlEntity xmlEntityAmp = {
  51     NULL, XML_ENTITY_DECL, BAD_CAST "amp",
  52     NULL, NULL, NULL, NULL, NULL, NULL,
  53     BAD_CAST "&", BAD_CAST "&", 1,
  54     XML_INTERNAL_PREDEFINED_ENTITY,
  55     NULL, NULL, NULL, NULL, 0, 1
  56 };
  57 static xmlEntity xmlEntityQuot = {
  58     NULL, XML_ENTITY_DECL, BAD_CAST "quot",
  59     NULL, NULL, NULL, NULL, NULL, NULL,
  60     BAD_CAST "\"", BAD_CAST "\"", 1,
  61     XML_INTERNAL_PREDEFINED_ENTITY,
  62     NULL, NULL, NULL, NULL, 0, 1
  63 };
  64 static xmlEntity xmlEntityApos = {
  65     NULL, XML_ENTITY_DECL, BAD_CAST "apos",
  66     NULL, NULL, NULL, NULL, NULL, NULL,
  67     BAD_CAST "'", BAD_CAST "'", 1,
  68     XML_INTERNAL_PREDEFINED_ENTITY,
  69     NULL, NULL, NULL, NULL, 0, 1
  70 };
  71
  72 /**
  73  * xmlEntitiesErrMemory:
  74  * @extra:  extra informations
  75  *
  76  * Handle an out of memory condition
  77  */
  78 static void
  79 xmlEntitiesErrMemory(const char *extra)
  80 {
  81     __xmlSimpleError(XML_FROM_TREE, XML_ERR_NO_MEMORY, NULL, NULL, extra);
  82 }
  83
  84 /**
  85  * xmlEntitiesErr:
  86  * @code:  the error code
  87  * @msg:  the message
  88  *
  89  * Handle an out of memory condition
  90  */
  91 static void LIBXML_ATTR_FORMAT(2,0)
  92 xmlEntitiesErr(xmlParserErrors code, const char *msg)
  93 {
  94     __xmlSimpleError(XML_FROM_TREE, code, NULL, msg, NULL);
  95 }
  96
  97 /*
  98  * xmlFreeEntity : clean-up an entity record.
  99  */
 100 static void
 101 xmlFreeEntity(xmlEntityPtr entity)
 102 {
 103     xmlDictPtr dict = NULL;
 104
 105     if (entity == NULL)
 106         return;
 107
 108     if (entity->doc != NULL)
 109         dict = entity->doc->dict;
 110
 111
 112     if ((entity->children) && (entity->owner == 1) &&
 113         (entity == (xmlEntityPtr) entity->children->parent))
 114         xmlFreeNodeList(entity->children);
 115     if (dict != NULL) {
 116         if ((entity->name != NULL) && (!xmlDictOwns(dict, entity->name)))
 117             xmlFree((char *) entity->name);
 118         if ((entity->ExternalID != NULL) &&
 119             (!xmlDictOwns(dict, entity->ExternalID)))
 120             xmlFree((char *) entity->ExternalID);
 121         if ((entity->SystemID != NULL) &&
 122             (!xmlDictOwns(dict, entity->SystemID)))
 123             xmlFree((char *) entity->SystemID);
 124         if ((entity->URI != NULL) && (!xmlDictOwns(dict, entity->URI)))
 125             xmlFree((char *) entity->URI);
 126         if ((entity->content != NULL)
 127             && (!xmlDictOwns(dict, entity->content)))
 128             xmlFree((char *) entity->content);
 129         if ((entity->orig != NULL) && (!xmlDictOwns(dict, entity->orig)))
 130             xmlFree((char *) entity->orig);
 131     } else {
 132         if (entity->name != NULL)
 133             xmlFree((char *) entity->name);
 134         if (entity->ExternalID != NULL)
 135             xmlFree((char *) entity->ExternalID);
 136         if (entity->SystemID != NULL)
 137             xmlFree((char *) entity->SystemID);
 138         if (entity->URI != NULL)
 139             xmlFree((char *) entity->URI);
 140         if (entity->content != NULL)
 141             xmlFree((char *) entity->content);
 142         if (entity->orig != NULL)
 143             xmlFree((char *) entity->orig);
 144     }
 145     xmlFree(entity);
 146 }
 147
 148 /*
 149  * xmlCreateEntity:
 150  *
 151  * internal routine doing the entity node strutures allocations
 152  */
 153 static xmlEntityPtr
 154 xmlCreateEntity(xmlDictPtr dict, const xmlChar *name, int type,
 155                 const xmlChar *ExternalID, const xmlChar *SystemID,
 156                 const xmlChar *content) {
 157     xmlEntityPtr ret;
 158
 159     ret = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
 160     if (ret == NULL) {
 161         xmlEntitiesErrMemory("xmlCreateEntity: malloc failed");
 162         return(NULL);
 163     }
 164     memset(ret, 0, sizeof(xmlEntity));
 165     ret->type = XML_ENTITY_DECL;
 166     ret->checked = 0;
 167
 168     /*
 169      * fill the structure.
 170      */
 171     ret->etype = (xmlEntityType) type;
 172     if (dict == NULL) {
 173         ret->name = xmlStrdup(name);
 174         if (ExternalID != NULL)
 175             ret->ExternalID = xmlStrdup(ExternalID);
 176         if (SystemID != NULL)
 177             ret->SystemID = xmlStrdup(SystemID);
 178     } else {
 179         ret->name = xmlDictLookup(dict, name, -1);
 180         if (ExternalID != NULL)
 181             ret->ExternalID = xmlDictLookup(dict, ExternalID, -1);
 182         if (SystemID != NULL)
 183             ret->SystemID = xmlDictLookup(dict, SystemID, -1);
 184     }
 185     if (content != NULL) {
 186         ret->length = xmlStrlen(content);
 187         if ((dict != NULL) && (ret->length < 5))
 188             ret->content = (xmlChar *)
 189                            xmlDictLookup(dict, content, ret->length);
 190         else
 191             ret->content = xmlStrndup(content, ret->length);
 192      } else {
 193         ret->length = 0;
 194         ret->content = NULL;
 195     }
 196     ret->URI = NULL; /* to be computed by the layer knowing
 197                         the defining entity */
 198     ret->orig = NULL;
 199     ret->owner = 0;
 200
 201     return(ret);
 202 }
 203
 204 /*
 205  * xmlAddEntity : register a new entity for an entities table.
 206  */
 207 static xmlEntityPtr
 208 xmlAddEntity(xmlDtdPtr dtd, const xmlChar *name, int type,
 209           const xmlChar *ExternalID, const xmlChar *SystemID,
 210           const xmlChar *content) {
 211     xmlDictPtr dict = NULL;
 212     xmlEntitiesTablePtr table = NULL;
 213     xmlEntityPtr ret;
 214
 215     if (name == NULL)
 216         return(NULL);
 217     if (dtd == NULL)
 218         return(NULL);
 219     if (dtd->doc != NULL)
 220         dict = dtd->doc->dict;
 221
 222     switch (type) {
 223         case XML_INTERNAL_GENERAL_ENTITY:
 224         case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
 225         case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
 226             if (dtd->entities == NULL)
 227                 dtd->entities = xmlHashCreateDict(0, dict);
 228             table = dtd->entities;
 229             break;
 230         case XML_INTERNAL_PARAMETER_ENTITY:
 231         case XML_EXTERNAL_PARAMETER_ENTITY:
 232             if (dtd->pentities == NULL)
 233                 dtd->pentities = xmlHashCreateDict(0, dict);
 234             table = dtd->pentities;
 235             break;
 236         case XML_INTERNAL_PREDEFINED_ENTITY:
 237             return(NULL);
 238     }
 239     if (table == NULL)
 240         return(NULL);
 241     ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content);
 242     if (ret == NULL)
 243         return(NULL);
 244     ret->doc = dtd->doc;
 245
 246     if (xmlHashAddEntry(table, name, ret)) {
 247         /*
 248          * entity was already defined at another level.
 249          */
 250         xmlFreeEntity(ret);
 251         return(NULL);
 252     }
 253     return(ret);
 254 }
 255
 256 /**
 257  * xmlGetPredefinedEntity:
 258  * @name:  the entity name
 259  *
 260  * Check whether this name is an predefined entity.
 261  *
 262  * Returns NULL if not, otherwise the entity
 263  */
 264 xmlEntityPtr
 265 xmlGetPredefinedEntity(const xmlChar *name) {
 266     if (name == NULL) return(NULL);
 267     switch (name[0]) {
 268         case 'l':
 269             if (xmlStrEqual(name, BAD_CAST "lt"))
 270                 return(&xmlEntityLt);
 271             break;
 272         case 'g':
 273             if (xmlStrEqual(name, BAD_CAST "gt"))
 274                 return(&xmlEntityGt);
 275             break;
 276         case 'a':
 277             if (xmlStrEqual(name, BAD_CAST "amp"))
 278                 return(&xmlEntityAmp);
 279             if (xmlStrEqual(name, BAD_CAST "apos"))
 280                 return(&xmlEntityApos);
 281             break;
 282         case 'q':
 283             if (xmlStrEqual(name, BAD_CAST "quot"))
 284                 return(&xmlEntityQuot);
 285             break;
 286         default:
 287             break;
 288     }
 289     return(NULL);
 290 }
 291
 292 /**
 293  * xmlAddDtdEntity:
 294  * @doc:  the document
 295  * @name:  the entity name
 296  * @type:  the entity type XML_xxx_yyy_ENTITY
 297  * @ExternalID:  the entity external ID if available
 298  * @SystemID:  the entity system ID if available
 299  * @content:  the entity content
 300  *
 301  * Register a new entity for this document DTD external subset.
 302  *
 303  * Returns a pointer to the entity or NULL in case of error
 304  */
 305 xmlEntityPtr
 306 xmlAddDtdEntity(xmlDocPtr doc, const xmlChar *name, int type,
 307                 const xmlChar *ExternalID, const xmlChar *SystemID,
 308                 const xmlChar *content) {
 309     xmlEntityPtr ret;
 310     xmlDtdPtr dtd;
 311
 312     if (doc == NULL) {
 313         xmlEntitiesErr(XML_DTD_NO_DOC,
 314                 "xmlAddDtdEntity: document is NULL");
 315         return(NULL);
 316     }
 317     if (doc->extSubset == NULL) {
 318         xmlEntitiesErr(XML_DTD_NO_DTD,
 319                 "xmlAddDtdEntity: document without external subset");
 320         return(NULL);
 321     }
 322     dtd = doc->extSubset;
 323     ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
 324     if (ret == NULL) return(NULL);
 325
 326     /*
 327      * Link it to the DTD
 328      */
 329     ret->parent = dtd;
 330     ret->doc = dtd->doc;
 331     if (dtd->last == NULL) {
 332         dtd->children = dtd->last = (xmlNodePtr) ret;
 333     } else {
 334         dtd->last->next = (xmlNodePtr) ret;
 335         ret->prev = dtd->last;
 336         dtd->last = (xmlNodePtr) ret;
 337     }
 338     return(ret);
 339 }
 340
 341 /**
 342  * xmlAddDocEntity:
 343  * @doc:  the document
 344  * @name:  the entity name
 345  * @type:  the entity type XML_xxx_yyy_ENTITY
 346  * @ExternalID:  the entity external ID if available
 347  * @SystemID:  the entity system ID if available
 348  * @content:  the entity content
 349  *
 350  * Register a new entity for this document.
 351  *
 352  * Returns a pointer to the entity or NULL in case of error
 353  */
 354 xmlEntityPtr
 355 xmlAddDocEntity(xmlDocPtr doc, const xmlChar *name, int type,
 356                 const xmlChar *ExternalID, const xmlChar *SystemID,
 357                 const xmlChar *content) {
 358     xmlEntityPtr ret;
 359     xmlDtdPtr dtd;
 360
 361     if (doc == NULL) {
 362         xmlEntitiesErr(XML_DTD_NO_DOC,
 363                 "xmlAddDocEntity: document is NULL");
 364         return(NULL);
 365     }
 366     if (doc->intSubset == NULL) {
 367         xmlEntitiesErr(XML_DTD_NO_DTD,
 368                 "xmlAddDocEntity: document without internal subset");
 369         return(NULL);
 370     }
 371     dtd = doc->intSubset;
 372     ret = xmlAddEntity(dtd, name, type, ExternalID, SystemID, content);
 373     if (ret == NULL) return(NULL);
 374
 375     /*
 376      * Link it to the DTD
 377      */
 378     ret->parent = dtd;
 379     ret->doc = dtd->doc;
 380     if (dtd->last == NULL) {
 381         dtd->children = dtd->last = (xmlNodePtr) ret;
 382     } else {
 383         dtd->last->next = (xmlNodePtr) ret;
 384         ret->prev = dtd->last;
 385         dtd->last = (xmlNodePtr) ret;
 386     }
 387     return(ret);
 388 }
 389
 390 /**
 391  * xmlNewEntity:
 392  * @doc:  the document
 393  * @name:  the entity name
 394  * @type:  the entity type XML_xxx_yyy_ENTITY
 395  * @ExternalID:  the entity external ID if available
 396  * @SystemID:  the entity system ID if available
 397  * @content:  the entity content
 398  *
 399  * Create a new entity, this differs from xmlAddDocEntity() that if
 400  * the document is NULL or has no internal subset defined, then an
 401  * unlinked entity structure will be returned, it is then the responsability
 402  * of the caller to link it to the document later or free it when not needed
 403  * anymore.
 404  *
 405  * Returns a pointer to the entity or NULL in case of error
 406  */
 407 xmlEntityPtr
 408 xmlNewEntity(xmlDocPtr doc, const xmlChar *name, int type,
 409              const xmlChar *ExternalID, const xmlChar *SystemID,
 410              const xmlChar *content) {
 411     xmlEntityPtr ret;
 412     xmlDictPtr dict;
 413
 414     if ((doc != NULL) && (doc->intSubset != NULL)) {
 415         return(xmlAddDocEntity(doc, name, type, ExternalID, SystemID, content));
 416     }
 417     if (doc != NULL)
 418         dict = doc->dict;
 419     else
 420         dict = NULL;
 421     ret = xmlCreateEntity(dict, name, type, ExternalID, SystemID, content);
 422     if (ret == NULL)
 423         return(NULL);
 424     ret->doc = doc;
 425     return(ret);
 426 }
 427
 428 /**
 429  * xmlGetEntityFromTable:
 430  * @table:  an entity table
 431  * @name:  the entity name
 432  * @parameter:  look for parameter entities
 433  *
 434  * Do an entity lookup in the table.
 435  * returns the corresponding parameter entity, if found.
 436  *
 437  * Returns A pointer to the entity structure or NULL if not found.
 438  */
 439 static xmlEntityPtr
 440 xmlGetEntityFromTable(xmlEntitiesTablePtr table, const xmlChar *name) {
 441     return((xmlEntityPtr) xmlHashLookup(table, name));
 442 }
 443
 444 /**
 445  * xmlGetParameterEntity:
 446  * @doc:  the document referencing the entity
 447  * @name:  the entity name
 448  *
 449  * Do an entity lookup in the internal and external subsets and
 450  * returns the corresponding parameter entity, if found.
 451  *
 452  * Returns A pointer to the entity structure or NULL if not found.
 453  */
 454 xmlEntityPtr
 455 xmlGetParameterEntity(xmlDocPtr doc, const xmlChar *name) {
 456     xmlEntitiesTablePtr table;
 457     xmlEntityPtr ret;
 458
 459     if (doc == NULL)
 460         return(NULL);
 461     if ((doc->intSubset != NULL) && (doc->intSubset->pentities != NULL)) {
 462         table = (xmlEntitiesTablePtr) doc->intSubset->pentities;
 463         ret = xmlGetEntityFromTable(table, name);
 464         if (ret != NULL)
 465             return(ret);
 466     }
 467     if ((doc->extSubset != NULL) && (doc->extSubset->pentities != NULL)) {
 468         table = (xmlEntitiesTablePtr) doc->extSubset->pentities;
 469         return(xmlGetEntityFromTable(table, name));
 470     }
 471     return(NULL);
 472 }
 473
 474 /**
 475  * xmlGetDtdEntity:
 476  * @doc:  the document referencing the entity
 477  * @name:  the entity name
 478  *
 479  * Do an entity lookup in the DTD entity hash table and
 480  * returns the corresponding entity, if found.
 481  * Note: the first argument is the document node, not the DTD node.
 482  *
 483  * Returns A pointer to the entity structure or NULL if not found.
 484  */
 485 xmlEntityPtr
 486 xmlGetDtdEntity(xmlDocPtr doc, const xmlChar *name) {
 487     xmlEntitiesTablePtr table;
 488
 489     if (doc == NULL)
 490         return(NULL);
 491     if ((doc->extSubset != NULL) && (doc->extSubset->entities != NULL)) {
 492         table = (xmlEntitiesTablePtr) doc->extSubset->entities;
 493         return(xmlGetEntityFromTable(table, name));
 494     }
 495     return(NULL);
 496 }
 497
 498 /**
 499  * xmlGetDocEntity:
 500  * @doc:  the document referencing the entity
 501  * @name:  the entity name
 502  *
 503  * Do an entity lookup in the document entity hash table and
 504  * returns the corresponding entity, otherwise a lookup is done
 505  * in the predefined entities too.
 506  *
 507  * Returns A pointer to the entity structure or NULL if not found.
 508  */
 509 xmlEntityPtr
 510 xmlGetDocEntity(const xmlDoc *doc, const xmlChar *name) {
 511     xmlEntityPtr cur;
 512     xmlEntitiesTablePtr table;
 513
 514     if (doc != NULL) {
 515         if ((doc->intSubset != NULL) && (doc->intSubset->entities != NULL)) {
 516             table = (xmlEntitiesTablePtr) doc->intSubset->entities;
 517             cur = xmlGetEntityFromTable(table, name);
 518             if (cur != NULL)
 519                 return(cur);
 520         }
 521         if (doc->standalone != 1) {
 522             if ((doc->extSubset != NULL) &&
 523                 (doc->extSubset->entities != NULL)) {
 524                 table = (xmlEntitiesTablePtr) doc->extSubset->entities;
 525                 cur = xmlGetEntityFromTable(table, name);
 526                 if (cur != NULL)
 527                     return(cur);
 528             }
 529         }
 530     }
 531     return(xmlGetPredefinedEntity(name));
 532 }
 533
 534 /*
 535  * Macro used to grow the current buffer.
 536  */
 537 #define growBufferReentrant() {                                         \
 538     xmlChar *tmp;                                                       \
 539     size_t new_size = buffer_size * 2;                                  \
 540     if (new_size < buffer_size) goto mem_error;                         \
 541     tmp = (xmlChar *) xmlRealloc(buffer, new_size);                     \
 542     if (tmp == NULL) goto mem_error;                                    \
 543     buffer = tmp;                                                       \
 544     buffer_size = new_size;                                             \
 545 }
 546
 547 /**
 548  * xmlEncodeEntitiesInternal:
 549  * @doc:  the document containing the string
 550  * @input:  A string to convert to XML.
 551  * @attr: are we handling an atrbute value
 552  *
 553  * Do a global encoding of a string, replacing the predefined entities
 554  * and non ASCII values with their entities and CharRef counterparts.
 555  * Contrary to xmlEncodeEntities, this routine is reentrant, and result
 556  * must be deallocated.
 557  *
 558  * Returns A newly allocated string with the substitution done.
 559  */
 560 static xmlChar *
 561 xmlEncodeEntitiesInternal(xmlDocPtr doc, const xmlChar *input, int attr) {
 562     const xmlChar *cur = input;
 563     xmlChar *buffer = NULL;
 564     xmlChar *out = NULL;
 565     size_t buffer_size = 0;
 566     int html = 0;
 567
 568     if (input == NULL) return(NULL);
 569     if (doc != NULL)
 570         html = (doc->type == XML_HTML_DOCUMENT_NODE);
 571
 572     /*
 573      * allocate an translation buffer.
 574      */
 575     buffer_size = 1000;
 576     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
 577     if (buffer == NULL) {
 578         xmlEntitiesErrMemory("xmlEncodeEntities: malloc failed");
 579         return(NULL);
 580     }
 581     out = buffer;
 582
 583     while (*cur != '\0') {
 584         size_t indx = out - buffer;
 585         if (indx + 100 > buffer_size) {
 586
 587             growBufferReentrant();
 588             out = &buffer[indx];
 589         }
 590
 591         /*
 592          * By default one have to encode at least '<', '>', '"' and '&' !
 593          */
 594         if (*cur == '<') {
 595             const xmlChar *end;
 596
 597             /*
 598              * Special handling of server side include in HTML attributes
 599              */
 600             if (html && attr &&
 601                 (cur[1] == '!') && (cur[2] == '-') && (cur[3] == '-') &&
 602                 ((end = xmlStrstr(cur, BAD_CAST "-->")) != NULL)) {
 603                 while (cur != end) {
 604                     *out++ = *cur++;
 605                     indx = out - buffer;
 606                     if (indx + 100 > buffer_size) {
 607                         growBufferReentrant();
 608                         out = &buffer[indx];
 609                     }
 610                 }
 611                 *out++ = *cur++;
 612                 *out++ = *cur++;
 613                 *out++ = *cur++;
 614                 continue;
 615             }
 616             *out++ = '&';
 617             *out++ = 'l';
 618             *out++ = 't';
 619             *out++ = ';';
 620         } else if (*cur == '>') {
 621             *out++ = '&';
 622             *out++ = 'g';
 623             *out++ = 't';
 624             *out++ = ';';
 625         } else if (*cur == '&') {
 626             /*
 627              * Special handling of &{...} construct from HTML 4, see
 628              * http://www.w3.org/TR/html401/appendix/notes.html#h-B.7.1
 629              */
 630             if (html && attr && (cur[1] == '{') &&
 631                 (strchr((const char *) cur, '}'))) {
 632                 while (*cur != '}') {
 633                     *out++ = *cur++;
 634                     indx = out - buffer;
 635                     if (indx + 100 > buffer_size) {
 636                         growBufferReentrant();
 637                         out = &buffer[indx];
 638                     }
 639                 }
 640                 *out++ = *cur++;
 641                 continue;
 642             }
 643             *out++ = '&';
 644             *out++ = 'a';
 645             *out++ = 'm';
 646             *out++ = 'p';
 647             *out++ = ';';
 648         } else if (((*cur >= 0x20) && (*cur < 0x80)) ||
 649             (*cur == '\n') || (*cur == '\t') || ((html) && (*cur == '\r'))) {
 650             /*
 651              * default case, just copy !
 652              */
 653             *out++ = *cur;
 654         } else if (*cur >= 0x80) {
 655             if (((doc != NULL) && (doc->encoding != NULL)) || (html)) {
 656                 /*
 657                  * Bjørn Reese <br@sseusa.com> provided the patch
 658                 xmlChar xc;
 659                 xc = (*cur & 0x3F) << 6;
 660                 if (cur[1] != 0) {
 661                     xc += *(++cur) & 0x3F;
 662                     *out++ = xc;
 663                 } else
 664                  */
 665                 *out++ = *cur;
 666             } else {
 667                 /*
 668                  * We assume we have UTF-8 input.
 669                  */
 670                 char buf[11], *ptr;
 671                 int val = 0, l = 1;
 672
 673                 if (*cur < 0xC0) {
 674                     xmlEntitiesErr(XML_CHECK_NOT_UTF8,
 675                             "xmlEncodeEntities: input not UTF-8");
 676                     if (doc != NULL)
 677                         doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
 678                     snprintf(buf, sizeof(buf), "&#%d;", *cur);
 679                     buf[sizeof(buf) - 1] = 0;
 680                     ptr = buf;
 681                     while (*ptr != 0) *out++ = *ptr++;
 682                     cur++;
 683                     continue;
 684                 } else if (*cur < 0xE0) {
 685                     val = (cur[0]) & 0x1F;
 686                     val <<= 6;
 687                     val |= (cur[1]) & 0x3F;
 688                     l = 2;
 689                 } else if (*cur < 0xF0) {
 690                     val = (cur[0]) & 0x0F;
 691                     val <<= 6;
 692                     val |= (cur[1]) & 0x3F;
 693                     val <<= 6;
 694                     val |= (cur[2]) & 0x3F;
 695                     l = 3;
 696                 } else if (*cur < 0xF8) {
 697                     val = (cur[0]) & 0x07;
 698                     val <<= 6;
 699                     val |= (cur[1]) & 0x3F;
 700                     val <<= 6;
 701                     val |= (cur[2]) & 0x3F;
 702                     val <<= 6;
 703                     val |= (cur[3]) & 0x3F;
 704                     l = 4;
 705                 }
 706                 if ((l == 1) || (!IS_CHAR(val))) {
 707                     xmlEntitiesErr(XML_ERR_INVALID_CHAR,
 708                         "xmlEncodeEntities: char out of range\n");
 709                     if (doc != NULL)
 710                         doc->encoding = xmlStrdup(BAD_CAST "ISO-8859-1");
 711                     snprintf(buf, sizeof(buf), "&#%d;", *cur);
 712                     buf[sizeof(buf) - 1] = 0;
 713                     ptr = buf;
 714                     while (*ptr != 0) *out++ = *ptr++;
 715                     cur++;
 716                     continue;
 717                 }
 718                 /*
 719                  * We could do multiple things here. Just save as a char ref
 720                  */
 721                 snprintf(buf, sizeof(buf), "&#x%X;", val);
 722                 buf[sizeof(buf) - 1] = 0;
 723                 ptr = buf;
 724                 while (*ptr != 0) *out++ = *ptr++;
 725                 cur += l;
 726                 continue;
 727             }
 728         } else if (IS_BYTE_CHAR(*cur)) {
 729             char buf[11], *ptr;
 730
 731             snprintf(buf, sizeof(buf), "&#%d;", *cur);
 732             buf[sizeof(buf) - 1] = 0;
 733             ptr = buf;
 734             while (*ptr != 0) *out++ = *ptr++;
 735         }
 736         cur++;
 737     }
 738     *out = 0;
 739     return(buffer);
 740
 741 mem_error:
 742     xmlEntitiesErrMemory("xmlEncodeEntities: realloc failed");
 743     xmlFree(buffer);
 744     return(NULL);
 745 }
 746
 747 /**
 748  * xmlEncodeAttributeEntities:
 749  * @doc:  the document containing the string
 750  * @input:  A string to convert to XML.
 751  *
 752  * Do a global encoding of a string, replacing the predefined entities
 753  * and non ASCII values with their entities and CharRef counterparts for
 754  * attribute values.
 755  *
 756  * Returns A newly allocated string with the substitution done.
 757  */
 758 xmlChar *
 759 xmlEncodeAttributeEntities(xmlDocPtr doc, const xmlChar *input) {
 760     return xmlEncodeEntitiesInternal(doc, input, 1);
 761 }
 762
 763 /**
 764  * xmlEncodeEntitiesReentrant:
 765  * @doc:  the document containing the string
 766  * @input:  A string to convert to XML.
 767  *
 768  * Do a global encoding of a string, replacing the predefined entities
 769  * and non ASCII values with their entities and CharRef counterparts.
 770  * Contrary to xmlEncodeEntities, this routine is reentrant, and result
 771  * must be deallocated.
 772  *
 773  * Returns A newly allocated string with the substitution done.
 774  */
 775 xmlChar *
 776 xmlEncodeEntitiesReentrant(xmlDocPtr doc, const xmlChar *input) {
 777     return xmlEncodeEntitiesInternal(doc, input, 0);
 778 }
 779
 780 /**
 781  * xmlEncodeSpecialChars:
 782  * @doc:  the document containing the string
 783  * @input:  A string to convert to XML.
 784  *
 785  * Do a global encoding of a string, replacing the predefined entities
 786  * this routine is reentrant, and result must be deallocated.
 787  *
 788  * Returns A newly allocated string with the substitution done.
 789  */
 790 xmlChar *
 791 xmlEncodeSpecialChars(const xmlDoc *doc ATTRIBUTE_UNUSED, const xmlChar *input) {
 792     const xmlChar *cur = input;
 793     xmlChar *buffer = NULL;
 794     xmlChar *out = NULL;
 795     size_t buffer_size = 0;
 796     if (input == NULL) return(NULL);
 797
 798     /*
 799      * allocate an translation buffer.
 800      */
 801     buffer_size = 1000;
 802     buffer = (xmlChar *) xmlMalloc(buffer_size * sizeof(xmlChar));
 803     if (buffer == NULL) {
 804         xmlEntitiesErrMemory("xmlEncodeSpecialChars: malloc failed");
 805         return(NULL);
 806     }
 807     out = buffer;
 808
 809     while (*cur != '\0') {
 810         size_t indx = out - buffer;
 811         if (indx + 10 > buffer_size) {
 812
 813             growBufferReentrant();
 814             out = &buffer[indx];
 815         }
 816
 817         /*
 818          * By default one have to encode at least '<', '>', '"' and '&' !
 819          */
 820         if (*cur == '<') {
 821             *out++ = '&';
 822             *out++ = 'l';
 823             *out++ = 't';
 824             *out++ = ';';
 825         } else if (*cur == '>') {
 826             *out++ = '&';
 827             *out++ = 'g';
 828             *out++ = 't';
 829             *out++ = ';';
 830         } else if (*cur == '&') {
 831             *out++ = '&';
 832             *out++ = 'a';
 833             *out++ = 'm';
 834             *out++ = 'p';
 835             *out++ = ';';
 836         } else if (*cur == '"') {
 837             *out++ = '&';
 838             *out++ = 'q';
 839             *out++ = 'u';
 840             *out++ = 'o';
 841             *out++ = 't';
 842             *out++ = ';';
 843         } else if (*cur == '\r') {
 844             *out++ = '&';
 845             *out++ = '#';
 846             *out++ = '1';
 847             *out++ = '3';
 848             *out++ = ';';
 849         } else {
 850             /*
 851              * Works because on UTF-8, all extended sequences cannot
 852              * result in bytes in the ASCII range.
 853              */
 854             *out++ = *cur;
 855         }
 856         cur++;
 857     }
 858     *out = 0;
 859     return(buffer);
 860
 861 mem_error:
 862     xmlEntitiesErrMemory("xmlEncodeSpecialChars: realloc failed");
 863     xmlFree(buffer);
 864     return(NULL);
 865 }
 866
 867 /**
 868  * xmlCreateEntitiesTable:
 869  *
 870  * create and initialize an empty entities hash table.
 871  * This really doesn't make sense and should be deprecated
 872  *
 873  * Returns the xmlEntitiesTablePtr just created or NULL in case of error.
 874  */
 875 xmlEntitiesTablePtr
 876 xmlCreateEntitiesTable(void) {
 877     return((xmlEntitiesTablePtr) xmlHashCreate(0));
 878 }
 879
 880 /**
 881  * xmlFreeEntityWrapper:
 882  * @entity:  An entity
 883  * @name:  its name
 884  *
 885  * Deallocate the memory used by an entities in the hash table.
 886  */
 887 static void
 888 xmlFreeEntityWrapper(xmlEntityPtr entity,
 889                        const xmlChar *name ATTRIBUTE_UNUSED) {
 890     if (entity != NULL)
 891         xmlFreeEntity(entity);
 892 }
 893
 894 /**
 895  * xmlFreeEntitiesTable:
 896  * @table:  An entity table
 897  *
 898  * Deallocate the memory used by an entities hash table.
 899  */
 900 void
 901 xmlFreeEntitiesTable(xmlEntitiesTablePtr table) {
 902     xmlHashFree(table, (xmlHashDeallocator) xmlFreeEntityWrapper);
 903 }
 904
 905 #ifdef LIBXML_TREE_ENABLED
 906 /**
 907  * xmlCopyEntity:
 908  * @ent:  An entity
 909  *
 910  * Build a copy of an entity
 911  *
 912  * Returns the new xmlEntitiesPtr or NULL in case of error.
 913  */
 914 static xmlEntityPtr
 915 xmlCopyEntity(xmlEntityPtr ent) {
 916     xmlEntityPtr cur;
 917
 918     cur = (xmlEntityPtr) xmlMalloc(sizeof(xmlEntity));
 919     if (cur == NULL) {
 920         xmlEntitiesErrMemory("xmlCopyEntity:: malloc failed");
 921         return(NULL);
 922     }
 923     memset(cur, 0, sizeof(xmlEntity));
 924     cur->type = XML_ENTITY_DECL;
 925
 926     cur->etype = ent->etype;
 927     if (ent->name != NULL)
 928         cur->name = xmlStrdup(ent->name);
 929     if (ent->ExternalID != NULL)
 930         cur->ExternalID = xmlStrdup(ent->ExternalID);
 931     if (ent->SystemID != NULL)
 932         cur->SystemID = xmlStrdup(ent->SystemID);
 933     if (ent->content != NULL)
 934         cur->content = xmlStrdup(ent->content);
 935     if (ent->orig != NULL)
 936         cur->orig = xmlStrdup(ent->orig);
 937     if (ent->URI != NULL)
 938         cur->URI = xmlStrdup(ent->URI);
 939     return(cur);
 940 }
 941
 942 /**
 943  * xmlCopyEntitiesTable:
 944  * @table:  An entity table
 945  *
 946  * Build a copy of an entity table.
 947  *
 948  * Returns the new xmlEntitiesTablePtr or NULL in case of error.
 949  */
 950 xmlEntitiesTablePtr
 951 xmlCopyEntitiesTable(xmlEntitiesTablePtr table) {
 952     return(xmlHashCopy(table, (xmlHashCopier) xmlCopyEntity));
 953 }
 954 #endif /* LIBXML_TREE_ENABLED */
 955
 956 #ifdef LIBXML_OUTPUT_ENABLED
 957
 958 /**
 959  * xmlDumpEntityContent:
 960  * @buf:  An XML buffer.
 961  * @content:  The entity content.
 962  *
 963  * This will dump the quoted string value, taking care of the special
 964  * treatment required by %
 965  */
 966 static void
 967 xmlDumpEntityContent(xmlBufferPtr buf, const xmlChar *content) {
 968     if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return;
 969     if (xmlStrchr(content, '%')) {
 970         const xmlChar * base, *cur;
 971
 972         xmlBufferCCat(buf, "\"");
 973         base = cur = content;
 974         while (*cur != 0) {
 975             if (*cur == '"') {
 976                 if (base != cur)
 977                     xmlBufferAdd(buf, base, cur - base);
 978                 xmlBufferAdd(buf, BAD_CAST "&quot;", 6);
 979                 cur++;
 980                 base = cur;
 981             } else if (*cur == '%') {
 982                 if (base != cur)
 983                     xmlBufferAdd(buf, base, cur - base);
 984                 xmlBufferAdd(buf, BAD_CAST "&#x25;", 6);
 985                 cur++;
 986                 base = cur;
 987             } else {
 988                 cur++;
 989             }
 990         }
 991         if (base != cur)
 992             xmlBufferAdd(buf, base, cur - base);
 993         xmlBufferCCat(buf, "\"");
 994     } else {
 995         xmlBufferWriteQuotedString(buf, content);
 996     }
 997 }
 998
 999 /**
1000  * xmlDumpEntityDecl:
1001  * @buf:  An XML buffer.
1002  * @ent:  An entity table
1003  *
1004  * This will dump the content of the entity table as an XML DTD definition
1005  */
1006 void
1007 xmlDumpEntityDecl(xmlBufferPtr buf, xmlEntityPtr ent) {
1008     if ((buf == NULL) || (ent == NULL)) return;
1009     switch (ent->etype) {
1010         case XML_INTERNAL_GENERAL_ENTITY:
1011             xmlBufferWriteChar(buf, "<!ENTITY ");
1012             xmlBufferWriteCHAR(buf, ent->name);
1013             xmlBufferWriteChar(buf, " ");
1014             if (ent->orig != NULL)
1015                 xmlBufferWriteQuotedString(buf, ent->orig);
1016             else
1017                 xmlDumpEntityContent(buf, ent->content);
1018             xmlBufferWriteChar(buf, ">\n");
1019             break;
1020         case XML_EXTERNAL_GENERAL_PARSED_ENTITY:
1021             xmlBufferWriteChar(buf, "<!ENTITY ");
1022             xmlBufferWriteCHAR(buf, ent->name);
1023             if (ent->ExternalID != NULL) {
1024                  xmlBufferWriteChar(buf, " PUBLIC ");
1025                  xmlBufferWriteQuotedString(buf, ent->ExternalID);
1026                  xmlBufferWriteChar(buf, " ");
1027                  xmlBufferWriteQuotedString(buf, ent->SystemID);
1028             } else {
1029                  xmlBufferWriteChar(buf, " SYSTEM ");
1030                  xmlBufferWriteQuotedString(buf, ent->SystemID);
1031             }
1032             xmlBufferWriteChar(buf, ">\n");
1033             break;
1034         case XML_EXTERNAL_GENERAL_UNPARSED_ENTITY:
1035             xmlBufferWriteChar(buf, "<!ENTITY ");
1036             xmlBufferWriteCHAR(buf, ent->name);
1037             if (ent->ExternalID != NULL) {
1038                  xmlBufferWriteChar(buf, " PUBLIC ");
1039                  xmlBufferWriteQuotedString(buf, ent->ExternalID);
1040                  xmlBufferWriteChar(buf, " ");
1041                  xmlBufferWriteQuotedString(buf, ent->SystemID);
1042             } else {
1043                  xmlBufferWriteChar(buf, " SYSTEM ");
1044                  xmlBufferWriteQuotedString(buf, ent->SystemID);
1045             }
1046             if (ent->content != NULL) { /* Should be true ! */
1047                 xmlBufferWriteChar(buf, " NDATA ");
1048                 if (ent->orig != NULL)
1049                     xmlBufferWriteCHAR(buf, ent->orig);
1050                 else
1051                     xmlBufferWriteCHAR(buf, ent->content);
1052             }
1053             xmlBufferWriteChar(buf, ">\n");
1054             break;
1055         case XML_INTERNAL_PARAMETER_ENTITY:
1056             xmlBufferWriteChar(buf, "<!ENTITY % ");
1057             xmlBufferWriteCHAR(buf, ent->name);
1058             xmlBufferWriteChar(buf, " ");
1059             if (ent->orig == NULL)
1060                 xmlDumpEntityContent(buf, ent->content);
1061             else
1062                 xmlBufferWriteQuotedString(buf, ent->orig);
1063             xmlBufferWriteChar(buf, ">\n");
1064             break;
1065         case XML_EXTERNAL_PARAMETER_ENTITY:
1066             xmlBufferWriteChar(buf, "<!ENTITY % ");
1067             xmlBufferWriteCHAR(buf, ent->name);
1068             if (ent->ExternalID != NULL) {
1069                  xmlBufferWriteChar(buf, " PUBLIC ");
1070                  xmlBufferWriteQuotedString(buf, ent->ExternalID);
1071                  xmlBufferWriteChar(buf, " ");
1072                  xmlBufferWriteQuotedString(buf, ent->SystemID);
1073             } else {
1074                  xmlBufferWriteChar(buf, " SYSTEM ");
1075                  xmlBufferWriteQuotedString(buf, ent->SystemID);
1076             }
1077             xmlBufferWriteChar(buf, ">\n");
1078             break;
1079         default:
1080             xmlEntitiesErr(XML_DTD_UNKNOWN_ENTITY,
1081                 "xmlDumpEntitiesDecl: internal: unknown type entity type");
1082     }
1083 }
1084
1085 /**
1086  * xmlDumpEntityDeclScan:
1087  * @ent:  An entity table
1088  * @buf:  An XML buffer.
1089  *
1090  * When using the hash table scan function, arguments need to be reversed
1091  */
1092 static void
1093 xmlDumpEntityDeclScan(xmlEntityPtr ent, xmlBufferPtr buf) {
1094     xmlDumpEntityDecl(buf, ent);
1095 }
1096
1097 /**
1098  * xmlDumpEntitiesTable:
1099  * @buf:  An XML buffer.
1100  * @table:  An entity table
1101  *
1102  * This will dump the content of the entity table as an XML DTD definition
1103  */
1104 void
1105 xmlDumpEntitiesTable(xmlBufferPtr buf, xmlEntitiesTablePtr table) {
1106     xmlHashScan(table, (xmlHashScanner)xmlDumpEntityDeclScan, buf);
1107 }
1108 #endif /* LIBXML_OUTPUT_ENABLED */
1109 #define bottom_entities
1110 #include "elfgcchack.h"