c8193376385f1cca7e62cdb3c1e601e785f6b627
[reactos.git] / sdk / lib / 3rdparty / libxml2 / 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"