[mirror_frr.git] / ldpd / util.c

/*	$OpenBSD$ */

/*
 * Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
 * Copyright (c) 2012 Alexander Bluhm <bluhm@openbsd.org>
 * Copyright (c) 2004 Esben Norby <norby@openbsd.org>
 * Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <zebra.h>

#include "ldpd.h"
#include "log.h"

uint8_t
mask2prefixlen(in_addr_t ina)
{
	if (ina == 0)
		return (0);
	else
		return (33 - ffs(ntohl(ina)));
}

uint8_t
mask2prefixlen6(struct sockaddr_in6 *sa_in6)
{
	uint8_t	l = 0, *ap, *ep;

	/*
	 * sin6_len is the size of the sockaddr so substract the offset of
	 * the possibly truncated sin6_addr struct.
	 */
	ap = (uint8_t *)&sa_in6->sin6_addr;
	ep = (uint8_t *)sa_in6 + sockaddr_len((struct sockaddr *)sa_in6);
	for (; ap < ep; ap++) {
		/* this "beauty" is adopted from sbin/route/show.c ... */
		switch (*ap) {
		case 0xff:
			l += 8;
			break;
		case 0xfe:
			l += 7;
			return (l);
		case 0xfc:
			l += 6;
			return (l);
		case 0xf8:
			l += 5;
			return (l);
		case 0xf0:
			l += 4;
			return (l);
		case 0xe0:
			l += 3;
			return (l);
		case 0xc0:
			l += 2;
			return (l);
		case 0x80:
			l += 1;
			return (l);
		case 0x00:
			return (l);
		default:
			fatalx("non contiguous inet6 netmask");
		}
	}

	return (l);
}

in_addr_t
prefixlen2mask(uint8_t prefixlen)
{
	if (prefixlen == 0)
		return (0);

	return (htonl(0xffffffff << (32 - prefixlen)));
}

struct in6_addr *
prefixlen2mask6(uint8_t prefixlen)
{
	static struct in6_addr	mask;
	int			i;

	memset(&mask, 0, sizeof(mask));
	for (i = 0; i < prefixlen / 8; i++)
		mask.s6_addr[i] = 0xff;
	i = prefixlen % 8;
	if (i)
		mask.s6_addr[prefixlen / 8] = 0xff00 >> i;

	return (&mask);
}

void
ldp_applymask(int af, union ldpd_addr *dest, const union ldpd_addr *src,
    int prefixlen)
{
	struct in6_addr	mask;
	int		i;

	switch (af) {
	case AF_INET:
		dest->v4.s_addr = src->v4.s_addr & prefixlen2mask(prefixlen);
		break;
	case AF_INET6:
		memset(&mask, 0, sizeof(mask));
		for (i = 0; i < prefixlen / 8; i++)
			mask.s6_addr[i] = 0xff;
		i = prefixlen % 8;
		if (i)
			mask.s6_addr[prefixlen / 8] = 0xff00 >> i;

		for (i = 0; i < 16; i++)
			dest->v6.s6_addr[i] = src->v6.s6_addr[i] &
			    mask.s6_addr[i];
		break;
	default:
		fatalx("ldp_applymask: unknown af");
	}
}

int
ldp_addrcmp(int af, const union ldpd_addr *a, const union ldpd_addr *b)
{
	switch (af) {
	case AF_INET:
		if (a->v4.s_addr == b->v4.s_addr)
			return (0);
		return ((ntohl(a->v4.s_addr) > ntohl(b->v4.s_addr)) ? 1 : -1);
	case AF_INET6:
		return (memcmp(&a->v6, &b->v6, sizeof(struct in6_addr)));
	default:
		fatalx("ldp_addrcmp: unknown af");
	}
}

int
ldp_addrisset(int af, const union ldpd_addr *addr)
{
	switch (af) {
	case AF_UNSPEC:
		return (0);
	case AF_INET:
		if (addr->v4.s_addr != INADDR_ANY)
			return (1);
		break;
	case AF_INET6:
		if (!IN6_IS_ADDR_UNSPECIFIED(&addr->v6))
			return (1);
		break;
	default:
		fatalx("ldp_addrisset: unknown af");
	}

	return (0);
}

int
ldp_prefixcmp(int af, const union ldpd_addr *a, const union ldpd_addr *b,
    uint8_t prefixlen)
{
	in_addr_t	mask, aa, ba;
	int		i;
	uint8_t		m;

	switch (af) {
	case AF_INET:
		if (prefixlen == 0)
			return (0);
		if (prefixlen > 32)
			fatalx("ldp_prefixcmp: bad IPv4 prefixlen");
		mask = htonl(prefixlen2mask(prefixlen));
		aa = htonl(a->v4.s_addr) & mask;
		ba = htonl(b->v4.s_addr) & mask;
		return (aa - ba);
	case AF_INET6:
		if (prefixlen == 0)
			return (0);
		if (prefixlen > 128)
			fatalx("ldp_prefixcmp: bad IPv6 prefixlen");
		for (i = 0; i < prefixlen / 8; i++)
			if (a->v6.s6_addr[i] != b->v6.s6_addr[i])
				return (a->v6.s6_addr[i] - b->v6.s6_addr[i]);
		i = prefixlen % 8;
		if (i) {
			m = 0xff00 >> i;
			if ((a->v6.s6_addr[prefixlen / 8] & m) !=
			    (b->v6.s6_addr[prefixlen / 8] & m))
				return ((a->v6.s6_addr[prefixlen / 8] & m) -
				    (b->v6.s6_addr[prefixlen / 8] & m));
		}
		return (0);
	default:
		fatalx("ldp_prefixcmp: unknown af");
	}
	return (-1);
}

int
bad_addr_v4(struct in_addr addr)
{
	uint32_t	 a = ntohl(addr.s_addr);

	if (((a >> IN_CLASSA_NSHIFT) == 0) ||
	    ((a >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) ||
	    IN_MULTICAST(a) || IN_BADCLASS(a))
		return (1);

	return (0);
}

int
bad_addr_v6(struct in6_addr *addr)
{
	if (IN6_IS_ADDR_UNSPECIFIED(addr) ||
	    IN6_IS_ADDR_LOOPBACK(addr) ||
	    IN6_IS_ADDR_MULTICAST(addr) ||
	    IN6_IS_ADDR_SITELOCAL(addr) ||
	    IN6_IS_ADDR_V4MAPPED(addr) ||
	    IN6_IS_ADDR_V4COMPAT(addr))
		return (1);

	return (0);
}

int
bad_addr(int af, union ldpd_addr *addr)
{
	switch (af) {
	case AF_INET:
		return (bad_addr_v4(addr->v4));
	case AF_INET6:
		return (bad_addr_v6(&addr->v6));
	default:
		fatalx("bad_addr: unknown af");
	}
}

void
embedscope(struct sockaddr_in6 *sin6)
{
	uint16_t	 tmp16;

	if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr)) {
		memcpy(&tmp16, &sin6->sin6_addr.s6_addr[2], sizeof(tmp16));
		if (tmp16 != 0) {
			log_warnx("%s: address %s already has embeded scope %u",
			    __func__, log_sockaddr(sin6), ntohs(tmp16));
		}
		tmp16 = htons(sin6->sin6_scope_id);
		memcpy(&sin6->sin6_addr.s6_addr[2], &tmp16, sizeof(tmp16));
		sin6->sin6_scope_id = 0;
	}
}

void
recoverscope(struct sockaddr_in6 *sin6)
{
	uint16_t	 tmp16;

	if (sin6->sin6_scope_id != 0)
		log_warnx("%s: address %s already has scope id %u",
		    __func__, log_sockaddr(sin6), sin6->sin6_scope_id);

	if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr)) {
		memcpy(&tmp16, &sin6->sin6_addr.s6_addr[2], sizeof(tmp16));
		sin6->sin6_scope_id = ntohs(tmp16);
		sin6->sin6_addr.s6_addr[2] = 0;
		sin6->sin6_addr.s6_addr[3] = 0;
	}
}

void
addscope(struct sockaddr_in6 *sin6, uint32_t id)
{
	if (sin6->sin6_scope_id != 0)
		log_warnx("%s: address %s already has scope id %u", __func__,
		    log_sockaddr(sin6), sin6->sin6_scope_id);

	if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr))
		sin6->sin6_scope_id = id;
}

void
clearscope(struct in6_addr *in6)
{
	if (IN6_IS_SCOPE_EMBED(in6)) {
		in6->s6_addr[2] = 0;
		in6->s6_addr[3] = 0;
	}
}

struct sockaddr *
addr2sa(int af, union ldpd_addr *addr, uint16_t port)
{
	static struct sockaddr_storage	 ss;
	struct sockaddr_in		*sa_in = (struct sockaddr_in *)&ss;
	struct sockaddr_in6		*sa_in6 = (struct sockaddr_in6 *)&ss;

	memset(&ss, 0, sizeof(ss));
	switch (af) {
	case AF_INET:
		sa_in->sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		sa_in->sin_len = sizeof(struct sockaddr_in);
#endif
		sa_in->sin_addr = addr->v4;
		sa_in->sin_port = htons(port);
		break;
	case AF_INET6:
		sa_in6->sin6_family = AF_INET6;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		sa_in6->sin6_len = sizeof(struct sockaddr_in6);
#endif
		sa_in6->sin6_addr = addr->v6;
		sa_in6->sin6_port = htons(port);
		break;
	default:
		fatalx("addr2sa: unknown af");
	}

	return ((struct sockaddr *)&ss);
}

void
sa2addr(struct sockaddr *sa, int *af, union ldpd_addr *addr, in_port_t *port)
{
	struct sockaddr_in		*sa_in = (struct sockaddr_in *)sa;
	struct sockaddr_in6		*sa_in6 = (struct sockaddr_in6 *)sa;

	if (addr)
		memset(addr, 0, sizeof(*addr));
	switch (sa->sa_family) {
	case AF_INET:
		if (af)
			*af = AF_INET;
		if (addr)
			addr->v4 = sa_in->sin_addr;
		if (port)
			*port = sa_in->sin_port;
		break;
	case AF_INET6:
		if (af)
			*af = AF_INET6;
		if (addr)
			addr->v6 = sa_in6->sin6_addr;
		if (port)
			*port = sa_in6->sin6_port;
		break;
	default:
		fatalx("sa2addr: unknown af");
	}
}

socklen_t
sockaddr_len(struct sockaddr *sa)
{
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	return (sa->sa_len);
#else
	switch (sa->sa_family) {
	case AF_INET:
		return (sizeof(struct sockaddr_in));
	case AF_INET6:
		return (sizeof(struct sockaddr_in6));
	default:
		fatalx("sockaddr_len: unknown af");
	}
#endif
}
Commit	Line	Data
8429abe0 RW	1	/* $OpenBSD$ */
	2
	3	/*
	4	* Copyright (c) 2015 Renato Westphal <renato@openbsd.org>
	5	* Copyright (c) 2012 Alexander Bluhm <bluhm@openbsd.org>
	6	* Copyright (c) 2004 Esben Norby <norby@openbsd.org>
	7	* Copyright (c) 2003, 2004 Henning Brauer <henning@openbsd.org>
	8	*
	9	* Permission to use, copy, modify, and distribute this software for any
	10	* purpose with or without fee is hereby granted, provided that the above
	11	* copyright notice and this permission notice appear in all copies.
	12	*
	13	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	14	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	15	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	16	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	17	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	18	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	19	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	20	*/
	21
eac6e3f0	22	#include <zebra.h>
8429abe0 RW	23
	24	#include "ldpd.h"
	25	#include "log.h"
	26
	27	uint8_t
	28	mask2prefixlen(in_addr_t ina)
	29	{
	30	if (ina == 0)
	31	return (0);
	32	else
	33	return (33 - ffs(ntohl(ina)));
	34	}
	35
	36	uint8_t
	37	mask2prefixlen6(struct sockaddr_in6 *sa_in6)
	38	{
	39	uint8_t l = 0, ap, ep;
	40
	41	/*
	42	* sin6_len is the size of the sockaddr so substract the offset of
	43	* the possibly truncated sin6_addr struct.
	44	*/
	45	ap = (uint8_t *)&sa_in6->sin6_addr;
eac6e3f0	46	ep = (uint8_t )sa_in6 + sockaddr_len((struct sockaddr )sa_in6);
8429abe0 RW	47	for (; ap < ep; ap++) {
	48	/* this "beauty" is adopted from sbin/route/show.c ... */
	49	switch (*ap) {
	50	case 0xff:
	51	l += 8;
	52	break;
	53	case 0xfe:
	54	l += 7;
	55	return (l);
	56	case 0xfc:
	57	l += 6;
	58	return (l);
	59	case 0xf8:
	60	l += 5;
	61	return (l);
	62	case 0xf0:
	63	l += 4;
	64	return (l);
	65	case 0xe0:
	66	l += 3;
	67	return (l);
	68	case 0xc0:
	69	l += 2;
	70	return (l);
	71	case 0x80:
	72	l += 1;
	73	return (l);
	74	case 0x00:
	75	return (l);
	76	default:
	77	fatalx("non contiguous inet6 netmask");
	78	}
	79	}
	80
	81	return (l);
	82	}
	83
	84	in_addr_t
	85	prefixlen2mask(uint8_t prefixlen)
	86	{
	87	if (prefixlen == 0)
	88	return (0);
	89
	90	return (htonl(0xffffffff << (32 - prefixlen)));
	91	}
	92
	93	struct in6_addr *
	94	prefixlen2mask6(uint8_t prefixlen)
	95	{
	96	static struct in6_addr mask;
	97	int i;
	98
	99	memset(&mask, 0, sizeof(mask));
	100	for (i = 0; i < prefixlen / 8; i++)
	101	mask.s6_addr[i] = 0xff;
	102	i = prefixlen % 8;
	103	if (i)
	104	mask.s6_addr[prefixlen / 8] = 0xff00 >> i;
	105
	106	return (&mask);
	107	}
	108
	109	void
	110	ldp_applymask(int af, union ldpd_addr dest, const union ldpd_addr src,
111	int prefixlen)
112	{
113	struct in6_addr mask;
114	int i;
115
116	switch (af) {
117	case AF_INET:
118	dest->v4.s_addr = src->v4.s_addr & prefixlen2mask(prefixlen);
119	break;
120	case AF_INET6:
121	memset(&mask, 0, sizeof(mask));
122	for (i = 0; i < prefixlen / 8; i++)
123	mask.s6_addr[i] = 0xff;
124	i = prefixlen % 8;
125	if (i)
126	mask.s6_addr[prefixlen / 8] = 0xff00 >> i;
127
128	for (i = 0; i < 16; i++)
129	dest->v6.s6_addr[i] = src->v6.s6_addr[i] &
130	mask.s6_addr[i];
131	break;
132	default:
133	fatalx("ldp_applymask: unknown af");
134	}
135	}
136
137	int
138	ldp_addrcmp(int af, const union ldpd_addr a, const union ldpd_addr b)
139	{
140	switch (af) {
141	case AF_INET:
142	if (a->v4.s_addr == b->v4.s_addr)
143	return (0);
144	return ((ntohl(a->v4.s_addr) > ntohl(b->v4.s_addr)) ? 1 : -1);
145	case AF_INET6:
146	return (memcmp(&a->v6, &b->v6, sizeof(struct in6_addr)));
147	default:
148	fatalx("ldp_addrcmp: unknown af");
149	}
150	}
151
152	int
153	ldp_addrisset(int af, const union ldpd_addr *addr)
154	{
155	switch (af) {
156	case AF_UNSPEC:
157	return (0);
158	case AF_INET:
159	if (addr->v4.s_addr != INADDR_ANY)
160	return (1);
161	break;
162	case AF_INET6:
163	if (!IN6_IS_ADDR_UNSPECIFIED(&addr->v6))
164	return (1);
165	break;
166	default:
167	fatalx("ldp_addrisset: unknown af");
168	}
169
170	return (0);
171	}
172
173	int
174	ldp_prefixcmp(int af, const union ldpd_addr a, const union ldpd_addr b,
175	uint8_t prefixlen)
176	{
177	in_addr_t mask, aa, ba;
178	int i;
179	uint8_t m;
180
181	switch (af) {
182	case AF_INET:
183	if (prefixlen == 0)
184	return (0);
185	if (prefixlen > 32)
186	fatalx("ldp_prefixcmp: bad IPv4 prefixlen");
187	mask = htonl(prefixlen2mask(prefixlen));
188	aa = htonl(a->v4.s_addr) & mask;
189	ba = htonl(b->v4.s_addr) & mask;
190	return (aa - ba);
191	case AF_INET6:
192	if (prefixlen == 0)
193	return (0);
194	if (prefixlen > 128)
195	fatalx("ldp_prefixcmp: bad IPv6 prefixlen");
196	for (i = 0; i < prefixlen / 8; i++)
197	if (a->v6.s6_addr[i] != b->v6.s6_addr[i])
198	return (a->v6.s6_addr[i] - b->v6.s6_addr[i]);
199	i = prefixlen % 8;
200	if (i) {
201	m = 0xff00 >> i;
202	if ((a->v6.s6_addr[prefixlen / 8] & m) !=
203	(b->v6.s6_addr[prefixlen / 8] & m))
204	return ((a->v6.s6_addr[prefixlen / 8] & m) -
205	(b->v6.s6_addr[prefixlen / 8] & m));
206	}
207	return (0);
208	default:
209	fatalx("ldp_prefixcmp: unknown af");
210	}
211	return (-1);
212	}
213
214	int
215	bad_addr_v4(struct in_addr addr)
216	{
217	uint32_t a = ntohl(addr.s_addr);
218
219	if (((a >> IN_CLASSA_NSHIFT) == 0) \|\|
220	((a >> IN_CLASSA_NSHIFT) == IN_LOOPBACKNET) \|\|
221	IN_MULTICAST(a) \|\| IN_BADCLASS(a))
222	return (1);
223
224	return (0);
225	}
226
227	int
228	bad_addr_v6(struct in6_addr *addr)
229	{
230	if (IN6_IS_ADDR_UNSPECIFIED(addr) \|\|
231	IN6_IS_ADDR_LOOPBACK(addr) \|\|
232	IN6_IS_ADDR_MULTICAST(addr) \|\|
233	IN6_IS_ADDR_SITELOCAL(addr) \|\|
234	IN6_IS_ADDR_V4MAPPED(addr) \|\|
235	IN6_IS_ADDR_V4COMPAT(addr))
236	return (1);
237
238	return (0);
239	}
240
241	int
242	bad_addr(int af, union ldpd_addr *addr)
243	{
244	switch (af) {
245	case AF_INET:
246	return (bad_addr_v4(addr->v4));
247	case AF_INET6:
248	return (bad_addr_v6(&addr->v6));
249	default:
250	fatalx("bad_addr: unknown af");
251	}
252	}
253
254	void
255	embedscope(struct sockaddr_in6 *sin6)
256	{
257	uint16_t tmp16;
258
259	if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr)) {
260	memcpy(&tmp16, &sin6->sin6_addr.s6_addr[2], sizeof(tmp16));
261	if (tmp16 != 0) {
262	log_warnx("%s: address %s already has embeded scope %u",
263	__func__, log_sockaddr(sin6), ntohs(tmp16));
264	}
265	tmp16 = htons(sin6->sin6_scope_id);
266	memcpy(&sin6->sin6_addr.s6_addr[2], &tmp16, sizeof(tmp16));
267	sin6->sin6_scope_id = 0;
268	}
269	}
270
271	void
272	recoverscope(struct sockaddr_in6 *sin6)
273	{
274	uint16_t tmp16;
275
276	if (sin6->sin6_scope_id != 0)
277	log_warnx("%s: address %s already has scope id %u",
278	__func__, log_sockaddr(sin6), sin6->sin6_scope_id);
279
280	if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr)) {
281	memcpy(&tmp16, &sin6->sin6_addr.s6_addr[2], sizeof(tmp16));
282	sin6->sin6_scope_id = ntohs(tmp16);
283	sin6->sin6_addr.s6_addr[2] = 0;
284	sin6->sin6_addr.s6_addr[3] = 0;
285	}
286	}
287
288	void
289	addscope(struct sockaddr_in6 *sin6, uint32_t id)
290	{
291	if (sin6->sin6_scope_id != 0)
292	log_warnx("%s: address %s already has scope id %u", __func__,
293	log_sockaddr(sin6), sin6->sin6_scope_id);
294
295	if (IN6_IS_SCOPE_EMBED(&sin6->sin6_addr))
296	sin6->sin6_scope_id = id;
297	}
298
299	void
300	clearscope(struct in6_addr *in6)
301	{
302	if (IN6_IS_SCOPE_EMBED(in6)) {
303	in6->s6_addr[2] = 0;
304	in6->s6_addr[3] = 0;
305	}
306	}
307
308	struct sockaddr *
309	addr2sa(int af, union ldpd_addr *addr, uint16_t port)
310	{
311	static struct sockaddr_storage ss;
312	struct sockaddr_in sa_in = (struct sockaddr_in )&ss;
313	struct sockaddr_in6 sa_in6 = (struct sockaddr_in6 )&ss;
314
315	memset(&ss, 0, sizeof(ss));
316	switch (af) {
317	case AF_INET:
318	sa_in->sin_family = AF_INET;
eac6e3f0	319	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
8429abe0	320	sa_in->sin_len = sizeof(struct sockaddr_in);
eac6e3f0	321	#endif
8429abe0 RW	322	sa_in->sin_addr = addr->v4;
	323	sa_in->sin_port = htons(port);
	324	break;
	325	case AF_INET6:
	326	sa_in6->sin6_family = AF_INET6;
eac6e3f0	327	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
8429abe0	328	sa_in6->sin6_len = sizeof(struct sockaddr_in6);
eac6e3f0	329	#endif
8429abe0 RW	330	sa_in6->sin6_addr = addr->v6;
	331	sa_in6->sin6_port = htons(port);
	332	break;
	333	default:
	334	fatalx("addr2sa: unknown af");
	335	}
	336
	337	return ((struct sockaddr *)&ss);
	338	}
	339
	340	void
eac6e3f0	341	sa2addr(struct sockaddr sa, int af, union ldpd_addr addr, in_port_t port)
8429abe0 RW	342	{
	343	struct sockaddr_in sa_in = (struct sockaddr_in )sa;
	344	struct sockaddr_in6 sa_in6 = (struct sockaddr_in6 )sa;
	345
eac6e3f0 RW	346	if (addr)
eac6e3f0 RW	347	memset(addr, 0, sizeof(*addr));
8429abe0 RW	348	switch (sa->sa_family) {
8429abe0 RW	349	case AF_INET:
eac6e3f0 RW	350	if (af)
	351	*af = AF_INET;
	352	if (addr)
	353	addr->v4 = sa_in->sin_addr;
	354	if (port)
	355	*port = sa_in->sin_port;
8429abe0 RW	356	break;
8429abe0 RW	357	case AF_INET6:
eac6e3f0 RW	358	if (af)
	359	*af = AF_INET6;
	360	if (addr)
	361	addr->v6 = sa_in6->sin6_addr;
	362	if (port)
	363	*port = sa_in6->sin6_port;
8429abe0 RW	364	break;
	365	default:
	366	fatalx("sa2addr: unknown af");
	367	}
	368	}
eac6e3f0 RW	369
	370	socklen_t
	371	sockaddr_len(struct sockaddr *sa)
	372	{
	373	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
	374	return (sa->sa_len);
	375	#else
	376	switch (sa->sa_family) {
	377	case AF_INET:
	378	return (sizeof(struct sockaddr_in));
	379	case AF_INET6:
	380	return (sizeof(struct sockaddr_in6));
	381	default:
	382	fatalx("sockaddr_len: unknown af");
	383	}
	384	#endif
	385	}