xref: /openbsd-src/lib/libradius/radius_attr.c (revision 834c20a7b5c2a65cf5762aa69a1d44b3ff24e960)

/*	$OpenBSD: radius_attr.c,v 1.3 2024/07/24 08:19:16 yasuoka Exp $ */

/*-
 * Copyright (c) 2009 Internet Initiative Japan Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE"AUTHOR" AND CONTRIBUTORS AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <netinet/in.h>
#include <arpa/inet.h>

#include <endian.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include "radius.h"

#include "radius_local.h"

#define FIND_ATTRIBUTE_BEGIN(constness, redolabel)		\
	constness RADIUS_ATTRIBUTE* attr;			\
	constness RADIUS_ATTRIBUTE* end;			\
								\
	attr = ATTRS_BEGIN(packet->pdata);			\
	end  = ATTRS_END(packet->pdata);			\
								\
	for (;; ATTRS_ADVANCE(attr))				\
	{							\
	redolabel						\
		if (attr >= end)				\
			break;					\
		if (attr->type != type)				\
			continue;				\
		{

#define FIND_ATTRIBUTE_END \
	} }

#define FIND_VS_ATTRIBUTE_BEGIN(constness, redolabel)		\
	constness RADIUS_ATTRIBUTE* attr;			\
	constness RADIUS_ATTRIBUTE* end;			\
								\
	attr = ATTRS_BEGIN(packet->pdata);			\
	end  = ATTRS_END(packet->pdata);			\
								\
	for (;; ATTRS_ADVANCE(attr))				\
	{							\
	redolabel						\
		if (attr >= end)				\
			break;					\
		if (attr->type != RADIUS_TYPE_VENDOR_SPECIFIC)	\
			continue;				\
		if (attr->vendor != htonl(vendor))		\
			continue;				\
		if (attr->vtype != vtype)			\
			continue;				\
		{

#define FIND_VS_ATTRIBUTE_END					\
	} }


int
radius_get_raw_attr_ptr(const RADIUS_PACKET * packet, uint8_t type,
    const void **ptr, size_t * length)
{
	FIND_ATTRIBUTE_BEGIN(const,) {
		*length = attr->length - 2;
		*ptr = attr->data;
		return (0);
	} FIND_ATTRIBUTE_END;

	return (-1);
}

int
radius_get_vs_raw_attr_ptr(const RADIUS_PACKET * packet, uint32_t vendor,
    uint8_t vtype, const void **ptr, size_t * length)
{
	FIND_VS_ATTRIBUTE_BEGIN(const,) {
		*length = attr->vlength - 2;
		*ptr = attr->vdata;
		return (0);
	} FIND_VS_ATTRIBUTE_END;

	return (-1);
}

int
radius_get_raw_attr(const RADIUS_PACKET * packet, uint8_t type, void *buf,
    size_t * length)
{
	FIND_ATTRIBUTE_BEGIN(const,) {
		*length = MINIMUM(attr->length - 2, *length);
		memcpy(buf, attr->data, *length);
		return (0);
	} FIND_ATTRIBUTE_END;

	return (-1);
}

int
radius_get_vs_raw_attr(const RADIUS_PACKET * packet, uint32_t vendor,
    uint8_t vtype, void *buf, size_t * length)
{
	FIND_VS_ATTRIBUTE_BEGIN(const,) {
		*length = MINIMUM(attr->vlength - 2, *length);
		memcpy(buf, attr->vdata, *length);
		return (0);
	} FIND_VS_ATTRIBUTE_END;

	return (-1);
}

int
radius_get_raw_attr_cat(const RADIUS_PACKET * packet, uint8_t type, void *buf,
    size_t * length)
{
	size_t	 off = 0;

	FIND_ATTRIBUTE_BEGIN(const,) {
		if (buf != NULL) {
			if (off + attr->length - 2 <= *length)
				memcpy((char *)buf + off, attr->data,
				    attr->length - 2);
			else
				return (-1);
		}
		off += attr->length - 2;
	} FIND_ATTRIBUTE_END;

	*length = off;

	return (0);
}

int
radius_get_vs_raw_attr_cat(const RADIUS_PACKET * packet, uint32_t vendor,
    uint8_t vtype, void *buf, size_t * length)
{
	size_t	 off = 0;

	FIND_VS_ATTRIBUTE_BEGIN(const,) {
		if (buf != NULL) {
			if (off + attr->vlength - 2 <= *length)
				memcpy((char *)buf + off, attr->vdata,
				    attr->vlength - 2);
			else
				return (-1);
		}
		off += attr->vlength - 2;
	} FIND_VS_ATTRIBUTE_END;

	*length = off;

	return (0);
}

int
radius_put_raw_attr(RADIUS_PACKET * packet, uint8_t type, const void *buf,
    size_t length)
{
	RADIUS_ATTRIBUTE	*newattr;

	if (length > 255 - 2)
		return (-1);

	if (radius_ensure_add_capacity(packet, length + 2) != 0)
		return (-1);

	newattr = ATTRS_END(packet->pdata);
	newattr->type = type;
	newattr->length = length + 2;
	memcpy(newattr->data, buf, length);
	packet->pdata->length = htons(radius_get_length(packet) + length + 2);

	return (0);
}

int
radius_unshift_raw_attr(RADIUS_PACKET * packet, uint8_t type, const void *buf,
    size_t length)
{
	RADIUS_ATTRIBUTE	*newattr;

	if (length > 255 - 2)
		return (-1);

	if (radius_ensure_add_capacity(packet, length + 2) != 0)
		return (-1);

	memmove(packet->pdata->attributes + length + 2,
	    packet->pdata->attributes,
	    radius_get_length(packet) - sizeof(RADIUS_PACKET_DATA));

	newattr = ATTRS_BEGIN(packet->pdata);
	newattr->type = type;
	newattr->length = length + 2;
	memcpy(newattr->data, buf, length);
	packet->pdata->length = htons(radius_get_length(packet) + length + 2);

	return (0);
}

int
radius_put_vs_raw_attr(RADIUS_PACKET * packet, uint32_t vendor, uint8_t vtype,
    const void *buf, size_t length)
{
	RADIUS_ATTRIBUTE	*newattr;

	if (length > 255 - 8)
		return (-1);
	if ((vendor & 0xff000000U) != 0)
		return (-1);

	if (radius_ensure_add_capacity(packet, length + 8) != 0)
		return (-1);

	newattr = ATTRS_END(packet->pdata);
	newattr->type = RADIUS_TYPE_VENDOR_SPECIFIC;
	newattr->length = length + 8;
	newattr->vendor = htonl(vendor);
	newattr->vtype = vtype;
	newattr->vlength = length + 2;
	memcpy(newattr->vdata, buf, length);
	packet->pdata->length = htons(radius_get_length(packet) + length + 8);

	return (0);
}

int
radius_put_raw_attr_cat(RADIUS_PACKET * packet, uint8_t type, const void *buf,
    size_t length)
{
	int	 off, len0;

	off = 0;
	while (off < length) {
		len0 = MINIMUM(length - off, 255 - 2);

		if (radius_put_raw_attr(packet, type, (const char *)buf + off,
		    len0) != 0)
			return (-1);

		off += len0;
	}

	return (0);
}

int
radius_put_vs_raw_attr_cat(RADIUS_PACKET * packet, uint32_t vendor,
    uint8_t vtype, const void *buf, size_t length)
{
	int	 off, len0;

	off = 0;
	while (off < length) {
		len0 = MINIMUM(length - off, 255 - 8);

		if (radius_put_vs_raw_attr(packet, vendor, vtype,
		    (const char *)buf + off, len0) != 0)
			return (-1);

		off += len0;
	}

	return (0);
}

int
radius_set_raw_attr(RADIUS_PACKET * packet,
    uint8_t type, const void *buf, size_t length)
{
	FIND_ATTRIBUTE_BEGIN(,) {
		if (length != attr->length - 2)
			return (-1);
		memcpy(attr->data, buf, length);
		return (0);
	} FIND_ATTRIBUTE_END;

	return (-1);
}

int
radius_set_vs_raw_attr(RADIUS_PACKET * packet,
    uint32_t vendor, uint8_t vtype, const void *buf, size_t length)
{
	FIND_VS_ATTRIBUTE_BEGIN(,) {
		if (length != attr->vlength - 2)
			return (-1);
		memcpy(attr->vdata, buf, length);
		return (0);
	} FIND_VS_ATTRIBUTE_END;

	return (-1);
}

int
radius_del_attr_all(RADIUS_PACKET * packet, uint8_t type)
{
	FIND_ATTRIBUTE_BEGIN(, redo:) {
		RADIUS_ATTRIBUTE *next = ATTRS_NEXT(attr);
		packet->pdata->length =
		    htons(ntohs(packet->pdata->length) - attr->length);
		memmove(attr, next, ((char *)end) - ((char *)next));
		end = ATTRS_END(packet->pdata);
		goto redo;
	} FIND_ATTRIBUTE_END;

	return (0);
}

int
radius_del_vs_attr_all(RADIUS_PACKET * packet, uint32_t vendor, uint8_t vtype)
{
	FIND_VS_ATTRIBUTE_BEGIN(, redo:) {
		RADIUS_ATTRIBUTE *next = ATTRS_NEXT(attr);
		packet->pdata->length =
		    htons(ntohs(packet->pdata->length) - attr->length);
		memmove(attr, next, ((char *)end) - ((char *)next));
		end = ATTRS_END(packet->pdata);
		goto redo;
	} FIND_VS_ATTRIBUTE_END;

	return (0);
}

bool
radius_has_attr(const RADIUS_PACKET * packet, uint8_t type)
{
	FIND_ATTRIBUTE_BEGIN(const,) {
		return (true);
	} FIND_VS_ATTRIBUTE_END;

	return (false);
}

bool
radius_has_vs_attr(const RADIUS_PACKET * packet, uint32_t vendor, uint8_t vtype)
{
	FIND_VS_ATTRIBUTE_BEGIN(const,) {
		return (true);
	} FIND_VS_ATTRIBUTE_END;

	return (false);
}

int
radius_get_string_attr(const RADIUS_PACKET * packet, uint8_t type, char *str,
    size_t len)
{
	const void	*p;
	size_t		 origlen;

	if (radius_get_raw_attr_ptr(packet, type, &p, &origlen) != 0)
		return (-1);
	if (memchr(p, 0, origlen) != NULL)
		return (-1);
	if (len >= 1) {
		len = MINIMUM(origlen, len - 1);
		memcpy(str, (const char *)p, len);
		str[len] = '\0';
	}
	return (0);
}

int
radius_get_vs_string_attr(const RADIUS_PACKET * packet,
    uint32_t vendor, uint8_t vtype, char *str, size_t len)
{
	const void *p;
	size_t origlen;

	if (radius_get_vs_raw_attr_ptr(packet,
		vendor, vtype, &p, &origlen) != 0)
		return (-1);
	if (memchr(p, 0, origlen) != NULL)
		return (-1);
	if (len >= 1) {
		len = MINIMUM(origlen, len - 1);
		memcpy(str, (const char *)p, len);
		str[len] = '\0';
	}

	return (0);
}

int
radius_put_string_attr(RADIUS_PACKET * packet, uint8_t type, const char *str)
{
	return radius_put_raw_attr(packet, type, str, strlen(str));
}

int
radius_put_vs_string_attr(RADIUS_PACKET * packet,
    uint32_t vendor, uint8_t vtype, const char *str)
{
	return radius_put_vs_raw_attr(packet, vendor, vtype, str, strlen(str));
}


#define DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYVAL(ftname, tname, hton, ntoh) \
int radius_get_ ## ftname ## _attr(const RADIUS_PACKET *packet,		\
	uint8_t type, tname *val)					\
{									\
	const void *p;							\
	tname nval;							\
	size_t len;							\
									\
	if (radius_get_raw_attr_ptr(packet, type, &p, &len) != 0)	\
		return (-1);						\
	if (len != sizeof(tname))					\
		return (-1);						\
	memcpy(&nval, p, sizeof(tname));				\
	*val = ntoh(nval);						\
	return (0);							\
}									\
									\
int radius_get_vs_ ## ftname ## _attr(const RADIUS_PACKET *packet,	\
	uint32_t vendor, uint8_t vtype, tname *val)			\
{									\
	const void *p;							\
	tname nval;							\
	size_t len;							\
									\
	if (radius_get_vs_raw_attr_ptr(packet,				\
			vendor, vtype, &p, &len) != 0)			\
		return (-1);						\
	if (len != sizeof(tname))					\
		return (-1);						\
	memcpy(&nval, p, sizeof(tname));				\
	*val = ntoh(nval);						\
	return (0);							\
}									\
									\
int radius_put_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint8_t type, tname val)					\
{									\
	tname nval;							\
									\
	nval = hton(val);						\
	return radius_put_raw_attr(packet, type, &nval, sizeof(tname));	\
}									\
									\
int radius_put_vs_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint32_t vendor, uint8_t vtype, tname val)			\
{									\
	tname nval;							\
									\
	nval = hton(val);						\
	return radius_put_vs_raw_attr(packet, vendor, vtype,		\
			&nval, sizeof(tname));				\
}									\
									\
int radius_set_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint8_t type, tname val)					\
{									\
	tname nval;							\
									\
	nval = hton(val);						\
	return radius_set_raw_attr(packet, type, &nval, sizeof(tname));	\
}									\
									\
int radius_set_vs_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint32_t vendor, uint8_t vtype, tname val)			\
{									\
	tname nval;							\
									\
	nval = hton(val);						\
	return radius_set_vs_raw_attr(packet, vendor, vtype,		\
			&nval, sizeof(tname));				\
}

#define DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYPTR(ftname, tname) \
int radius_get_ ## ftname ## _attr(const RADIUS_PACKET *packet,		\
	uint8_t type, tname *val)					\
{									\
	const void	*p;						\
	size_t		 len;						\
									\
	if (radius_get_raw_attr_ptr(packet, type, &p, &len) != 0)	\
		return (-1);						\
	if (len != sizeof(tname))					\
		return (-1);						\
	memcpy(val, p, sizeof(tname));					\
	return (0);							\
}									\
									\
int radius_get_vs_ ## ftname ## _attr(const RADIUS_PACKET *packet,	\
	uint32_t vendor, uint8_t vtype, tname *val)			\
{									\
	const void	*p;						\
	size_t		 len;						\
									\
	if (radius_get_vs_raw_attr_ptr(packet,				\
			vendor, vtype, &p, &len) != 0)			\
		return (-1);						\
	if (len != sizeof(tname))					\
		return (-1);						\
	memcpy(val, p, sizeof(tname));					\
	return (0);							\
}									\
									\
int radius_put_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint8_t type, const tname *val)					\
{									\
	return radius_put_raw_attr(packet, type, val, sizeof(tname));	\
}									\
									\
int radius_put_vs_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint32_t vendor, uint8_t vtype, const tname *val)		\
{									\
	return radius_put_vs_raw_attr(packet, vendor, vtype,		\
			val, sizeof(tname));				\
}									\
									\
int radius_set_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint8_t type, const tname *val)					\
{									\
	return radius_set_raw_attr(packet, type, val, sizeof(tname));	\
}									\
									\
int radius_set_vs_ ## ftname ## _attr(RADIUS_PACKET *packet,		\
	uint32_t vendor, uint8_t vtype, const tname *val)		\
{									\
	return radius_set_vs_raw_attr(packet, vendor, vtype,		\
			val, sizeof(tname));				\
}

DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYVAL(uint16, uint16_t, htons, ntohs)
DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYVAL(uint32, uint32_t, htonl, ntohl)
DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYVAL(uint64, uint64_t, htobe64, betoh64)
DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYVAL(ipv4, struct in_addr,,)
DEFINE_TYPED_ATTRIBUTE_ACCESSOR_BYPTR(ipv6, struct in6_addr)