VirtualBox

儲存庫 vbox 的更動 44084


忽略:
時間撮記:
2012-12-10 下午04:40:47 (12 年 以前)
作者:
vboxsync
訊息:

libxml2: fixes from upstream

位置:
trunk/src/libs/libxml2-2.6.31
檔案:
修改 2 筆資料

圖例:

未更動
新增
刪除

  • trunk/src/libs/libxml2-2.6.31/entities.c

    r39921 r44084  
    473473 */
    474474#define growBufferReentrant() {                                         \
    475     buffer_size *= 2;                                                   \
    476     buffer = (xmlChar *)                                                \
    477                 xmlRealloc(buffer, buffer_size * sizeof(xmlChar));      \
    478     if (buffer == NULL) {                                               \
    479         xmlEntitiesErrMemory("xmlEncodeEntitiesReentrant: realloc failed");\
    480         return(NULL);                                                   \
    481     }                                                                   \
     475    xmlChar *tmp;                                                       \
     476    size_t new_size = buffer_size * 2;                                  \
     477    if (new_size < buffer_size) goto mem_error;                         \
     478    tmp = (xmlChar *) xmlRealloc(buffer, new_size);                     \
     479    if (tmp == NULL) goto mem_error;                                    \
     480    buffer = tmp;                                                       \
     481    buffer_size = new_size;                                             \
    482482}
    483483
    … …  
    500500    xmlChar *buffer = NULL;
    501501    xmlChar *out = NULL;
    502     int buffer_size = 0;
     502    size_t buffer_size = 0;
    503503    int html = 0;
    504504
    … …  
    519519
    520520    while (*cur != '\0') {
    521         if (out - buffer > buffer_size - 100) {
    522             int indx = out - buffer;
     521        size_t indx = out - buffer;
     522        if (indx + 100 > buffer_size) {
    523523
    524524            growBufferReentrant();
    … …  
    637637    *out++ = 0;
    638638    return(buffer);
     639
     640mem_error:
     641    xmlEntitiesErrMemory("xmlEncodeEntitiesReentrant: realloc failed");
     642    xmlFree(buffer);
     643    return(NULL);
    639644}
    640645
    … …  
    654659    xmlChar *buffer = NULL;
    655660    xmlChar *out = NULL;
    656     int buffer_size = 0;
     661    size_t buffer_size = 0;
    657662    if (input == NULL) return(NULL);
    658663
    … …  
    669674
    670675    while (*cur != '\0') {
    671         if (out - buffer > buffer_size - 10) {
    672             int indx = out - buffer;
     676        size_t indx = out - buffer;
     677        if (indx + 10 > buffer_size) {
    673678
    674679            growBufferReentrant();
    … …  
    719724    *out++ = 0;
    720725    return(buffer);
     726
     727mem_error:
     728    xmlEntitiesErrMemory("xmlEncodeSpecialChars: realloc failed");
     729    xmlFree(buffer);
     730    return(NULL);
    721731}
    722732

  • trunk/src/libs/libxml2-2.6.31/parser.c

    r39921 r44084  
    4141
    4242#include <stdlib.h>
     43#include <limits.h>
    4344#include <string.h>
    4445#include <stdarg.h>
    … …  
    110111 */
    111112static int
    112 xmlParserEntityCheck(xmlParserCtxtPtr ctxt, unsigned long size,
     113xmlParserEntityCheck(xmlParserCtxtPtr ctxt, size_t size,
    113114                     xmlEntityPtr ent)
    114115{
    115     unsigned long consumed = 0;
     116    size_t consumed = 0;
    116117
    117118    if (ctxt == NULL)
    … …  
    22702271#define growBuffer(buffer, n) {                                         \
    22712272    xmlChar *tmp;                                                       \
    2272     buffer##_size *= 2;                                                 \
    2273     buffer##_size += n;                                                 \
    2274     tmp = (xmlChar *)                                                   \
    2275                 xmlRealloc(buffer, buffer##_size * sizeof(xmlChar));    \
     2273    size_t new_size = buffer##_size * 2 + n;                            \
     2274    if (new_size < buffer##_size) goto mem_error;                       \
     2275    tmp = (xmlChar *) xmlRealloc(buffer, new_size);                     \
    22762276    if (tmp == NULL) goto mem_error;                                    \
    22772277    buffer = tmp;                                                       \
     2278    buffer##_size = new_size;                                           \
    22782279}
    22792280
    … …  
    23012302                      int what, xmlChar end, xmlChar  end2, xmlChar end3) {
    23022303    xmlChar *buffer = NULL;
    2303     int buffer_size = 0;
     2304    size_t buffer_size = 0;
     2305    size_t nbchars = 0;
    23042306
    23052307    xmlChar *current = NULL;
    … …  
    23072309    xmlEntityPtr ent;
    23082310    int c,l;
    2309     int nbchars = 0;
    23102311
    23112312    if ((ctxt == NULL) || (str == NULL) || (len < 0))
    … …  
    23222323     */
    23232324    buffer_size = XML_PARSER_BIG_BUFFER_SIZE;
    2324     buffer = (xmlChar *) xmlMallocAtomic(buffer_size * sizeof(xmlChar));
     2325    buffer = (xmlChar *) xmlMallocAtomic(buffer_size);
    23252326    if (buffer == NULL) goto mem_error;
    23262327
    … …  
    23422343                COPY_BUF(0,buffer,nbchars,val);
    23432344            }
    2344             if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
     2345            if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
    23452346                growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
    23462347            }
    … …  
    23592360                if (ent->content != NULL) {
    23602361                    COPY_BUF(0,buffer,nbchars,ent->content[0]);
    2361                     if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
     2362                    if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
    23622363                        growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
    23632364                    }
    … …  
    23772378                    while (*current != 0) { /* non input consuming loop */
    23782379                        buffer[nbchars++] = *current++;
    2379                         if (nbchars >
    2380                             buffer_size - XML_PARSER_BUFFER_SIZE) {
     2380                        if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
    23812381                            if (xmlParserEntityCheck(ctxt, nbchars, ent)) {
    23822382                                xmlFree(rep);
    … …  
    23932393
    23942394                buffer[nbchars++] = '&';
    2395                 if (nbchars > buffer_size - i - XML_PARSER_BUFFER_SIZE) {
     2395                if (nbchars + i + XML_PARSER_BUFFER_SIZE > buffer_size) {
    23962396                    growBuffer(buffer, i + XML_PARSER_BUFFER_SIZE);
    23972397                }
    … …  
    24202420                    while (*current != 0) { /* non input consuming loop */
    24212421                        buffer[nbchars++] = *current++;
    2422                         if (nbchars >
    2423                             buffer_size - XML_PARSER_BUFFER_SIZE) {
     2422                        if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
    24242423                            if (xmlParserEntityCheck(ctxt, nbchars, ent)) {
    24252424                                xmlFree(rep);
    … …  
    24352434            COPY_BUF(l,buffer,nbchars,c);
    24362435            str += l;
    2437             if (nbchars > buffer_size - XML_PARSER_BUFFER_SIZE) {
    2438               growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
     2436            if (nbchars + XML_PARSER_BUFFER_SIZE > buffer_size) {
     2437                growBuffer(buffer, XML_PARSER_BUFFER_SIZE);
    24392438            }
    24402439        }
    … …  
    31953194    xmlChar limit = 0;
    31963195    xmlChar *buf = NULL;
    3197     int len = 0;
    3198     int buf_size = 0;
     3196    size_t len = 0;
     3197    size_t buf_size = 0;
    31993198    int c, l, in_space = 0;
    32003199    xmlChar *current = NULL;
    … …  
    32183217     */
    32193218    buf_size = XML_PARSER_BUFFER_SIZE;
    3220     buf = (xmlChar *) xmlMallocAtomic(buf_size * sizeof(xmlChar));
     3219    buf = (xmlChar *) xmlMallocAtomic(buf_size);
    32213220    if (buf == NULL) goto mem_error;
    32223221
    … …  
    32353234                if (val == '&') {
    32363235                    if (ctxt->replaceEntities) {
    3237                         if (len > buf_size - 10) {
     3236                        if (len + 10 > buf_size) {
    32383237                            growBuffer(buf, 10);
    32393238                        }
    … …  
    32443243                         * called by the attribute() function in SAX.c
    32453244                         */
    3246                         if (len > buf_size - 10) {
     3245                        if (len + 10 > buf_size) {
    32473246                            growBuffer(buf, 10);
    32483247                        }
    … …  
    32543253                    }
    32553254                } else {
    3256                     if (len > buf_size - 10) {
     3255                    if (len + 10 > buf_size) {
    32573256                        growBuffer(buf, 10);
    32583257                    }
    … …  
    32663265                if ((ent != NULL) &&
    32673266                    (ent->etype == XML_INTERNAL_PREDEFINED_ENTITY)) {
    3268                     if (len > buf_size - 10) {
     3267                    if (len + 10 > buf_size) {
    32693268                        growBuffer(buf, 10);
    32703269                    }
    … …  
    32913290                            while (*current != 0) { /* non input consuming */
    32923291                                buf[len++] = *current++;
    3293                                 if (len > buf_size - 10) {
     3292                                if (len + 10 > buf_size) {
    32943293                                    growBuffer(buf, 10);
    32953294                                }
    … …  
    32983297                        }
    32993298                    } else {
    3300                         if (len > buf_size - 10) {
     3299                        if (len + 10 > buf_size) {
    33013300                            growBuffer(buf, 10);
    33023301                        }
    … …  
    33253324                     */
    33263325                    buf[len++] = '&';
    3327                     while (len > buf_size - i - 10) {
     3326                    while (len + i + 10 > buf_size) {
    33283327                        growBuffer(buf, i + 10);
    33293328                    }
    … …  
    33383337                    if ((!normalize) || (!in_space)) {
    33393338                        COPY_BUF(l,buf,len,0x20);
    3340                         if (len > buf_size - 10) {
     3339                        if (len + 10 > buf_size) {
    33413340                            growBuffer(buf, 10);
    33423341                        }
    … …  
    33473346                in_space = 0;
    33483347                COPY_BUF(l,buf,len,c);
    3349                 if (len > buf_size - 10) {
     3348                if (len + 10 > buf_size) {
    33503349                    growBuffer(buf, 10);
    33513350                }
    … …  
    33573356    }
    33583357    if ((in_space) && (normalize)) {
    3359         while (buf[len - 1] == 0x20) len--;
     3358        while ((len > 0) && (buf[len - 1] == 0x20)) len--;
    33603359    }
    33613360    buf[len] = 0;
    … …  
    33723371    } else
    33733372        NEXT;
    3374     if (attlen != NULL) *attlen = len;
     3373
     3374    /*
     3375     * There we potentially risk an overflow, don't allow attribute value of
     3376     * lenght more than INT_MAX it is a very reasonnable assumption !
     3377     */
     3378    if (len >= INT_MAX) {
     3379        xmlFatalErrMsg(ctxt, XML_ERR_ATTRIBUTE_NOT_FINISHED,
     3380                       "AttValue lenght too long\n");
     3381        goto mem_error;
     3382    }
     3383
     3384    if (attlen != NULL) *attlen = (int) len;
    33753385    return(buf);
    33763386
注意: 瀏覽 TracChangeset 來幫助您使用更動檢視器

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette