NetBSD/sbin/ifconfig/af_inet6.c

490 lines
14 KiB
C

/* $NetBSD: af_inet6.c,v 1.39 2019/08/16 10:33:17 msaitoh Exp $ */
/*
* Copyright (c) 1983, 1993
* The Regents of the University of California. 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.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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 <sys/cdefs.h>
#ifndef lint
__RCSID("$NetBSD: af_inet6.c,v 1.39 2019/08/16 10:33:17 msaitoh Exp $");
#endif /* not lint */
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in_var.h>
#include <netinet6/nd6.h>
#include <err.h>
#include <errno.h>
#include <ifaddrs.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <util.h>
#include "env.h"
#include "extern.h"
#include "parse.h"
#include "extern.h"
#include "af_inetany.h"
#include "prog_ops.h"
static void in6_constructor(void) __attribute__((constructor));
static void in6_alias(struct ifaddrs *, prop_dictionary_t, prop_dictionary_t);
static void in6_commit_address(prop_dictionary_t, prop_dictionary_t);
static int setia6eui64_impl(prop_dictionary_t, struct in6_aliasreq *);
static int setia6flags_impl(prop_dictionary_t, struct in6_aliasreq *);
static int setia6pltime_impl(prop_dictionary_t, struct in6_aliasreq *);
static int setia6vltime_impl(prop_dictionary_t, struct in6_aliasreq *);
static int setia6lifetime(prop_dictionary_t, int64_t, time_t *, uint32_t *);
static void in6_status(prop_dictionary_t, prop_dictionary_t, bool);
static bool in6_addr_tentative(struct ifaddrs *ifa);
static bool in6_addr_tentative_or_detached(struct ifaddrs *ifa);
static struct usage_func usage;
static cmdloop_branch_t branch[2];
static const struct kwinst ia6flagskw[] = {
IFKW("anycast", IN6_IFF_ANYCAST)
, IFKW("deprecated", IN6_IFF_DEPRECATED)
};
static struct pinteger parse_pltime = PINTEGER_INITIALIZER(&parse_pltime,
"pltime", 0, NULL, "pltime", &command_root.pb_parser);
static struct pinteger parse_vltime = PINTEGER_INITIALIZER(&parse_vltime,
"vltime", 0, NULL, "vltime", &command_root.pb_parser);
static const struct kwinst inet6kw[] = {
{.k_word = "pltime", .k_nextparser = &parse_pltime.pi_parser}
, {.k_word = "vltime", .k_nextparser = &parse_vltime.pi_parser}
, {.k_word = "eui64", .k_key = "eui64", .k_type = KW_T_BOOL,
.k_bool = true, .k_nextparser = &command_root.pb_parser}
};
struct pkw ia6flags = PKW_INITIALIZER(&ia6flags, "ia6flags", NULL,
"ia6flag", ia6flagskw, __arraycount(ia6flagskw), &command_root.pb_parser);
struct pkw inet6 = PKW_INITIALIZER(&inet6, "IPv6 keywords", NULL,
NULL, inet6kw, __arraycount(inet6kw), NULL);
static struct afswtch in6af = {
.af_name = "inet6", .af_af = AF_INET6, .af_status = in6_status,
.af_addr_commit = in6_commit_address,
.af_addr_tentative = in6_addr_tentative,
.af_addr_tentative_or_detached = in6_addr_tentative_or_detached
};
static int
prefix(void *val, int size)
{
u_char *pname = (u_char *)val;
int byte, bit, plen = 0;
for (byte = 0; byte < size; byte++, plen += 8)
if (pname[byte] != 0xff)
break;
if (byte == size)
return (plen);
for (bit = 7; bit != 0; bit--, plen++)
if (!(pname[byte] & (1 << bit)))
break;
for (; bit != 0; bit--)
if (pname[byte] & (1 << bit))
return(0);
byte++;
for (; byte < size; byte++)
if (pname[byte])
return(0);
return (plen);
}
int
setia6flags_impl(prop_dictionary_t env, struct in6_aliasreq *ifra)
{
int64_t ia6flag;
if (!prop_dictionary_get_int64(env, "ia6flag", &ia6flag)) {
errno = ENOENT;
return -1;
}
if (ia6flag < 0) {
ia6flag = -ia6flag;
ifra->ifra_flags &= ~ia6flag;
} else
ifra->ifra_flags |= ia6flag;
return 0;
}
int
setia6pltime_impl(prop_dictionary_t env, struct in6_aliasreq *ifra)
{
int64_t pltime;
if (!prop_dictionary_get_int64(env, "pltime", &pltime)) {
errno = ENOENT;
return -1;
}
return setia6lifetime(env, pltime,
&ifra->ifra_lifetime.ia6t_preferred,
&ifra->ifra_lifetime.ia6t_pltime);
}
int
setia6vltime_impl(prop_dictionary_t env, struct in6_aliasreq *ifra)
{
int64_t vltime;
if (!prop_dictionary_get_int64(env, "vltime", &vltime)) {
errno = ENOENT;
return -1;
}
return setia6lifetime(env, vltime,
&ifra->ifra_lifetime.ia6t_expire,
&ifra->ifra_lifetime.ia6t_vltime);
}
static int
setia6lifetime(prop_dictionary_t env, int64_t val, time_t *timep,
uint32_t *ivalp)
{
time_t t;
int af;
if ((af = getaf(env)) == -1 || af != AF_INET6) {
errx(EXIT_FAILURE,
"inet6 address lifetime not allowed for the AF");
}
t = time(NULL);
*timep = t + val;
*ivalp = val;
return 0;
}
int
setia6eui64_impl(prop_dictionary_t env, struct in6_aliasreq *ifra)
{
char buf[2][80];
struct ifaddrs *ifap, *ifa;
const struct sockaddr_in6 *sin6 = NULL;
const struct in6_addr *lladdr = NULL;
struct in6_addr *in6;
const char *ifname;
bool doit = false;
int af;
if (!prop_dictionary_get_bool(env, "eui64", &doit) || !doit) {
errno = ENOENT;
return -1;
}
if ((ifname = getifname(env)) == NULL)
return -1;
af = getaf(env);
if (af != AF_INET6) {
errx(EXIT_FAILURE,
"eui64 address modifier not allowed for the AF");
}
in6 = &ifra->ifra_addr.sin6_addr;
if (memcmp(&in6addr_any.s6_addr[8], &in6->s6_addr[8], 8) != 0) {
union {
struct sockaddr_in6 sin6;
struct sockaddr sa;
} any = {.sin6 = {.sin6_family = AF_INET6}};
memcpy(&any.sin6.sin6_addr, &in6addr_any,
sizeof(any.sin6.sin6_addr));
(void)sockaddr_snprintf(buf[0], sizeof(buf[0]), "%a%%S",
&any.sa);
(void)sockaddr_snprintf(buf[1], sizeof(buf[1]), "%a%%S",
(const struct sockaddr *)&ifra->ifra_addr);
errx(EXIT_FAILURE, "interface index is already filled, %s | %s",
buf[0], buf[1]);
}
if (getifaddrs(&ifap) != 0)
err(EXIT_FAILURE, "getifaddrs");
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
if (ifa->ifa_addr->sa_family == AF_INET6 &&
strcmp(ifa->ifa_name, ifname) == 0) {
sin6 = (const struct sockaddr_in6 *)ifa->ifa_addr;
if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
lladdr = &sin6->sin6_addr;
break;
}
}
}
if (lladdr == NULL)
errx(EXIT_FAILURE, "could not determine link local address");
memcpy(&in6->s6_addr[8], &lladdr->s6_addr[8], 8);
freeifaddrs(ifap);
return 0;
}
/* XXX not really an alias */
void
in6_alias(struct ifaddrs *ifa, prop_dictionary_t env, prop_dictionary_t oenv)
{
struct sockaddr_in6 *sin6;
char hbuf[NI_MAXHOST];
u_int32_t scopeid;
const int niflag = Nflag ? 0 : NI_NUMERICHOST;
char fbuf[1024];
sin6 = (struct sockaddr_in6 *)ifa->ifa_addr;
inet6_getscopeid(sin6, INET6_IS_ADDR_LINKLOCAL);
scopeid = sin6->sin6_scope_id;
if (getnameinfo((const struct sockaddr *)sin6, sin6->sin6_len,
hbuf, sizeof(hbuf), NULL, 0, niflag))
strlcpy(hbuf, "", sizeof(hbuf)); /* some message? */
printf("\tinet6 %s", hbuf);
inet6_putscopeid(sin6, INET6_IS_ADDR_LINKLOCAL);
sin6 = (struct sockaddr_in6 *)ifa->ifa_netmask;
printf("/%d", prefix(&sin6->sin6_addr, sizeof(struct in6_addr)));
if (ifa->ifa_flags & IFF_POINTOPOINT) {
sin6 = (struct sockaddr_in6 *)ifa->ifa_dstaddr;
inet6_getscopeid(sin6, INET6_IS_ADDR_LINKLOCAL);
hbuf[0] = '\0';
if (getnameinfo((struct sockaddr *)sin6, sin6->sin6_len,
hbuf, sizeof(hbuf), NULL, 0, niflag))
strlcpy(hbuf, "", sizeof(hbuf)); /* some message? */
printf(" -> %s", hbuf);
}
(void)snprintb(fbuf, sizeof(fbuf), IN6_IFFBITS, ifa->ifa_addrflags);
printf(" flags %s", fbuf);
if (scopeid)
printf(" scopeid 0x%x", scopeid);
if (get_flag('L')) {
int s;
struct in6_ifreq ifr6;
struct in6_addrlifetime *lifetime;
if ((s = getsock(AF_INET6)) == -1) {
if (errno == EAFNOSUPPORT)
return;
err(EXIT_FAILURE, "socket");
}
memset(&ifr6, 0, sizeof(ifr6));
estrlcpy(ifr6.ifr_name, ifa->ifa_name, sizeof(ifr6.ifr_name));
memcpy(&ifr6.ifr_addr, ifa->ifa_addr, ifa->ifa_addr->sa_len);
lifetime = &ifr6.ifr_ifru.ifru_lifetime;
if (prog_ioctl(s, SIOCGIFALIFETIME_IN6, &ifr6) == -1) {
if (errno != EADDRNOTAVAIL)
warn("SIOCGIFALIFETIME_IN6");
} else if (lifetime->ia6t_preferred || lifetime->ia6t_expire) {
time_t t = time(NULL);
printf(" pltime ");
if (lifetime->ia6t_preferred) {
printf("%lu",
(unsigned long)(lifetime->ia6t_preferred -
MIN(t, lifetime->ia6t_preferred)));
} else
printf("infty");
printf(" vltime ");
if (lifetime->ia6t_expire) {
printf("%lu",
(unsigned long)(lifetime->ia6t_expire -
MIN(t, lifetime->ia6t_expire)));
} else
printf("infty");
}
}
}
static void
in6_status(prop_dictionary_t env, prop_dictionary_t oenv, bool force)
{
struct ifaddrs *ifap, *ifa;
const char *ifname;
bool printprefs = false;
if ((ifname = getifname(env)) == NULL)
err(EXIT_FAILURE, "%s: getifname", __func__);
if (getifaddrs(&ifap) != 0)
err(EXIT_FAILURE, "getifaddrs");
printprefs = ifa_any_preferences(ifname, ifap, AF_INET6);
for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
if (strcmp(ifname, ifa->ifa_name) != 0)
continue;
if (ifa->ifa_addr->sa_family != AF_INET6)
continue;
in6_alias(ifa, env, oenv);
if (printprefs)
ifa_print_preference(ifa->ifa_name, ifa->ifa_addr);
printf("\n");
}
freeifaddrs(ifap);
}
static int
in6_pre_aifaddr(prop_dictionary_t env, const struct afparam *param)
{
struct in6_aliasreq *ifra = param->req.buf;
setia6eui64_impl(env, ifra);
setia6vltime_impl(env, ifra);
setia6pltime_impl(env, ifra);
setia6flags_impl(env, ifra);
inet6_putscopeid(&ifra->ifra_addr, INET6_IS_ADDR_LINKLOCAL);
inet6_putscopeid(&ifra->ifra_dstaddr, INET6_IS_ADDR_LINKLOCAL);
return 0;
}
static void
in6_commit_address(prop_dictionary_t env, prop_dictionary_t oenv)
{
struct in6_ifreq in6_ifr = {
.ifr_addr = {
.sin6_family = AF_INET6,
.sin6_len = sizeof(in6_ifr.ifr_addr),
.sin6_addr = {
.s6_addr =
{0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff}
}
}
};
static struct sockaddr_in6 in6_defmask = {
.sin6_family = AF_INET6,
.sin6_len = sizeof(in6_defmask),
.sin6_addr = {
.s6_addr = {0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff}
}
};
struct in6_aliasreq in6_ifra = {
.ifra_prefixmask = {
.sin6_family = AF_INET6,
.sin6_len = sizeof(in6_ifra.ifra_prefixmask),
.sin6_addr = {
.s6_addr =
{0xff, 0xff, 0xff, 0xff,
0xff, 0xff, 0xff, 0xff}}},
.ifra_lifetime = {
.ia6t_pltime = ND6_INFINITE_LIFETIME
, .ia6t_vltime = ND6_INFINITE_LIFETIME
}
};
struct afparam in6param = {
.req = BUFPARAM(in6_ifra)
, .dgreq = BUFPARAM(in6_ifr)
, .name = {
{.buf = in6_ifr.ifr_name,
.buflen = sizeof(in6_ifr.ifr_name)},
{.buf = in6_ifra.ifra_name,
.buflen = sizeof(in6_ifra.ifra_name)}
}
, .dgaddr = BUFPARAM(in6_ifr.ifr_addr)
, .addr = BUFPARAM(in6_ifra.ifra_addr)
, .dst = BUFPARAM(in6_ifra.ifra_dstaddr)
, .brd = BUFPARAM(in6_ifra.ifra_broadaddr)
, .mask = BUFPARAM(in6_ifra.ifra_prefixmask)
, .aifaddr = IFADDR_PARAM(SIOCAIFADDR_IN6)
, .difaddr = IFADDR_PARAM(SIOCDIFADDR_IN6)
, .gifaddr = IFADDR_PARAM(SIOCGIFADDR_IN6)
, .defmask = BUFPARAM(in6_defmask)
, .pre_aifaddr = in6_pre_aifaddr
};
commit_address(env, oenv, &in6param);
}
static bool
in6_addr_flags(struct ifaddrs *ifa, int flags)
{
int s;
struct in6_ifreq ifr;
if ((s = getsock(AF_INET6)) == -1)
err(EXIT_FAILURE, "%s: getsock", __func__);
memset(&ifr, 0, sizeof(ifr));
estrlcpy(ifr.ifr_name, ifa->ifa_name, sizeof(ifr.ifr_name));
ifr.ifr_addr = *(struct sockaddr_in6 *)ifa->ifa_addr;
if (prog_ioctl(s, SIOCGIFAFLAG_IN6, &ifr) == -1)
err(EXIT_FAILURE, "SIOCGIFAFLAG_IN6");
return ifr.ifr_ifru.ifru_flags6 & flags ? true : false;
}
static bool
in6_addr_tentative(struct ifaddrs *ifa)
{
return in6_addr_flags(ifa, IN6_IFF_TENTATIVE);
}
static bool
in6_addr_tentative_or_detached(struct ifaddrs *ifa)
{
return in6_addr_flags(ifa, IN6_IFF_TENTATIVE | IN6_IFF_DETACHED);
}
static void
in6_usage(prop_dictionary_t env)
{
fprintf(stderr,
"\t[ anycast | -anycast ] [ deprecated | -deprecated ]\n"
"\t[ pltime n ] [ vltime n ] "
"[ eui64 ]\n");
}
static void
in6_constructor(void)
{
if (register_flag('L') != 0)
err(EXIT_FAILURE, __func__);
register_family(&in6af);
usage_func_init(&usage, in6_usage);
register_usage(&usage);
cmdloop_branch_init(&branch[0], &ia6flags.pk_parser);
cmdloop_branch_init(&branch[1], &inet6.pk_parser);
register_cmdloop_branch(&branch[0]);
register_cmdloop_branch(&branch[1]);
}