Annotation of embedaddon/libxml2/buf.c, revision 1.1
1.1 ! misho 1: /*
! 2: * buf.c: memory buffers for libxml2
! 3: *
! 4: * new buffer structures and entry points to simplify the maintainance
! 5: * of libxml2 and ensure we keep good control over memory allocations
! 6: * and stay 64 bits clean.
! 7: * The new entry point use the xmlBufPtr opaque structure and
! 8: * xmlBuf...() counterparts to the old xmlBuf...() functions
! 9: *
! 10: * See Copyright for the status of this software.
! 11: *
! 12: * daniel@veillard.com
! 13: */
! 14:
! 15: #define IN_LIBXML
! 16: #include "libxml.h"
! 17:
! 18: #include <string.h> /* for memset() only ! */
! 19: #include <limits.h>
! 20: #ifdef HAVE_CTYPE_H
! 21: #include <ctype.h>
! 22: #endif
! 23: #ifdef HAVE_STDLIB_H
! 24: #include <stdlib.h>
! 25: #endif
! 26:
! 27: #include <libxml/tree.h>
! 28: #include <libxml/globals.h>
! 29: #include <libxml/tree.h>
! 30: #include "buf.h"
! 31:
! 32: #define WITH_BUFFER_COMPAT
! 33:
! 34: /**
! 35: * xmlBuf:
! 36: *
! 37: * A buffer structure. The base of the structure is somehow compatible
! 38: * with struct _xmlBuffer to limit risks on application which accessed
! 39: * directly the input->buf->buffer structures.
! 40: */
! 41:
! 42: struct _xmlBuf {
! 43: xmlChar *content; /* The buffer content UTF8 */
! 44: unsigned int compat_use; /* for binary compatibility */
! 45: unsigned int compat_size; /* for binary compatibility */
! 46: xmlBufferAllocationScheme alloc; /* The realloc method */
! 47: xmlChar *contentIO; /* in IO mode we may have a different base */
! 48: size_t use; /* The buffer size used */
! 49: size_t size; /* The buffer size */
! 50: xmlBufferPtr buffer; /* wrapper for an old buffer */
! 51: int error; /* an error code if a failure occured */
! 52: };
! 53:
! 54: #ifdef WITH_BUFFER_COMPAT
! 55: /*
! 56: * Macro for compatibility with xmlBuffer to be used after an xmlBuf
! 57: * is updated. This makes sure the compat fields are updated too.
! 58: */
! 59: #define UPDATE_COMPAT(buf) \
! 60: if (buf->size < INT_MAX) buf->compat_size = buf->size; \
! 61: else buf->compat_size = INT_MAX; \
! 62: if (buf->use < INT_MAX) buf->compat_use = buf->use; \
! 63: else buf->compat_use = INT_MAX;
! 64:
! 65: /*
! 66: * Macro for compatibility with xmlBuffer to be used in all the xmlBuf
! 67: * entry points, it checks that the compat fields have not been modified
! 68: * by direct call to xmlBuffer function from code compiled before 2.9.0 .
! 69: */
! 70: #define CHECK_COMPAT(buf) \
! 71: if (buf->size != (size_t) buf->compat_size) \
! 72: if (buf->compat_size < INT_MAX) \
! 73: buf->size = buf->compat_size; \
! 74: if (buf->use != (size_t) buf->compat_use) \
! 75: if (buf->compat_use < INT_MAX) \
! 76: buf->use = buf->compat_use;
! 77:
! 78: #else /* ! WITH_BUFFER_COMPAT */
! 79: #define UPDATE_COMPAT(buf)
! 80: #define CHECK_COMPAT(buf)
! 81: #endif /* WITH_BUFFER_COMPAT */
! 82:
! 83: /**
! 84: * xmlBufMemoryError:
! 85: * @extra: extra informations
! 86: *
! 87: * Handle an out of memory condition
! 88: * To be improved...
! 89: */
! 90: static void
! 91: xmlBufMemoryError(xmlBufPtr buf, const char *extra)
! 92: {
! 93: __xmlSimpleError(XML_FROM_BUFFER, XML_ERR_NO_MEMORY, NULL, NULL, extra);
! 94: if ((buf) && (buf->error == 0))
! 95: buf->error = XML_ERR_NO_MEMORY;
! 96: }
! 97:
! 98: /**
! 99: * xmlBufOverflowError:
! 100: * @extra: extra informations
! 101: *
! 102: * Handle a buffer overflow error
! 103: * To be improved...
! 104: */
! 105: static void
! 106: xmlBufOverflowError(xmlBufPtr buf, const char *extra)
! 107: {
! 108: __xmlSimpleError(XML_FROM_BUFFER, XML_BUF_OVERFLOW, NULL, NULL, extra);
! 109: if ((buf) && (buf->error == 0))
! 110: buf->error = XML_BUF_OVERFLOW;
! 111: }
! 112:
! 113:
! 114: /**
! 115: * xmlBufCreate:
! 116: *
! 117: * routine to create an XML buffer.
! 118: * returns the new structure.
! 119: */
! 120: xmlBufPtr
! 121: xmlBufCreate(void) {
! 122: xmlBufPtr ret;
! 123:
! 124: ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
! 125: if (ret == NULL) {
! 126: xmlBufMemoryError(NULL, "creating buffer");
! 127: return(NULL);
! 128: }
! 129: ret->compat_use = 0;
! 130: ret->use = 0;
! 131: ret->error = 0;
! 132: ret->buffer = NULL;
! 133: ret->size = xmlDefaultBufferSize;
! 134: ret->compat_size = xmlDefaultBufferSize;
! 135: ret->alloc = xmlBufferAllocScheme;
! 136: ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
! 137: if (ret->content == NULL) {
! 138: xmlBufMemoryError(ret, "creating buffer");
! 139: xmlFree(ret);
! 140: return(NULL);
! 141: }
! 142: ret->content[0] = 0;
! 143: ret->contentIO = NULL;
! 144: return(ret);
! 145: }
! 146:
! 147: /**
! 148: * xmlBufCreateSize:
! 149: * @size: initial size of buffer
! 150: *
! 151: * routine to create an XML buffer.
! 152: * returns the new structure.
! 153: */
! 154: xmlBufPtr
! 155: xmlBufCreateSize(size_t size) {
! 156: xmlBufPtr ret;
! 157:
! 158: ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
! 159: if (ret == NULL) {
! 160: xmlBufMemoryError(NULL, "creating buffer");
! 161: return(NULL);
! 162: }
! 163: ret->compat_use = 0;
! 164: ret->use = 0;
! 165: ret->error = 0;
! 166: ret->buffer = NULL;
! 167: ret->alloc = xmlBufferAllocScheme;
! 168: ret->size = (size ? size+2 : 0); /* +1 for ending null */
! 169: ret->compat_size = (int) ret->size;
! 170: if (ret->size){
! 171: ret->content = (xmlChar *) xmlMallocAtomic(ret->size * sizeof(xmlChar));
! 172: if (ret->content == NULL) {
! 173: xmlBufMemoryError(ret, "creating buffer");
! 174: xmlFree(ret);
! 175: return(NULL);
! 176: }
! 177: ret->content[0] = 0;
! 178: } else
! 179: ret->content = NULL;
! 180: ret->contentIO = NULL;
! 181: return(ret);
! 182: }
! 183:
! 184: /**
! 185: * xmlBufDetach:
! 186: * @buf: the buffer
! 187: *
! 188: * Remove the string contained in a buffer and give it back to the
! 189: * caller. The buffer is reset to an empty content.
! 190: * This doesn't work with immutable buffers as they can't be reset.
! 191: *
! 192: * Returns the previous string contained by the buffer.
! 193: */
! 194: xmlChar *
! 195: xmlBufDetach(xmlBufPtr buf) {
! 196: xmlChar *ret;
! 197:
! 198: if (buf == NULL)
! 199: return(NULL);
! 200: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
! 201: return(NULL);
! 202: if (buf->buffer != NULL)
! 203: return(NULL);
! 204: if (buf->error)
! 205: return(NULL);
! 206:
! 207: ret = buf->content;
! 208: buf->content = NULL;
! 209: buf->size = 0;
! 210: buf->use = 0;
! 211: buf->compat_use = 0;
! 212: buf->compat_size = 0;
! 213:
! 214: return ret;
! 215: }
! 216:
! 217:
! 218: /**
! 219: * xmlBufCreateStatic:
! 220: * @mem: the memory area
! 221: * @size: the size in byte
! 222: *
! 223: * routine to create an XML buffer from an immutable memory area.
! 224: * The area won't be modified nor copied, and is expected to be
! 225: * present until the end of the buffer lifetime.
! 226: *
! 227: * returns the new structure.
! 228: */
! 229: xmlBufPtr
! 230: xmlBufCreateStatic(void *mem, size_t size) {
! 231: xmlBufPtr ret;
! 232:
! 233: if ((mem == NULL) || (size == 0))
! 234: return(NULL);
! 235:
! 236: ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
! 237: if (ret == NULL) {
! 238: xmlBufMemoryError(NULL, "creating buffer");
! 239: return(NULL);
! 240: }
! 241: if (size < INT_MAX) {
! 242: ret->compat_use = size;
! 243: ret->compat_size = size;
! 244: } else {
! 245: ret->compat_use = INT_MAX;
! 246: ret->compat_size = INT_MAX;
! 247: }
! 248: ret->use = size;
! 249: ret->size = size;
! 250: ret->alloc = XML_BUFFER_ALLOC_IMMUTABLE;
! 251: ret->content = (xmlChar *) mem;
! 252: ret->error = 0;
! 253: ret->buffer = NULL;
! 254: return(ret);
! 255: }
! 256:
! 257: /**
! 258: * xmlBufGetAllocationScheme:
! 259: * @buf: the buffer
! 260: *
! 261: * Get the buffer allocation scheme
! 262: *
! 263: * Returns the scheme or -1 in case of error
! 264: */
! 265: int
! 266: xmlBufGetAllocationScheme(xmlBufPtr buf) {
! 267: if (buf == NULL) {
! 268: #ifdef DEBUG_BUFFER
! 269: xmlGenericError(xmlGenericErrorContext,
! 270: "xmlBufGetAllocationScheme: buf == NULL\n");
! 271: #endif
! 272: return(-1);
! 273: }
! 274: return(buf->alloc);
! 275: }
! 276:
! 277: /**
! 278: * xmlBufSetAllocationScheme:
! 279: * @buf: the buffer to tune
! 280: * @scheme: allocation scheme to use
! 281: *
! 282: * Sets the allocation scheme for this buffer
! 283: *
! 284: * returns 0 in case of success and -1 in case of failure
! 285: */
! 286: int
! 287: xmlBufSetAllocationScheme(xmlBufPtr buf,
! 288: xmlBufferAllocationScheme scheme) {
! 289: if ((buf == NULL) || (buf->error != 0)) {
! 290: #ifdef DEBUG_BUFFER
! 291: xmlGenericError(xmlGenericErrorContext,
! 292: "xmlBufSetAllocationScheme: buf == NULL or in error\n");
! 293: #endif
! 294: return(-1);
! 295: }
! 296: if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
! 297: (buf->alloc == XML_BUFFER_ALLOC_IO))
! 298: return(-1);
! 299: if ((scheme == XML_BUFFER_ALLOC_DOUBLEIT) ||
! 300: (scheme == XML_BUFFER_ALLOC_EXACT) ||
! 301: (scheme == XML_BUFFER_ALLOC_HYBRID) ||
! 302: (scheme == XML_BUFFER_ALLOC_IMMUTABLE)) {
! 303: buf->alloc = scheme;
! 304: if (buf->buffer)
! 305: buf->buffer->alloc = scheme;
! 306: return(0);
! 307: }
! 308: /*
! 309: * Switching a buffer ALLOC_IO has the side effect of initializing
! 310: * the contentIO field with the current content
! 311: */
! 312: if (scheme == XML_BUFFER_ALLOC_IO) {
! 313: buf->alloc = XML_BUFFER_ALLOC_IO;
! 314: buf->contentIO = buf->content;
! 315: }
! 316: return(-1);
! 317: }
! 318:
! 319: /**
! 320: * xmlBufFree:
! 321: * @buf: the buffer to free
! 322: *
! 323: * Frees an XML buffer. It frees both the content and the structure which
! 324: * encapsulate it.
! 325: */
! 326: void
! 327: xmlBufFree(xmlBufPtr buf) {
! 328: if (buf == NULL) {
! 329: #ifdef DEBUG_BUFFER
! 330: xmlGenericError(xmlGenericErrorContext,
! 331: "xmlBufFree: buf == NULL\n");
! 332: #endif
! 333: return;
! 334: }
! 335:
! 336: if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
! 337: (buf->contentIO != NULL)) {
! 338: xmlFree(buf->contentIO);
! 339: } else if ((buf->content != NULL) &&
! 340: (buf->alloc != XML_BUFFER_ALLOC_IMMUTABLE)) {
! 341: xmlFree(buf->content);
! 342: }
! 343: xmlFree(buf);
! 344: }
! 345:
! 346: /**
! 347: * xmlBufEmpty:
! 348: * @buf: the buffer
! 349: *
! 350: * empty a buffer.
! 351: */
! 352: void
! 353: xmlBufEmpty(xmlBufPtr buf) {
! 354: if ((buf == NULL) || (buf->error != 0)) return;
! 355: if (buf->content == NULL) return;
! 356: CHECK_COMPAT(buf)
! 357: buf->use = 0;
! 358: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) {
! 359: buf->content = BAD_CAST "";
! 360: } else if ((buf->alloc == XML_BUFFER_ALLOC_IO) &&
! 361: (buf->contentIO != NULL)) {
! 362: size_t start_buf = buf->content - buf->contentIO;
! 363:
! 364: buf->size += start_buf;
! 365: buf->content = buf->contentIO;
! 366: buf->content[0] = 0;
! 367: } else {
! 368: buf->content[0] = 0;
! 369: }
! 370: UPDATE_COMPAT(buf)
! 371: }
! 372:
! 373: /**
! 374: * xmlBufShrink:
! 375: * @buf: the buffer to dump
! 376: * @len: the number of xmlChar to remove
! 377: *
! 378: * Remove the beginning of an XML buffer.
! 379: * NOTE that this routine behaviour differs from xmlBufferShrink()
! 380: * as it will return 0 on error instead of -1 due to size_t being
! 381: * used as the return type.
! 382: *
! 383: * Returns the number of byte removed or 0 in case of failure
! 384: */
! 385: size_t
! 386: xmlBufShrink(xmlBufPtr buf, size_t len) {
! 387: if ((buf == NULL) || (buf->error != 0)) return(0);
! 388: CHECK_COMPAT(buf)
! 389: if (len == 0) return(0);
! 390: if (len > buf->use) return(0);
! 391:
! 392: buf->use -= len;
! 393: if ((buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) ||
! 394: ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL))) {
! 395: /*
! 396: * we just move the content pointer, but also make sure
! 397: * the perceived buffer size has shrinked accordingly
! 398: */
! 399: buf->content += len;
! 400: buf->size -= len;
! 401:
! 402: /*
! 403: * sometimes though it maybe be better to really shrink
! 404: * on IO buffers
! 405: */
! 406: if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
! 407: size_t start_buf = buf->content - buf->contentIO;
! 408: if (start_buf >= buf->size) {
! 409: memmove(buf->contentIO, &buf->content[0], buf->use);
! 410: buf->content = buf->contentIO;
! 411: buf->content[buf->use] = 0;
! 412: buf->size += start_buf;
! 413: }
! 414: }
! 415: } else {
! 416: memmove(buf->content, &buf->content[len], buf->use);
! 417: buf->content[buf->use] = 0;
! 418: }
! 419: UPDATE_COMPAT(buf)
! 420: return(len);
! 421: }
! 422:
! 423: /**
! 424: * xmlBufGrowInternal:
! 425: * @buf: the buffer
! 426: * @len: the minimum free size to allocate
! 427: *
! 428: * Grow the available space of an XML buffer, @len is the target value
! 429: * Error checking should be done on buf->error since using the return
! 430: * value doesn't work that well
! 431: *
! 432: * Returns 0 in case of error or the length made available otherwise
! 433: */
! 434: static size_t
! 435: xmlBufGrowInternal(xmlBufPtr buf, size_t len) {
! 436: size_t size;
! 437: xmlChar *newbuf;
! 438:
! 439: if ((buf == NULL) || (buf->error != 0)) return(0);
! 440: CHECK_COMPAT(buf)
! 441:
! 442: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
! 443: if (buf->use + len < buf->size)
! 444: return(buf->size - buf->use);
! 445:
! 446: /*
! 447: * Windows has a BIG problem on realloc timing, so we try to double
! 448: * the buffer size (if that's enough) (bug 146697)
! 449: * Apparently BSD too, and it's probably best for linux too
! 450: * On an embedded system this may be something to change
! 451: */
! 452: #if 1
! 453: if (buf->size > (size_t) len)
! 454: size = buf->size * 2;
! 455: else
! 456: size = buf->use + len + 100;
! 457: #else
! 458: size = buf->use + len + 100;
! 459: #endif
! 460:
! 461: if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
! 462: size_t start_buf = buf->content - buf->contentIO;
! 463:
! 464: newbuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + size);
! 465: if (newbuf == NULL) {
! 466: xmlBufMemoryError(buf, "growing buffer");
! 467: return(0);
! 468: }
! 469: buf->contentIO = newbuf;
! 470: buf->content = newbuf + start_buf;
! 471: } else {
! 472: newbuf = (xmlChar *) xmlRealloc(buf->content, size);
! 473: if (newbuf == NULL) {
! 474: xmlBufMemoryError(buf, "growing buffer");
! 475: return(0);
! 476: }
! 477: buf->content = newbuf;
! 478: }
! 479: buf->size = size;
! 480: UPDATE_COMPAT(buf)
! 481: return(buf->size - buf->use);
! 482: }
! 483:
! 484: /**
! 485: * xmlBufGrow:
! 486: * @buf: the buffer
! 487: * @len: the minimum free size to allocate
! 488: *
! 489: * Grow the available space of an XML buffer, @len is the target value
! 490: * This is been kept compatible with xmlBufferGrow() as much as possible
! 491: *
! 492: * Returns -1 in case of error or the length made available otherwise
! 493: */
! 494: int
! 495: xmlBufGrow(xmlBufPtr buf, int len) {
! 496: size_t ret;
! 497:
! 498: if ((buf == NULL) || (len < 0)) return(-1);
! 499: if (len == 0)
! 500: return(0);
! 501: ret = xmlBufGrowInternal(buf, len);
! 502: if (buf->error != 0)
! 503: return(-1);
! 504: return((int) ret);
! 505: }
! 506:
! 507: /**
! 508: * xmlBufInflate:
! 509: * @buf: the buffer
! 510: * @len: the minimum extra free size to allocate
! 511: *
! 512: * Grow the available space of an XML buffer, adding at least @len bytes
! 513: *
! 514: * Returns 0 if successful or -1 in case of error
! 515: */
! 516: int
! 517: xmlBufInflate(xmlBufPtr buf, size_t len) {
! 518: if (buf == NULL) return(-1);
! 519: xmlBufGrowInternal(buf, len + buf->size);
! 520: if (buf->error)
! 521: return(-1);
! 522: return(0);
! 523: }
! 524:
! 525: /**
! 526: * xmlBufDump:
! 527: * @file: the file output
! 528: * @buf: the buffer to dump
! 529: *
! 530: * Dumps an XML buffer to a FILE *.
! 531: * Returns the number of #xmlChar written
! 532: */
! 533: size_t
! 534: xmlBufDump(FILE *file, xmlBufPtr buf) {
! 535: size_t ret;
! 536:
! 537: if ((buf == NULL) || (buf->error != 0)) {
! 538: #ifdef DEBUG_BUFFER
! 539: xmlGenericError(xmlGenericErrorContext,
! 540: "xmlBufDump: buf == NULL or in error\n");
! 541: #endif
! 542: return(0);
! 543: }
! 544: if (buf->content == NULL) {
! 545: #ifdef DEBUG_BUFFER
! 546: xmlGenericError(xmlGenericErrorContext,
! 547: "xmlBufDump: buf->content == NULL\n");
! 548: #endif
! 549: return(0);
! 550: }
! 551: CHECK_COMPAT(buf)
! 552: if (file == NULL)
! 553: file = stdout;
! 554: ret = fwrite(buf->content, sizeof(xmlChar), buf->use, file);
! 555: return(ret);
! 556: }
! 557:
! 558: /**
! 559: * xmlBufContent:
! 560: * @buf: the buffer
! 561: *
! 562: * Function to extract the content of a buffer
! 563: *
! 564: * Returns the internal content
! 565: */
! 566:
! 567: xmlChar *
! 568: xmlBufContent(const xmlBufPtr buf)
! 569: {
! 570: if ((!buf) || (buf->error))
! 571: return NULL;
! 572:
! 573: return(buf->content);
! 574: }
! 575:
! 576: /**
! 577: * xmlBufEnd:
! 578: * @buf: the buffer
! 579: *
! 580: * Function to extract the end of the content of a buffer
! 581: *
! 582: * Returns the end of the internal content or NULL in case of error
! 583: */
! 584:
! 585: xmlChar *
! 586: xmlBufEnd(const xmlBufPtr buf)
! 587: {
! 588: if ((!buf) || (buf->error))
! 589: return NULL;
! 590: CHECK_COMPAT(buf)
! 591:
! 592: return(&buf->content[buf->use]);
! 593: }
! 594:
! 595: /**
! 596: * xmlBufAddLen:
! 597: * @buf: the buffer
! 598: * @len: the size which were added at the end
! 599: *
! 600: * Sometime data may be added at the end of the buffer without
! 601: * using the xmlBuf APIs that is used to expand the used space
! 602: * and set the zero terminating at the end of the buffer
! 603: *
! 604: * Returns -1 in case of error and 0 otherwise
! 605: */
! 606: int
! 607: xmlBufAddLen(xmlBufPtr buf, size_t len) {
! 608: if ((buf == NULL) || (buf->error))
! 609: return(-1);
! 610: CHECK_COMPAT(buf)
! 611: if (len > (buf->size - buf->use))
! 612: return(-1);
! 613: buf->use += len;
! 614: UPDATE_COMPAT(buf)
! 615: if (buf->size > buf->use)
! 616: buf->content[buf->use] = 0;
! 617: else
! 618: return(-1);
! 619: return(0);
! 620: }
! 621:
! 622: /**
! 623: * xmlBufErase:
! 624: * @buf: the buffer
! 625: * @len: the size to erase at the end
! 626: *
! 627: * Sometime data need to be erased at the end of the buffer
! 628: *
! 629: * Returns -1 in case of error and 0 otherwise
! 630: */
! 631: int
! 632: xmlBufErase(xmlBufPtr buf, size_t len) {
! 633: if ((buf == NULL) || (buf->error))
! 634: return(-1);
! 635: CHECK_COMPAT(buf)
! 636: if (len > buf->use)
! 637: return(-1);
! 638: buf->use -= len;
! 639: buf->content[buf->use] = 0;
! 640: UPDATE_COMPAT(buf)
! 641: return(0);
! 642: }
! 643:
! 644: /**
! 645: * xmlBufLength:
! 646: * @buf: the buffer
! 647: *
! 648: * Function to get the length of a buffer
! 649: *
! 650: * Returns the length of data in the internal content
! 651: */
! 652:
! 653: size_t
! 654: xmlBufLength(const xmlBufPtr buf)
! 655: {
! 656: if ((!buf) || (buf->error))
! 657: return 0;
! 658: CHECK_COMPAT(buf)
! 659:
! 660: return(buf->use);
! 661: }
! 662:
! 663: /**
! 664: * xmlBufUse:
! 665: * @buf: the buffer
! 666: *
! 667: * Function to get the length of a buffer
! 668: *
! 669: * Returns the length of data in the internal content
! 670: */
! 671:
! 672: size_t
! 673: xmlBufUse(const xmlBufPtr buf)
! 674: {
! 675: if ((!buf) || (buf->error))
! 676: return 0;
! 677: CHECK_COMPAT(buf)
! 678:
! 679: return(buf->use);
! 680: }
! 681:
! 682: /**
! 683: * xmlBufAvail:
! 684: * @buf: the buffer
! 685: *
! 686: * Function to find how much free space is allocated but not
! 687: * used in the buffer. It does not account for the terminating zero
! 688: * usually needed
! 689: *
! 690: * Returns the amount or 0 if none or an error occured
! 691: */
! 692:
! 693: size_t
! 694: xmlBufAvail(const xmlBufPtr buf)
! 695: {
! 696: if ((!buf) || (buf->error))
! 697: return 0;
! 698: CHECK_COMPAT(buf)
! 699:
! 700: return(buf->size - buf->use);
! 701: }
! 702:
! 703: /**
! 704: * xmlBufIsEmpty:
! 705: * @buf: the buffer
! 706: *
! 707: * Tell if a buffer is empty
! 708: *
! 709: * Returns 0 if no, 1 if yes and -1 in case of error
! 710: */
! 711: int
! 712: xmlBufIsEmpty(const xmlBufPtr buf)
! 713: {
! 714: if ((!buf) || (buf->error))
! 715: return(-1);
! 716: CHECK_COMPAT(buf)
! 717:
! 718: return(buf->use == 0);
! 719: }
! 720:
! 721: /**
! 722: * xmlBufResize:
! 723: * @buf: the buffer to resize
! 724: * @size: the desired size
! 725: *
! 726: * Resize a buffer to accommodate minimum size of @size.
! 727: *
! 728: * Returns 0 in case of problems, 1 otherwise
! 729: */
! 730: int
! 731: xmlBufResize(xmlBufPtr buf, size_t size)
! 732: {
! 733: unsigned int newSize;
! 734: xmlChar* rebuf = NULL;
! 735: size_t start_buf;
! 736:
! 737: if ((buf == NULL) || (buf->error))
! 738: return(0);
! 739: CHECK_COMPAT(buf)
! 740:
! 741: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return(0);
! 742:
! 743: /* Don't resize if we don't have to */
! 744: if (size < buf->size)
! 745: return 1;
! 746:
! 747: /* figure out new size */
! 748: switch (buf->alloc){
! 749: case XML_BUFFER_ALLOC_IO:
! 750: case XML_BUFFER_ALLOC_DOUBLEIT:
! 751: /*take care of empty case*/
! 752: newSize = (buf->size ? buf->size*2 : size + 10);
! 753: while (size > newSize) {
! 754: if (newSize > UINT_MAX / 2) {
! 755: xmlBufMemoryError(buf, "growing buffer");
! 756: return 0;
! 757: }
! 758: newSize *= 2;
! 759: }
! 760: break;
! 761: case XML_BUFFER_ALLOC_EXACT:
! 762: newSize = size+10;
! 763: break;
! 764: case XML_BUFFER_ALLOC_HYBRID:
! 765: if (buf->use < BASE_BUFFER_SIZE)
! 766: newSize = size;
! 767: else {
! 768: newSize = buf->size * 2;
! 769: while (size > newSize) {
! 770: if (newSize > UINT_MAX / 2) {
! 771: xmlBufMemoryError(buf, "growing buffer");
! 772: return 0;
! 773: }
! 774: newSize *= 2;
! 775: }
! 776: }
! 777: break;
! 778:
! 779: default:
! 780: newSize = size+10;
! 781: break;
! 782: }
! 783:
! 784: if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
! 785: start_buf = buf->content - buf->contentIO;
! 786:
! 787: if (start_buf > newSize) {
! 788: /* move data back to start */
! 789: memmove(buf->contentIO, buf->content, buf->use);
! 790: buf->content = buf->contentIO;
! 791: buf->content[buf->use] = 0;
! 792: buf->size += start_buf;
! 793: } else {
! 794: rebuf = (xmlChar *) xmlRealloc(buf->contentIO, start_buf + newSize);
! 795: if (rebuf == NULL) {
! 796: xmlBufMemoryError(buf, "growing buffer");
! 797: return 0;
! 798: }
! 799: buf->contentIO = rebuf;
! 800: buf->content = rebuf + start_buf;
! 801: }
! 802: } else {
! 803: if (buf->content == NULL) {
! 804: rebuf = (xmlChar *) xmlMallocAtomic(newSize);
! 805: } else if (buf->size - buf->use < 100) {
! 806: rebuf = (xmlChar *) xmlRealloc(buf->content, newSize);
! 807: } else {
! 808: /*
! 809: * if we are reallocating a buffer far from being full, it's
! 810: * better to make a new allocation and copy only the used range
! 811: * and free the old one.
! 812: */
! 813: rebuf = (xmlChar *) xmlMallocAtomic(newSize);
! 814: if (rebuf != NULL) {
! 815: memcpy(rebuf, buf->content, buf->use);
! 816: xmlFree(buf->content);
! 817: rebuf[buf->use] = 0;
! 818: }
! 819: }
! 820: if (rebuf == NULL) {
! 821: xmlBufMemoryError(buf, "growing buffer");
! 822: return 0;
! 823: }
! 824: buf->content = rebuf;
! 825: }
! 826: buf->size = newSize;
! 827: UPDATE_COMPAT(buf)
! 828:
! 829: return 1;
! 830: }
! 831:
! 832: /**
! 833: * xmlBufAdd:
! 834: * @buf: the buffer to dump
! 835: * @str: the #xmlChar string
! 836: * @len: the number of #xmlChar to add
! 837: *
! 838: * Add a string range to an XML buffer. if len == -1, the length of
! 839: * str is recomputed.
! 840: *
! 841: * Returns 0 successful, a positive error code number otherwise
! 842: * and -1 in case of internal or API error.
! 843: */
! 844: int
! 845: xmlBufAdd(xmlBufPtr buf, const xmlChar *str, int len) {
! 846: unsigned int needSize;
! 847:
! 848: if ((str == NULL) || (buf == NULL) || (buf->error))
! 849: return -1;
! 850: CHECK_COMPAT(buf)
! 851:
! 852: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
! 853: if (len < -1) {
! 854: #ifdef DEBUG_BUFFER
! 855: xmlGenericError(xmlGenericErrorContext,
! 856: "xmlBufAdd: len < 0\n");
! 857: #endif
! 858: return -1;
! 859: }
! 860: if (len == 0) return 0;
! 861:
! 862: if (len < 0)
! 863: len = xmlStrlen(str);
! 864:
! 865: if (len < 0) return -1;
! 866: if (len == 0) return 0;
! 867:
! 868: needSize = buf->use + len + 2;
! 869: if (needSize > buf->size){
! 870: if (!xmlBufResize(buf, needSize)){
! 871: xmlBufMemoryError(buf, "growing buffer");
! 872: return XML_ERR_NO_MEMORY;
! 873: }
! 874: }
! 875:
! 876: memmove(&buf->content[buf->use], str, len*sizeof(xmlChar));
! 877: buf->use += len;
! 878: buf->content[buf->use] = 0;
! 879: UPDATE_COMPAT(buf)
! 880: return 0;
! 881: }
! 882:
! 883: /**
! 884: * xmlBufAddHead:
! 885: * @buf: the buffer
! 886: * @str: the #xmlChar string
! 887: * @len: the number of #xmlChar to add
! 888: *
! 889: * Add a string range to the beginning of an XML buffer.
! 890: * if len == -1, the length of @str is recomputed.
! 891: *
! 892: * Returns 0 successful, a positive error code number otherwise
! 893: * and -1 in case of internal or API error.
! 894: */
! 895: int
! 896: xmlBufAddHead(xmlBufPtr buf, const xmlChar *str, int len) {
! 897: unsigned int needSize;
! 898:
! 899: if ((buf == NULL) || (buf->error))
! 900: return(-1);
! 901: CHECK_COMPAT(buf)
! 902: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
! 903: if (str == NULL) {
! 904: #ifdef DEBUG_BUFFER
! 905: xmlGenericError(xmlGenericErrorContext,
! 906: "xmlBufAddHead: str == NULL\n");
! 907: #endif
! 908: return -1;
! 909: }
! 910: if (len < -1) {
! 911: #ifdef DEBUG_BUFFER
! 912: xmlGenericError(xmlGenericErrorContext,
! 913: "xmlBufAddHead: len < 0\n");
! 914: #endif
! 915: return -1;
! 916: }
! 917: if (len == 0) return 0;
! 918:
! 919: if (len < 0)
! 920: len = xmlStrlen(str);
! 921:
! 922: if (len <= 0) return -1;
! 923:
! 924: if ((buf->alloc == XML_BUFFER_ALLOC_IO) && (buf->contentIO != NULL)) {
! 925: size_t start_buf = buf->content - buf->contentIO;
! 926:
! 927: if (start_buf > (unsigned int) len) {
! 928: /*
! 929: * We can add it in the space previously shrinked
! 930: */
! 931: buf->content -= len;
! 932: memmove(&buf->content[0], str, len);
! 933: buf->use += len;
! 934: buf->size += len;
! 935: UPDATE_COMPAT(buf)
! 936: return(0);
! 937: }
! 938: }
! 939: needSize = buf->use + len + 2;
! 940: if (needSize > buf->size){
! 941: if (!xmlBufResize(buf, needSize)){
! 942: xmlBufMemoryError(buf, "growing buffer");
! 943: return XML_ERR_NO_MEMORY;
! 944: }
! 945: }
! 946:
! 947: memmove(&buf->content[len], &buf->content[0], buf->use);
! 948: memmove(&buf->content[0], str, len);
! 949: buf->use += len;
! 950: buf->content[buf->use] = 0;
! 951: UPDATE_COMPAT(buf)
! 952: return 0;
! 953: }
! 954:
! 955: /**
! 956: * xmlBufCat:
! 957: * @buf: the buffer to add to
! 958: * @str: the #xmlChar string
! 959: *
! 960: * Append a zero terminated string to an XML buffer.
! 961: *
! 962: * Returns 0 successful, a positive error code number otherwise
! 963: * and -1 in case of internal or API error.
! 964: */
! 965: int
! 966: xmlBufCat(xmlBufPtr buf, const xmlChar *str) {
! 967: if ((buf == NULL) || (buf->error))
! 968: return(-1);
! 969: CHECK_COMPAT(buf)
! 970: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
! 971: if (str == NULL) return -1;
! 972: return xmlBufAdd(buf, str, -1);
! 973: }
! 974:
! 975: /**
! 976: * xmlBufCCat:
! 977: * @buf: the buffer to dump
! 978: * @str: the C char string
! 979: *
! 980: * Append a zero terminated C string to an XML buffer.
! 981: *
! 982: * Returns 0 successful, a positive error code number otherwise
! 983: * and -1 in case of internal or API error.
! 984: */
! 985: int
! 986: xmlBufCCat(xmlBufPtr buf, const char *str) {
! 987: const char *cur;
! 988:
! 989: if ((buf == NULL) || (buf->error))
! 990: return(-1);
! 991: CHECK_COMPAT(buf)
! 992: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE) return -1;
! 993: if (str == NULL) {
! 994: #ifdef DEBUG_BUFFER
! 995: xmlGenericError(xmlGenericErrorContext,
! 996: "xmlBufCCat: str == NULL\n");
! 997: #endif
! 998: return -1;
! 999: }
! 1000: for (cur = str;*cur != 0;cur++) {
! 1001: if (buf->use + 10 >= buf->size) {
! 1002: if (!xmlBufResize(buf, buf->use+10)){
! 1003: xmlBufMemoryError(buf, "growing buffer");
! 1004: return XML_ERR_NO_MEMORY;
! 1005: }
! 1006: }
! 1007: buf->content[buf->use++] = *cur;
! 1008: }
! 1009: buf->content[buf->use] = 0;
! 1010: UPDATE_COMPAT(buf)
! 1011: return 0;
! 1012: }
! 1013:
! 1014: /**
! 1015: * xmlBufWriteCHAR:
! 1016: * @buf: the XML buffer
! 1017: * @string: the string to add
! 1018: *
! 1019: * routine which manages and grows an output buffer. This one adds
! 1020: * xmlChars at the end of the buffer.
! 1021: *
! 1022: * Returns 0 if successful, a positive error code number otherwise
! 1023: * and -1 in case of internal or API error.
! 1024: */
! 1025: int
! 1026: xmlBufWriteCHAR(xmlBufPtr buf, const xmlChar *string) {
! 1027: if ((buf == NULL) || (buf->error))
! 1028: return(-1);
! 1029: CHECK_COMPAT(buf)
! 1030: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
! 1031: return(-1);
! 1032: return(xmlBufCat(buf, string));
! 1033: }
! 1034:
! 1035: /**
! 1036: * xmlBufWriteChar:
! 1037: * @buf: the XML buffer output
! 1038: * @string: the string to add
! 1039: *
! 1040: * routine which manage and grows an output buffer. This one add
! 1041: * C chars at the end of the array.
! 1042: *
! 1043: * Returns 0 if successful, a positive error code number otherwise
! 1044: * and -1 in case of internal or API error.
! 1045: */
! 1046: int
! 1047: xmlBufWriteChar(xmlBufPtr buf, const char *string) {
! 1048: if ((buf == NULL) || (buf->error))
! 1049: return(-1);
! 1050: CHECK_COMPAT(buf)
! 1051: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
! 1052: return(-1);
! 1053: return(xmlBufCCat(buf, string));
! 1054: }
! 1055:
! 1056:
! 1057: /**
! 1058: * xmlBufWriteQuotedString:
! 1059: * @buf: the XML buffer output
! 1060: * @string: the string to add
! 1061: *
! 1062: * routine which manage and grows an output buffer. This one writes
! 1063: * a quoted or double quoted #xmlChar string, checking first if it holds
! 1064: * quote or double-quotes internally
! 1065: *
! 1066: * Returns 0 if successful, a positive error code number otherwise
! 1067: * and -1 in case of internal or API error.
! 1068: */
! 1069: int
! 1070: xmlBufWriteQuotedString(xmlBufPtr buf, const xmlChar *string) {
! 1071: const xmlChar *cur, *base;
! 1072: if ((buf == NULL) || (buf->error))
! 1073: return(-1);
! 1074: CHECK_COMPAT(buf)
! 1075: if (buf->alloc == XML_BUFFER_ALLOC_IMMUTABLE)
! 1076: return(-1);
! 1077: if (xmlStrchr(string, '\"')) {
! 1078: if (xmlStrchr(string, '\'')) {
! 1079: #ifdef DEBUG_BUFFER
! 1080: xmlGenericError(xmlGenericErrorContext,
! 1081: "xmlBufWriteQuotedString: string contains quote and double-quotes !\n");
! 1082: #endif
! 1083: xmlBufCCat(buf, "\"");
! 1084: base = cur = string;
! 1085: while(*cur != 0){
! 1086: if(*cur == '"'){
! 1087: if (base != cur)
! 1088: xmlBufAdd(buf, base, cur - base);
! 1089: xmlBufAdd(buf, BAD_CAST """, 6);
! 1090: cur++;
! 1091: base = cur;
! 1092: }
! 1093: else {
! 1094: cur++;
! 1095: }
! 1096: }
! 1097: if (base != cur)
! 1098: xmlBufAdd(buf, base, cur - base);
! 1099: xmlBufCCat(buf, "\"");
! 1100: }
! 1101: else{
! 1102: xmlBufCCat(buf, "\'");
! 1103: xmlBufCat(buf, string);
! 1104: xmlBufCCat(buf, "\'");
! 1105: }
! 1106: } else {
! 1107: xmlBufCCat(buf, "\"");
! 1108: xmlBufCat(buf, string);
! 1109: xmlBufCCat(buf, "\"");
! 1110: }
! 1111: return(0);
! 1112: }
! 1113:
! 1114: /**
! 1115: * xmlBufFromBuffer:
! 1116: * @buffer: incoming old buffer to convert to a new one
! 1117: *
! 1118: * Helper routine to switch from the old buffer structures in use
! 1119: * in various APIs. It creates a wrapper xmlBufPtr which will be
! 1120: * used for internal processing until the xmlBufBackToBuffer() is
! 1121: * issued.
! 1122: *
! 1123: * Returns a new xmlBufPtr unless the call failed and NULL is returned
! 1124: */
! 1125: xmlBufPtr
! 1126: xmlBufFromBuffer(xmlBufferPtr buffer) {
! 1127: xmlBufPtr ret;
! 1128:
! 1129: if (buffer == NULL)
! 1130: return(NULL);
! 1131:
! 1132: ret = (xmlBufPtr) xmlMalloc(sizeof(xmlBuf));
! 1133: if (ret == NULL) {
! 1134: xmlBufMemoryError(NULL, "creating buffer");
! 1135: return(NULL);
! 1136: }
! 1137: ret->use = buffer->use;
! 1138: ret->size = buffer->size;
! 1139: ret->compat_use = buffer->use;
! 1140: ret->compat_size = buffer->size;
! 1141: ret->error = 0;
! 1142: ret->buffer = buffer;
! 1143: ret->alloc = buffer->alloc;
! 1144: ret->content = buffer->content;
! 1145: ret->contentIO = buffer->contentIO;
! 1146:
! 1147: return(ret);
! 1148: }
! 1149:
! 1150: /**
! 1151: * xmlBufBackToBuffer:
! 1152: * @buf: new buffer wrapping the old one
! 1153: *
! 1154: * Function to be called once internal processing had been done to
! 1155: * update back the buffer provided by the user. This can lead to
! 1156: * a failure in case the size accumulated in the xmlBuf is larger
! 1157: * than what an xmlBuffer can support on 64 bits (INT_MAX)
! 1158: * The xmlBufPtr @buf wrapper is deallocated by this call in any case.
! 1159: *
! 1160: * Returns the old xmlBufferPtr unless the call failed and NULL is returned
! 1161: */
! 1162: xmlBufferPtr
! 1163: xmlBufBackToBuffer(xmlBufPtr buf) {
! 1164: xmlBufferPtr ret;
! 1165:
! 1166: if ((buf == NULL) || (buf->error))
! 1167: return(NULL);
! 1168: CHECK_COMPAT(buf)
! 1169: if (buf->buffer == NULL) {
! 1170: xmlBufFree(buf);
! 1171: return(NULL);
! 1172: }
! 1173:
! 1174: ret = buf->buffer;
! 1175: /*
! 1176: * What to do in case of error in the buffer ???
! 1177: */
! 1178: if (buf->use > INT_MAX) {
! 1179: /*
! 1180: * Worse case, we really allocated and used more than the
! 1181: * maximum allowed memory for an xmlBuffer on this architecture.
! 1182: * Keep the buffer but provide a truncated size value.
! 1183: */
! 1184: xmlBufOverflowError(buf, "Used size too big for xmlBuffer");
! 1185: ret->use = INT_MAX;
! 1186: ret->size = INT_MAX;
! 1187: } else if (buf->size > INT_MAX) {
! 1188: /*
! 1189: * milder case, we allocated more than the maximum allowed memory
! 1190: * for an xmlBuffer on this architecture, but used less than the
! 1191: * limit.
! 1192: * Keep the buffer but provide a truncated size value.
! 1193: */
! 1194: xmlBufOverflowError(buf, "Allocated size too big for xmlBuffer");
! 1195: ret->size = INT_MAX;
! 1196: }
! 1197: ret->use = (int) buf->use;
! 1198: ret->size = (int) buf->size;
! 1199: ret->alloc = buf->alloc;
! 1200: ret->content = buf->content;
! 1201: ret->contentIO = buf->contentIO;
! 1202: xmlFree(buf);
! 1203: return(ret);
! 1204: }
! 1205:
! 1206: /**
! 1207: * xmlBufMergeBuffer:
! 1208: * @buf: an xmlBufPtr
! 1209: * @buffer: the buffer to consume into @buf
! 1210: *
! 1211: * The content of @buffer is appended to @buf and @buffer is freed
! 1212: *
! 1213: * Returns -1 in case of error, 0 otherwise, in any case @buffer is freed
! 1214: */
! 1215: int
! 1216: xmlBufMergeBuffer(xmlBufPtr buf, xmlBufferPtr buffer) {
! 1217: int ret = 0;
! 1218:
! 1219: if ((buf == NULL) || (buf->error)) {
! 1220: xmlBufferFree(buffer);
! 1221: return(-1);
! 1222: }
! 1223: CHECK_COMPAT(buf)
! 1224: if ((buffer != NULL) && (buffer->content != NULL) &&
! 1225: (buffer->use > 0)) {
! 1226: ret = xmlBufAdd(buf, buffer->content, buffer->use);
! 1227: }
! 1228: xmlBufferFree(buffer);
! 1229: return(ret);
! 1230: }
! 1231:
! 1232: /**
! 1233: * xmlBufResetInput:
! 1234: * @buf: an xmlBufPtr
! 1235: * @input: an xmlParserInputPtr
! 1236: *
! 1237: * Update the input to use the current set of pointers from the buffer.
! 1238: *
! 1239: * Returns -1 in case of error, 0 otherwise
! 1240: */
! 1241: int
! 1242: xmlBufResetInput(xmlBufPtr buf, xmlParserInputPtr input) {
! 1243: if ((input == NULL) || (buf == NULL) || (buf->error))
! 1244: return(-1);
! 1245: CHECK_COMPAT(buf)
! 1246: input->base = input->cur = buf->content;
! 1247: input->end = &buf->content[buf->use];
! 1248: return(0);
! 1249: }
! 1250:
! 1251: /**
! 1252: * xmlBufGetInputBase:
! 1253: * @buf: an xmlBufPtr
! 1254: * @input: an xmlParserInputPtr
! 1255: *
! 1256: * Get the base of the @input relative to the beginning of the buffer
! 1257: *
! 1258: * Returns the size_t corresponding to the displacement
! 1259: */
! 1260: size_t
! 1261: xmlBufGetInputBase(xmlBufPtr buf, xmlParserInputPtr input) {
! 1262: size_t base;
! 1263:
! 1264: if ((input == NULL) || (buf == NULL) || (buf->error))
! 1265: return(-1);
! 1266: CHECK_COMPAT(buf)
! 1267: base = input->base - buf->content;
! 1268: /*
! 1269: * We could do some pointer arythmetic checks but that's probably
! 1270: * sufficient.
! 1271: */
! 1272: if (base > buf->size) {
! 1273: xmlBufOverflowError(buf, "Input reference outside of the buffer");
! 1274: base = 0;
! 1275: }
! 1276: return(base);
! 1277: }
! 1278:
! 1279: /**
! 1280: * xmlBufSetInputBaseCur:
! 1281: * @buf: an xmlBufPtr
! 1282: * @input: an xmlParserInputPtr
! 1283: * @base: the base value relative to the beginning of the buffer
! 1284: * @cur: the cur value relative to the beginning of the buffer
! 1285: *
! 1286: * Update the input to use the base and cur relative to the buffer
! 1287: * after a possible reallocation of its content
! 1288: *
! 1289: * Returns -1 in case of error, 0 otherwise
! 1290: */
! 1291: int
! 1292: xmlBufSetInputBaseCur(xmlBufPtr buf, xmlParserInputPtr input,
! 1293: size_t base, size_t cur) {
! 1294: if ((input == NULL) || (buf == NULL) || (buf->error))
! 1295: return(-1);
! 1296: CHECK_COMPAT(buf)
! 1297: input->base = &buf->content[base];
! 1298: input->cur = input->base + cur;
! 1299: input->end = &buf->content[buf->use];
! 1300: return(0);
! 1301: }
! 1302:
! 1303: #define bottom_buf
! 1304: #include "elfgcchack.h"
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to buf.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libxml2