buffer.c revision 0c27b3fe77ac1d5094ba3521e8142d9e7973133f
/*
* Copyright (C) 1998-2002, 2004-2008, 2012, 2014-2016 Internet Systems Consortium, Inc. ("ISC")
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
/*! \file */
#include <config.h>
void
/*
* Make 'b' refer to the 'length'-byte region starting at 'base'.
* XXXDCL see the comment in buffer.h about base being const.
*/
}
void
/*
* Initialize a new buffer which has no backing store. This can
* later be grown as needed and swapped in place.
*/
ISC__BUFFER_INIT(b, NULL, 0);
}
void
/*
* Re-initialize the buffer enough to reconfigure the base of the
* buffer. We will swap in the new buffer, after copying any
* data we contain into the new buffer and adjusting all of our
* internal pointers.
*
* The buffer must not be smaller than the length of the original
* buffer.
*/
}
void
/*
* Make 'b' an invalid buffer.
*/
REQUIRE(ISC_BUFFER_VALID(b));
}
void
REQUIRE(ISC_BUFFER_VALID(b));
}
void
/*
* Make 'r' refer to the region of 'b'.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_REGION(b, r);
}
void
/*
* Make 'r' refer to the used region of 'b'.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_USEDREGION(b, r);
}
void
/*
* Make 'r' refer to the available region of 'b'.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_AVAILABLEREGION(b, r);
}
void
isc__buffer_add(isc_buffer_t *b, unsigned int n) {
/*
* Increase the 'used' region of 'b' by 'n' bytes.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_ADD(b, n);
}
void
isc__buffer_subtract(isc_buffer_t *b, unsigned int n) {
/*
* Decrease the 'used' region of 'b' by 'n' bytes.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_SUBTRACT(b, n);
}
void
/*
* Make the used region empty.
*/
REQUIRE(ISC_BUFFER_VALID(b));
}
void
/*
* Make 'r' refer to the consumed region of 'b'.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_CONSUMEDREGION(b, r);
}
void
/*
* Make 'r' refer to the remaining region of 'b'.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_REMAININGREGION(b, r);
}
void
/*
* Make 'r' refer to the active region of 'b'.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_ACTIVEREGION(b, r);
}
void
isc__buffer_setactive(isc_buffer_t *b, unsigned int n) {
/*
* Sets the end of the active region 'n' bytes after current.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_SETACTIVE(b, n);
}
void
/*
* Make the consumed region empty.
*/
REQUIRE(ISC_BUFFER_VALID(b));
}
void
isc__buffer_forward(isc_buffer_t *b, unsigned int n) {
/*
* Increase the 'consumed' region of 'b' by 'n' bytes.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_FORWARD(b, n);
}
void
isc__buffer_back(isc_buffer_t *b, unsigned int n) {
/*
* Decrease the 'consumed' region of 'b' by 'n' bytes.
*/
REQUIRE(ISC_BUFFER_VALID(b));
ISC__BUFFER_BACK(b, n);
}
void
unsigned int length;
void *src;
/*
* Compact the used region by moving the remaining region so it occurs
* at the start of the buffer. The used region is shrunk by the size
* of the consumed region, and the consumed region is then made empty.
*/
REQUIRE(ISC_BUFFER_VALID(b));
src = isc_buffer_current(b);
else
b->active = 0;
b->current = 0;
}
unsigned char *cp;
/*
* Read an unsigned 8-bit integer from 'b' and return it.
*/
REQUIRE(ISC_BUFFER_VALID(b));
cp = isc_buffer_current(b);
b->current += 1;
return (result);
}
void
REQUIRE(ISC_BUFFER_VALID(b));
if (b->autore) {
}
ISC__BUFFER_PUTUINT8(b, val);
}
unsigned char *cp;
/*
* Read an unsigned 16-bit integer in network byte order from 'b',
* convert it to host byte order, and return it.
*/
REQUIRE(ISC_BUFFER_VALID(b));
cp = isc_buffer_current(b);
b->current += 2;
return (result);
}
void
REQUIRE(ISC_BUFFER_VALID(b));
if (b->autore) {
}
ISC__BUFFER_PUTUINT16(b, val);
}
void
REQUIRE(ISC_BUFFER_VALID(b));
if (b->autore) {
}
ISC__BUFFER_PUTUINT24(b, val);
}
unsigned char *cp;
/*
* Read an unsigned 32-bit integer in network byte order from 'b',
* convert it to host byte order, and return it.
*/
REQUIRE(ISC_BUFFER_VALID(b));
cp = isc_buffer_current(b);
b->current += 4;
return (result);
}
void
REQUIRE(ISC_BUFFER_VALID(b));
if (b->autore) {
}
ISC__BUFFER_PUTUINT32(b, val);
}
unsigned char *cp;
/*
* Read an unsigned 48-bit integer in network byte order from 'b',
* convert it to host byte order, and return it.
*/
REQUIRE(ISC_BUFFER_VALID(b));
cp = isc_buffer_current(b);
b->current += 6;
return (result);
}
void
REQUIRE(ISC_BUFFER_VALID(b));
if (b->autore) {
}
}
void
unsigned int length)
{
REQUIRE(ISC_BUFFER_VALID(b));
if (b->autore) {
}
}
void
unsigned int l;
unsigned char *cp;
REQUIRE(ISC_BUFFER_VALID(b));
/*
* Do not use ISC__BUFFER_PUTSTR(), so strlen is only done once.
*/
if (b->autore) {
result = isc_buffer_reserve(&b, l);
}
REQUIRE(isc_buffer_availablelength(b) >= l);
cp = isc_buffer_used(b);
b->used += l;
}
void
unsigned int l=0;
unsigned char *cp;
char buf[21];
REQUIRE(ISC_BUFFER_VALID(b));
/* xxxwpk do it more low-level way ? */
RUNTIME_CHECK(l <= 21);
if (b->autore) {
result = isc_buffer_reserve(&b, l);
}
REQUIRE(isc_buffer_availablelength(b) >= l);
cp = isc_buffer_used(b);
b->used += l;
}
if (result != ISC_R_SUCCESS)
return (result);
return (ISC_R_SUCCESS);
}
unsigned char *base;
unsigned int available;
REQUIRE(ISC_BUFFER_VALID(b));
/*
* XXXDCL
*/
base = isc_buffer_used(b);
if (b->autore) {
if (result != ISC_R_SUCCESS)
return (result);
}
return (ISC_R_NOSPACE);
return (ISC_R_SUCCESS);
}
unsigned int length)
{
unsigned char * bdata;
return (ISC_R_NOMEMORY);
return (ISC_R_NOMEMORY);
}
return (ISC_R_SUCCESS);
}
unsigned char *bdata;
return (ISC_R_NOSPACE);
/*
* XXXMUKS: This is far more expensive than plain realloc() as
* it doesn't remap pages, but does ordinary copy. So is
* isc_mem_reallocate(), which has additional issues.
*/
return (ISC_R_NOMEMORY);
return (ISC_R_SUCCESS);
}
return (ISC_R_SUCCESS);
return (ISC_R_NOSPACE);
/* Round to nearest buffer size increment */
/* Cap at UINT_MAX */
}
return (ISC_R_NOMEMORY);
}
void
}