OLD | NEW |
1 /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd | 1 /* Copyright (c) 1998, 1999, 2000 Thai Open Source Software Center Ltd |
2 See the file COPYING for copying permission. | 2 See the file COPYING for copying permission. |
3 */ | 3 */ |
4 | 4 |
5 #include <stddef.h> | 5 #include <stddef.h> |
6 #include <string.h> /* memset(), memcpy() */ | 6 #include <string.h> /* memset(), memcpy() */ |
7 #include <assert.h> | 7 #include <assert.h> |
8 #include <limits.h> /* UINT_MAX */ | 8 #include <limits.h> /* UINT_MAX */ |
9 #include <time.h> /* time() */ | 9 |
| 10 #ifdef WIN32 |
| 11 #define getpid GetCurrentProcessId |
| 12 #else |
| 13 #include <sys/time.h> /* gettimeofday() */ |
| 14 #include <sys/types.h> /* getpid() */ |
| 15 #include <unistd.h> /* getpid() */ |
| 16 #endif |
10 | 17 |
11 #define XML_BUILDING_EXPAT 1 | 18 #define XML_BUILDING_EXPAT 1 |
12 | 19 |
13 #ifdef COMPILED_FROM_DSP | 20 #ifdef WIN32 |
14 #include "winconfig.h" | 21 #include "winconfig.h" |
15 #elif defined(MACOS_CLASSIC) | 22 #elif defined(MACOS_CLASSIC) |
16 #include "macconfig.h" | 23 #include "macconfig.h" |
17 #elif defined(__amigaos__) | 24 #elif defined(__amigaos__) |
18 #include "amigaconfig.h" | 25 #include "amigaconfig.h" |
19 #elif defined(__WATCOMC__) | 26 #elif defined(__WATCOMC__) |
20 #include "watcomconfig.h" | 27 #include "watcomconfig.h" |
21 #elif defined(HAVE_EXPAT_CONFIG_H) | 28 #elif defined(HAVE_EXPAT_CONFIG_H) |
22 #include <expat_config.h> | 29 #include <expat_config.h> |
23 #endif /* ndef COMPILED_FROM_DSP */ | 30 #endif /* ndef WIN32 */ |
24 | 31 |
25 #include "ascii.h" | 32 #include "ascii.h" |
26 #include "expat.h" | 33 #include "expat.h" |
27 | 34 |
28 #ifdef XML_UNICODE | 35 #ifdef XML_UNICODE |
29 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX | 36 #define XML_ENCODE_MAX XML_UTF16_ENCODE_MAX |
30 #define XmlConvert XmlUtf16Convert | 37 #define XmlConvert XmlUtf16Convert |
31 #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding | 38 #define XmlGetInternalEncoding XmlGetUtf16InternalEncoding |
32 #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS | 39 #define XmlGetInternalEncodingNS XmlGetUtf16InternalEncodingNS |
33 #define XmlEncode XmlUtf16Encode | 40 #define XmlEncode XmlUtf16Encode |
(...skipping 391 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
425 poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n); | 432 poolCopyStringN(STRING_POOL *pool, const XML_Char *s, int n); |
426 static const XML_Char * FASTCALL | 433 static const XML_Char * FASTCALL |
427 poolAppendString(STRING_POOL *pool, const XML_Char *s); | 434 poolAppendString(STRING_POOL *pool, const XML_Char *s); |
428 | 435 |
429 static int FASTCALL nextScaffoldPart(XML_Parser parser); | 436 static int FASTCALL nextScaffoldPart(XML_Parser parser); |
430 static XML_Content * build_model(XML_Parser parser); | 437 static XML_Content * build_model(XML_Parser parser); |
431 static ELEMENT_TYPE * | 438 static ELEMENT_TYPE * |
432 getElementType(XML_Parser parser, const ENCODING *enc, | 439 getElementType(XML_Parser parser, const ENCODING *enc, |
433 const char *ptr, const char *end); | 440 const char *ptr, const char *end); |
434 | 441 |
435 static unsigned long generate_hash_secret_salt(void); | 442 static unsigned long generate_hash_secret_salt(XML_Parser parser); |
436 static XML_Bool startParsing(XML_Parser parser); | 443 static XML_Bool startParsing(XML_Parser parser); |
437 | 444 |
438 static XML_Parser | 445 static XML_Parser |
439 parserCreate(const XML_Char *encodingName, | 446 parserCreate(const XML_Char *encodingName, |
440 const XML_Memory_Handling_Suite *memsuite, | 447 const XML_Memory_Handling_Suite *memsuite, |
441 const XML_Char *nameSep, | 448 const XML_Char *nameSep, |
442 DTD *dtd); | 449 DTD *dtd); |
443 | 450 |
444 static void | 451 static void |
445 parserInit(XML_Parser parser, const XML_Char *encodingName); | 452 parserInit(XML_Parser parser, const XML_Char *encodingName); |
(...skipping 238 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
684 static const XML_Char implicitContext[] = { | 691 static const XML_Char implicitContext[] = { |
685 ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p, | 692 ASCII_x, ASCII_m, ASCII_l, ASCII_EQUALS, ASCII_h, ASCII_t, ASCII_t, ASCII_p, |
686 ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, | 693 ASCII_COLON, ASCII_SLASH, ASCII_SLASH, ASCII_w, ASCII_w, ASCII_w, |
687 ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, | 694 ASCII_PERIOD, ASCII_w, ASCII_3, ASCII_PERIOD, ASCII_o, ASCII_r, ASCII_g, |
688 ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, | 695 ASCII_SLASH, ASCII_X, ASCII_M, ASCII_L, ASCII_SLASH, ASCII_1, ASCII_9, |
689 ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e, | 696 ASCII_9, ASCII_8, ASCII_SLASH, ASCII_n, ASCII_a, ASCII_m, ASCII_e, |
690 ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0' | 697 ASCII_s, ASCII_p, ASCII_a, ASCII_c, ASCII_e, '\0' |
691 }; | 698 }; |
692 | 699 |
693 static unsigned long | 700 static unsigned long |
694 generate_hash_secret_salt(void) | 701 gather_time_entropy(void) |
695 { | 702 { |
696 unsigned int seed = time(NULL) % UINT_MAX; | 703 #ifdef WIN32 |
697 srand(seed); | 704 FILETIME ft; |
698 return rand(); | 705 GetSystemTimeAsFileTime(&ft); /* never fails */ |
| 706 return ft.dwHighDateTime ^ ft.dwLowDateTime; |
| 707 #else |
| 708 struct timeval tv; |
| 709 int gettimeofday_res; |
| 710 |
| 711 gettimeofday_res = gettimeofday(&tv, NULL); |
| 712 assert (gettimeofday_res == 0); |
| 713 (void)gettimeofday_res; |
| 714 |
| 715 /* Microseconds time is <20 bits entropy */ |
| 716 return tv.tv_usec; |
| 717 #endif |
| 718 } |
| 719 |
| 720 static unsigned long |
| 721 generate_hash_secret_salt(XML_Parser parser) |
| 722 { |
| 723 #if defined(__UINTPTR_TYPE__) |
| 724 # define PARSER_CAST(p) (__UINTPTR_TYPE__)(p) |
| 725 #elif defined(_WIN64) && defined(_MSC_VER) |
| 726 # define PARSER_CAST(p) (unsigned __int64)(p) |
| 727 #else |
| 728 # define PARSER_CAST(p) (p) |
| 729 #endif |
| 730 |
| 731 /* Factors are 2^31-1 and 2^61-1 (Mersenne primes M31 and M61) */ |
| 732 unsigned long small_factory = 2147483647ul; |
| 733 unsigned long long big_factory = 2305843009213693951ull; |
| 734 |
| 735 /* Process ID is 0 bits entropy if attacker has local access |
| 736 * XML_Parser address is few bits of entropy if attacker has local access */ |
| 737 const unsigned long entropy = |
| 738 gather_time_entropy() ^ getpid() ^ (unsigned long)PARSER_CAST(parser); |
| 739 |
| 740 if (sizeof(unsigned long) == 4) { |
| 741 return entropy * small_factory; |
| 742 } else { |
| 743 return entropy * (unsigned long)big_factory; |
| 744 } |
699 } | 745 } |
700 | 746 |
701 static XML_Bool /* only valid for root parser */ | 747 static XML_Bool /* only valid for root parser */ |
702 startParsing(XML_Parser parser) | 748 startParsing(XML_Parser parser) |
703 { | 749 { |
704 /* hash functions must be initialized before setContext() is called */ | 750 /* hash functions must be initialized before setContext() is called */ |
705 if (hash_secret_salt == 0) | 751 if (hash_secret_salt == 0) |
706 hash_secret_salt = generate_hash_secret_salt(); | 752 hash_secret_salt = generate_hash_secret_salt(parser); |
707 if (ns) { | 753 if (ns) { |
708 /* implicit context only set for root parser, since child | 754 /* implicit context only set for root parser, since child |
709 parsers (i.e. external entity parsers) will inherit it | 755 parsers (i.e. external entity parsers) will inherit it |
710 */ | 756 */ |
711 return setContext(parser, implicitContext); | 757 return setContext(parser, implicitContext); |
712 } | 758 } |
713 return XML_TRUE; | 759 return XML_TRUE; |
714 } | 760 } |
715 | 761 |
716 XML_Parser XMLCALL | 762 XML_Parser XMLCALL |
(...skipping 826 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1543 } | 1589 } |
1544 } | 1590 } |
1545 eventEndPtr = eventPtr; | 1591 eventEndPtr = eventPtr; |
1546 processor = errorProcessor; | 1592 processor = errorProcessor; |
1547 return XML_STATUS_ERROR; | 1593 return XML_STATUS_ERROR; |
1548 } | 1594 } |
1549 #ifndef XML_CONTEXT_BYTES | 1595 #ifndef XML_CONTEXT_BYTES |
1550 else if (bufferPtr == bufferEnd) { | 1596 else if (bufferPtr == bufferEnd) { |
1551 const char *end; | 1597 const char *end; |
1552 int nLeftOver; | 1598 int nLeftOver; |
1553 enum XML_Error result; | 1599 enum XML_Status result; |
1554 parseEndByteIndex += len; | 1600 parseEndByteIndex += len; |
1555 positionPtr = s; | 1601 positionPtr = s; |
1556 ps_finalBuffer = (XML_Bool)isFinal; | 1602 ps_finalBuffer = (XML_Bool)isFinal; |
1557 | 1603 |
1558 errorCode = processor(parser, s, parseEndPtr = s + len, &end); | 1604 errorCode = processor(parser, s, parseEndPtr = s + len, &end); |
1559 | 1605 |
1560 if (errorCode != XML_ERROR_NONE) { | 1606 if (errorCode != XML_ERROR_NONE) { |
1561 eventEndPtr = eventPtr; | 1607 eventEndPtr = eventPtr; |
1562 processor = errorProcessor; | 1608 processor = errorProcessor; |
1563 return XML_STATUS_ERROR; | 1609 return XML_STATUS_ERROR; |
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1671 } | 1717 } |
1672 | 1718 |
1673 XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position); | 1719 XmlUpdatePosition(encoding, positionPtr, bufferPtr, &position); |
1674 positionPtr = bufferPtr; | 1720 positionPtr = bufferPtr; |
1675 return result; | 1721 return result; |
1676 } | 1722 } |
1677 | 1723 |
1678 void * XMLCALL | 1724 void * XMLCALL |
1679 XML_GetBuffer(XML_Parser parser, int len) | 1725 XML_GetBuffer(XML_Parser parser, int len) |
1680 { | 1726 { |
1681 /* BEGIN MOZILLA CHANGE (sanity check len) */ | |
1682 if (len < 0) { | 1727 if (len < 0) { |
1683 errorCode = XML_ERROR_NO_MEMORY; | 1728 errorCode = XML_ERROR_NO_MEMORY; |
1684 return NULL; | 1729 return NULL; |
1685 } | 1730 } |
1686 /* END MOZILLA CHANGE */ | |
1687 switch (ps_parsing) { | 1731 switch (ps_parsing) { |
1688 case XML_SUSPENDED: | 1732 case XML_SUSPENDED: |
1689 errorCode = XML_ERROR_SUSPENDED; | 1733 errorCode = XML_ERROR_SUSPENDED; |
1690 return NULL; | 1734 return NULL; |
1691 case XML_FINISHED: | 1735 case XML_FINISHED: |
1692 errorCode = XML_ERROR_FINISHED; | 1736 errorCode = XML_ERROR_FINISHED; |
1693 return NULL; | 1737 return NULL; |
1694 default: ; | 1738 default: ; |
1695 } | 1739 } |
1696 | 1740 |
1697 if (len > bufferLim - bufferEnd) { | 1741 if (len > bufferLim - bufferEnd) { |
1698 int neededSize = len + (int)(bufferEnd - bufferPtr); | 1742 #ifdef XML_CONTEXT_BYTES |
1699 /* BEGIN MOZILLA CHANGE (sanity check neededSize) */ | 1743 int keep; |
| 1744 #endif /* defined XML_CONTEXT_BYTES */ |
| 1745 /* Do not invoke signed arithmetic overflow: */ |
| 1746 int neededSize = (int) ((unsigned)len + (unsigned)(bufferEnd - bufferPtr)); |
1700 if (neededSize < 0) { | 1747 if (neededSize < 0) { |
1701 errorCode = XML_ERROR_NO_MEMORY; | 1748 errorCode = XML_ERROR_NO_MEMORY; |
1702 return NULL; | 1749 return NULL; |
1703 } | 1750 } |
1704 /* END MOZILLA CHANGE */ | |
1705 #ifdef XML_CONTEXT_BYTES | 1751 #ifdef XML_CONTEXT_BYTES |
1706 int keep = (int)(bufferPtr - buffer); | 1752 keep = (int)(bufferPtr - buffer); |
1707 | |
1708 if (keep > XML_CONTEXT_BYTES) | 1753 if (keep > XML_CONTEXT_BYTES) |
1709 keep = XML_CONTEXT_BYTES; | 1754 keep = XML_CONTEXT_BYTES; |
1710 neededSize += keep; | 1755 neededSize += keep; |
1711 #endif /* defined XML_CONTEXT_BYTES */ | 1756 #endif /* defined XML_CONTEXT_BYTES */ |
1712 if (neededSize <= bufferLim - buffer) { | 1757 if (neededSize <= bufferLim - buffer) { |
1713 #ifdef XML_CONTEXT_BYTES | 1758 #ifdef XML_CONTEXT_BYTES |
1714 if (keep < bufferPtr - buffer) { | 1759 if (keep < bufferPtr - buffer) { |
1715 int offset = (int)(bufferPtr - buffer) - keep; | 1760 int offset = (int)(bufferPtr - buffer) - keep; |
1716 memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep); | 1761 memmove(buffer, &buffer[offset], bufferEnd - bufferPtr + keep); |
1717 bufferEnd -= offset; | 1762 bufferEnd -= offset; |
1718 bufferPtr -= offset; | 1763 bufferPtr -= offset; |
1719 } | 1764 } |
1720 #else | 1765 #else |
1721 memmove(buffer, bufferPtr, bufferEnd - bufferPtr); | 1766 memmove(buffer, bufferPtr, bufferEnd - bufferPtr); |
1722 bufferEnd = buffer + (bufferEnd - bufferPtr); | 1767 bufferEnd = buffer + (bufferEnd - bufferPtr); |
1723 bufferPtr = buffer; | 1768 bufferPtr = buffer; |
1724 #endif /* not defined XML_CONTEXT_BYTES */ | 1769 #endif /* not defined XML_CONTEXT_BYTES */ |
1725 } | 1770 } |
1726 else { | 1771 else { |
1727 char *newBuf; | 1772 char *newBuf; |
1728 int bufferSize = (int)(bufferLim - bufferPtr); | 1773 int bufferSize = (int)(bufferLim - bufferPtr); |
1729 if (bufferSize == 0) | 1774 if (bufferSize == 0) |
1730 bufferSize = INIT_BUFFER_SIZE; | 1775 bufferSize = INIT_BUFFER_SIZE; |
1731 do { | 1776 do { |
1732 bufferSize *= 2; | 1777 /* Do not invoke signed arithmetic overflow: */ |
1733 /* BEGIN MOZILLA CHANGE (prevent infinite loop on overflow) */ | 1778 bufferSize = (int) (2U * (unsigned) bufferSize); |
1734 } while (bufferSize < neededSize && bufferSize > 0); | 1779 } while (bufferSize < neededSize && bufferSize > 0); |
1735 /* END MOZILLA CHANGE */ | |
1736 /* BEGIN MOZILLA CHANGE (sanity check bufferSize) */ | |
1737 if (bufferSize <= 0) { | 1780 if (bufferSize <= 0) { |
1738 errorCode = XML_ERROR_NO_MEMORY; | 1781 errorCode = XML_ERROR_NO_MEMORY; |
1739 return NULL; | 1782 return NULL; |
1740 } | 1783 } |
1741 /* END MOZILLA CHANGE */ | |
1742 newBuf = (char *)MALLOC(bufferSize); | 1784 newBuf = (char *)MALLOC(bufferSize); |
1743 if (newBuf == 0) { | 1785 if (newBuf == 0) { |
1744 errorCode = XML_ERROR_NO_MEMORY; | 1786 errorCode = XML_ERROR_NO_MEMORY; |
1745 return NULL; | 1787 return NULL; |
1746 } | 1788 } |
1747 bufferLim = newBuf + bufferSize; | 1789 bufferLim = newBuf + bufferSize; |
1748 #ifdef XML_CONTEXT_BYTES | 1790 #ifdef XML_CONTEXT_BYTES |
1749 if (bufferPtr) { | 1791 if (bufferPtr) { |
1750 int keep = (int)(bufferPtr - buffer); | 1792 int keep = (int)(bufferPtr - buffer); |
1751 if (keep > XML_CONTEXT_BYTES) | 1793 if (keep > XML_CONTEXT_BYTES) |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1853 enum XML_Error XMLCALL | 1895 enum XML_Error XMLCALL |
1854 XML_GetErrorCode(XML_Parser parser) | 1896 XML_GetErrorCode(XML_Parser parser) |
1855 { | 1897 { |
1856 return errorCode; | 1898 return errorCode; |
1857 } | 1899 } |
1858 | 1900 |
1859 XML_Index XMLCALL | 1901 XML_Index XMLCALL |
1860 XML_GetCurrentByteIndex(XML_Parser parser) | 1902 XML_GetCurrentByteIndex(XML_Parser parser) |
1861 { | 1903 { |
1862 if (eventPtr) | 1904 if (eventPtr) |
1863 return parseEndByteIndex - (parseEndPtr - eventPtr); | 1905 return (XML_Index)(parseEndByteIndex - (parseEndPtr - eventPtr)); |
1864 return -1; | 1906 return -1; |
1865 } | 1907 } |
1866 | 1908 |
1867 int XMLCALL | 1909 int XMLCALL |
1868 XML_GetCurrentByteCount(XML_Parser parser) | 1910 XML_GetCurrentByteCount(XML_Parser parser) |
1869 { | 1911 { |
1870 if (eventEndPtr && eventPtr) | 1912 if (eventEndPtr && eventPtr) |
1871 return (int)(eventEndPtr - eventPtr); | 1913 return (int)(eventEndPtr - eventPtr); |
1872 return 0; | 1914 return 0; |
1873 } | 1915 } |
(...skipping 553 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2427 tag->rawName = s + enc->minBytesPerChar; | 2469 tag->rawName = s + enc->minBytesPerChar; |
2428 tag->rawNameLength = XmlNameLength(enc, tag->rawName); | 2470 tag->rawNameLength = XmlNameLength(enc, tag->rawName); |
2429 ++tagLevel; | 2471 ++tagLevel; |
2430 { | 2472 { |
2431 const char *rawNameEnd = tag->rawName + tag->rawNameLength; | 2473 const char *rawNameEnd = tag->rawName + tag->rawNameLength; |
2432 const char *fromPtr = tag->rawName; | 2474 const char *fromPtr = tag->rawName; |
2433 toPtr = (XML_Char *)tag->buf; | 2475 toPtr = (XML_Char *)tag->buf; |
2434 for (;;) { | 2476 for (;;) { |
2435 int bufSize; | 2477 int bufSize; |
2436 int convLen; | 2478 int convLen; |
2437 XmlConvert(enc, | 2479 const enum XML_Convert_Result convert_res = XmlConvert(enc, |
2438 &fromPtr, rawNameEnd, | 2480 &fromPtr, rawNameEnd, |
2439 (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1); | 2481 (ICHAR **)&toPtr, (ICHAR *)tag->bufEnd - 1); |
2440 convLen = (int)(toPtr - (XML_Char *)tag->buf); | 2482 convLen = (int)(toPtr - (XML_Char *)tag->buf); |
2441 if (fromPtr == rawNameEnd) { | 2483 if ((fromPtr >= rawNameEnd) || (convert_res == XML_CONVERT_INPUT_INC
OMPLETE)) { |
2442 tag->name.strLen = convLen; | 2484 tag->name.strLen = convLen; |
2443 break; | 2485 break; |
2444 } | 2486 } |
2445 bufSize = (int)(tag->bufEnd - tag->buf) << 1; | 2487 bufSize = (int)(tag->bufEnd - tag->buf) << 1; |
2446 { | 2488 { |
2447 char *temp = (char *)REALLOC(tag->buf, bufSize); | 2489 char *temp = (char *)REALLOC(tag->buf, bufSize); |
2448 if (temp == NULL) | 2490 if (temp == NULL) |
2449 return XML_ERROR_NO_MEMORY; | 2491 return XML_ERROR_NO_MEMORY; |
2450 tag->buf = temp; | 2492 tag->buf = temp; |
2451 tag->bufEnd = temp + bufSize; | 2493 tag->bufEnd = temp + bufSize; |
(...skipping 200 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2652 } | 2694 } |
2653 *nextPtr = end; | 2695 *nextPtr = end; |
2654 return XML_ERROR_NONE; | 2696 return XML_ERROR_NONE; |
2655 case XML_TOK_DATA_CHARS: | 2697 case XML_TOK_DATA_CHARS: |
2656 { | 2698 { |
2657 XML_CharacterDataHandler charDataHandler = characterDataHandler; | 2699 XML_CharacterDataHandler charDataHandler = characterDataHandler; |
2658 if (charDataHandler) { | 2700 if (charDataHandler) { |
2659 if (MUST_CONVERT(enc, s)) { | 2701 if (MUST_CONVERT(enc, s)) { |
2660 for (;;) { | 2702 for (;;) { |
2661 ICHAR *dataPtr = (ICHAR *)dataBuf; | 2703 ICHAR *dataPtr = (ICHAR *)dataBuf; |
2662 XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); | 2704 const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, ne
xt, &dataPtr, (ICHAR *)dataBufEnd); |
2663 *eventEndPP = s; | 2705 *eventEndPP = s; |
2664 charDataHandler(handlerArg, dataBuf, | 2706 charDataHandler(handlerArg, dataBuf, |
2665 (int)(dataPtr - (ICHAR *)dataBuf)); | 2707 (int)(dataPtr - (ICHAR *)dataBuf)); |
2666 if (s == next) | 2708 if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_
CONVERT_INPUT_INCOMPLETE)) |
2667 break; | 2709 break; |
2668 *eventPP = s; | 2710 *eventPP = s; |
2669 } | 2711 } |
2670 } | 2712 } |
2671 else | 2713 else |
2672 charDataHandler(handlerArg, | 2714 charDataHandler(handlerArg, |
2673 (XML_Char *)s, | 2715 (XML_Char *)s, |
2674 (int)((XML_Char *)next - (XML_Char *)s)); | 2716 (int)((XML_Char *)next - (XML_Char *)s)); |
2675 } | 2717 } |
2676 else if (defaultHandler) | 2718 else if (defaultHandler) |
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2923 | 2965 |
2924 /* expand prefixed names and check for duplicates */ | 2966 /* expand prefixed names and check for duplicates */ |
2925 for (; i < attIndex; i += 2) { | 2967 for (; i < attIndex; i += 2) { |
2926 const XML_Char *s = appAtts[i]; | 2968 const XML_Char *s = appAtts[i]; |
2927 if (s[-1] == 2) { /* prefixed */ | 2969 if (s[-1] == 2) { /* prefixed */ |
2928 ATTRIBUTE_ID *id; | 2970 ATTRIBUTE_ID *id; |
2929 const BINDING *b; | 2971 const BINDING *b; |
2930 unsigned long uriHash = hash_secret_salt; | 2972 unsigned long uriHash = hash_secret_salt; |
2931 ((XML_Char *)s)[-1] = 0; /* clear flag */ | 2973 ((XML_Char *)s)[-1] = 0; /* clear flag */ |
2932 id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0); | 2974 id = (ATTRIBUTE_ID *)lookup(parser, &dtd->attributeIds, s, 0); |
| 2975 if (!id || !id->prefix) |
| 2976 return XML_ERROR_NO_MEMORY; |
2933 b = id->prefix->binding; | 2977 b = id->prefix->binding; |
2934 if (!b) | 2978 if (!b) |
2935 return XML_ERROR_UNBOUND_PREFIX; | 2979 return XML_ERROR_UNBOUND_PREFIX; |
2936 | 2980 |
2937 /* as we expand the name we also calculate its hash value */ | 2981 /* as we expand the name we also calculate its hash value */ |
2938 for (j = 0; j < b->uriLen; j++) { | 2982 for (j = 0; j < b->uriLen; j++) { |
2939 const XML_Char c = b->uri[j]; | 2983 const XML_Char c = b->uri[j]; |
2940 if (!poolAppendChar(&tempPool, c)) | 2984 if (!poolAppendChar(&tempPool, c)) |
2941 return XML_ERROR_NO_MEMORY; | 2985 return XML_ERROR_NO_MEMORY; |
2942 uriHash = CHAR_HASH(uriHash, c); | 2986 uriHash = CHAR_HASH(uriHash, c); |
(...skipping 317 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3260 else if (defaultHandler) | 3304 else if (defaultHandler) |
3261 reportDefault(parser, enc, s, next); | 3305 reportDefault(parser, enc, s, next); |
3262 break; | 3306 break; |
3263 case XML_TOK_DATA_CHARS: | 3307 case XML_TOK_DATA_CHARS: |
3264 { | 3308 { |
3265 XML_CharacterDataHandler charDataHandler = characterDataHandler; | 3309 XML_CharacterDataHandler charDataHandler = characterDataHandler; |
3266 if (charDataHandler) { | 3310 if (charDataHandler) { |
3267 if (MUST_CONVERT(enc, s)) { | 3311 if (MUST_CONVERT(enc, s)) { |
3268 for (;;) { | 3312 for (;;) { |
3269 ICHAR *dataPtr = (ICHAR *)dataBuf; | 3313 ICHAR *dataPtr = (ICHAR *)dataBuf; |
3270 XmlConvert(enc, &s, next, &dataPtr, (ICHAR *)dataBufEnd); | 3314 const enum XML_Convert_Result convert_res = XmlConvert(enc, &s, ne
xt, &dataPtr, (ICHAR *)dataBufEnd); |
3271 *eventEndPP = next; | 3315 *eventEndPP = next; |
3272 charDataHandler(handlerArg, dataBuf, | 3316 charDataHandler(handlerArg, dataBuf, |
3273 (int)(dataPtr - (ICHAR *)dataBuf)); | 3317 (int)(dataPtr - (ICHAR *)dataBuf)); |
3274 if (s == next) | 3318 if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_
CONVERT_INPUT_INCOMPLETE)) |
3275 break; | 3319 break; |
3276 *eventPP = s; | 3320 *eventPP = s; |
3277 } | 3321 } |
3278 } | 3322 } |
3279 else | 3323 else |
3280 charDataHandler(handlerArg, | 3324 charDataHandler(handlerArg, |
3281 (XML_Char *)s, | 3325 (XML_Char *)s, |
3282 (int)((XML_Char *)next - (XML_Char *)s)); | 3326 (int)((XML_Char *)next - (XML_Char *)s)); |
3283 } | 3327 } |
3284 else if (defaultHandler) | 3328 else if (defaultHandler) |
(...skipping 1638 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4923 { | 4967 { |
4924 processor = contentProcessor; | 4968 processor = contentProcessor; |
4925 /* see externalEntityContentProcessor vs contentProcessor */ | 4969 /* see externalEntityContentProcessor vs contentProcessor */ |
4926 return doContent(parser, parentParser ? 1 : 0, encoding, s, end, | 4970 return doContent(parser, parentParser ? 1 : 0, encoding, s, end, |
4927 nextPtr, (XML_Bool)!ps_finalBuffer); | 4971 nextPtr, (XML_Bool)!ps_finalBuffer); |
4928 } | 4972 } |
4929 } | 4973 } |
4930 | 4974 |
4931 static enum XML_Error PTRCALL | 4975 static enum XML_Error PTRCALL |
4932 errorProcessor(XML_Parser parser, | 4976 errorProcessor(XML_Parser parser, |
4933 const char *s, | 4977 const char *UNUSED_P(s), |
4934 const char *end, | 4978 const char *UNUSED_P(end), |
4935 const char **nextPtr) | 4979 const char **UNUSED_P(nextPtr)) |
4936 { | 4980 { |
4937 return errorCode; | 4981 return errorCode; |
4938 } | 4982 } |
4939 | 4983 |
4940 static enum XML_Error | 4984 static enum XML_Error |
4941 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata, | 4985 storeAttributeValue(XML_Parser parser, const ENCODING *enc, XML_Bool isCdata, |
4942 const char *ptr, const char *end, | 4986 const char *ptr, const char *end, |
4943 STRING_POOL *pool) | 4987 STRING_POOL *pool) |
4944 { | 4988 { |
4945 enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, | 4989 enum XML_Error result = appendAttributeValue(parser, enc, isCdata, ptr, |
(...skipping 395 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5341 commentHandler(handlerArg, data); | 5385 commentHandler(handlerArg, data); |
5342 poolClear(&tempPool); | 5386 poolClear(&tempPool); |
5343 return 1; | 5387 return 1; |
5344 } | 5388 } |
5345 | 5389 |
5346 static void | 5390 static void |
5347 reportDefault(XML_Parser parser, const ENCODING *enc, | 5391 reportDefault(XML_Parser parser, const ENCODING *enc, |
5348 const char *s, const char *end) | 5392 const char *s, const char *end) |
5349 { | 5393 { |
5350 if (MUST_CONVERT(enc, s)) { | 5394 if (MUST_CONVERT(enc, s)) { |
| 5395 enum XML_Convert_Result convert_res; |
5351 const char **eventPP; | 5396 const char **eventPP; |
5352 const char **eventEndPP; | 5397 const char **eventEndPP; |
5353 if (enc == encoding) { | 5398 if (enc == encoding) { |
5354 eventPP = &eventPtr; | 5399 eventPP = &eventPtr; |
5355 eventEndPP = &eventEndPtr; | 5400 eventEndPP = &eventEndPtr; |
5356 } | 5401 } |
5357 else { | 5402 else { |
5358 eventPP = &(openInternalEntities->internalEventPtr); | 5403 eventPP = &(openInternalEntities->internalEventPtr); |
5359 eventEndPP = &(openInternalEntities->internalEventEndPtr); | 5404 eventEndPP = &(openInternalEntities->internalEventEndPtr); |
5360 } | 5405 } |
5361 do { | 5406 do { |
5362 ICHAR *dataPtr = (ICHAR *)dataBuf; | 5407 ICHAR *dataPtr = (ICHAR *)dataBuf; |
5363 XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); | 5408 convert_res = XmlConvert(enc, &s, end, &dataPtr, (ICHAR *)dataBufEnd); |
5364 *eventEndPP = s; | 5409 *eventEndPP = s; |
5365 defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf)); | 5410 defaultHandler(handlerArg, dataBuf, (int)(dataPtr - (ICHAR *)dataBuf)); |
5366 *eventPP = s; | 5411 *eventPP = s; |
5367 } while (s != end); | 5412 } while ((convert_res != XML_CONVERT_COMPLETED) && (convert_res != XML_CONVE
RT_INPUT_INCOMPLETE)); |
5368 } | 5413 } |
5369 else | 5414 else |
5370 defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char
*)s)); | 5415 defaultHandler(handlerArg, (XML_Char *)s, (int)((XML_Char *)end - (XML_Char
*)s)); |
5371 } | 5416 } |
5372 | 5417 |
5373 | 5418 |
5374 static int | 5419 static int |
5375 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata, | 5420 defineAttribute(ELEMENT_TYPE *type, ATTRIBUTE_ID *attId, XML_Bool isCdata, |
5376 XML_Bool isId, const XML_Char *value, XML_Parser parser) | 5421 XML_Bool isId, const XML_Char *value, XML_Parser parser) |
5377 { | 5422 { |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5487 if (name[i] == XML_T(ASCII_COLON)) { | 5532 if (name[i] == XML_T(ASCII_COLON)) { |
5488 int j; | 5533 int j; |
5489 for (j = 0; j < i; j++) { | 5534 for (j = 0; j < i; j++) { |
5490 if (!poolAppendChar(&dtd->pool, name[j])) | 5535 if (!poolAppendChar(&dtd->pool, name[j])) |
5491 return NULL; | 5536 return NULL; |
5492 } | 5537 } |
5493 if (!poolAppendChar(&dtd->pool, XML_T('\0'))) | 5538 if (!poolAppendChar(&dtd->pool, XML_T('\0'))) |
5494 return NULL; | 5539 return NULL; |
5495 id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->
pool), | 5540 id->prefix = (PREFIX *)lookup(parser, &dtd->prefixes, poolStart(&dtd->
pool), |
5496 sizeof(PREFIX)); | 5541 sizeof(PREFIX)); |
| 5542 if (!id->prefix) |
| 5543 return NULL; |
5497 if (id->prefix->name == poolStart(&dtd->pool)) | 5544 if (id->prefix->name == poolStart(&dtd->pool)) |
5498 poolFinish(&dtd->pool); | 5545 poolFinish(&dtd->pool); |
5499 else | 5546 else |
5500 poolDiscard(&dtd->pool); | 5547 poolDiscard(&dtd->pool); |
5501 break; | 5548 break; |
5502 } | 5549 } |
5503 } | 5550 } |
5504 } | 5551 } |
5505 } | 5552 } |
5506 return id; | 5553 return id; |
(...skipping 327 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5834 if (!name) | 5881 if (!name) |
5835 return 0; | 5882 return 0; |
5836 newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name, | 5883 newE = (ELEMENT_TYPE *)lookup(oldParser, &(newDtd->elementTypes), name, |
5837 sizeof(ELEMENT_TYPE)); | 5884 sizeof(ELEMENT_TYPE)); |
5838 if (!newE) | 5885 if (!newE) |
5839 return 0; | 5886 return 0; |
5840 if (oldE->nDefaultAtts) { | 5887 if (oldE->nDefaultAtts) { |
5841 newE->defaultAtts = (DEFAULT_ATTRIBUTE *) | 5888 newE->defaultAtts = (DEFAULT_ATTRIBUTE *) |
5842 ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE)); | 5889 ms->malloc_fcn(oldE->nDefaultAtts * sizeof(DEFAULT_ATTRIBUTE)); |
5843 if (!newE->defaultAtts) { | 5890 if (!newE->defaultAtts) { |
5844 ms->free_fcn(newE); | |
5845 return 0; | 5891 return 0; |
5846 } | 5892 } |
5847 } | 5893 } |
5848 if (oldE->idAtt) | 5894 if (oldE->idAtt) |
5849 newE->idAtt = (ATTRIBUTE_ID *) | 5895 newE->idAtt = (ATTRIBUTE_ID *) |
5850 lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0); | 5896 lookup(oldParser, &(newDtd->attributeIds), oldE->idAtt->name, 0); |
5851 newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts; | 5897 newE->allocDefaultAtts = newE->nDefaultAtts = oldE->nDefaultAtts; |
5852 if (oldE->prefix) | 5898 if (oldE->prefix) |
5853 newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes), | 5899 newE->prefix = (PREFIX *)lookup(oldParser, &(newDtd->prefixes), |
5854 oldE->prefix->name, 0); | 5900 oldE->prefix->name, 0); |
(...skipping 305 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6160 } | 6206 } |
6161 } | 6207 } |
6162 | 6208 |
6163 static XML_Char * | 6209 static XML_Char * |
6164 poolAppend(STRING_POOL *pool, const ENCODING *enc, | 6210 poolAppend(STRING_POOL *pool, const ENCODING *enc, |
6165 const char *ptr, const char *end) | 6211 const char *ptr, const char *end) |
6166 { | 6212 { |
6167 if (!pool->ptr && !poolGrow(pool)) | 6213 if (!pool->ptr && !poolGrow(pool)) |
6168 return NULL; | 6214 return NULL; |
6169 for (;;) { | 6215 for (;;) { |
6170 XmlConvert(enc, &ptr, end, (ICHAR **)&(pool->ptr), (ICHAR *)pool->end); | 6216 const enum XML_Convert_Result convert_res = XmlConvert(enc, &ptr, end, (ICHA
R **)&(pool->ptr), (ICHAR *)pool->end); |
6171 if (ptr == end) | 6217 if ((convert_res == XML_CONVERT_COMPLETED) || (convert_res == XML_CONVERT_IN
PUT_INCOMPLETE)) |
6172 break; | 6218 break; |
6173 if (!poolGrow(pool)) | 6219 if (!poolGrow(pool)) |
6174 return NULL; | 6220 return NULL; |
6175 } | 6221 } |
6176 return pool->start; | 6222 return pool->start; |
6177 } | 6223 } |
6178 | 6224 |
6179 static const XML_Char * FASTCALL | 6225 static const XML_Char * FASTCALL |
6180 poolCopyString(STRING_POOL *pool, const XML_Char *s) | 6226 poolCopyString(STRING_POOL *pool, const XML_Char *s) |
6181 { | 6227 { |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6245 pool->freeBlocks = tem; | 6291 pool->freeBlocks = tem; |
6246 memcpy(pool->blocks->s, pool->start, | 6292 memcpy(pool->blocks->s, pool->start, |
6247 (pool->end - pool->start) * sizeof(XML_Char)); | 6293 (pool->end - pool->start) * sizeof(XML_Char)); |
6248 pool->ptr = pool->blocks->s + (pool->ptr - pool->start); | 6294 pool->ptr = pool->blocks->s + (pool->ptr - pool->start); |
6249 pool->start = pool->blocks->s; | 6295 pool->start = pool->blocks->s; |
6250 pool->end = pool->start + pool->blocks->size; | 6296 pool->end = pool->start + pool->blocks->size; |
6251 return XML_TRUE; | 6297 return XML_TRUE; |
6252 } | 6298 } |
6253 } | 6299 } |
6254 if (pool->blocks && pool->start == pool->blocks->s) { | 6300 if (pool->blocks && pool->start == pool->blocks->s) { |
6255 int blockSize = (int)(pool->end - pool->start)*2; | 6301 BLOCK *temp; |
6256 BLOCK *temp = (BLOCK *) | 6302 int blockSize = (int)((unsigned)(pool->end - pool->start)*2U); |
| 6303 |
| 6304 if (blockSize < 0) |
| 6305 return XML_FALSE; |
| 6306 |
| 6307 temp = (BLOCK *) |
6257 pool->mem->realloc_fcn(pool->blocks, | 6308 pool->mem->realloc_fcn(pool->blocks, |
6258 (offsetof(BLOCK, s) | 6309 (offsetof(BLOCK, s) |
6259 + blockSize * sizeof(XML_Char))); | 6310 + blockSize * sizeof(XML_Char))); |
6260 if (temp == NULL) | 6311 if (temp == NULL) |
6261 return XML_FALSE; | 6312 return XML_FALSE; |
6262 pool->blocks = temp; | 6313 pool->blocks = temp; |
6263 pool->blocks->size = blockSize; | 6314 pool->blocks->size = blockSize; |
6264 pool->ptr = pool->blocks->s + (pool->ptr - pool->start); | 6315 pool->ptr = pool->blocks->s + (pool->ptr - pool->start); |
6265 pool->start = pool->blocks->s; | 6316 pool->start = pool->blocks->s; |
6266 pool->end = pool->start + blockSize; | 6317 pool->end = pool->start + blockSize; |
6267 } | 6318 } |
6268 else { | 6319 else { |
6269 BLOCK *tem; | 6320 BLOCK *tem; |
6270 int blockSize = (int)(pool->end - pool->start); | 6321 int blockSize = (int)(pool->end - pool->start); |
| 6322 |
| 6323 if (blockSize < 0) |
| 6324 return XML_FALSE; |
| 6325 |
6271 if (blockSize < INIT_BLOCK_SIZE) | 6326 if (blockSize < INIT_BLOCK_SIZE) |
6272 blockSize = INIT_BLOCK_SIZE; | 6327 blockSize = INIT_BLOCK_SIZE; |
6273 else | 6328 else |
6274 blockSize *= 2; | 6329 blockSize *= 2; |
6275 tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s) | 6330 tem = (BLOCK *)pool->mem->malloc_fcn(offsetof(BLOCK, s) |
6276 + blockSize * sizeof(XML_Char)); | 6331 + blockSize * sizeof(XML_Char)); |
6277 if (!tem) | 6332 if (!tem) |
6278 return XML_FALSE; | 6333 return XML_FALSE; |
6279 tem->size = blockSize; | 6334 tem->size = blockSize; |
6280 tem->next = pool->blocks; | 6335 tem->next = pool->blocks; |
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
6413 return NULL; | 6468 return NULL; |
6414 if (ret->name != name) | 6469 if (ret->name != name) |
6415 poolDiscard(&dtd->pool); | 6470 poolDiscard(&dtd->pool); |
6416 else { | 6471 else { |
6417 poolFinish(&dtd->pool); | 6472 poolFinish(&dtd->pool); |
6418 if (!setElementTypePrefix(parser, ret)) | 6473 if (!setElementTypePrefix(parser, ret)) |
6419 return NULL; | 6474 return NULL; |
6420 } | 6475 } |
6421 return ret; | 6476 return ret; |
6422 } | 6477 } |
OLD | NEW |