[mirror_frr.git] / lib / sockunion.c

/* Socket union related function.
 * Copyright (c) 1997, 98 Kunihiro Ishiguro
 *
 * This file is part of GNU Zebra.
 *
 * GNU Zebra is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2, or (at your option) any
 * later version.
 *
 * GNU Zebra is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "prefix.h"
#include "vty.h"
#include "sockunion.h"
#include "memory.h"
#include "log.h"
#include "jhash.h"
#include "lib_errors.h"

DEFINE_MTYPE_STATIC(LIB, SOCKUNION, "Socket union")

const char *inet_sutop(const union sockunion *su, char *str)
{
	switch (su->sa.sa_family) {
	case AF_INET:
		inet_ntop(AF_INET, &su->sin.sin_addr, str, INET_ADDRSTRLEN);
		break;
	case AF_INET6:
		inet_ntop(AF_INET6, &su->sin6.sin6_addr, str, INET6_ADDRSTRLEN);
		break;
	}
	return str;
}

int str2sockunion(const char *str, union sockunion *su)
{
	int ret;

	if (str == NULL)
		return -1;

	memset(su, 0, sizeof(union sockunion));

	ret = inet_pton(AF_INET, str, &su->sin.sin_addr);
	if (ret > 0) /* Valid IPv4 address format. */
	{
		su->sin.sin_family = AF_INET;
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		su->sin.sin_len = sizeof(struct sockaddr_in);
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
		return 0;
	}
	ret = inet_pton(AF_INET6, str, &su->sin6.sin6_addr);
	if (ret > 0) /* Valid IPv6 address format. */
	{
		su->sin6.sin6_family = AF_INET6;
#ifdef SIN6_LEN
		su->sin6.sin6_len = sizeof(struct sockaddr_in6);
#endif /* SIN6_LEN */
		return 0;
	}
	return -1;
}

const char *sockunion2str(const union sockunion *su, char *buf, size_t len)
{
	switch (sockunion_family(su)) {
	case AF_UNSPEC:
		snprintf(buf, len, "(unspec)");
		return buf;
	case AF_INET:
		return inet_ntop(AF_INET, &su->sin.sin_addr, buf, len);
	case AF_INET6:
		return inet_ntop(AF_INET6, &su->sin6.sin6_addr, buf, len);
	}
	snprintf(buf, len, "(af %d)", sockunion_family(su));
	return buf;
}

union sockunion *sockunion_str2su(const char *str)
{
	union sockunion *su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));

	if (!str2sockunion(str, su))
		return su;

	XFREE(MTYPE_SOCKUNION, su);
	return NULL;
}

/* Convert IPv4 compatible IPv6 address to IPv4 address. */
static void sockunion_normalise_mapped(union sockunion *su)
{
	struct sockaddr_in sin;

	if (su->sa.sa_family == AF_INET6
	    && IN6_IS_ADDR_V4MAPPED(&su->sin6.sin6_addr)) {
		memset(&sin, 0, sizeof(struct sockaddr_in));
		sin.sin_family = AF_INET;
		sin.sin_port = su->sin6.sin6_port;
		memcpy(&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
		memcpy(su, &sin, sizeof(struct sockaddr_in));
	}
}

/* return sockunion structure : this function should be revised. */
static const char *sockunion_log(const union sockunion *su, char *buf,
				 size_t len)
{
	switch (su->sa.sa_family) {
	case AF_INET:
		return inet_ntop(AF_INET, &su->sin.sin_addr, buf, len);

	case AF_INET6:
		return inet_ntop(AF_INET6, &(su->sin6.sin6_addr), buf, len);
		break;

	default:
		snprintf(buf, len, "af_unknown %d ", su->sa.sa_family);
		return buf;
	}
}

/* Return socket of sockunion. */
int sockunion_socket(const union sockunion *su)
{
	int sock;

	sock = socket(su->sa.sa_family, SOCK_STREAM, 0);
	if (sock < 0) {
		char buf[SU_ADDRSTRLEN];
		flog_err(EC_LIB_SOCKET, "Can't make socket for %s : %s",
			 sockunion_log(su, buf, SU_ADDRSTRLEN),
			 safe_strerror(errno));
		return -1;
	}

	return sock;
}

/* Return accepted new socket file descriptor. */
int sockunion_accept(int sock, union sockunion *su)
{
	socklen_t len;
	int client_sock;

	len = sizeof(union sockunion);
	client_sock = accept(sock, (struct sockaddr *)su, &len);

	sockunion_normalise_mapped(su);
	return client_sock;
}

/* Return sizeof union sockunion.  */
int sockunion_sizeof(const union sockunion *su)
{
	int ret;

	ret = 0;
	switch (su->sa.sa_family) {
	case AF_INET:
		ret = sizeof(struct sockaddr_in);
		break;
	case AF_INET6:
		ret = sizeof(struct sockaddr_in6);
		break;
	}
	return ret;
}

/* Performs a non-blocking connect().  */
enum connect_result sockunion_connect(int fd, const union sockunion *peersu,
				      unsigned short port, ifindex_t ifindex)
{
	int ret;
	union sockunion su;

	memcpy(&su, peersu, sizeof(union sockunion));

	switch (su.sa.sa_family) {
	case AF_INET:
		su.sin.sin_port = port;
		break;
	case AF_INET6:
		su.sin6.sin6_port = port;
#ifdef KAME
		if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr) && ifindex) {
			su.sin6.sin6_scope_id = ifindex;
			SET_IN6_LINKLOCAL_IFINDEX(su.sin6.sin6_addr, ifindex);
		}
#endif /* KAME */
		break;
	}

	/* Call connect function. */
	ret = connect(fd, (struct sockaddr *)&su, sockunion_sizeof(&su));

	/* Immediate success */
	if (ret == 0)
		return connect_success;

	/* If connect is in progress then return 1 else it's real error. */
	if (ret < 0) {
		if (errno != EINPROGRESS) {
			char str[SU_ADDRSTRLEN];
			zlog_info("can't connect to %s fd %d : %s",
				  sockunion_log(&su, str, sizeof str), fd,
				  safe_strerror(errno));
			return connect_error;
		}
	}

	return connect_in_progress;
}

/* Make socket from sockunion union. */
int sockunion_stream_socket(union sockunion *su)
{
	int sock;

	if (su->sa.sa_family == 0)
		su->sa.sa_family = AF_INET_UNION;

	sock = socket(su->sa.sa_family, SOCK_STREAM, 0);

	if (sock < 0)
		flog_err(EC_LIB_SOCKET,
			 "can't make socket sockunion_stream_socket");

	return sock;
}

/* Bind socket to specified address. */
int sockunion_bind(int sock, union sockunion *su, unsigned short port,
		   union sockunion *su_addr)
{
	int size = 0;
	int ret;

	if (su->sa.sa_family == AF_INET) {
		size = sizeof(struct sockaddr_in);
		su->sin.sin_port = htons(port);
#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
		su->sin.sin_len = size;
#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
		if (su_addr == NULL)
			sockunion2ip(su) = htonl(INADDR_ANY);
	} else if (su->sa.sa_family == AF_INET6) {
		size = sizeof(struct sockaddr_in6);
		su->sin6.sin6_port = htons(port);
#ifdef SIN6_LEN
		su->sin6.sin6_len = size;
#endif /* SIN6_LEN */
		if (su_addr == NULL) {
#ifdef LINUX_IPV6
			memset(&su->sin6.sin6_addr, 0, sizeof(struct in6_addr));
#else
			su->sin6.sin6_addr = in6addr_any;
#endif /* LINUX_IPV6 */
		}
	}

	ret = bind(sock, (struct sockaddr *)su, size);
	if (ret < 0) {
		char buf[SU_ADDRSTRLEN];
		flog_err(EC_LIB_SOCKET, "can't bind socket for %s : %s",
			 sockunion_log(su, buf, SU_ADDRSTRLEN),
			 safe_strerror(errno));
	}

	return ret;
}

int sockopt_reuseaddr(int sock)
{
	int ret;
	int on = 1;

	ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on,
			 sizeof(on));
	if (ret < 0) {
		flog_err(EC_LIB_SOCKET,
			 "can't set sockopt SO_REUSEADDR to socket %d", sock);
		return -1;
	}
	return 0;
}

#ifdef SO_REUSEPORT
int sockopt_reuseport(int sock)
{
	int ret;
	int on = 1;

	ret = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (void *)&on,
			 sizeof(on));
	if (ret < 0) {
		flog_err(EC_LIB_SOCKET,
			 "can't set sockopt SO_REUSEPORT to socket %d", sock);
		return -1;
	}
	return 0;
}
#else
int sockopt_reuseport(int sock)
{
	return 0;
}
#endif /* 0 */

int sockopt_ttl(int family, int sock, int ttl)
{
	int ret;

#ifdef IP_TTL
	if (family == AF_INET) {
		ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&ttl,
				 sizeof(int));
		if (ret < 0) {
			flog_err(EC_LIB_SOCKET,
				 "can't set sockopt IP_TTL %d to socket %d",
				 ttl, sock);
			return -1;
		}
		return 0;
	}
#endif /* IP_TTL */
	if (family == AF_INET6) {
		ret = setsockopt(sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
				 (void *)&ttl, sizeof(int));
		if (ret < 0) {
			flog_err(
				EC_LIB_SOCKET,
				"can't set sockopt IPV6_UNICAST_HOPS %d to socket %d",
				ttl, sock);
			return -1;
		}
		return 0;
	}
	return 0;
}

/*
 * This function called setsockopt(.., TCP_CORK,...)
 * Which on linux is a no-op since it is enabled by
 * default and on BSD it uses TCP_NOPUSH to do
 * the same thing( which it was not configured to
 * use).  This cleanup of the api occurred on 8/1/17
 * I imagine if after more than 1 year of no-one
 * complaining, and a major upgrade release we
 * can deprecate and remove this function call
 */
int sockopt_cork(int sock, int onoff)
{
	return 0;
}

int sockopt_minttl(int family, int sock, int minttl)
{
#ifdef IP_MINTTL
	if (family == AF_INET) {
		int ret = setsockopt(sock, IPPROTO_IP, IP_MINTTL, &minttl,
				     sizeof(minttl));
		if (ret < 0)
			flog_err(
				EC_LIB_SOCKET,
				"can't set sockopt IP_MINTTL to %d on socket %d: %s",
				minttl, sock, safe_strerror(errno));
		return ret;
	}
#endif /* IP_MINTTL */
#ifdef IPV6_MINHOPCOUNT
	if (family == AF_INET6) {
		int ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MINHOPCOUNT,
				     &minttl, sizeof(minttl));
		if (ret < 0)
			flog_err(
				EC_LIB_SOCKET,
				"can't set sockopt IPV6_MINHOPCOUNT to %d on socket %d: %s",
				minttl, sock, safe_strerror(errno));
		return ret;
	}
#endif

	errno = EOPNOTSUPP;
	return -1;
}

int sockopt_v6only(int family, int sock)
{
	int ret, on = 1;

#ifdef IPV6_V6ONLY
	if (family == AF_INET6) {
		ret = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&on,
				 sizeof(int));
		if (ret < 0) {
			flog_err(EC_LIB_SOCKET,
				 "can't set sockopt IPV6_V6ONLY "
				 "to socket %d",
				 sock);
			return -1;
		}
		return 0;
	}
#endif /* IPV6_V6ONLY */
	return 0;
}

/* If same family and same prefix return 1. */
int sockunion_same(const union sockunion *su1, const union sockunion *su2)
{
	int ret = 0;

	if (su1->sa.sa_family != su2->sa.sa_family)
		return 0;

	switch (su1->sa.sa_family) {
	case AF_INET:
		ret = memcmp(&su1->sin.sin_addr, &su2->sin.sin_addr,
			     sizeof(struct in_addr));
		break;
	case AF_INET6:
		ret = memcmp(&su1->sin6.sin6_addr, &su2->sin6.sin6_addr,
			     sizeof(struct in6_addr));
		if ((ret == 0) && IN6_IS_ADDR_LINKLOCAL(&su1->sin6.sin6_addr)) {
			/* compare interface indices */
			if (su1->sin6.sin6_scope_id && su2->sin6.sin6_scope_id)
				ret = (su1->sin6.sin6_scope_id
				       == su2->sin6.sin6_scope_id)
					      ? 0
					      : 1;
		}
		break;
	}
	if (ret == 0)
		return 1;
	else
		return 0;
}

unsigned int sockunion_hash(const union sockunion *su)
{
	switch (sockunion_family(su)) {
	case AF_INET:
		return jhash_1word(su->sin.sin_addr.s_addr, 0);
	case AF_INET6:
		return jhash2(su->sin6.sin6_addr.s6_addr32,
			      array_size(su->sin6.sin6_addr.s6_addr32), 0);
	}
	return 0;
}

size_t family2addrsize(int family)
{
	switch (family) {
	case AF_INET:
		return sizeof(struct in_addr);
	case AF_INET6:
		return sizeof(struct in6_addr);
	}
	return 0;
}

size_t sockunion_get_addrlen(const union sockunion *su)
{
	return family2addrsize(sockunion_family(su));
}

const uint8_t *sockunion_get_addr(const union sockunion *su)
{
	switch (sockunion_family(su)) {
	case AF_INET:
		return (const uint8_t *)&su->sin.sin_addr.s_addr;
	case AF_INET6:
		return (const uint8_t *)&su->sin6.sin6_addr;
	}
	return NULL;
}

void sockunion_set(union sockunion *su, int family, const uint8_t *addr,
		   size_t bytes)
{
	if (family2addrsize(family) != bytes)
		return;

	sockunion_family(su) = family;
	switch (family) {
	case AF_INET:
		memcpy(&su->sin.sin_addr.s_addr, addr, bytes);
		break;
	case AF_INET6:
		memcpy(&su->sin6.sin6_addr, addr, bytes);
		break;
	}
}

/* After TCP connection is established.  Get local address and port. */
union sockunion *sockunion_getsockname(int fd)
{
	int ret;
	socklen_t len;
	union {
		struct sockaddr sa;
		struct sockaddr_in sin;
		struct sockaddr_in6 sin6;
		char tmp_buffer[128];
	} name;
	union sockunion *su;

	memset(&name, 0, sizeof name);
	len = sizeof name;

	ret = getsockname(fd, (struct sockaddr *)&name, &len);
	if (ret < 0) {
		flog_err(EC_LIB_SOCKET,
			 "Can't get local address and port by getsockname: %s",
			 safe_strerror(errno));
		return NULL;
	}

	if (name.sa.sa_family == AF_INET) {
		su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
		memcpy(su, &name, sizeof(struct sockaddr_in));
		return su;
	}
	if (name.sa.sa_family == AF_INET6) {
		su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
		memcpy(su, &name, sizeof(struct sockaddr_in6));
		sockunion_normalise_mapped(su);
		return su;
	}
	return NULL;
}

/* After TCP connection is established.  Get remote address and port. */
union sockunion *sockunion_getpeername(int fd)
{
	int ret;
	socklen_t len;
	union {
		struct sockaddr sa;
		struct sockaddr_in sin;
		struct sockaddr_in6 sin6;
		char tmp_buffer[128];
	} name;
	union sockunion *su;

	memset(&name, 0, sizeof name);
	len = sizeof name;
	ret = getpeername(fd, (struct sockaddr *)&name, &len);
	if (ret < 0) {
		flog_err(EC_LIB_SOCKET, "Can't get remote address and port: %s",
			 safe_strerror(errno));
		return NULL;
	}

	if (name.sa.sa_family == AF_INET) {
		su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
		memcpy(su, &name, sizeof(struct sockaddr_in));
		return su;
	}
	if (name.sa.sa_family == AF_INET6) {
		su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
		memcpy(su, &name, sizeof(struct sockaddr_in6));
		sockunion_normalise_mapped(su);
		return su;
	}
	return NULL;
}

/* Print sockunion structure */
static void __attribute__((unused)) sockunion_print(const union sockunion *su)
{
	if (su == NULL)
		return;

	switch (su->sa.sa_family) {
	case AF_INET:
		printf("%s\n", inet_ntoa(su->sin.sin_addr));
		break;
	case AF_INET6: {
		char buf[SU_ADDRSTRLEN];

		printf("%s\n", inet_ntop(AF_INET6, &(su->sin6.sin6_addr), buf,
					 sizeof(buf)));
	} break;

#ifdef AF_LINK
	case AF_LINK: {
		struct sockaddr_dl *sdl;

		sdl = (struct sockaddr_dl *)&(su->sa);
		printf("link#%d\n", sdl->sdl_index);
	} break;
#endif /* AF_LINK */
	default:
		printf("af_unknown %d\n", su->sa.sa_family);
		break;
	}
}

static int in6addr_cmp(const struct in6_addr *addr1,
		       const struct in6_addr *addr2)
{
	unsigned int i;
	const uint8_t *p1, *p2;

	p1 = (const uint8_t *)addr1;
	p2 = (const uint8_t *)addr2;

	for (i = 0; i < sizeof(struct in6_addr); i++) {
		if (p1[i] > p2[i])
			return 1;
		else if (p1[i] < p2[i])
			return -1;
	}
	return 0;
}

int sockunion_cmp(const union sockunion *su1, const union sockunion *su2)
{
	if (su1->sa.sa_family > su2->sa.sa_family)
		return 1;
	if (su1->sa.sa_family < su2->sa.sa_family)
		return -1;

	if (su1->sa.sa_family == AF_INET) {
		if (ntohl(sockunion2ip(su1)) == ntohl(sockunion2ip(su2)))
			return 0;
		if (ntohl(sockunion2ip(su1)) > ntohl(sockunion2ip(su2)))
			return 1;
		else
			return -1;
	}
	if (su1->sa.sa_family == AF_INET6)
		return in6addr_cmp(&su1->sin6.sin6_addr, &su2->sin6.sin6_addr);
	return 0;
}

/* Duplicate sockunion. */
union sockunion *sockunion_dup(const union sockunion *su)
{
	union sockunion *dup =
		XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	memcpy(dup, su, sizeof(union sockunion));
	return dup;
}

void sockunion_free(union sockunion *su)
{
	XFREE(MTYPE_SOCKUNION, su);
}

void sockunion_init(union sockunion *su)
{
	memset(su, 0, sizeof(union sockunion));
}
Commit	Line	Data
718e3744	1	/* Socket union related function.
	2	* Copyright (c) 1997, 98 Kunihiro Ishiguro
	3	*
	4	* This file is part of GNU Zebra.
	5	*
	6	* GNU Zebra is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2, or (at your option) any
	9	* later version.
	10	*
	11	* GNU Zebra is distributed in the hope that it will be useful, but
	12	* WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	14	* General Public License for more details.
	15	*
896014f4 DL	16	* You should have received a copy of the GNU General Public License along
	17	* with this program; see the file COPYING; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
718e3744	19	*/
	20
	21	#include <zebra.h>
	22
	23	#include "prefix.h"
	24	#include "vty.h"
	25	#include "sockunion.h"
	26	#include "memory.h"
718e3744	27	#include "log.h"
7cb5cdbb	28	#include "jhash.h"
174482ef	29	#include "lib_errors.h"
718e3744	30
4a1ab8e4 DL	31	DEFINE_MTYPE_STATIC(LIB, SOCKUNION, "Socket union")
4a1ab8e4 DL	32
d62a17ae	33	const char inet_sutop(const union sockunion su, char *str)
	34	{
	35	switch (su->sa.sa_family) {
	36	case AF_INET:
	37	inet_ntop(AF_INET, &su->sin.sin_addr, str, INET_ADDRSTRLEN);
	38	break;
	39	case AF_INET6:
	40	inet_ntop(AF_INET6, &su->sin6.sin6_addr, str, INET6_ADDRSTRLEN);
	41	break;
	42	}
	43	return str;
718e3744	44	}
718e3744	45
d62a17ae	46	int str2sockunion(const char str, union sockunion su)
718e3744	47	{
d62a17ae	48	int ret;
718e3744	49
d1f92e45	50	if (str == NULL)
	51	return -1;
	52
d62a17ae	53	memset(su, 0, sizeof(union sockunion));
718e3744	54
d62a17ae	55	ret = inet_pton(AF_INET, str, &su->sin.sin_addr);
	56	if (ret > 0) /* Valid IPv4 address format. */
	57	{
	58	su->sin.sin_family = AF_INET;
6f0e3f6e	59	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
d62a17ae	60	su->sin.sin_len = sizeof(struct sockaddr_in);
6f0e3f6e	61	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
d62a17ae	62	return 0;
	63	}
	64	ret = inet_pton(AF_INET6, str, &su->sin6.sin6_addr);
	65	if (ret > 0) /* Valid IPv6 address format. */
	66	{
	67	su->sin6.sin6_family = AF_INET6;
718e3744	68	#ifdef SIN6_LEN
d62a17ae	69	su->sin6.sin6_len = sizeof(struct sockaddr_in6);
718e3744	70	#endif /* SIN6_LEN */
d62a17ae	71	return 0;
	72	}
	73	return -1;
718e3744	74	}
718e3744	75
d62a17ae	76	const char sockunion2str(const union sockunion su, char *buf, size_t len)
718e3744	77	{
d62a17ae	78	switch (sockunion_family(su)) {
	79	case AF_UNSPEC:
	80	snprintf(buf, len, "(unspec)");
	81	return buf;
	82	case AF_INET:
	83	return inet_ntop(AF_INET, &su->sin.sin_addr, buf, len);
	84	case AF_INET6:
	85	return inet_ntop(AF_INET6, &su->sin6.sin6_addr, buf, len);
	86	}
	87	snprintf(buf, len, "(af %d)", sockunion_family(su));
	88	return buf;
718e3744	89	}
718e3744	90
d62a17ae	91	union sockunion sockunion_str2su(const char str)
2fb2a455	92	{
d62a17ae	93	union sockunion *su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	94
	95	if (!str2sockunion(str, su))
	96	return su;
	97
	98	XFREE(MTYPE_SOCKUNION, su);
	99	return NULL;
2fb2a455 PJ	100	}
2fb2a455 PJ	101
1a7dcf42	102	/* Convert IPv4 compatible IPv6 address to IPv4 address. */
d62a17ae	103	static void sockunion_normalise_mapped(union sockunion *su)
	104	{
	105	struct sockaddr_in sin;
	106
	107	if (su->sa.sa_family == AF_INET6
	108	&& IN6_IS_ADDR_V4MAPPED(&su->sin6.sin6_addr)) {
	109	memset(&sin, 0, sizeof(struct sockaddr_in));
	110	sin.sin_family = AF_INET;
	111	sin.sin_port = su->sin6.sin6_port;
	112	memcpy(&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
	113	memcpy(su, &sin, sizeof(struct sockaddr_in));
	114	}
1a7dcf42 PJ	115	}
1a7dcf42 PJ	116
fc9707c3	117	/* return sockunion structure : this function should be revised. */
d62a17ae	118	static const char sockunion_log(const union sockunion su, char *buf,
d62a17ae	119	size_t len)
fc9707c3	120	{
d62a17ae	121	switch (su->sa.sa_family) {
	122	case AF_INET:
	123	return inet_ntop(AF_INET, &su->sin.sin_addr, buf, len);
fc9707c3	124
d62a17ae	125	case AF_INET6:
	126	return inet_ntop(AF_INET6, &(su->sin6.sin6_addr), buf, len);
	127	break;
fc9707c3	128
d62a17ae	129	default:
	130	snprintf(buf, len, "af_unknown %d ", su->sa.sa_family);
	131	return buf;
	132	}
fc9707c3 DW	133	}
fc9707c3 DW	134
718e3744	135	/* Return socket of sockunion. */
d62a17ae	136	int sockunion_socket(const union sockunion *su)
718e3744	137	{
d62a17ae	138	int sock;
718e3744	139
d62a17ae	140	sock = socket(su->sa.sa_family, SOCK_STREAM, 0);
	141	if (sock < 0) {
	142	char buf[SU_ADDRSTRLEN];
450971aa	143	flog_err(EC_LIB_SOCKET, "Can't make socket for %s : %s",
1b5e2f89 DS	144	sockunion_log(su, buf, SU_ADDRSTRLEN),
1b5e2f89 DS	145	safe_strerror(errno));
d62a17ae	146	return -1;
d62a17ae	147	}
718e3744	148
d62a17ae	149	return sock;
718e3744	150	}
	151
	152	/* Return accepted new socket file descriptor. */
d62a17ae	153	int sockunion_accept(int sock, union sockunion *su)
718e3744	154	{
d62a17ae	155	socklen_t len;
d62a17ae	156	int client_sock;
718e3744	157
d62a17ae	158	len = sizeof(union sockunion);
	159	client_sock = accept(sock, (struct sockaddr *)su, &len);
	160
	161	sockunion_normalise_mapped(su);
	162	return client_sock;
718e3744	163	}
	164
	165	/* Return sizeof union sockunion. */
862f2f37	166	int sockunion_sizeof(const union sockunion *su)
d62a17ae	167	{
	168	int ret;
	169
	170	ret = 0;
	171	switch (su->sa.sa_family) {
	172	case AF_INET:
	173	ret = sizeof(struct sockaddr_in);
	174	break;
	175	case AF_INET6:
	176	ret = sizeof(struct sockaddr_in6);
	177	break;
	178	}
	179	return ret;
718e3744	180	}
718e3744	181
b11b5772	182	/* Performs a non-blocking connect(). */
d62a17ae	183	enum connect_result sockunion_connect(int fd, const union sockunion *peersu,
	184	unsigned short port, ifindex_t ifindex)
	185	{
	186	int ret;
d62a17ae	187	union sockunion su;
	188
	189	memcpy(&su, peersu, sizeof(union sockunion));
	190
	191	switch (su.sa.sa_family) {
	192	case AF_INET:
	193	su.sin.sin_port = port;
	194	break;
	195	case AF_INET6:
	196	su.sin6.sin6_port = port;
718e3744	197	#ifdef KAME
d62a17ae	198	if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr) && ifindex) {
	199	su.sin6.sin6_scope_id = ifindex;
	200	SET_IN6_LINKLOCAL_IFINDEX(su.sin6.sin6_addr, ifindex);
	201	}
718e3744	202	#endif /* KAME */
d62a17ae	203	break;
	204	}
	205
d62a17ae	206	/* Call connect function. */
	207	ret = connect(fd, (struct sockaddr *)&su, sockunion_sizeof(&su));
	208
	209	/* Immediate success */
b11b5772	210	if (ret == 0)
d62a17ae	211	return connect_success;
d62a17ae	212
	213	/* If connect is in progress then return 1 else it's real error. */
	214	if (ret < 0) {
	215	if (errno != EINPROGRESS) {
	216	char str[SU_ADDRSTRLEN];
	217	zlog_info("can't connect to %s fd %d : %s",
	218	sockunion_log(&su, str, sizeof str), fd,
	219	safe_strerror(errno));
	220	return connect_error;
	221	}
718e3744	222	}
718e3744	223
d62a17ae	224	return connect_in_progress;
718e3744	225	}
	226
	227	/* Make socket from sockunion union. */
d62a17ae	228	int sockunion_stream_socket(union sockunion *su)
718e3744	229	{
d62a17ae	230	int sock;
718e3744	231
d62a17ae	232	if (su->sa.sa_family == 0)
d62a17ae	233	su->sa.sa_family = AF_INET_UNION;
718e3744	234
d62a17ae	235	sock = socket(su->sa.sa_family, SOCK_STREAM, 0);
718e3744	236
d62a17ae	237	if (sock < 0)
450971aa	238	flog_err(EC_LIB_SOCKET,
1b5e2f89	239	"can't make socket sockunion_stream_socket");
718e3744	240
d62a17ae	241	return sock;
718e3744	242	}
	243
	244	/* Bind socket to specified address. */
d62a17ae	245	int sockunion_bind(int sock, union sockunion *su, unsigned short port,
d62a17ae	246	union sockunion *su_addr)
718e3744	247	{
d62a17ae	248	int size = 0;
d62a17ae	249	int ret;
718e3744	250
d62a17ae	251	if (su->sa.sa_family == AF_INET) {
	252	size = sizeof(struct sockaddr_in);
	253	su->sin.sin_port = htons(port);
6f0e3f6e	254	#ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
d62a17ae	255	su->sin.sin_len = size;
6f0e3f6e	256	#endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
d62a17ae	257	if (su_addr == NULL)
	258	sockunion2ip(su) = htonl(INADDR_ANY);
	259	} else if (su->sa.sa_family == AF_INET6) {
	260	size = sizeof(struct sockaddr_in6);
	261	su->sin6.sin6_port = htons(port);
718e3744	262	#ifdef SIN6_LEN
d62a17ae	263	su->sin6.sin6_len = size;
718e3744	264	#endif /* SIN6_LEN */
d62a17ae	265	if (su_addr == NULL) {
1cbb5dfc	266	#ifdef LINUX_IPV6
d62a17ae	267	memset(&su->sin6.sin6_addr, 0, sizeof(struct in6_addr));
718e3744	268	#else
d62a17ae	269	su->sin6.sin6_addr = in6addr_any;
718e3744	270	#endif /* LINUX_IPV6 */
d62a17ae	271	}
718e3744	272	}
718e3744	273
d62a17ae	274	ret = bind(sock, (struct sockaddr *)su, size);
	275	if (ret < 0) {
	276	char buf[SU_ADDRSTRLEN];
450971aa	277	flog_err(EC_LIB_SOCKET, "can't bind socket for %s : %s",
1b5e2f89 DS	278	sockunion_log(su, buf, SU_ADDRSTRLEN),
1b5e2f89 DS	279	safe_strerror(errno));
d62a17ae	280	}
718e3744	281
d62a17ae	282	return ret;
718e3744	283	}
718e3744	284
d62a17ae	285	int sockopt_reuseaddr(int sock)
718e3744	286	{
d62a17ae	287	int ret;
d62a17ae	288	int on = 1;
718e3744	289
d62a17ae	290	ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on,
	291	sizeof(on));
	292	if (ret < 0) {
450971aa	293	flog_err(EC_LIB_SOCKET,
1b5e2f89	294	"can't set sockopt SO_REUSEADDR to socket %d", sock);
d62a17ae	295	return -1;
	296	}
	297	return 0;
718e3744	298	}
	299
	300	#ifdef SO_REUSEPORT
d62a17ae	301	int sockopt_reuseport(int sock)
718e3744	302	{
d62a17ae	303	int ret;
d62a17ae	304	int on = 1;
718e3744	305
d62a17ae	306	ret = setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, (void *)&on,
	307	sizeof(on));
	308	if (ret < 0) {
450971aa	309	flog_err(EC_LIB_SOCKET,
1b5e2f89	310	"can't set sockopt SO_REUSEPORT to socket %d", sock);
d62a17ae	311	return -1;
	312	}
	313	return 0;
718e3744	314	}
718e3744	315	#else
d62a17ae	316	int sockopt_reuseport(int sock)
718e3744	317	{
d62a17ae	318	return 0;
718e3744	319	}
	320	#endif /* 0 */
	321
d62a17ae	322	int sockopt_ttl(int family, int sock, int ttl)
718e3744	323	{
d62a17ae	324	int ret;
718e3744	325
718e3744	326	#ifdef IP_TTL
d62a17ae	327	if (family == AF_INET) {
	328	ret = setsockopt(sock, IPPROTO_IP, IP_TTL, (void *)&ttl,
	329	sizeof(int));
	330	if (ret < 0) {
450971aa	331	flog_err(EC_LIB_SOCKET,
1b5e2f89	332	"can't set sockopt IP_TTL %d to socket %d",
ade6974d	333	ttl, sock);
d62a17ae	334	return -1;
	335	}
	336	return 0;
718e3744	337	}
718e3744	338	#endif /* IP_TTL */
d62a17ae	339	if (family == AF_INET6) {
	340	ret = setsockopt(sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
	341	(void *)&ttl, sizeof(int));
	342	if (ret < 0) {
ade6974d	343	flog_err(
450971aa	344	EC_LIB_SOCKET,
ade6974d QY	345	"can't set sockopt IPV6_UNICAST_HOPS %d to socket %d",
ade6974d QY	346	ttl, sock);
d62a17ae	347	return -1;
	348	}
	349	return 0;
718e3744	350	}
d62a17ae	351	return 0;
718e3744	352	}
718e3744	353
c62232b4 DS	354	/*
	355	* This function called setsockopt(.., TCP_CORK,...)
	356	* Which on linux is a no-op since it is enabled by
	357	* default and on BSD it uses TCP_NOPUSH to do
	358	* the same thing( which it was not configured to
0437e105	359	* use). This cleanup of the api occurred on 8/1/17
c62232b4 DS	360	* I imagine if after more than 1 year of no-one
	361	* complaining, and a major upgrade release we
	362	* can deprecate and remove this function call
	363	*/
d62a17ae	364	int sockopt_cork(int sock, int onoff)
58192df7	365	{
d62a17ae	366	return 0;
ed40466a DS	367	}
ed40466a DS	368
d62a17ae	369	int sockopt_minttl(int family, int sock, int minttl)
fa411a21	370	{
89b6d1f8	371	#ifdef IP_MINTTL
d62a17ae	372	if (family == AF_INET) {
	373	int ret = setsockopt(sock, IPPROTO_IP, IP_MINTTL, &minttl,
	374	sizeof(minttl));
	375	if (ret < 0)
ade6974d	376	flog_err(
450971aa	377	EC_LIB_SOCKET,
ade6974d QY	378	"can't set sockopt IP_MINTTL to %d on socket %d: %s",
ade6974d QY	379	minttl, sock, safe_strerror(errno));
d62a17ae	380	return ret;
d62a17ae	381	}
d876bdf4	382	#endif /* IP_MINTTL */
d8dc5257	383	#ifdef IPV6_MINHOPCOUNT
d62a17ae	384	if (family == AF_INET6) {
	385	int ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MINHOPCOUNT,
	386	&minttl, sizeof(minttl));
	387	if (ret < 0)
ade6974d	388	flog_err(
450971aa	389	EC_LIB_SOCKET,
ade6974d QY	390	"can't set sockopt IPV6_MINHOPCOUNT to %d on socket %d: %s",
ade6974d QY	391	minttl, sock, safe_strerror(errno));
d62a17ae	392	return ret;
d62a17ae	393	}
d876bdf4	394	#endif
fa411a21	395
d62a17ae	396	errno = EOPNOTSUPP;
d62a17ae	397	return -1;
fa411a21 NH	398	}
fa411a21 NH	399
d62a17ae	400	int sockopt_v6only(int family, int sock)
ca051269	401	{
d62a17ae	402	int ret, on = 1;
ca051269	403
ca051269	404	#ifdef IPV6_V6ONLY
d62a17ae	405	if (family == AF_INET6) {
	406	ret = setsockopt(sock, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&on,
	407	sizeof(int));
	408	if (ret < 0) {
450971aa	409	flog_err(EC_LIB_SOCKET,
1b5e2f89 DS	410	"can't set sockopt IPV6_V6ONLY "
	411	"to socket %d",
	412	sock);
d62a17ae	413	return -1;
	414	}
	415	return 0;
ca051269	416	}
ca051269	417	#endif /* IPV6_V6ONLY */
d62a17ae	418	return 0;
ca051269 DL	419	}
ca051269 DL	420
718e3744	421	/* If same family and same prefix return 1. */
d62a17ae	422	int sockunion_same(const union sockunion su1, const union sockunion su2)
	423	{
	424	int ret = 0;
	425
	426	if (su1->sa.sa_family != su2->sa.sa_family)
	427	return 0;
	428
	429	switch (su1->sa.sa_family) {
	430	case AF_INET:
	431	ret = memcmp(&su1->sin.sin_addr, &su2->sin.sin_addr,
	432	sizeof(struct in_addr));
	433	break;
	434	case AF_INET6:
	435	ret = memcmp(&su1->sin6.sin6_addr, &su2->sin6.sin6_addr,
	436	sizeof(struct in6_addr));
	437	if ((ret == 0) && IN6_IS_ADDR_LINKLOCAL(&su1->sin6.sin6_addr)) {
	438	/* compare interface indices */
	439	if (su1->sin6.sin6_scope_id && su2->sin6.sin6_scope_id)
	440	ret = (su1->sin6.sin6_scope_id
	441	== su2->sin6.sin6_scope_id)
	442	? 0
	443	: 1;
	444	}
	445	break;
f2345335	446	}
d62a17ae	447	if (ret == 0)
	448	return 1;
	449	else
	450	return 0;
718e3744	451	}
718e3744	452
d62a17ae	453	unsigned int sockunion_hash(const union sockunion *su)
7cb5cdbb	454	{
d62a17ae	455	switch (sockunion_family(su)) {
	456	case AF_INET:
	457	return jhash_1word(su->sin.sin_addr.s_addr, 0);
	458	case AF_INET6:
	459	return jhash2(su->sin6.sin6_addr.s6_addr32,
7e3a1ec7	460	array_size(su->sin6.sin6_addr.s6_addr32), 0);
d62a17ae	461	}
d62a17ae	462	return 0;
7cb5cdbb TT	463	}
7cb5cdbb TT	464
d62a17ae	465	size_t family2addrsize(int family)
95e0999c	466	{
d62a17ae	467	switch (family) {
	468	case AF_INET:
	469	return sizeof(struct in_addr);
	470	case AF_INET6:
	471	return sizeof(struct in6_addr);
	472	}
	473	return 0;
95e0999c TT	474	}
95e0999c TT	475
d62a17ae	476	size_t sockunion_get_addrlen(const union sockunion *su)
95e0999c	477	{
d62a17ae	478	return family2addrsize(sockunion_family(su));
95e0999c TT	479	}
95e0999c TT	480
d7c0a89a	481	const uint8_t sockunion_get_addr(const union sockunion su)
95e0999c	482	{
d62a17ae	483	switch (sockunion_family(su)) {
d62a17ae	484	case AF_INET:
d7c0a89a	485	return (const uint8_t *)&su->sin.sin_addr.s_addr;
d62a17ae	486	case AF_INET6:
d7c0a89a	487	return (const uint8_t *)&su->sin6.sin6_addr;
d62a17ae	488	}
d62a17ae	489	return NULL;
95e0999c TT	490	}
95e0999c TT	491
d7c0a89a	492	void sockunion_set(union sockunion su, int family, const uint8_t addr,
d62a17ae	493	size_t bytes)
95e0999c	494	{
d62a17ae	495	if (family2addrsize(family) != bytes)
d62a17ae	496	return;
95e0999c	497
d62a17ae	498	sockunion_family(su) = family;
	499	switch (family) {
	500	case AF_INET:
	501	memcpy(&su->sin.sin_addr.s_addr, addr, bytes);
	502	break;
	503	case AF_INET6:
	504	memcpy(&su->sin6.sin6_addr, addr, bytes);
	505	break;
	506	}
95e0999c TT	507	}
95e0999c TT	508
718e3744	509	/* After TCP connection is established. Get local address and port. */
d62a17ae	510	union sockunion *sockunion_getsockname(int fd)
	511	{
	512	int ret;
	513	socklen_t len;
	514	union {
	515	struct sockaddr sa;
	516	struct sockaddr_in sin;
	517	struct sockaddr_in6 sin6;
	518	char tmp_buffer[128];
	519	} name;
	520	union sockunion *su;
	521
	522	memset(&name, 0, sizeof name);
	523	len = sizeof name;
	524
	525	ret = getsockname(fd, (struct sockaddr *)&name, &len);
	526	if (ret < 0) {
450971aa	527	flog_err(EC_LIB_SOCKET,
1b5e2f89 DS	528	"Can't get local address and port by getsockname: %s",
1b5e2f89 DS	529	safe_strerror(errno));
d62a17ae	530	return NULL;
	531	}
	532
	533	if (name.sa.sa_family == AF_INET) {
	534	su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	535	memcpy(su, &name, sizeof(struct sockaddr_in));
	536	return su;
	537	}
	538	if (name.sa.sa_family == AF_INET6) {
	539	su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	540	memcpy(su, &name, sizeof(struct sockaddr_in6));
	541	sockunion_normalise_mapped(su);
	542	return su;
	543	}
	544	return NULL;
718e3744	545	}
	546
	547	/* After TCP connection is established. Get remote address and port. */
d62a17ae	548	union sockunion *sockunion_getpeername(int fd)
	549	{
	550	int ret;
	551	socklen_t len;
	552	union {
	553	struct sockaddr sa;
	554	struct sockaddr_in sin;
	555	struct sockaddr_in6 sin6;
	556	char tmp_buffer[128];
	557	} name;
	558	union sockunion *su;
	559
	560	memset(&name, 0, sizeof name);
	561	len = sizeof name;
	562	ret = getpeername(fd, (struct sockaddr *)&name, &len);
	563	if (ret < 0) {
1c50c1c0	564	flog_err(EC_LIB_SOCKET, "Can't get remote address and port: %s",
1b5e2f89	565	safe_strerror(errno));
d62a17ae	566	return NULL;
	567	}
	568
	569	if (name.sa.sa_family == AF_INET) {
	570	su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	571	memcpy(su, &name, sizeof(struct sockaddr_in));
	572	return su;
	573	}
	574	if (name.sa.sa_family == AF_INET6) {
	575	su = XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	576	memcpy(su, &name, sizeof(struct sockaddr_in6));
	577	sockunion_normalise_mapped(su);
	578	return su;
	579	}
	580	return NULL;
718e3744	581	}
	582
	583	/* Print sockunion structure */
d62a17ae	584	static void __attribute__((unused)) sockunion_print(const union sockunion *su)
	585	{
	586	if (su == NULL)
	587	return;
	588
	589	switch (su->sa.sa_family) {
	590	case AF_INET:
	591	printf("%s\n", inet_ntoa(su->sin.sin_addr));
	592	break;
	593	case AF_INET6: {
	594	char buf[SU_ADDRSTRLEN];
	595
	596	printf("%s\n", inet_ntop(AF_INET6, &(su->sin6.sin6_addr), buf,
	597	sizeof(buf)));
	598	} break;
718e3744	599
718e3744	600	#ifdef AF_LINK
d62a17ae	601	case AF_LINK: {
	602	struct sockaddr_dl *sdl;
	603
	604	sdl = (struct sockaddr_dl *)&(su->sa);
	605	printf("link#%d\n", sdl->sdl_index);
	606	} break;
718e3744	607	#endif /* AF_LINK */
d62a17ae	608	default:
	609	printf("af_unknown %d\n", su->sa.sa_family);
	610	break;
	611	}
718e3744	612	}
718e3744	613
d62a17ae	614	static int in6addr_cmp(const struct in6_addr *addr1,
d62a17ae	615	const struct in6_addr *addr2)
718e3744	616	{
d62a17ae	617	unsigned int i;
d7c0a89a	618	const uint8_t p1, p2;
718e3744	619
d7c0a89a QY	620	p1 = (const uint8_t *)addr1;
d7c0a89a QY	621	p2 = (const uint8_t *)addr2;
718e3744	622
d62a17ae	623	for (i = 0; i < sizeof(struct in6_addr); i++) {
	624	if (p1[i] > p2[i])
	625	return 1;
	626	else if (p1[i] < p2[i])
	627	return -1;
	628	}
	629	return 0;
718e3744	630	}
718e3744	631
d62a17ae	632	int sockunion_cmp(const union sockunion su1, const union sockunion su2)
718e3744	633	{
d62a17ae	634	if (su1->sa.sa_family > su2->sa.sa_family)
	635	return 1;
	636	if (su1->sa.sa_family < su2->sa.sa_family)
	637	return -1;
718e3744	638
d62a17ae	639	if (su1->sa.sa_family == AF_INET) {
	640	if (ntohl(sockunion2ip(su1)) == ntohl(sockunion2ip(su2)))
	641	return 0;
	642	if (ntohl(sockunion2ip(su1)) > ntohl(sockunion2ip(su2)))
	643	return 1;
	644	else
	645	return -1;
	646	}
	647	if (su1->sa.sa_family == AF_INET6)
	648	return in6addr_cmp(&su1->sin6.sin6_addr, &su2->sin6.sin6_addr);
718e3744	649	return 0;
718e3744	650	}
	651
	652	/* Duplicate sockunion. */
d62a17ae	653	union sockunion sockunion_dup(const union sockunion su)
718e3744	654	{
d62a17ae	655	union sockunion *dup =
	656	XCALLOC(MTYPE_SOCKUNION, sizeof(union sockunion));
	657	memcpy(dup, su, sizeof(union sockunion));
	658	return dup;
718e3744	659	}
718e3744	660
d62a17ae	661	void sockunion_free(union sockunion *su)
718e3744	662	{
d62a17ae	663	XFREE(MTYPE_SOCKUNION, su);
718e3744	664	}
dd793e4a	665
d62a17ae	666	void sockunion_init(union sockunion *su)
dd793e4a	667	{
d62a17ae	668	memset(su, 0, sizeof(union sockunion));
dd793e4a	669	}