/*
* Copyright (c) 2010-2011, Red Hat, Inc.
*
* Permission to use, copy, modify, and/or 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 RED HAT, INC. DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL RED HAT, INC. 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.
*/
/*
* Author: Jan Friesse <jfriesse@redhat.com>
*/
#include <sys/types.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <err.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "addrfunc.h"
#include "logging.h"
/*
* Compares two addrinfo structures. Family, socktype, protocol and sockaddr are
* compared. This one don't goes to deep, so compares really only one struct not
* list of them.
*/
int
af_ai_eq(const struct addrinfo *a1, const struct addrinfo *a2)
{
return ((a1->ai_family == a2->ai_family) &&
(a1->ai_socktype == a2->ai_socktype) &&
(a1->ai_protocol == a2->ai_protocol) &&
af_sockaddr_eq(a1->ai_addr, a2->ai_addr));
}
/*
* Deep compare of two addrinfo structures. Internally calls addrinfo_eq
* function to compare one struct. It returns 1, if at least one addr from a1
* matches with at least on addr from a2.
*/
int
af_ai_deep_eq(const struct addrinfo *a1, const struct addrinfo *a2)
{
const struct addrinfo *a1_i, *a2_i;
for (a1_i = a1; a1_i != NULL; a1_i = a1_i->ai_next) {
for (a2_i = a2; a2_i != NULL; a2_i = a2_i->ai_next) {
if (af_ai_eq(a1_i, a2_i)) {
return (1);
}
}
}
return (0);
}
/*
* Find out if ai is duplicate of items in ai_list. ai_list is first addrinfo item (returned by
* getaddrinfo) and list is traversed up to ai item.
* Function return 0 if ai is not duplicate of items in ai_list, otherwise 1
*/
int
af_ai_is_dup(const struct addrinfo *ai_list, const struct addrinfo *ai)
{
const struct addrinfo *ai_i;
int res;
res = 0;
for (ai_i = ai_list; res == 0 && ai_i != ai && ai_i != NULL; ai_i = ai_i->ai_next) {
if (af_ai_eq(ai_i, ai)) {
res = 1;
}
}
return (res);
}
/*
* Test if given list of addrinfo ai is loopback address or not. Returns > 0 if
* addrinfo list ai is loopback, otherwise 0. This one goes to deep.
*/
int
af_ai_deep_is_loopback(const struct addrinfo *a1)
{
const struct addrinfo *a1_i;
for (a1_i = a1; a1_i != NULL; a1_i = a1_i->ai_next) {
if (af_ai_is_loopback(a1_i)) {
return (1);
}
}
return (0);
}
/* Deeply test what IP versions are supported on given ai_addr. Can return 4 (only ipv4 is
* supported), 6 (only ipv6 is supported), 0 (both ipv4 and ipv6 are supported) and -1 (nether ipv4
* or ipv6 are supported)
*/
int
af_ai_deep_supported_ipv(const struct addrinfo *ai_addr)
{
const struct addrinfo *ai_iter;
int ip4, ip6;
ip4 = 0;
ip6 = 0;
for (ai_iter = ai_addr; ai_iter != NULL; ai_iter = ai_iter->ai_next) {
switch (af_ai_supported_ipv(ai_iter)) {
case 4:
ip4 = 1;
break;
case 6:
ip6 = 1;
break;
case 0:
DEBUG_PRINTF("internal program error.");
err(1, "Internal program error");
break;
}
}
if (ip4 && ip6)
return (0);
if (ip6)
return (6);
if (ip4)
return (4);
return (-1);
}
/*
* Test if given addrinfo ai is loopback address or not. Returns > 0 if
* addrinfo ai is loopback, otherwise 0. This one don't goes to deep,
* so compares really only one struct not list of them.
*/
int
af_ai_is_loopback(const struct addrinfo *ai)
{
int res;
switch (ai->ai_family) {
case PF_INET:
res = ntohl(((struct sockaddr_in *)(ai->ai_addr))->sin_addr.s_addr) >> 24 == 0x7f;
break;
case PF_INET6:
res = IN6_IS_ADDR_LOOPBACK(&((struct sockaddr_in6 *)(ai->ai_addr))->sin6_addr);
break;
default:
DEBUG_PRINTF("Unknown ai family %d", ai->ai_family);
errx(1, "Unknown ai family %d", ai->ai_family);
}
return (res);
}
/*
* Free content of ai_list. List must have sas field active (not ai field)
*/
void
af_ai_list_free(struct ai_list *ai_list)
{
struct ai_item *ai_item;
struct ai_item *ai_item_next;
ai_item = TAILQ_FIRST(ai_list);
while (ai_item != NULL) {
ai_item_next = TAILQ_NEXT(ai_item, entries);
free(ai_item->host_name);
free(ai_item);
ai_item = ai_item_next;
}
TAILQ_INIT(ai_list);
}
/* Return supported ip version. This function doesn't go deeply to structure. It can return 4 (ipv4
* is supported), 6 (ipv6 is supported) or 0 (nether ipv4 or ipv6 are supported).
*/
int
af_ai_supported_ipv(const struct addrinfo *ai_addr)
{
int ipv;
ipv = 0;
switch (ai_addr->ai_family) {
case PF_INET:
ipv = 4;
break;
case PF_INET6:
ipv = 6;
break;
}
return (ipv);
}
/*
* Make result address from two addresses a1 and a2. addr_source is primary source of address (for
* ipv6 also scope, ...) and can be 1 or 2. port_source address is for copy of port number. Result
* is stored in res.
* Function can return -1 on fail (addr_source or port_number is not 1 or 2), otherwise 0.
*/
int
af_copy_addr(const struct sockaddr_storage *a1, const struct sockaddr_storage *a2, int addr_source,
int port_source, struct sockaddr_storage *res)
{
const struct sockaddr_storage *sas;
if (addr_source != 1 && addr_source != 2) {
return (-1);
}
if (port_source != 1 && port_source != 2) {
return (-1);
}
sas = (addr_source == 1 ? a1 : a2);
memcpy(res, sas, sizeof(struct sockaddr_storage));
if (addr_source == port_source) {
return (0);
}
sas = (port_source == 1 ? a1 : a2);
switch (sas->ss_family) {
case AF_INET:
((struct sockaddr_in *)res)->sin_port = ((struct sockaddr_in *)sas)->sin_port;
break;
case AF_INET6:
((struct sockaddr_in6 *)res)->sin6_port = ((struct sockaddr_in6 *)sas)->sin6_port;
break;
default:
DEBUG_PRINTF("Unknown sas family %d", sas->ss_family);
errx(1, "Unknown sas family %d", sas->ss_family);
}
return (0);
}
/*
* Copy informations stored in sockaddr sa to sockaddr_storage sas.
*/
void
af_copy_sa_to_sas(struct sockaddr_storage *sas, const struct sockaddr *sa)
{
memset(sas, 0, sizeof(*sa));
memcpy(sas, sa, af_sa_len(sa));
}
/*
* Fill in sockaddr sa pointer with in addr any for specified sa_family with specified port. port
* must be in local byte order.
*/
void
af_create_any_addr(struct sockaddr *sa, int sa_family, uint16_t port)
{
struct sockaddr_in sa_in;
struct sockaddr_in6 sa_in6;
switch (sa_family) {
case PF_INET:
memset(&sa_in, 0, sizeof(sa_in));
sa_in.sin_family = sa_family;
sa_in.sin_port = htons(port);
sa_in.sin_addr.s_addr = INADDR_ANY;
memcpy(sa, &sa_in, sizeof(sa_in));
break;
case PF_INET6:
memset(&sa_in6, 0, sizeof(sa_in6));
sa_in6.sin6_family = sa_family;
sa_in6.sin6_port = htons(port);
sa_in6.sin6_addr = in6addr_any;
memcpy(sa, &sa_in6, sizeof(sa_in6));
break;
default:
DEBUG_PRINTF("Unknown ai family %d", sa_family);
errx(1, "Unknown ai family %d", sa_family);
}
}
/*
* Tries to find local address in ai_list with given ip_ver. if_flags may be set to bit mask with
* IFF_MULTICAST and/or IFF_BROADCAST and only network interface with that flags will be accepted.
* Returns 0 on success, otherwise -1.
* It also changes ifa_list (result of getaddrs), ifa_local (local addr) and ai_item (addrinfo item
* which matches ifa_local).
*/
int
af_find_local_ai(const struct ai_list *ai_list, int *ip_ver, struct ifaddrs **ifa_list,
struct ifaddrs **ifa_local, struct ai_item **ai_item, unsigned int if_flags)
{
struct addrinfo *ai_i;
struct ai_item *aip;
struct ifaddrs *ifa, *ifa_i;
char sa_str[LOGGING_SA_TO_STR_LEN];
char sa_str2[LOGGING_SA_TO_STR_LEN];
int ipv4_fallback;
int res;
*ifa_local = NULL;
ipv4_fallback = 0;
if (getifaddrs(&ifa) == -1) {
err(1, "getifaddrs");
}
TAILQ_FOREACH(aip, ai_list, entries) {
for (ai_i = aip->ai; ai_i != NULL; ai_i = ai_i->ai_next) {
if (af_ai_is_dup(aip->ai, ai_i)) {
logging_sa_to_str(ai_i->ai_addr, sa_str, sizeof(sa_str));
DEBUG2_PRINTF("Found duplicate addr %s", sa_str);
continue ;
}
for (ifa_i = ifa; ifa_i != NULL; ifa_i = ifa_i->ifa_next) {
if (ifa_i->ifa_addr == NULL ||
(ifa_i->ifa_addr->sa_family != AF_INET &&
ifa_i->ifa_addr->sa_family != AF_INET6)) {
continue ;
}
logging_sa_to_str(ifa_i->ifa_addr, sa_str, sizeof(sa_str));
logging_sa_to_str(ai_i->ai_addr, sa_str2, sizeof(sa_str2));
DEBUG2_PRINTF("Comparing %s(%s) with %s", sa_str, ifa_i->ifa_name,
sa_str2);
if (af_sockaddr_eq(ifa_i->ifa_addr, ai_i->ai_addr)) {
res = af_is_supported_local_ifa(ifa_i, *ip_ver, if_flags);
if (res == 1 || res == 2) {
if (*ifa_local != NULL && ipv4_fallback == 0)
goto multiple_match_error;
*ifa_list = ifa;
*ifa_local = ifa_i;
*ai_item = aip;
if (*ip_ver == 0) {
/*
* Device supports ipv6
*/
*ip_ver = 6;
DEBUG2_PRINTF("Supports ipv6");
}
if (res == 2) {
/*
* Set this item as ipv4 fallback
*/
ipv4_fallback++;
DEBUG2_PRINTF("Supports ipv4 - fallback");
}
}
}
}
}
}
if (*ip_ver == 0 && *ifa_local != NULL) {
if (ipv4_fallback > 1)
goto multiple_match_error;
*ip_ver = 4;
}
if (*ifa_local != NULL) {
return (0);
}
DEBUG_PRINTF("Can't find local addr");
return (-1);
multiple_match_error:
errx(1, "Multiple local interfaces match parameters.");
return (-1);
}
/*
* Convert host_name and port with ip ver (4 or 6) to addrinfo.
* Wrapper on getaddrinfo
*/
struct addrinfo *
af_host_to_ai(const char *host_name, const char *port, int ip_ver)
{
struct addrinfo ai_hints, *ai_res0, *ai_i;
int error;
char ai_s[LOGGING_SA_TO_STR_LEN];
memset(&ai_hints, 0, sizeof(ai_hints));
switch (ip_ver) {
case 0:
ai_hints.ai_family = PF_UNSPEC;
break;
case 4:
ai_hints.ai_family = PF_INET;
break;
case 6:
ai_hints.ai_family = PF_INET6;
break;
default:
errx(1, "Unknown PF Family");
/* NOTREACHED */
}
ai_hints.ai_socktype = SOCK_DGRAM;
ai_hints.ai_protocol = IPPROTO_UDP;
ai_hints.ai_flags = AI_PASSIVE;
DEBUG_PRINTF("getaddrinfo for \"%s\" port %s ip_ver %d", host_name,
port, ip_ver);
error = getaddrinfo(host_name, port, &ai_hints, &ai_res0);
if (error != 0) {
errx(1, "Can't get addr info for %s: %s", host_name, gai_strerror(error));
}
if (logging_get_verbose() >= LOGGING_LEVEL_DEBUG2) {
for (ai_i = ai_res0; ai_i != NULL; ai_i = ai_i->ai_next) {
logging_ai_to_str(ai_i, ai_s, sizeof(ai_s));
DEBUG2_PRINTF("%s", ai_s);
}
}
return (ai_res0);
}
/*
* Test if addrinfo a1 is included in ai_list list. Return 1 if a1 is included, otherwise 0.
*/
int
af_is_ai_in_list(const struct addrinfo *a1, const struct ai_list *ai_list)
{
struct ai_item *aip;
TAILQ_FOREACH(aip, ai_list, entries) {
if (af_ai_deep_eq(a1, aip->ai))
return (1);
}
return (0);
}
/*
* Test if addr is multicast address.
* Return 0 if address is not multicast addres, otherwise != 0.
*/
int
af_is_sa_mcast(const struct sockaddr *addr)
{
switch (addr->sa_family) {
case AF_INET:
return IN_MULTICAST(ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr));
break;
case AF_INET6:
return IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6 *)addr)->sin6_addr);
break;
default:
DEBUG_PRINTF("Unknown sockaddr family");
errx(1, "Unknown sockaddr family");
break;
}
return (0);
}
/*
* Test if ifa is supported device.
* Such device must:
* - not be loopback
* - be up
* - support for if_flags (multicast/broadcast)
* - support given ip_ver
* if_flags may be set to bit mask with IFF_MULTICAST and/or IFF_BROADCAST.
* Function returns 0, if device doesn't fulfill requirements. 1, if device supports all
* requirements and 2, if device support requirements and ip_ver is set to 0 but device supports
* ipv4.
*/
int
af_is_supported_local_ifa(const struct ifaddrs *ifa, int ip_ver, unsigned int if_flags)
{
char ai_s[LOGGING_SA_TO_STR_LEN];
logging_sa_to_str(ifa->ifa_addr, ai_s, sizeof(ai_s));
if (ifa->ifa_flags & IFF_LOOPBACK) {
DEBUG2_PRINTF("%s with addr %s is loopback", ifa->ifa_name, ai_s);
return (0);
}
if (!(ifa->ifa_flags & IFF_UP)) {
DEBUG2_PRINTF("%s with addr %s is not up", ifa->ifa_name, ai_s);
return (0);
}
if (if_flags & IFF_MULTICAST) {
if (!(ifa->ifa_flags & IFF_MULTICAST)) {
DEBUG2_PRINTF("%s with addr %s doesn't support mcast", ifa->ifa_name, ai_s);
return (0);
}
}
if (if_flags & IFF_BROADCAST) {
if (!(ifa->ifa_flags & IFF_BROADCAST)) {
DEBUG2_PRINTF("%s with addr %s doesn't support broadcast", ifa->ifa_name,
ai_s);
return (0);
}
}
if (ip_ver != 0 && af_sa_supported_ipv(ifa->ifa_addr) != ip_ver) {
DEBUG2_PRINTF("%s doesn't support requested ipv%d", ai_s, ip_ver);
return (0);
}
if (ip_ver == 0 && af_sa_supported_ipv(ifa->ifa_addr) == 4) {
DEBUG2_PRINTF("%s doesn't support ipv6. Saving ipv4 as fallback", ai_s);
return (2);
}
DEBUG_PRINTF("Found local addr %s as device %s", ai_s, ifa->ifa_name);
return (1);
}
/*
* Return length of sockaddr structure.
*/
socklen_t
af_sa_len(const struct sockaddr *sa)
{
socklen_t res;
switch (sa->sa_family) {
case AF_INET:
res = sizeof(struct sockaddr_in);
break;
case AF_INET6:
res = sizeof(struct sockaddr_in6);
break;
default:
DEBUG_PRINTF("Internal program error");
errx(1,"Internal program error");
break;
}
return (res);
}
/*
* Return port number in network order from addr
*/
uint16_t
af_sa_port(const struct sockaddr *addr)
{
uint16_t port;
switch (addr->sa_family) {
case AF_INET:
port = (((struct sockaddr_in *)addr)->sin_port);
break;
case AF_INET6:
port = (((struct sockaddr_in6 *)addr)->sin6_port);
break;
default:
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
break;
}
return (port);
}
/*
* Set port number in network order to addr
*/
void
af_sa_set_port(struct sockaddr *addr, uint16_t port)
{
switch (addr->sa_family) {
case AF_INET:
((struct sockaddr_in *)addr)->sin_port = port;
break;
case AF_INET6:
((struct sockaddr_in6 *)addr)->sin6_port = port;
break;
default:
DEBUG_PRINTF("Internal program error");
err(1, "Internal program error");
break;
}
}
/*
* Return supported ip version. This function doesn't go deeply to structure. It can return 4 (ipv4
* is supported), 6 (ipv6 is supported) or 0 (nether ipv4 or ipv6 are supported).
*/
int
af_sa_supported_ipv(const struct sockaddr *sa)
{
int ipv;
ipv = 0;
switch (sa->sa_family) {
case AF_INET:
ipv = 4;
break;
case AF_INET6:
ipv = 6;
break;
}
return (ipv);
}
/*
* Fill in sockaddr dest pointer with in addr any for family from src and port from src.
*/
void
af_sa_to_any_addr(struct sockaddr *dest, const struct sockaddr *src)
{
uint16_t port;
switch (src->sa_family) {
case PF_INET:
port = ntohs(((struct sockaddr_in *)src)->sin_port);
break;
case PF_INET6:
port = ntohs(((struct sockaddr_in6 *)src)->sin6_port);
break;
default:
DEBUG_PRINTF("Unknown ai family %d", src->sa_family);
errx(1, "Unknown ai family %d", src->sa_family);
}
af_create_any_addr(dest, src->sa_family, port);
}
/*
* Convert sockaddr address to string. Returned value is dst or NULL on fail.
*/
char *
af_sa_to_str(const struct sockaddr *sa, char dst[INET6_ADDRSTRLEN])
{
dst[0] = 0;
switch (sa->sa_family) {
case PF_INET:
inet_ntop(sa->sa_family, &((struct sockaddr_in *)(sa))->sin_addr, dst,
INET6_ADDRSTRLEN);
break;
case PF_INET6:
inet_ntop(sa->sa_family, &((struct sockaddr_in6 *)(sa))->sin6_addr, dst,
INET6_ADDRSTRLEN);
break;
default:
return (NULL);
}
return (dst);
}
/*
* Return length of sockaddr_storage structure.
*/
socklen_t
af_sas_len(const struct sockaddr_storage *sas)
{
return (af_sa_len((const struct sockaddr *)sas));
}
/*
* Compares two sockaddr structures. Only family and addr is compared. If
* sockaddr differs 0 is returned, otherwise not 0.
*/
int
af_sockaddr_eq(const struct sockaddr *sa1, const struct sockaddr *sa2)
{
int res;
res = 0;
if (sa1->sa_family == sa2->sa_family) {
switch (sa1->sa_family) {
case AF_INET:
res = (((struct sockaddr_in *)sa1)->sin_addr.s_addr ==
((struct sockaddr_in *)sa2)->sin_addr.s_addr);
break;
case AF_INET6:
res = IN6_ARE_ADDR_EQUAL(
&((struct sockaddr_in6 *)sa1)->sin6_addr,
&((struct sockaddr_in6 *)sa2)->sin6_addr);
break;
default:
err(1, "Unknown sockaddr family");
break;
}
}
return (res);
}