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