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