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 (at) 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 * 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 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 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 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 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 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 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 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 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 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 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 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 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 *escaped; 720 xmlChar *tmp = value; 721 722 while (IS_BLANK_CH(*tmp)) tmp++; 723 724 /* 725 * the < and > have already been escaped at the entity level 726 * And doing so here breaks server side includes 727 */ 728 escaped = xmlURIEscapeStr(tmp, BAD_CAST"@/:=?;#%&,+<>"); 729 if (escaped != NULL) { 730 xmlBufWriteQuotedString(buf->buffer, escaped); 731 xmlFree(escaped); 732 } else { 733 xmlBufWriteQuotedString(buf->buffer, value); 734 } 735 } else { 736 xmlBufWriteQuotedString(buf->buffer, value); 737 } 738 xmlFree(value); 739 } else { 740 xmlOutputBufferWriteString(buf, "=\"\""); 741 } 742 } 743 } 744 745 /** 746 * htmlAttrListDumpOutput: 747 * @buf: the HTML buffer output 748 * @doc: the document 749 * @cur: the first attribute pointer 750 * @encoding: the encoding string 751 * 752 * Dump a list of HTML attributes 753 */ 754 static void 755 htmlAttrListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, xmlAttrPtr cur, const char *encoding) { 756 if (cur == NULL) { 757 return; 758 } 759 while (cur != NULL) { 760 htmlAttrDumpOutput(buf, doc, cur, encoding); 761 cur = cur->next; 762 } 763 } 764 765 766 767 /** 768 * htmlNodeListDumpOutput: 769 * @buf: the HTML buffer output 770 * @doc: the document 771 * @cur: the first node 772 * @encoding: the encoding string 773 * @format: should formatting spaces been added 774 * 775 * Dump an HTML node list, recursive behaviour,children are printed too. 776 */ 777 static void 778 htmlNodeListDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, 779 xmlNodePtr cur, const char *encoding, int format) { 780 if (cur == NULL) { 781 return; 782 } 783 while (cur != NULL) { 784 htmlNodeDumpFormatOutput(buf, doc, cur, encoding, format); 785 cur = cur->next; 786 } 787 } 788 789 /** 790 * htmlNodeDumpFormatOutput: 791 * @buf: the HTML buffer output 792 * @doc: the document 793 * @cur: the current node 794 * @encoding: the encoding string 795 * @format: should formatting spaces been added 796 * 797 * Dump an HTML node, recursive behaviour,children are printed too. 798 */ 799 void 800 htmlNodeDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, 801 xmlNodePtr cur, const char *encoding, int format) { 802 const htmlElemDesc * info; 803 804 xmlInitParser(); 805 806 if ((cur == NULL) || (buf == NULL)) { 807 return; 808 } 809 /* 810 * Special cases. 811 */ 812 if (cur->type == XML_DTD_NODE) 813 return; 814 if ((cur->type == XML_HTML_DOCUMENT_NODE) || 815 (cur->type == XML_DOCUMENT_NODE)){ 816 htmlDocContentDumpOutput(buf, (xmlDocPtr) cur, encoding); 817 return; 818 } 819 if (cur->type == XML_ATTRIBUTE_NODE) { 820 htmlAttrDumpOutput(buf, doc, (xmlAttrPtr) cur, encoding); 821 return; 822 } 823 if (cur->type == HTML_TEXT_NODE) { 824 if (cur->content != NULL) { 825 if (((cur->name == (const xmlChar *)xmlStringText) || 826 (cur->name != (const xmlChar *)xmlStringTextNoenc)) && 827 ((cur->parent == NULL) || 828 ((xmlStrcasecmp(cur->parent->name, BAD_CAST "script")) && 829 (xmlStrcasecmp(cur->parent->name, BAD_CAST "style"))))) { 830 xmlChar *buffer; 831 832 buffer = xmlEncodeEntitiesReentrant(doc, cur->content); 833 if (buffer != NULL) { 834 xmlOutputBufferWriteString(buf, (const char *)buffer); 835 xmlFree(buffer); 836 } 837 } else { 838 xmlOutputBufferWriteString(buf, (const char *)cur->content); 839 } 840 } 841 return; 842 } 843 if (cur->type == HTML_COMMENT_NODE) { 844 if (cur->content != NULL) { 845 xmlOutputBufferWriteString(buf, "<!--"); 846 xmlOutputBufferWriteString(buf, (const char *)cur->content); 847 xmlOutputBufferWriteString(buf, "-->"); 848 } 849 return; 850 } 851 if (cur->type == HTML_PI_NODE) { 852 if (cur->name == NULL) 853 return; 854 xmlOutputBufferWriteString(buf, "<?"); 855 xmlOutputBufferWriteString(buf, (const char *)cur->name); 856 if (cur->content != NULL) { 857 xmlOutputBufferWriteString(buf, " "); 858 xmlOutputBufferWriteString(buf, (const char *)cur->content); 859 } 860 xmlOutputBufferWriteString(buf, ">"); 861 return; 862 } 863 if (cur->type == HTML_ENTITY_REF_NODE) { 864 xmlOutputBufferWriteString(buf, "&"); 865 xmlOutputBufferWriteString(buf, (const char *)cur->name); 866 xmlOutputBufferWriteString(buf, ";"); 867 return; 868 } 869 if (cur->type == HTML_PRESERVE_NODE) { 870 if (cur->content != NULL) { 871 xmlOutputBufferWriteString(buf, (const char *)cur->content); 872 } 873 return; 874 } 875 876 /* 877 * Get specific HTML info for that node. 878 */ 879 if (cur->ns == NULL) 880 info = htmlTagLookup(cur->name); 881 else 882 info = NULL; 883 884 xmlOutputBufferWriteString(buf, "<"); 885 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) { 886 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix); 887 xmlOutputBufferWriteString(buf, ":"); 888 } 889 xmlOutputBufferWriteString(buf, (const char *)cur->name); 890 if (cur->nsDef) 891 xmlNsListDumpOutput(buf, cur->nsDef); 892 if (cur->properties != NULL) 893 htmlAttrListDumpOutput(buf, doc, cur->properties, encoding); 894 895 if ((info != NULL) && (info->empty)) { 896 xmlOutputBufferWriteString(buf, ">"); 897 if ((format) && (!info->isinline) && (cur->next != NULL)) { 898 if ((cur->next->type != HTML_TEXT_NODE) && 899 (cur->next->type != HTML_ENTITY_REF_NODE) && 900 (cur->parent != NULL) && 901 (cur->parent->name != NULL) && 902 (cur->parent->name[0] != 'p')) /* p, pre, param */ 903 xmlOutputBufferWriteString(buf, "\n"); 904 } 905 return; 906 } 907 if (((cur->type == XML_ELEMENT_NODE) || (cur->content == NULL)) && 908 (cur->children == NULL)) { 909 if ((info != NULL) && (info->saveEndTag != 0) && 910 (xmlStrcmp(BAD_CAST info->name, BAD_CAST "html")) && 911 (xmlStrcmp(BAD_CAST info->name, BAD_CAST "body"))) { 912 xmlOutputBufferWriteString(buf, ">"); 913 } else { 914 xmlOutputBufferWriteString(buf, "></"); 915 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) { 916 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix); 917 xmlOutputBufferWriteString(buf, ":"); 918 } 919 xmlOutputBufferWriteString(buf, (const char *)cur->name); 920 xmlOutputBufferWriteString(buf, ">"); 921 } 922 if ((format) && (cur->next != NULL) && 923 (info != NULL) && (!info->isinline)) { 924 if ((cur->next->type != HTML_TEXT_NODE) && 925 (cur->next->type != HTML_ENTITY_REF_NODE) && 926 (cur->parent != NULL) && 927 (cur->parent->name != NULL) && 928 (cur->parent->name[0] != 'p')) /* p, pre, param */ 929 xmlOutputBufferWriteString(buf, "\n"); 930 } 931 return; 932 } 933 xmlOutputBufferWriteString(buf, ">"); 934 if ((cur->type != XML_ELEMENT_NODE) && 935 (cur->content != NULL)) { 936 /* 937 * Uses the OutputBuffer property to automatically convert 938 * invalids to charrefs 939 */ 940 941 xmlOutputBufferWriteString(buf, (const char *) cur->content); 942 } 943 if (cur->children != NULL) { 944 if ((format) && (info != NULL) && (!info->isinline) && 945 (cur->children->type != HTML_TEXT_NODE) && 946 (cur->children->type != HTML_ENTITY_REF_NODE) && 947 (cur->children != cur->last) && 948 (cur->name != NULL) && 949 (cur->name[0] != 'p')) /* p, pre, param */ 950 xmlOutputBufferWriteString(buf, "\n"); 951 htmlNodeListDumpOutput(buf, doc, cur->children, encoding, format); 952 if ((format) && (info != NULL) && (!info->isinline) && 953 (cur->last->type != HTML_TEXT_NODE) && 954 (cur->last->type != HTML_ENTITY_REF_NODE) && 955 (cur->children != cur->last) && 956 (cur->name != NULL) && 957 (cur->name[0] != 'p')) /* p, pre, param */ 958 xmlOutputBufferWriteString(buf, "\n"); 959 } 960 xmlOutputBufferWriteString(buf, "</"); 961 if ((cur->ns != NULL) && (cur->ns->prefix != NULL)) { 962 xmlOutputBufferWriteString(buf, (const char *)cur->ns->prefix); 963 xmlOutputBufferWriteString(buf, ":"); 964 } 965 xmlOutputBufferWriteString(buf, (const char *)cur->name); 966 xmlOutputBufferWriteString(buf, ">"); 967 if ((format) && (info != NULL) && (!info->isinline) && 968 (cur->next != NULL)) { 969 if ((cur->next->type != HTML_TEXT_NODE) && 970 (cur->next->type != HTML_ENTITY_REF_NODE) && 971 (cur->parent != NULL) && 972 (cur->parent->name != NULL) && 973 (cur->parent->name[0] != 'p')) /* p, pre, param */ 974 xmlOutputBufferWriteString(buf, "\n"); 975 } 976 } 977 978 /** 979 * htmlNodeDumpOutput: 980 * @buf: the HTML buffer output 981 * @doc: the document 982 * @cur: the current node 983 * @encoding: the encoding string 984 * 985 * Dump an HTML node, recursive behaviour,children are printed too, 986 * and formatting returns/spaces are added. 987 */ 988 void 989 htmlNodeDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr doc, 990 xmlNodePtr cur, const char *encoding) { 991 htmlNodeDumpFormatOutput(buf, doc, cur, encoding, 1); 992 } 993 994 /** 995 * htmlDocContentDumpFormatOutput: 996 * @buf: the HTML buffer output 997 * @cur: the document 998 * @encoding: the encoding string 999 * @format: should formatting spaces been added 1000 * 1001 * Dump an HTML document. 1002 */ 1003 void 1004 htmlDocContentDumpFormatOutput(xmlOutputBufferPtr buf, xmlDocPtr cur, 1005 const char *encoding, int format) { 1006 int type; 1007 1008 xmlInitParser(); 1009 1010 if ((buf == NULL) || (cur == NULL)) 1011 return; 1012 1013 /* 1014 * force to output the stuff as HTML, especially for entities 1015 */ 1016 type = cur->type; 1017 cur->type = XML_HTML_DOCUMENT_NODE; 1018 if (cur->intSubset != NULL) { 1019 htmlDtdDumpOutput(buf, cur, NULL); 1020 } 1021 if (cur->children != NULL) { 1022 htmlNodeListDumpOutput(buf, cur, cur->children, encoding, format); 1023 } 1024 xmlOutputBufferWriteString(buf, "\n"); 1025 cur->type = (xmlElementType) type; 1026 } 1027 1028 /** 1029 * htmlDocContentDumpOutput: 1030 * @buf: the HTML buffer output 1031 * @cur: the document 1032 * @encoding: the encoding string 1033 * 1034 * Dump an HTML document. Formating return/spaces are added. 1035 */ 1036 void 1037 htmlDocContentDumpOutput(xmlOutputBufferPtr buf, xmlDocPtr cur, 1038 const char *encoding) { 1039 htmlDocContentDumpFormatOutput(buf, cur, encoding, 1); 1040 } 1041 1042 /************************************************************************ 1043 * * 1044 * Saving functions front-ends * 1045 * * 1046 ************************************************************************/ 1047 1048 /** 1049 * htmlDocDump: 1050 * @f: the FILE* 1051 * @cur: the document 1052 * 1053 * Dump an HTML document to an open FILE. 1054 * 1055 * returns: the number of byte written or -1 in case of failure. 1056 */ 1057 int 1058 htmlDocDump(FILE *f, xmlDocPtr cur) { 1059 xmlOutputBufferPtr buf; 1060 xmlCharEncodingHandlerPtr handler = NULL; 1061 const char *encoding; 1062 int ret; 1063 1064 xmlInitParser(); 1065 1066 if ((cur == NULL) || (f == NULL)) { 1067 return(-1); 1068 } 1069 1070 encoding = (const char *) htmlGetMetaEncoding(cur); 1071 1072 if (encoding != NULL) { 1073 xmlCharEncoding enc; 1074 1075 enc = xmlParseCharEncoding(encoding); 1076 if (enc != cur->charset) { 1077 if (cur->charset != XML_CHAR_ENCODING_UTF8) { 1078 /* 1079 * Not supported yet 1080 */ 1081 return(-1); 1082 } 1083 1084 handler = xmlFindCharEncodingHandler(encoding); 1085 if (handler == NULL) 1086 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding); 1087 } else { 1088 handler = xmlFindCharEncodingHandler(encoding); 1089 } 1090 } 1091 1092 /* 1093 * Fallback to HTML or ASCII when the encoding is unspecified 1094 */ 1095 if (handler == NULL) 1096 handler = xmlFindCharEncodingHandler("HTML"); 1097 if (handler == NULL) 1098 handler = xmlFindCharEncodingHandler("ascii"); 1099 1100 buf = xmlOutputBufferCreateFile(f, handler); 1101 if (buf == NULL) return(-1); 1102 htmlDocContentDumpOutput(buf, cur, NULL); 1103 1104 ret = xmlOutputBufferClose(buf); 1105 return(ret); 1106 } 1107 1108 /** 1109 * htmlSaveFile: 1110 * @filename: the filename (or URL) 1111 * @cur: the document 1112 * 1113 * Dump an HTML document to a file. If @filename is "-" the stdout file is 1114 * used. 1115 * returns: the number of byte written or -1 in case of failure. 1116 */ 1117 int 1118 htmlSaveFile(const char *filename, xmlDocPtr cur) { 1119 xmlOutputBufferPtr buf; 1120 xmlCharEncodingHandlerPtr handler = NULL; 1121 const char *encoding; 1122 int ret; 1123 1124 if ((cur == NULL) || (filename == NULL)) 1125 return(-1); 1126 1127 xmlInitParser(); 1128 1129 encoding = (const char *) htmlGetMetaEncoding(cur); 1130 1131 if (encoding != NULL) { 1132 xmlCharEncoding enc; 1133 1134 enc = xmlParseCharEncoding(encoding); 1135 if (enc != cur->charset) { 1136 if (cur->charset != XML_CHAR_ENCODING_UTF8) { 1137 /* 1138 * Not supported yet 1139 */ 1140 return(-1); 1141 } 1142 1143 handler = xmlFindCharEncodingHandler(encoding); 1144 if (handler == NULL) 1145 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding); 1146 } 1147 } 1148 1149 /* 1150 * Fallback to HTML or ASCII when the encoding is unspecified 1151 */ 1152 if (handler == NULL) 1153 handler = xmlFindCharEncodingHandler("HTML"); 1154 if (handler == NULL) 1155 handler = xmlFindCharEncodingHandler("ascii"); 1156 1157 /* 1158 * save the content to a temp buffer. 1159 */ 1160 buf = xmlOutputBufferCreateFilename(filename, handler, cur->compression); 1161 if (buf == NULL) return(0); 1162 1163 htmlDocContentDumpOutput(buf, cur, NULL); 1164 1165 ret = xmlOutputBufferClose(buf); 1166 return(ret); 1167 } 1168 1169 /** 1170 * htmlSaveFileFormat: 1171 * @filename: the filename 1172 * @cur: the document 1173 * @format: should formatting spaces been added 1174 * @encoding: the document encoding 1175 * 1176 * Dump an HTML document to a file using a given encoding. 1177 * 1178 * returns: the number of byte written or -1 in case of failure. 1179 */ 1180 int 1181 htmlSaveFileFormat(const char *filename, xmlDocPtr cur, 1182 const char *encoding, int format) { 1183 xmlOutputBufferPtr buf; 1184 xmlCharEncodingHandlerPtr handler = NULL; 1185 int ret; 1186 1187 if ((cur == NULL) || (filename == NULL)) 1188 return(-1); 1189 1190 xmlInitParser(); 1191 1192 if (encoding != NULL) { 1193 xmlCharEncoding enc; 1194 1195 enc = xmlParseCharEncoding(encoding); 1196 if (enc != cur->charset) { 1197 if (cur->charset != XML_CHAR_ENCODING_UTF8) { 1198 /* 1199 * Not supported yet 1200 */ 1201 return(-1); 1202 } 1203 1204 handler = xmlFindCharEncodingHandler(encoding); 1205 if (handler == NULL) 1206 htmlSaveErr(XML_SAVE_UNKNOWN_ENCODING, NULL, encoding); 1207 } 1208 htmlSetMetaEncoding(cur, (const xmlChar *) encoding); 1209 } else { 1210 htmlSetMetaEncoding(cur, (const xmlChar *) "UTF-8"); 1211 } 1212 1213 /* 1214 * Fallback to HTML or ASCII when the encoding is unspecified 1215 */ 1216 if (handler == NULL) 1217 handler = xmlFindCharEncodingHandler("HTML"); 1218 if (handler == NULL) 1219 handler = xmlFindCharEncodingHandler("ascii"); 1220 1221 /* 1222 * save the content to a temp buffer. 1223 */ 1224 buf = xmlOutputBufferCreateFilename(filename, handler, 0); 1225 if (buf == NULL) return(0); 1226 1227 htmlDocContentDumpFormatOutput(buf, cur, encoding, format); 1228 1229 ret = xmlOutputBufferClose(buf); 1230 return(ret); 1231 } 1232 1233 /** 1234 * htmlSaveFileEnc: 1235 * @filename: the filename 1236 * @cur: the document 1237 * @encoding: the document encoding 1238 * 1239 * Dump an HTML document to a file using a given encoding 1240 * and formatting returns/spaces are added. 1241 * 1242 * returns: the number of byte written or -1 in case of failure. 1243 */ 1244 int 1245 htmlSaveFileEnc(const char *filename, xmlDocPtr cur, const char *encoding) { 1246 return(htmlSaveFileFormat(filename, cur, encoding, 1)); 1247 } 1248 1249 #endif /* LIBXML_OUTPUT_ENABLED */ 1250 1251 #define bottom_HTMLtree 1252 #include "elfgcchack.h" 1253 #endif /* LIBXML_HTML_ENABLED */ 1254
