File Manager

003 File Manager

Current Path: /usr/src/contrib/ldns

📁 ..
📄 Changelog(42.17 KB)
📄 LICENSE(1.47 KB)
📄 Makefile.in(77.62 KB)
📄 README(4.04 KB)
📄 README.git(858 B)
📄 README.snapshots(257 B)
📄 aclocal.m4(883 B)
📄 acx_nlnetlabs.m4(42.25 KB)
📄 ax_pkg_swig.m4(6.65 KB)
📄 ax_python_devel.m4(10.87 KB)
📄 buffer.c(3.74 KB)
📁 compat
📄 config.guess(42.74 KB)
📄 config.sub(35.31 KB)
📄 configure(560.43 KB)
📄 configure.ac(31.6 KB)
📄 dane.c(22.96 KB)
📄 dname.c(13.12 KB)
📄 dnssec.c(50.58 KB)
📄 dnssec_sign.c(40.7 KB)
📄 dnssec_verify.c(74.11 KB)
📄 dnssec_zone.c(27.93 KB)
📁 drill
📄 duration.c(8.63 KB)
📄 error.c(9.53 KB)
📄 freebsd-configure.sh(681 B)
📄 higher.c(7.56 KB)
📄 host2str.c(67.47 KB)
📄 host2wire.c(13.13 KB)
📄 install-sh(14.8 KB)
📄 keys.c(52.57 KB)
📁 ldns
📄 libdns.doxygen(103.99 KB)
📄 libdns.vim(19.14 KB)
📄 linktest.c(136 B)
📄 ltmain.sh(316.81 KB)
📁 m4
📄 net.c(23.2 KB)
📁 packaging
📄 packet.c(24.25 KB)
📄 parse.c(8.58 KB)
📄 radix.c(36.53 KB)
📄 rbtree.c(17.31 KB)
📄 rdata.c(16 KB)
📄 resolver.c(35.62 KB)
📄 rr.c(84.07 KB)
📄 rr_functions.c(8.59 KB)
📄 sha1.c(6.08 KB)
📄 sha2.c(29.86 KB)
📄 str2host.c(37.63 KB)
📄 tsig.c(11.98 KB)
📄 update.c(7.54 KB)
📄 util.c(17.68 KB)
📄 wire2host.c(12.71 KB)
📄 zone.c(6.17 KB)

Editing: buffer.c

/*
 * buffer.c -- generic memory buffer .
 *
 * Copyright (c) 2001-2008, NLnet Labs. All rights reserved.
 *
 * See LICENSE for the license.
 *
 */

#include <ldns/config.h>

#include <ldns/ldns.h>
#include <ldns/buffer.h>

ldns_buffer *
ldns_buffer_new(size_t capacity)
{
	ldns_buffer *buffer = LDNS_MALLOC(ldns_buffer);

if (!buffer) {
		return NULL;
	}
	
	buffer->_data = (uint8_t *) LDNS_XMALLOC(uint8_t, capacity);
	if (!buffer->_data) {
		LDNS_FREE(buffer);
		return NULL;
	}
	
	buffer->_position = 0;
	buffer->_limit = buffer->_capacity = capacity;
	buffer->_fixed = 0;
	buffer->_status = LDNS_STATUS_OK;
	
	ldns_buffer_invariant(buffer);
	
	return buffer;
}

void
ldns_buffer_new_frm_data(ldns_buffer *buffer, const void *data, size_t size)
{
	assert(data != NULL);

buffer->_position = 0; 
	buffer->_limit = buffer->_capacity = size;
	buffer->_fixed = 0;
	buffer->_data = LDNS_XMALLOC(uint8_t, size);
	if(!buffer->_data) {
		buffer->_status = LDNS_STATUS_MEM_ERR;
		return;
	}
	memcpy(buffer->_data, data, size);
	buffer->_status = LDNS_STATUS_OK;
	
	ldns_buffer_invariant(buffer);
}

bool
ldns_buffer_set_capacity(ldns_buffer *buffer, size_t capacity)
{
	void *data;
	
	ldns_buffer_invariant(buffer);
	assert(buffer->_position <= capacity);

data = (uint8_t *) LDNS_XREALLOC(buffer->_data, uint8_t, capacity);
	if (!data) {
		buffer->_status = LDNS_STATUS_MEM_ERR;
		return false;
	} else {
		buffer->_data = data;
		buffer->_limit = buffer->_capacity = capacity;
		return true;
	}
}

bool
ldns_buffer_reserve(ldns_buffer *buffer, size_t amount)
{
	ldns_buffer_invariant(buffer);
	assert(!buffer->_fixed);
	if (buffer->_capacity < buffer->_position + amount) {
		size_t new_capacity = buffer->_capacity * 3 / 2;

if (new_capacity < buffer->_position + amount) {
			new_capacity = buffer->_position + amount;
		}
		if (!ldns_buffer_set_capacity(buffer, new_capacity)) {
			buffer->_status = LDNS_STATUS_MEM_ERR;
			return false;
		}
	}
	buffer->_limit = buffer->_capacity;
	return true;
}

int
ldns_buffer_printf(ldns_buffer *buffer, const char *format, ...)
{
	va_list args;
	int written = 0;
	size_t remaining;
	
	if (ldns_buffer_status_ok(buffer)) {
		ldns_buffer_invariant(buffer);
		assert(buffer->_limit == buffer->_capacity);

remaining = ldns_buffer_remaining(buffer);
		va_start(args, format);
		written = vsnprintf((char *) ldns_buffer_current(buffer), remaining,
				    format, args);
		va_end(args);
		if (written == -1) {
			buffer->_status = LDNS_STATUS_INTERNAL_ERR;
			return -1;
		} else if ((size_t) written >= remaining) {
			if (!ldns_buffer_reserve(buffer, (size_t) written + 1)) {
				buffer->_status = LDNS_STATUS_MEM_ERR;
				return -1;
			}
			va_start(args, format);
			written = vsnprintf((char *) ldns_buffer_current(buffer),
			    ldns_buffer_remaining(buffer), format, args);
			va_end(args);
			if (written == -1) {
				buffer->_status = LDNS_STATUS_INTERNAL_ERR;
				return -1;
			}
		}
		buffer->_position += written;
	}
	return written;
}

void
ldns_buffer_free(ldns_buffer *buffer)
{
	if (!buffer) {
		return;
	}

if (!buffer->_fixed)
		LDNS_FREE(buffer->_data);

LDNS_FREE(buffer);
}

void *
ldns_buffer_export(ldns_buffer *buffer)
{
	buffer->_fixed = 1;
	return buffer->_data;
}

int
ldns_bgetc(ldns_buffer *buffer)
{
	if (!ldns_buffer_available_at(buffer, buffer->_position, sizeof(uint8_t))) {
		ldns_buffer_set_position(buffer, ldns_buffer_limit(buffer));
		/* ldns_buffer_rewind(buffer);*/
		return EOF;
	}
	return (int)ldns_buffer_read_u8(buffer);
}

void 
ldns_buffer_copy(ldns_buffer* result, const ldns_buffer* from)
{
	size_t tocopy = ldns_buffer_limit(from);

if(tocopy > ldns_buffer_capacity(result))
		tocopy = ldns_buffer_capacity(result);
	ldns_buffer_clear(result);
	ldns_buffer_write(result, ldns_buffer_begin(from), tocopy);
	ldns_buffer_flip(result);
}

003 File Manager

Editing: buffer.c

Upload File

Create Folder