edns.c

/*
 * edns.c
 *
 * edns implementation
 *
 * a Net::DNS like library for C
 *
 * (c) NLnet Labs, 2004-2022
 *
 * See the file LICENSE for the license
 */

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

#define LDNS_OPTIONLIST_INIT 8

/*
 * Access functions
 * functions to get and set type checking
 */

/* read */
size_t
ldns_edns_get_size(const ldns_edns_option *edns)
{
	assert(edns != NULL);
	return edns->_size;
}

ldns_edns_option_code
ldns_edns_get_code(const ldns_edns_option *edns)
{
	assert(edns != NULL);
	return edns->_code;
}

uint8_t *
ldns_edns_get_data(const ldns_edns_option *edns)
{
	assert(edns != NULL);
	return edns->_data;
}

ldns_status 
ldns_edns_ede_get_code(const ldns_edns_option *edns, uint16_t *ede_code)
{
	assert(edns != NULL);
	assert(ede_code != NULL);

	if (edns->_code != LDNS_EDNS_EDE) return LDNS_STATUS_NOT_EDE;

	if (edns->_size < 2) return LDNS_STATUS_EDE_OPTION_MALFORMED;

	*ede_code = (uint16_t) ntohs(*((uint16_t*) edns->_data));

	return LDNS_STATUS_OK;
}

ldns_status 
ldns_edns_ede_get_text(const ldns_edns_option* edns, char **ede_text)
{
	assert(edns != NULL);
	assert(ede_text != NULL);

	if (edns->_code != LDNS_EDNS_EDE) return LDNS_STATUS_NOT_EDE;

	if (edns->_size < 2) return LDNS_STATUS_EDE_OPTION_MALFORMED;

	*ede_text = NULL;

	if (edns->_size > 2)
	{
		*ede_text = (char*) malloc((edns->_size - 1) * sizeof(char));

		memset(*ede_text, 0, edns->_size - 1);
		memcpy(*ede_text, &((char*)edns->_data)[2], edns->_size - 2);
	}

	return LDNS_STATUS_OK;
}

ldns_buffer *
ldns_edns_get_wireformat_buffer(const ldns_edns_option *edns)
{
	uint16_t option;
	size_t size;
	uint8_t* data;
	ldns_buffer* buffer;

	if (edns == NULL) {
		return NULL;
	}

	option = ldns_edns_get_code(edns);
	size = ldns_edns_get_size(edns);
	data = ldns_edns_get_data(edns);

	buffer = ldns_buffer_new(size + 4);

	if (buffer == NULL) {
		return NULL;
	}

	ldns_buffer_write_u16(buffer, option);
	ldns_buffer_write_u16(buffer, size);
	ldns_buffer_write(buffer, data, size);

	ldns_buffer_flip(buffer);

	return buffer;
}

/* write */
static void
ldns_edns_set_size(ldns_edns_option *edns, size_t size)
{
	assert(edns != NULL);
	edns->_size = size;
}

static void
ldns_edns_set_code(ldns_edns_option *edns, ldns_edns_option_code code)
{
	assert(edns != NULL);
	edns->_code = code;
}

static void
ldns_edns_set_data(ldns_edns_option *edns, void *data)
{
	/* only copy the pointer */
	assert(edns != NULL);
	edns->_data = data;
}

/* note: data must be allocated memory */
ldns_edns_option *
ldns_edns_new(ldns_edns_option_code code, size_t size, void *data)
{
	ldns_edns_option *edns;
	edns = LDNS_MALLOC(ldns_edns_option);
	if (!edns) {
		return NULL;
	}
	ldns_edns_set_code(edns, code);
	ldns_edns_set_size(edns, size);
	ldns_edns_set_data(edns, data);

	return edns;
}

ldns_edns_option *
ldns_edns_new_from_data(ldns_edns_option_code code, size_t size, const void *data)
{
	ldns_edns_option *edns;
	edns = LDNS_MALLOC(ldns_edns_option);
	if (!edns) {
		return NULL;
	}
	edns->_data = LDNS_XMALLOC(uint8_t, size);
	if (!edns->_data) {
		LDNS_FREE(edns);
		return NULL;
	}

	/* set the values */
	ldns_edns_set_code(edns, code);
	ldns_edns_set_size(edns, size);
	memcpy(edns->_data, data, size);

	return edns;
}

ldns_edns_option *
ldns_edns_clone(ldns_edns_option *edns)
{
	ldns_edns_option *new_option;

	assert(edns != NULL);

	new_option = ldns_edns_new_from_data(ldns_edns_get_code(edns),
		ldns_edns_get_size(edns),
		ldns_edns_get_data(edns));

	return new_option;
}

void
ldns_edns_deep_free(ldns_edns_option *edns)
{
	if (edns) {
		if (edns->_data) {
			LDNS_FREE(edns->_data);
		}
		LDNS_FREE(edns);
	}
}

void 
ldns_edns_free(ldns_edns_option *edns)
{
	if (edns) {
		LDNS_FREE(edns);
	}
}

ldns_edns_option_list*
ldns_edns_option_list_new(void)
{
	ldns_edns_option_list *option_list = LDNS_MALLOC(ldns_edns_option_list);
	if(!option_list) {
		return NULL;
	}

	option_list->_option_count = 0;
	option_list->_option_capacity = 0;
	option_list->_options_size = 0;
	option_list->_options = NULL;
	return option_list;
}

ldns_edns_option_list *
ldns_edns_option_list_clone(ldns_edns_option_list *old_list)
{
	size_t i;
	ldns_edns_option_list *new_list;

	if (!old_list) {
		return NULL;
	}

	new_list = ldns_edns_option_list_new();
	if (!new_list) {
		return NULL;
	}

	if (old_list->_option_count == 0) {
		return new_list;
	}

	/* adding options also updates the total options size */
	for (i = 0; i < old_list->_option_count; i++) {
		ldns_edns_option *option = ldns_edns_clone(ldns_edns_option_list_get_option(old_list, i));
		if (!ldns_edns_option_list_push(new_list, option)) {
			ldns_edns_deep_free(option);
			ldns_edns_option_list_deep_free(new_list);
			return NULL;
		}
	}
	return new_list;
}

void
ldns_edns_option_list_free(ldns_edns_option_list *option_list)
{
	if (option_list) {
		LDNS_FREE(option_list->_options);
		LDNS_FREE(option_list);
	}
}

void
ldns_edns_option_list_deep_free(ldns_edns_option_list *option_list)
{
	size_t i;

	if (option_list) {
		for (i=0; i < ldns_edns_option_list_get_count(option_list); i++) {
			ldns_edns_deep_free(ldns_edns_option_list_get_option(option_list, i));
		}
		ldns_edns_option_list_free(option_list);
	}
}

size_t
ldns_edns_option_list_get_count(const ldns_edns_option_list *option_list)
{
	if (option_list) {
		return option_list->_option_count;
	} else {
		return 0;
	}
}

ldns_edns_option *
ldns_edns_option_list_get_option(const ldns_edns_option_list *option_list, size_t index)
{
	if (option_list && index < ldns_edns_option_list_get_count(option_list)) {
		assert(option_list->_options[index]);
		return option_list->_options[index];
	} else {
		return NULL;
	}
}

size_t
ldns_edns_option_list_get_options_size(const ldns_edns_option_list *option_list)
{
	if (option_list) {
		return option_list->_options_size;
	} else {
		return 0;
	}
}


ldns_edns_option *
ldns_edns_option_list_set_option(ldns_edns_option_list *option_list,
	ldns_edns_option *option, size_t index)
{
	ldns_edns_option* old;

	assert(option_list != NULL);

	if (index > ldns_edns_option_list_get_count(option_list)) {
		return NULL;
	}

	if (option == NULL) {
		return NULL;
	}

	old = ldns_edns_option_list_get_option(option_list, index);

	/* shrink the total EDNS size if the old EDNS option exists */
	if (old != NULL) {
		option_list->_options_size -= (ldns_edns_get_size(old) + 4);
	}

	option_list->_options_size += (ldns_edns_get_size(option) + 4);

	option_list->_options[index] = option;
	return old;
}

bool
ldns_edns_option_list_push(ldns_edns_option_list *option_list,
	ldns_edns_option *option)
{
	size_t cap;
	size_t option_count;

	assert(option_list != NULL);

	if (option == NULL) {
		return false;
	}

	cap = option_list->_option_capacity;
	option_count = ldns_edns_option_list_get_count(option_list);

	/* verify we need to grow the array to fit the new option */
	if (option_count+1 > cap) {
		ldns_edns_option **new_list;

		/* initialize the capacity if needed, otherwise grow by doubling */
		if (cap == 0) {
			cap = LDNS_OPTIONLIST_INIT; /* initial list size */
		} else {
			cap *= 2;
		}

		new_list = LDNS_XREALLOC(option_list->_options,
			ldns_edns_option *, cap);

		if (!new_list) {
			return false;
		}

		option_list->_options = new_list;
		option_list->_option_capacity = cap;
	}

	/* add the new option */
	ldns_edns_option_list_set_option(option_list, option,
		option_list->_option_count);
	option_list->_option_count += 1;

	return true;
}

ldns_edns_option *
ldns_edns_option_list_pop(ldns_edns_option_list *option_list)
{
	ldns_edns_option* pop;
	size_t count;
	size_t cap;

	assert(option_list != NULL);

	cap = option_list->_option_capacity;
	count = ldns_edns_option_list_get_count(option_list);

	if (count == 0) {
		return NULL;
	}
	/* get the last option from the list */
	pop = ldns_edns_option_list_get_option(option_list, count-1);

	/* shrink the array */
	if (cap > LDNS_OPTIONLIST_INIT && count-1 <= cap/2) {
		ldns_edns_option **new_list;

		cap /= 2;

		new_list = LDNS_XREALLOC(option_list->_options,
			ldns_edns_option *, cap);
		if (new_list) {
			option_list->_options = new_list;
		}
		/* if the realloc fails, the capacity for the list remains unchanged */
	}

	/* shrink the total EDNS size of the options if the popped EDNS option exists */
	if (pop != NULL) {
		option_list->_options_size -= (ldns_edns_get_size(pop) + 4);
	}

	option_list->_option_count = count - 1;

	return pop;
}

ldns_buffer *
ldns_edns_option_list2wireformat_buffer(const ldns_edns_option_list *option_list)
{
	size_t i, list_size, options_size, option, size;
	ldns_buffer* buffer;
	ldns_edns_option *edns;
	uint8_t* data = NULL;

	if (!option_list) {
		return NULL;
	}

	/* get the number of EDNS options in the list*/
	list_size = ldns_edns_option_list_get_count(option_list);

	/* create buffer the size of the total EDNS wireformat options */
	options_size = ldns_edns_option_list_get_options_size(option_list);
	buffer = ldns_buffer_new(options_size);
	
	if (!buffer) {
		return NULL;
	}

	/* write individual serialized EDNS options to final buffer*/
	for (i = 0; i < list_size; i++) {
		edns = ldns_edns_option_list_get_option(option_list, i);

		if (edns == NULL) {
			/* this shouldn't be possible */
			return NULL;
		}

		option = ldns_edns_get_code(edns);
		size = ldns_edns_get_size(edns);
		data = ldns_edns_get_data(edns);

		/* make sure the option fits */
		if (!(ldns_buffer_available(buffer, size + 4))) {
			ldns_buffer_free(buffer);
			return NULL;
		}

		ldns_buffer_write_u16(buffer, option);
		ldns_buffer_write_u16(buffer, size);
		ldns_buffer_write(buffer, data, size);
	}

	ldns_buffer_flip(buffer);

	return buffer;
}