1 /*
2  * HTMLtree.c : implementation of access function for an HTML tree.
3  *
4  * See Copyright for the status of this software.
5  *
6  * daniel@veillard.com
7  */
8 
9 
10 #define IN_LIBXML
11 #include "libxml.h"
12 #ifdef LIBXML_HTML_ENABLED
13 
14 #include <string.h> /* for memset() only ! */
15 
16 #ifdef HAVE_CTYPE_H
17 #include <ctype.h>
18 #endif
19 #ifdef HAVE_STDLIB_H
20 #include <stdlib.h>
21 #endif
22 
23 #include <libxml/xmlmemory.h>
24 #include <libxml/HTMLparser.h>
25 #include <libxml/HTMLtree.h>
26 #include <libxml/entities.h>
27 #include <libxml/valid.h>
28 #include <libxml/xmlerror.h>
29 #include <libxml/parserInternals.h>
30 #include <libxml/globals.h>
31 #include <libxml/uri.h>
32 
33 #include "buf.h"
34 
35 /************************************************************************
36  *									*
37  *		Getting/Setting encoding meta tags			*
38  *									*
39  ************************************************************************/
40 
41 /**
42  * htmlGetMetaEncoding:
43  * @doc:  the document
44  *
45  * Encoding definition lookup in the Meta tags
46  *
47  * Returns the current encoding as flagged in the HTML source
48  */
49 const xmlChar *
htmlGetMetaEncoding(htmlDocPtr doc)50 htmlGetMetaEncoding(htmlDocPtr doc) {
51     htmlNodePtr cur;
52     const xmlChar *content;
53     const xmlChar *encoding;
54 
55     if (doc == NULL)
56 	return(NULL);
57     cur = doc->children;
58 
59     /*
60      * Search the html
61      */
62     while (cur != NULL) {
63 	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
64 	    if (xmlStrEqual(cur->name, BAD_CAST"html"))
65 		break;
66 	    if (xmlStrEqual(cur->name, BAD_CAST"head"))
67 		goto found_head;
68 	    if (xmlStrEqual(cur->name, BAD_CAST"meta"))
69 		goto found_meta;
70 	}
71 	cur = cur->next;
72     }
73     if (cur == NULL)
74 	return(NULL);
75     cur = cur->children;
76 
77     /*
78      * Search the head
79      */
80     while (cur != NULL) {
81 	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
82 	    if (xmlStrEqual(cur->name, BAD_CAST"head"))
83 		break;
84 	    if (xmlStrEqual(cur->name, BAD_CAST"meta"))
85 		goto found_meta;
86 	}
87 	cur = cur->next;
88     }
89     if (cur == NULL)
90 	return(NULL);
91 found_head:
92     cur = cur->children;
93 
94     /*
95      * Search the meta elements
96      */
97 found_meta:
98     while (cur != NULL) {
99 	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
100 	    if (xmlStrEqual(cur->name, BAD_CAST"meta")) {
101 		xmlAttrPtr attr = cur->properties;
102 		int http;
103 		const xmlChar *value;
104 
105 		content = NULL;
106 		http = 0;
107 		while (attr != NULL) {
108 		    if ((attr->children != NULL) &&
109 		        (attr->children->type == XML_TEXT_NODE) &&
110 		        (attr->children->next == NULL)) {
111 			value = attr->children->content;
112 			if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
113 			 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
114 			    http = 1;
115 			else if ((value != NULL)
116 			 && (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
117 			    content = value;
118 			if ((http != 0) && (content != NULL))
119 			    goto found_content;
120 		    }
121 		    attr = attr->next;
122 		}
123 	    }
124 	}
125 	cur = cur->next;
126     }
127     return(NULL);
128 
129 found_content:
130     encoding = xmlStrstr(content, BAD_CAST"charset=");
131     if (encoding == NULL)
132 	encoding = xmlStrstr(content, BAD_CAST"Charset=");
133     if (encoding == NULL)
134 	encoding = xmlStrstr(content, BAD_CAST"CHARSET=");
135     if (encoding != NULL) {
136 	encoding += 8;
137     } else {
138 	encoding = xmlStrstr(content, BAD_CAST"charset =");
139 	if (encoding == NULL)
140 	    encoding = xmlStrstr(content, BAD_CAST"Charset =");
141 	if (encoding == NULL)
142 	    encoding = xmlStrstr(content, BAD_CAST"CHARSET =");
143 	if (encoding != NULL)
144 	    encoding += 9;
145     }
146     if (encoding != NULL) {
147 	while ((*encoding == ' ') || (*encoding == '\t')) encoding++;
148     }
149     return(encoding);
150 }
151 
152 /**
153  * htmlSetMetaEncoding:
154  * @doc:  the document
155  * @encoding:  the encoding string
156  *
157  * Sets the current encoding in the Meta tags
158  * NOTE: this will not change the document content encoding, just
159  * the META flag associated.
160  *
161  * Returns 0 in case of success and -1 in case of error
162  */
163 int
htmlSetMetaEncoding(htmlDocPtr doc,const xmlChar * encoding)164 htmlSetMetaEncoding(htmlDocPtr doc, const xmlChar *encoding) {
165     htmlNodePtr cur, meta = NULL, head = NULL;
166     const xmlChar *content = NULL;
167     char newcontent[100];
168 
169     newcontent[0] = 0;
170 
171     if (doc == NULL)
172 	return(-1);
173 
174     /* html isn't a real encoding it's just libxml2 way to get entities */
175     if (!xmlStrcasecmp(encoding, BAD_CAST "html"))
176         return(-1);
177 
178     if (encoding != NULL) {
179 	snprintf(newcontent, sizeof(newcontent), "text/html; charset=%s",
180                 (char *)encoding);
181 	newcontent[sizeof(newcontent) - 1] = 0;
182     }
183 
184     cur = doc->children;
185 
186     /*
187      * Search the html
188      */
189     while (cur != NULL) {
190 	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
191 	    if (xmlStrcasecmp(cur->name, BAD_CAST"html") == 0)
192 		break;
193 	    if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
194 		goto found_head;
195 	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0)
196 		goto found_meta;
197 	}
198 	cur = cur->next;
199     }
200     if (cur == NULL)
201 	return(-1);
202     cur = cur->children;
203 
204     /*
205      * Search the head
206      */
207     while (cur != NULL) {
208 	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
209 	    if (xmlStrcasecmp(cur->name, BAD_CAST"head") == 0)
210 		break;
211 	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
212                 head = cur->parent;
213 		goto found_meta;
214             }
215 	}
216 	cur = cur->next;
217     }
218     if (cur == NULL)
219 	return(-1);
220 found_head:
221     head = cur;
222     if (cur->children == NULL)
223         goto create;
224     cur = cur->children;
225 
226 found_meta:
227     /*
228      * Search and update all the remaining the meta elements carrying
229      * encoding informations
230      */
231     while (cur != NULL) {
232 	if ((cur->type == XML_ELEMENT_NODE) && (cur->name != NULL)) {
233 	    if (xmlStrcasecmp(cur->name, BAD_CAST"meta") == 0) {
234 		xmlAttrPtr attr = cur->properties;
235 		int http;
236 		const xmlChar *value;
237 
238 		content = NULL;
239 		http = 0;
240 		while (attr != NULL) {
241 		    if ((attr->children != NULL) &&
242 		        (attr->children->type == XML_TEXT_NODE) &&
243 		        (attr->children->next == NULL)) {
244 			value = attr->children->content;
245 			if ((!xmlStrcasecmp(attr->name, BAD_CAST"http-equiv"))
246 			 && (!xmlStrcasecmp(value, BAD_CAST"Content-Type")))
247 			    http = 1;
248 			else
249                         {
250                            if ((value != NULL) &&
251                                (!xmlStrcasecmp(attr->name, BAD_CAST"content")))
252 			       content = value;
253                         }
254 		        if ((http != 0) && (content != NULL))
255 			    break;
256 		    }
257 		    attr = attr->next;
258 		}
259 		if ((http != 0) && (content != NULL)) {
260 		    meta = cur;
261 		    break;
262 		}
263 
264 	    }
265 	}
266 	cur = cur->next;
267     }
268 create:
269     if (meta == NULL) {
270         if ((encoding != NULL) && (head != NULL)) {
271             /*
272              * Create a new Meta element with the right attributes
273              */
274 
275             meta = xmlNewDocNode(doc, NULL, BAD_CAST"meta", NULL);
276             if (head->children == NULL)
277                 xmlAddChild(head, meta);
278             else
279                 xmlAddPrevSibling(head->children, meta);
280             xmlNewProp(meta, BAD_CAST"http-equiv", BAD_CAST"Content-Type");
281             xmlNewProp(meta, BAD_CAST"content", BAD_CAST newcontent);
282         }
283     } else {
284         /* remove the meta tag if NULL is passed */
285         if (encoding == NULL) {
286             xmlUnlinkNode(meta);
287             xmlFreeNode(meta);
288         }
289         /* change the document only if there is a real encoding change */
290         else if (xmlStrcasestr(content, encoding) == NULL) {
291             xmlSetProp(meta, BAD_CAST"content", BAD_CAST newcontent);
292         }
293     }
294 
295 
296     return(0);
297 }
298 
299 /**
300  * booleanHTMLAttrs:
301  *
302  * These are the HTML attributes which will be output
303  * in minimized form, i.e. <option selected="selected"> will be
304  * output as <option selected>, as per XSLT 1.0 16.2 "HTML Output Method"
305  *
306  */
307 static const char* htmlBooleanAttrs[] = {
308   "checked", "compact", "declare", "defer", "disabled", "ismap",
309   "multiple", "nohref", "noresize", "noshade", "nowrap", "readonly",
310   "selected", NULL
311 };
312 
313 
314 /**
315  * htmlIsBooleanAttr:
316  * @name:  the name of the attribute to check
317  *
318  * Determine if a given attribute is a boolean attribute.
319  *
320  * returns: false if the attribute is not boolean, true otherwise.
321  */
322 int
htmlIsBooleanAttr(const xmlChar * name)323 htmlIsBooleanAttr(const xmlChar *name)
324 {
325     int i = 0;
326 
327     while (htmlBooleanAttrs[i] != NULL) {
328         if (xmlStrcasecmp((const xmlChar *)htmlBooleanAttrs[i], name) == 0)
329             return 1;
330         i++;
331     }
332     return 0;
333 }
334 
335 #ifdef LIBXML_OUTPUT_ENABLED
336 /*
337  * private routine exported from xmlIO.c
338  */
339 xmlOutputBufferPtr
340 xmlAllocOutputBufferInternal(xmlCharEncodingHandlerPtr encoder);
341 /************************************************************************
342  *									*
343  *			Output error handlers				*
344  *									*
345  ************************************************************************/
346 /**
347  * htmlSaveErrMemory:
348  * @extra:  extra informations
349  *
350  * Handle an out of memory condition
351  */
352 static void
htmlSaveErrMemory(const char * extra)353 htmlSaveErrMemory(const char *extra)
354 {
355     __xmlSimpleError(XML_FROM_OUTPUT, XML_ERR_NO_MEMORY, NULL, NULL, extra);
356 }
357 
358 /**
359  * htmlSaveErr:
360  * @code:  the error number
361  * @node:  the location of the error.
362  * @extra:  extra informations
363  *
364  * Handle an out of memory condition
365  */
366 static void
htmlSaveErr(int code,xmlNodePtr node,const char * extra)367 htmlSaveErr(int code, xmlNodePtr node, const char *extra)
368 {
369     const char *msg = NULL;
370 
371     switch(code) {
372         case XML_SAVE_NOT_UTF8:
373 	    msg = "string is not in UTF-8\n";
374 	    break;
375 	case XML_SAVE_CHAR_INVALID:
376 	    msg = "invalid character value\n";
377 	    break;
378 	case XML_SAVE_UNKNOWN_ENCODING:
379 	    msg = "unknown encoding %s\n";
380 	    break;
381 	case XML_SAVE_NO_DOCTYPE:
382 	    msg = "HTML has no DOCTYPE\n";
383 	    break;
384 	default:
385 	    msg = "unexpected error number\n";
386     }
387     __xmlSimpleError(XML_FROM_OUTPUT, code, node, msg, extra);
388 }
389 
390 /************************************************************************
391  *									*
392  *		Dumping HTML tree content to a simple buffer		*
393  *									*
394  ************************************************************************/
395 
396 /**
397  * htmlBufNodeDumpFormat:
398  * @buf:  the xmlBufPtr output
399  * @doc:  the document
400  * @cur:  the current node
401  * @format:  should formatting spaces been added
402  *
403  * Dump an HTML node, recursive behaviour,children are printed too.
404  *
405  * Returns the number of byte written or -1 in case of error
406  */
407 static size_t
htmlBufNodeDumpFormat(xmlBufPtr buf,xmlDocPtr doc,xmlNodePtr cur,int format)408 htmlBufNodeDumpFormat(xmlBufPtr buf, xmlDocPtr doc, xmlNodePtr cur,
409 	           int format) {
410     size_t use;
411     int ret;
412     xmlOutputBufferPtr outbuf;
413 
414     if (cur == NULL) {
415 	return (-1);
416     }
417     if (buf == NULL) {
418 	return (-1);
419     }
420     outbuf = (xmlOutputBufferPtr) xmlMalloc(sizeof(xmlOutputBuffer));
421     if (outbuf == NULL) {
422         htmlSaveErrMemory("allocating HTML output buffer");
423 	return (-1);
424     }
425     memset(outbuf, 0, (size_t) sizeof(xmlOutputBuffer));
426     outbuf->buffer = buf;
427     outbuf->encoder = NULL;
428     outbuf->writecallback = NULL;
429     outbuf->closecallback = NULL;
430     outbuf->context = NULL;
431     outbuf->written = 0;
432 
433     use = xmlBufUse(buf);
434     htmlNodeDumpFormatOutput(outbuf, doc, cur, NULL, format);
435     xmlFree(outbuf);
436     ret = xmlBufUse(buf) - use;
437     return (ret);
438 }
439 
440 /**
441  * htmlNodeDump:
442  * @buf:  the HTML buffer output
443  * @doc:  the document
444  * @cur:  the current node
445  *
446  * Dump an HTML node, recursive behaviour,children are printed too,
447  * and formatting returns are added.
448  *
449  * Returns the number of byte written or -1 in case of error
450  */
451 int
htmlNodeDump(xmlBufferPtr buf,xmlDocPtr doc,xmlNodePtr cur)452 htmlNodeDump(xmlBufferPtr buf, xmlDocPtr doc, xmlNodePtr cur) {
453     xmlBufPtr buffer;
454     size_t ret;
455 
456     if ((buf == NULL) || (cur == NULL))
457         return(-1);
458 
459     xmlInitParser();
460     buffer = xmlBufFromBuffer(buf);
461     if (buffer == NULL)
462         return(-1);
463 
464     ret = htmlBufNodeDumpFormat(buffer, doc, cur, 1);
465 
466     xmlBufBackToBuffer(buffer);
467 
468     if (ret > INT_MAX)
469         return(-1);
470     return((int) ret);
471 }
472 
473 /**
474  * htmlNodeDumpFileFormat:
475  * @out:  the FILE pointer
476  * @doc:  the document
477  * @cur:  the current node
478  * @encoding: the document encoding
479  * @format:  should formatting spaces been added
480  *
481  * Dump an HTML node, recursive behaviour,children are printed too.
482  *
483  * TODO: if encoding == NULL try to save in the doc encoding
484  *
485  * returns: the number of byte written or -1 in case of failure.
486  */
487 int
htmlNodeDumpFileFormat(FILE * out,xmlDocPtr doc,xmlNodePtr cur,const char * encoding,int format)488 htmlNodeDumpFileFormat(FILE *out, xmlDocPtr doc,
489 	               xmlNodePtr cur, const char *encoding, int format) {
490     xmlOutputBufferPtr buf;
491     xmlCharEncodingHandlerPtr handler = NULL;
492     int ret;
493 
494     xmlInitParser();
495 
496     if (encoding != NULL) {
497 	xmlCharEncoding enc;
498 
499 	enc = xmlParseCharEncoding(encoding);
500 	if (enc != XML_CHAR_ENCODING_UTF8) {
501 	    handler = xmlFindCharEncodingHandler(encoding);
502 	    if (handler == NULL)
503 		htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
504 	}
505     }
506 
507     /*
508      * Fallback to HTML or ASCII when the encoding is unspecified
509      */
510     if (handler == NULL)
511 	handler = xmlFindCharEncodingHandler("HTML");
512     if (handler == NULL)
513 	handler = xmlFindCharEncodingHandler("ascii");
514 
515     /*
516      * save the content to a temp buffer.
517      */
518     buf = xmlOutputBufferCreateFile(out, handler);
519     if (buf == NULL) return(0);
520 
521     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
522 
523     ret = xmlOutputBufferClose(buf);
524     return(ret);
525 }
526 
527 /**
528  * htmlNodeDumpFile:
529  * @out:  the FILE pointer
530  * @doc:  the document
531  * @cur:  the current node
532  *
533  * Dump an HTML node, recursive behaviour,children are printed too,
534  * and formatting returns are added.
535  */
536 void
htmlNodeDumpFile(FILE * out,xmlDocPtr doc,xmlNodePtr cur)537 htmlNodeDumpFile(FILE *out, xmlDocPtr doc, xmlNodePtr cur) {
538     htmlNodeDumpFileFormat(out, doc, cur, NULL, 1);
539 }
540 
541 /**
542  * htmlDocDumpMemoryFormat:
543  * @cur:  the document
544  * @mem:  OUT: the memory pointer
545  * @size:  OUT: the memory length
546  * @format:  should formatting spaces been added
547  *
548  * Dump an HTML document in memory and return the xmlChar * and it's size.
549  * It's up to the caller to free the memory.
550  */
551 void
htmlDocDumpMemoryFormat(xmlDocPtr cur,xmlChar ** mem,int * size,int format)552 htmlDocDumpMemoryFormat(xmlDocPtr cur, xmlChar**mem, int *size, int format) {
553     xmlOutputBufferPtr buf;
554     xmlCharEncodingHandlerPtr handler = NULL;
555     const char *encoding;
556 
557     xmlInitParser();
558 
559     if ((mem == NULL) || (size == NULL))
560         return;
561     if (cur == NULL) {
562 	*mem = NULL;
563 	*size = 0;
564 	return;
565     }
566 
567     encoding = (const char *) htmlGetMetaEncoding(cur);
568 
569     if (encoding != NULL) {
570 	xmlCharEncoding enc;
571 
572 	enc = xmlParseCharEncoding(encoding);
573 	if (enc != cur->charset) {
574 	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
575 		/*
576 		 * Not supported yet
577 		 */
578 		*mem = NULL;
579 		*size = 0;
580 		return;
581 	    }
582 
583 	    handler = xmlFindCharEncodingHandler(encoding);
584 	    if (handler == NULL)
585                 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
586 
587 	} else {
588 	    handler = xmlFindCharEncodingHandler(encoding);
589 	}
590     }
591 
592     /*
593      * Fallback to HTML or ASCII when the encoding is unspecified
594      */
595     if (handler == NULL)
596 	handler = xmlFindCharEncodingHandler("HTML");
597     if (handler == NULL)
598 	handler = xmlFindCharEncodingHandler("ascii");
599 
600     buf = xmlAllocOutputBufferInternal(handler);
601     if (buf == NULL) {
602 	*mem = NULL;
603 	*size = 0;
604 	return;
605     }
606 
607     htmlDocContentDumpFormatOutput(buf, cur, NULL, format);
608 
609     xmlOutputBufferFlush(buf);
610     if (buf->conv != NULL) {
611 	*size = xmlBufUse(buf->conv);
612 	*mem = xmlStrndup(xmlBufContent(buf->conv), *size);
613     } else {
614 	*size = xmlBufUse(buf->buffer);
615 	*mem = xmlStrndup(xmlBufContent(buf->buffer), *size);
616     }
617     (void)xmlOutputBufferClose(buf);
618 }
619 
620 /**
621  * htmlDocDumpMemory:
622  * @cur:  the document
623  * @mem:  OUT: the memory pointer
624  * @size:  OUT: the memory length
625  *
626  * Dump an HTML document in memory and return the xmlChar * and it's size.
627  * It's up to the caller to free the memory.
628  */
629 void
htmlDocDumpMemory(xmlDocPtr cur,xmlChar ** mem,int * size)630 htmlDocDumpMemory(xmlDocPtr cur, xmlChar**mem, int *size) {
631 	htmlDocDumpMemoryFormat(cur, mem, size, 1);
632 }
633 
634 
635 /************************************************************************
636  *									*
637  *		Dumping HTML tree content to an I/O output buffer	*
638  *									*
639  ************************************************************************/
640 
641 void xmlNsListDumpOutput(xmlOutputBufferPtr buf, xmlNsPtr cur);
642 
643 /**
644  * htmlDtdDumpOutput:
645  * @buf:  the HTML buffer output
646  * @doc:  the document
647  * @encoding:  the encoding string
648  *
649  * TODO: check whether encoding is needed
650  *
651  * Dump the HTML document DTD, if any.
652  */
653 static void
htmlDtdDumpOutput(xmlOutputBufferPtr buf,xmlDocPtr doc,const char * encoding ATTRIBUTE_UNUSED)654 htmlDtdDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
655 	          const char *encoding ATTRIBUTE_UNUSED) {
656     xmlDtdPtr cur = doc->intSubset;
657 
658     if (cur == NULL) {
659 	htmlSaveErr(XML_SAVE_NO_DOCTYPE, (xmlNodePtr) doc, NULL);
660 	return;
661     }
662     xmlOutputBufferWriteString(buf, "<!DOCTYPE ");
663     xmlOutputBufferWriteString(buf, (const char *)cur->name);
664     if (cur->ExternalID != NULL) {
665 	xmlOutputBufferWriteString(buf, " PUBLIC ");
666 	xmlBufWriteQuotedString(buf->buffer, cur->ExternalID);
667 	if (cur->SystemID != NULL) {
668 	    xmlOutputBufferWriteString(buf, " ");
669 	    xmlBufWriteQuotedString(buf->buffer, cur->SystemID);
670 	}
671     }  else if (cur->SystemID != NULL) {
672 	xmlOutputBufferWriteString(buf, " SYSTEM ");
673 	xmlBufWriteQuotedString(buf->buffer, cur->SystemID);
674     }
675     xmlOutputBufferWriteString(buf, ">\n");
676 }
677 
678 /**
679  * htmlAttrDumpOutput:
680  * @buf:  the HTML buffer output
681  * @doc:  the document
682  * @cur:  the attribute pointer
683  * @encoding:  the encoding string
684  *
685  * Dump an HTML attribute
686  */
687 static void
htmlAttrDumpOutput(xmlOutputBufferPtr buf,xmlDocPtr doc,xmlAttrPtr cur,const char * encoding ATTRIBUTE_UNUSED)688 htmlAttrDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur,
689 	           const char *encoding ATTRIBUTE_UNUSED) {
690     xmlChar *value;
691 
692     /*
693      * The html output method should not escape a & character
694      * occurring in an attribute value immediately followed by
695      * a { character (see Section B.7.1 of the HTML 4.0 Recommendation).
696      * This is implemented in xmlEncodeEntitiesReentrant
697      */
698 
699     if (cur == NULL) {
700 	return;
701     }
702     xmlOutputBufferWriteString(buf, " ");
703     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
704         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
705 	xmlOutputBufferWriteString(buf, ":");
706     }
707     xmlOutputBufferWriteString(buf, (const char *)cur->name);
708     if ((cur->children != NULL) && (!htmlIsBooleanAttr(cur->name))) {
709 	value = xmlNodeListGetString(doc, cur->children, 0);
710 	if (value) {
711 	    xmlOutputBufferWriteString(buf, "=");
712 	    if ((cur->ns == NULL) && (cur->parent != NULL) &&
713 		(cur->parent->ns == NULL) &&
714 		((!xmlStrcasecmp(cur->name, BAD_CAST "href")) ||
715 	         (!xmlStrcasecmp(cur->name, BAD_CAST "action")) ||
716 		 (!xmlStrcasecmp(cur->name, BAD_CAST "src")) ||
717 		 ((!xmlStrcasecmp(cur->name, BAD_CAST "name")) &&
718 		  (!xmlStrcasecmp(cur->parent->name, BAD_CAST "a"))))) {
719 		xmlChar *tmp = value;
720 		/* xmlURIEscapeStr() escapes '"' so it can be safely used. */
721 		xmlBufCCat(buf->buffer, "\"");
722 
723 		while (IS_BLANK_CH(*tmp)) tmp++;
724 
725 		/* URI Escape everything, except server side includes. */
726 		for ( ; ; ) {
727 		    xmlChar *escaped;
728 		    xmlChar endChar;
729 		    xmlChar *end = NULL;
730 		    xmlChar *start = (xmlChar *)xmlStrstr(tmp, BAD_CAST "<!--");
731 		    if (start != NULL) {
732 			end = (xmlChar *)xmlStrstr(tmp, BAD_CAST "-->");
733 			if (end != NULL) {
734 			    *start = '\0';
735 			}
736 		    }
737 
738 		    /* Escape the whole string, or until start (set to '\0'). */
739 		    escaped = xmlURIEscapeStr(tmp, BAD_CAST"@/:=?;#%&,+");
740 		    if (escaped != NULL) {
741 		        xmlBufCat(buf->buffer, escaped);
742 		        xmlFree(escaped);
743 		    } else {
744 		        xmlBufCat(buf->buffer, tmp);
745 		    }
746 
747 		    if (end == NULL) { /* Everything has been written. */
748 			break;
749 		    }
750 
751 		    /* Do not escape anything within server side includes. */
752 		    *start = '<'; /* Restore the first character of "<!--". */
753 		    end += 3; /* strlen("-->") */
754 		    endChar = *end;
755 		    *end = '\0';
756 		    xmlBufCat(buf->buffer, start);
757 		    *end = endChar;
758 		    tmp = end;
759 		}
760 
761 		xmlBufCCat(buf->buffer, "\"");
762 	    } else {
763 		xmlBufWriteQuotedString(buf->buffer, value);
764 	    }
765 	    xmlFree(value);
766 	} else  {
767 	    xmlOutputBufferWriteString(buf, "=\"\"");
768 	}
769     }
770 }
771 
772 /**
773  * htmlAttrListDumpOutput:
774  * @buf:  the HTML buffer output
775  * @doc:  the document
776  * @cur:  the first attribute pointer
777  * @encoding:  the encoding string
778  *
779  * Dump a list of HTML attributes
780  */
781 static void
htmlAttrListDumpOutput(xmlOutputBufferPtr buf,xmlDocPtr doc,xmlAttrPtr cur,const char * encoding)782 htmlAttrListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur, const char *encoding) {
783     if (cur == NULL) {
784 	return;
785     }
786     while (cur != NULL) {
787         htmlAttrDumpOutput(buf, doc, cur, encoding);
788 	cur = cur->next;
789     }
790 }
791 
792 
793 
794 /**
795  * htmlNodeListDumpOutput:
796  * @buf:  the HTML buffer output
797  * @doc:  the document
798  * @cur:  the first node
799  * @encoding:  the encoding string
800  * @format:  should formatting spaces been added
801  *
802  * Dump an HTML node list, recursive behaviour,children are printed too.
803  */
804 static void
htmlNodeListDumpOutput(xmlOutputBufferPtr buf,xmlDocPtr doc,xmlNodePtr cur,const char * encoding,int format)805 htmlNodeListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
806 	               xmlNodePtr cur, const char *encoding, int format) {
807     if (cur == NULL) {
808 	return;
809     }
810     while (cur != NULL) {
811         htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format);
812 	cur = cur->next;
813     }
814 }
815 
816 /**
817  * htmlNodeDumpFormatOutput:
818  * @buf:  the HTML buffer output
819  * @doc:  the document
820  * @cur:  the current node
821  * @encoding:  the encoding string
822  * @format:  should formatting spaces been added
823  *
824  * Dump an HTML node, recursive behaviour,children are printed too.
825  */
826 void
htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf,xmlDocPtr doc,xmlNodePtr cur,const char * encoding,int format)827 htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
828 	                 xmlNodePtr cur, const char *encoding, int format) {
829     const htmlElemDesc * info;
830 
831     xmlInitParser();
832 
833     if ((cur == NULL) || (buf == NULL)) {
834 	return;
835     }
836     /*
837      * Special cases.
838      */
839     if (cur->type == XML_DTD_NODE)
840 	return;
841     if ((cur->type == XML_HTML_DOCUMENT_NODE) ||
842         (cur->type == XML_DOCUMENT_NODE)){
843 	htmlDocContentDumpOutput(buf, (xmlDocPtr) cur, encoding);
844 	return;
845     }
846     if (cur->type == XML_ATTRIBUTE_NODE) {
847         htmlAttrDumpOutput(buf, doc, (xmlAttrPtr) cur, encoding);
848 	return;
849     }
850     if (cur->type == HTML_TEXT_NODE) {
851 	if (cur->content != NULL) {
852 	    if (((cur->name == (const xmlChar *)xmlStringText) ||
853 		 (cur->name != (const xmlChar *)xmlStringTextNoenc)) &&
854 		((cur->parent == NULL) ||
855 		 ((xmlStrcasecmp(cur->parent->name, BAD_CAST "script")) &&
856 		  (xmlStrcasecmp(cur->parent->name, BAD_CAST "style"))))) {
857 		xmlChar *buffer;
858 
859 		buffer = xmlEncodeEntitiesReentrant(doc, cur->content);
860 		if (buffer != NULL) {
861 		    xmlOutputBufferWriteString(buf, (const char *)buffer);
862 		    xmlFree(buffer);
863 		}
864 	    } else {
865 		xmlOutputBufferWriteString(buf, (const char *)cur->content);
866 	    }
867 	}
868 	return;
869     }
870     if (cur->type == HTML_COMMENT_NODE) {
871 	if (cur->content != NULL) {
872 	    xmlOutputBufferWriteString(buf, "<!--");
873 	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
874 	    xmlOutputBufferWriteString(buf, "-->");
875 	}
876 	return;
877     }
878     if (cur->type == HTML_PI_NODE) {
879 	if (cur->name == NULL)
880 	    return;
881 	xmlOutputBufferWriteString(buf, "<?");
882 	xmlOutputBufferWriteString(buf, (const char *)cur->name);
883 	if (cur->content != NULL) {
884 	    xmlOutputBufferWriteString(buf, " ");
885 	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
886 	}
887 	xmlOutputBufferWriteString(buf, ">");
888 	return;
889     }
890     if (cur->type == HTML_ENTITY_REF_NODE) {
891         xmlOutputBufferWriteString(buf, "&");
892 	xmlOutputBufferWriteString(buf, (const char *)cur->name);
893         xmlOutputBufferWriteString(buf, ";");
894 	return;
895     }
896     if (cur->type == HTML_PRESERVE_NODE) {
897 	if (cur->content != NULL) {
898 	    xmlOutputBufferWriteString(buf, (const char *)cur->content);
899 	}
900 	return;
901     }
902 
903     /*
904      * Get specific HTML info for that node.
905      */
906     if (cur->ns == NULL)
907 	info = htmlTagLookup(cur->name);
908     else
909 	info = NULL;
910 
911     xmlOutputBufferWriteString(buf, "<");
912     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
913         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
914 	xmlOutputBufferWriteString(buf, ":");
915     }
916     xmlOutputBufferWriteString(buf, (const char *)cur->name);
917     if (cur->nsDef)
918 	xmlNsListDumpOutput(buf, cur->nsDef);
919     if (cur->properties != NULL)
920         htmlAttrListDumpOutput(buf, doc, cur->properties, encoding);
921 
922     if ((info != NULL) && (info->empty)) {
923         xmlOutputBufferWriteString(buf, ">");
924 	if ((format) && (!info->isinline) && (cur->next != NULL)) {
925 	    if ((cur->next->type != HTML_TEXT_NODE) &&
926 		(cur->next->type != HTML_ENTITY_REF_NODE) &&
927 		(cur->parent != NULL) &&
928 		(cur->parent->name != NULL) &&
929 		(cur->parent->name[0] != 'p')) /* p, pre, param */
930 		xmlOutputBufferWriteString(buf, "\n");
931 	}
932 	return;
933     }
934     if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) &&
935 	(cur->children == NULL)) {
936         if ((info != NULL) && (info->saveEndTag != 0) &&
937 	    (xmlStrcmp(BAD_CAST info->name, BAD_CAST "html")) &&
938 	    (xmlStrcmp(BAD_CAST info->name, BAD_CAST "body"))) {
939 	    xmlOutputBufferWriteString(buf, ">");
940 	} else {
941 	    xmlOutputBufferWriteString(buf, "></");
942             if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
943                 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
944                 xmlOutputBufferWriteString(buf, ":");
945             }
946 	    xmlOutputBufferWriteString(buf, (const char *)cur->name);
947 	    xmlOutputBufferWriteString(buf, ">");
948 	}
949 	if ((format) && (cur->next != NULL) &&
950             (info != NULL) && (!info->isinline)) {
951 	    if ((cur->next->type != HTML_TEXT_NODE) &&
952 		(cur->next->type != HTML_ENTITY_REF_NODE) &&
953 		(cur->parent != NULL) &&
954 		(cur->parent->name != NULL) &&
955 		(cur->parent->name[0] != 'p')) /* p, pre, param */
956 		xmlOutputBufferWriteString(buf, "\n");
957 	}
958 	return;
959     }
960     xmlOutputBufferWriteString(buf, ">");
961     if ((cur->type != XML_ELEMENT_NODE) &&
962 	(cur->content != NULL)) {
963 	    /*
964 	     * Uses the OutputBuffer property to automatically convert
965 	     * invalids to charrefs
966 	     */
967 
968             xmlOutputBufferWriteString(buf, (const char *) cur->content);
969     }
970     if (cur->children != NULL) {
971         if ((format) && (info != NULL) && (!info->isinline) &&
972 	    (cur->children->type != HTML_TEXT_NODE) &&
973 	    (cur->children->type != HTML_ENTITY_REF_NODE) &&
974 	    (cur->children != cur->last) &&
975 	    (cur->name != NULL) &&
976 	    (cur->name[0] != 'p')) /* p, pre, param */
977 	    xmlOutputBufferWriteString(buf, "\n");
978 	htmlNodeListDumpOutput(buf, doc, cur->children, encoding, format);
979         if ((format) && (info != NULL) && (!info->isinline) &&
980 	    (cur->last->type != HTML_TEXT_NODE) &&
981 	    (cur->last->type != HTML_ENTITY_REF_NODE) &&
982 	    (cur->children != cur->last) &&
983 	    (cur->name != NULL) &&
984 	    (cur->name[0] != 'p')) /* p, pre, param */
985 	    xmlOutputBufferWriteString(buf, "\n");
986     }
987     xmlOutputBufferWriteString(buf, "</");
988     if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) {
989         xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix);
990 	xmlOutputBufferWriteString(buf, ":");
991     }
992     xmlOutputBufferWriteString(buf, (const char *)cur->name);
993     xmlOutputBufferWriteString(buf, ">");
994     if ((format) && (info != NULL) && (!info->isinline) &&
995 	(cur->next != NULL)) {
996         if ((cur->next->type != HTML_TEXT_NODE) &&
997 	    (cur->next->type != HTML_ENTITY_REF_NODE) &&
998 	    (cur->parent != NULL) &&
999 	    (cur->parent->name != NULL) &&
1000 	    (cur->parent->name[0] != 'p')) /* p, pre, param */
1001 	    xmlOutputBufferWriteString(buf, "\n");
1002     }
1003 }
1004 
1005 /**
1006  * htmlNodeDumpOutput:
1007  * @buf:  the HTML buffer output
1008  * @doc:  the document
1009  * @cur:  the current node
1010  * @encoding:  the encoding string
1011  *
1012  * Dump an HTML node, recursive behaviour,children are printed too,
1013  * and formatting returns/spaces are added.
1014  */
1015 void
htmlNodeDumpOutput(xmlOutputBufferPtr buf,xmlDocPtr doc,xmlNodePtr cur,const char * encoding)1016 htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc,
1017 	           xmlNodePtr cur, const char *encoding) {
1018     htmlNodeDumpFormatOutput(buf, doc, cur, encoding, 1);
1019 }
1020 
1021 /**
1022  * htmlDocContentDumpFormatOutput:
1023  * @buf:  the HTML buffer output
1024  * @cur:  the document
1025  * @encoding:  the encoding string
1026  * @format:  should formatting spaces been added
1027  *
1028  * Dump an HTML document.
1029  */
1030 void
htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf,xmlDocPtr cur,const char * encoding,int format)1031 htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
1032 	                       const char *encoding, int format) {
1033     int type;
1034 
1035     xmlInitParser();
1036 
1037     if ((buf == NULL) || (cur == NULL))
1038         return;
1039 
1040     /*
1041      * force to output the stuff as HTML, especially for entities
1042      */
1043     type = cur->type;
1044     cur->type = XML_HTML_DOCUMENT_NODE;
1045     if (cur->intSubset != NULL) {
1046         htmlDtdDumpOutput(buf, cur, NULL);
1047     }
1048     if (cur->children != NULL) {
1049         htmlNodeListDumpOutput(buf, cur, cur->children, encoding, format);
1050     }
1051     xmlOutputBufferWriteString(buf, "\n");
1052     cur->type = (xmlElementType) type;
1053 }
1054 
1055 /**
1056  * htmlDocContentDumpOutput:
1057  * @buf:  the HTML buffer output
1058  * @cur:  the document
1059  * @encoding:  the encoding string
1060  *
1061  * Dump an HTML document. Formating return/spaces are added.
1062  */
1063 void
htmlDocContentDumpOutput(xmlOutputBufferPtr buf,xmlDocPtr cur,const char * encoding)1064 htmlDocContentDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr cur,
1065 	                 const char *encoding) {
1066     htmlDocContentDumpFormatOutput(buf, cur, encoding, 1);
1067 }
1068 
1069 /************************************************************************
1070  *									*
1071  *		Saving functions front-ends				*
1072  *									*
1073  ************************************************************************/
1074 
1075 /**
1076  * htmlDocDump:
1077  * @f:  the FILE*
1078  * @cur:  the document
1079  *
1080  * Dump an HTML document to an open FILE.
1081  *
1082  * returns: the number of byte written or -1 in case of failure.
1083  */
1084 int
htmlDocDump(FILE * f,xmlDocPtr cur)1085 htmlDocDump(FILE *f, xmlDocPtr cur) {
1086     xmlOutputBufferPtr buf;
1087     xmlCharEncodingHandlerPtr handler = NULL;
1088     const char *encoding;
1089     int ret;
1090 
1091     xmlInitParser();
1092 
1093     if ((cur == NULL) || (f == NULL)) {
1094 	return(-1);
1095     }
1096 
1097     encoding = (const char *) htmlGetMetaEncoding(cur);
1098 
1099     if (encoding != NULL) {
1100 	xmlCharEncoding enc;
1101 
1102 	enc = xmlParseCharEncoding(encoding);
1103 	if (enc != cur->charset) {
1104 	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1105 		/*
1106 		 * Not supported yet
1107 		 */
1108 		return(-1);
1109 	    }
1110 
1111 	    handler = xmlFindCharEncodingHandler(encoding);
1112 	    if (handler == NULL)
1113 		htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
1114 	} else {
1115 	    handler = xmlFindCharEncodingHandler(encoding);
1116 	}
1117     }
1118 
1119     /*
1120      * Fallback to HTML or ASCII when the encoding is unspecified
1121      */
1122     if (handler == NULL)
1123 	handler = xmlFindCharEncodingHandler("HTML");
1124     if (handler == NULL)
1125 	handler = xmlFindCharEncodingHandler("ascii");
1126 
1127     buf = xmlOutputBufferCreateFile(f, handler);
1128     if (buf == NULL) return(-1);
1129     htmlDocContentDumpOutput(buf, cur, NULL);
1130 
1131     ret = xmlOutputBufferClose(buf);
1132     return(ret);
1133 }
1134 
1135 /**
1136  * htmlSaveFile:
1137  * @filename:  the filename (or URL)
1138  * @cur:  the document
1139  *
1140  * Dump an HTML document to a file. If @filename is "-" the stdout file is
1141  * used.
1142  * returns: the number of byte written or -1 in case of failure.
1143  */
1144 int
htmlSaveFile(const char * filename,xmlDocPtr cur)1145 htmlSaveFile(const char *filename, xmlDocPtr cur) {
1146     xmlOutputBufferPtr buf;
1147     xmlCharEncodingHandlerPtr handler = NULL;
1148     const char *encoding;
1149     int ret;
1150 
1151     if ((cur == NULL) || (filename == NULL))
1152         return(-1);
1153 
1154     xmlInitParser();
1155 
1156     encoding = (const char *) htmlGetMetaEncoding(cur);
1157 
1158     if (encoding != NULL) {
1159 	xmlCharEncoding enc;
1160 
1161 	enc = xmlParseCharEncoding(encoding);
1162 	if (enc != cur->charset) {
1163 	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1164 		/*
1165 		 * Not supported yet
1166 		 */
1167 		return(-1);
1168 	    }
1169 
1170 	    handler = xmlFindCharEncodingHandler(encoding);
1171 	    if (handler == NULL)
1172 		htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
1173 	}
1174     }
1175 
1176     /*
1177      * Fallback to HTML or ASCII when the encoding is unspecified
1178      */
1179     if (handler == NULL)
1180 	handler = xmlFindCharEncodingHandler("HTML");
1181     if (handler == NULL)
1182 	handler = xmlFindCharEncodingHandler("ascii");
1183 
1184     /*
1185      * save the content to a temp buffer.
1186      */
1187     buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression);
1188     if (buf == NULL) return(0);
1189 
1190     htmlDocContentDumpOutput(buf, cur, NULL);
1191 
1192     ret = xmlOutputBufferClose(buf);
1193     return(ret);
1194 }
1195 
1196 /**
1197  * htmlSaveFileFormat:
1198  * @filename:  the filename
1199  * @cur:  the document
1200  * @format:  should formatting spaces been added
1201  * @encoding: the document encoding
1202  *
1203  * Dump an HTML document to a file using a given encoding.
1204  *
1205  * returns: the number of byte written or -1 in case of failure.
1206  */
1207 int
htmlSaveFileFormat(const char * filename,xmlDocPtr cur,const char * encoding,int format)1208 htmlSaveFileFormat(const char *filename, xmlDocPtr cur,
1209 	           const char *encoding, int format) {
1210     xmlOutputBufferPtr buf;
1211     xmlCharEncodingHandlerPtr handler = NULL;
1212     int ret;
1213 
1214     if ((cur == NULL) || (filename == NULL))
1215         return(-1);
1216 
1217     xmlInitParser();
1218 
1219     if (encoding != NULL) {
1220 	xmlCharEncoding enc;
1221 
1222 	enc = xmlParseCharEncoding(encoding);
1223 	if (enc != cur->charset) {
1224 	    if (cur->charset != XML_CHAR_ENCODING_UTF8) {
1225 		/*
1226 		 * Not supported yet
1227 		 */
1228 		return(-1);
1229 	    }
1230 
1231 	    handler = xmlFindCharEncodingHandler(encoding);
1232 	    if (handler == NULL)
1233 		htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding);
1234 	}
1235         htmlSetMetaEncoding(cur, (const xmlChar *) encoding);
1236     } else {
1237 	htmlSetMetaEncoding(cur, (const xmlChar *) "UTF-8");
1238     }
1239 
1240     /*
1241      * Fallback to HTML or ASCII when the encoding is unspecified
1242      */
1243     if (handler == NULL)
1244 	handler = xmlFindCharEncodingHandler("HTML");
1245     if (handler == NULL)
1246 	handler = xmlFindCharEncodingHandler("ascii");
1247 
1248     /*
1249      * save the content to a temp buffer.
1250      */
1251     buf = xmlOutputBufferCreateFilename(filename, handler, 0);
1252     if (buf == NULL) return(0);
1253 
1254     htmlDocContentDumpFormatOutput(buf, cur, encoding, format);
1255 
1256     ret = xmlOutputBufferClose(buf);
1257     return(ret);
1258 }
1259 
1260 /**
1261  * htmlSaveFileEnc:
1262  * @filename:  the filename
1263  * @cur:  the document
1264  * @encoding: the document encoding
1265  *
1266  * Dump an HTML document to a file using a given encoding
1267  * and formatting returns/spaces are added.
1268  *
1269  * returns: the number of byte written or -1 in case of failure.
1270  */
1271 int
htmlSaveFileEnc(const char * filename,xmlDocPtr cur,const char * encoding)1272 htmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) {
1273     return(htmlSaveFileFormat(filename, cur, encoding, 1));
1274 }
1275 
1276 #endif /* LIBXML_OUTPUT_ENABLED */
1277 
1278 #define bottom_HTMLtree
1279 #include "elfgcchack.h"
1280 #endif /* LIBXML_HTML_ENABLED */
1281