1/*
2 * Copyright (c) 1983, 1993
3 *	The Regents of the University of California.  All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * 1. Redistributions of source code must retain the above copyright
9 *    notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 *    notice, this list of conditions and the following disclaimer in the
12 *    documentation and/or other materials provided with the distribution.
13 * 4. Neither the name of the University nor the names of its contributors
14 *    may be used to endorse or promote products derived from this software
15 *    without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#ifndef lint
31static const char rcsid[] =
32  "$FreeBSD$";
33#endif /* not lint */
34
35#include <sys/param.h>
36#include <sys/ioctl.h>
37#include <sys/socket.h>
38#include <net/if.h>
39
40#include <err.h>
41#include <stdio.h>
42#include <stdlib.h>
43#include <string.h>
44#include <unistd.h>
45#include <time.h>
46#include <ifaddrs.h>
47
48#include <arpa/inet.h>
49
50#include <netinet/in.h>
51#include <net/if_var.h>		/* for struct ifaddr */
52#include <netinet/in_var.h>
53#include <arpa/inet.h>
54#include <netdb.h>
55
56#include <netinet6/nd6.h>	/* Define ND6_INFINITE_LIFETIME */
57
58#include "ifconfig.h"
59
60static	struct in6_ifreq in6_ridreq;
61static	struct in6_aliasreq in6_addreq =
62  { .ifra_flags = 0,
63    .ifra_lifetime = { 0, 0, ND6_INFINITE_LIFETIME, ND6_INFINITE_LIFETIME } };
64static	int ip6lifetime;
65
66static	int prefix(void *, int);
67static	char *sec2str(time_t);
68static	int explicit_prefix = 0;
69
70extern void setnd6flags(const char *, int, int, const struct afswtch *);
71extern void setnd6defif(const char *, int, int, const struct afswtch *);
72extern void nd6_status(int);
73
74static	char addr_buf[MAXHOSTNAMELEN *2 + 1];	/*for getnameinfo()*/
75
76static void
77setifprefixlen(const char *addr, int dummy __unused, int s,
78    const struct afswtch *afp)
79{
80        if (afp->af_getprefix != NULL)
81                afp->af_getprefix(addr, MASK);
82	explicit_prefix = 1;
83}
84
85static void
86setip6flags(const char *dummyaddr __unused, int flag, int dummysoc __unused,
87    const struct afswtch *afp)
88{
89	if (afp->af_af != AF_INET6)
90		err(1, "address flags can be set only for inet6 addresses");
91
92	if (flag < 0)
93		in6_addreq.ifra_flags &= ~(-flag);
94	else
95		in6_addreq.ifra_flags |= flag;
96}
97
98static void
99setip6lifetime(const char *cmd, const char *val, int s,
100    const struct afswtch *afp)
101{
102	struct timespec now;
103	time_t newval;
104	char *ep;
105
106	clock_gettime(CLOCK_MONOTONIC_FAST, &now);
107	newval = (time_t)strtoul(val, &ep, 0);
108	if (val == ep)
109		errx(1, "invalid %s", cmd);
110	if (afp->af_af != AF_INET6)
111		errx(1, "%s not allowed for the AF", cmd);
112	if (strcmp(cmd, "vltime") == 0) {
113		in6_addreq.ifra_lifetime.ia6t_expire = now.tv_sec + newval;
114		in6_addreq.ifra_lifetime.ia6t_vltime = newval;
115	} else if (strcmp(cmd, "pltime") == 0) {
116		in6_addreq.ifra_lifetime.ia6t_preferred = now.tv_sec + newval;
117		in6_addreq.ifra_lifetime.ia6t_pltime = newval;
118	}
119}
120
121static void
122setip6pltime(const char *seconds, int dummy __unused, int s,
123    const struct afswtch *afp)
124{
125	setip6lifetime("pltime", seconds, s, afp);
126}
127
128static void
129setip6vltime(const char *seconds, int dummy __unused, int s,
130    const struct afswtch *afp)
131{
132	setip6lifetime("vltime", seconds, s, afp);
133}
134
135static void
136setip6eui64(const char *cmd, int dummy __unused, int s,
137    const struct afswtch *afp)
138{
139	struct ifaddrs *ifap, *ifa;
140	const struct sockaddr_in6 *sin6 = NULL;
141	const struct in6_addr *lladdr = NULL;
142	struct in6_addr *in6;
143
144	if (afp->af_af != AF_INET6)
145		errx(EXIT_FAILURE, "%s not allowed for the AF", cmd);
146 	in6 = (struct in6_addr *)&in6_addreq.ifra_addr.sin6_addr;
147	if (memcmp(&in6addr_any.s6_addr[8], &in6->s6_addr[8], 8) != 0)
148		errx(EXIT_FAILURE, "interface index is already filled");
149	if (getifaddrs(&ifap) != 0)
150		err(EXIT_FAILURE, "getifaddrs");
151	for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
152		if (ifa->ifa_addr->sa_family == AF_INET6 &&
153		    strcmp(ifa->ifa_name, name) == 0) {
154			sin6 = (const struct sockaddr_in6 *)ifa->ifa_addr;
155			if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr)) {
156				lladdr = &sin6->sin6_addr;
157				break;
158			}
159		}
160	}
161	if (!lladdr)
162		errx(EXIT_FAILURE, "could not determine link local address");
163
164 	memcpy(&in6->s6_addr[8], &lladdr->s6_addr[8], 8);
165
166	freeifaddrs(ifap);
167}
168
169static void
170in6_status(int s __unused, const struct ifaddrs *ifa)
171{
172	struct sockaddr_in6 *sin, null_sin;
173	struct in6_ifreq ifr6;
174	int s6;
175	u_int32_t flags6;
176	struct in6_addrlifetime lifetime;
177	struct timespec now;
178	int error;
179
180	clock_gettime(CLOCK_MONOTONIC_FAST, &now);
181
182	memset(&null_sin, 0, sizeof(null_sin));
183
184	sin = (struct sockaddr_in6 *)ifa->ifa_addr;
185	if (sin == NULL)
186		return;
187
188	strncpy(ifr6.ifr_name, ifr.ifr_name, sizeof(ifr.ifr_name));
189	if ((s6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
190		warn("socket(AF_INET6,SOCK_DGRAM)");
191		return;
192	}
193	ifr6.ifr_addr = *sin;
194	if (ioctl(s6, SIOCGIFAFLAG_IN6, &ifr6) < 0) {
195		warn("ioctl(SIOCGIFAFLAG_IN6)");
196		close(s6);
197		return;
198	}
199	flags6 = ifr6.ifr_ifru.ifru_flags6;
200	memset(&lifetime, 0, sizeof(lifetime));
201	ifr6.ifr_addr = *sin;
202	if (ioctl(s6, SIOCGIFALIFETIME_IN6, &ifr6) < 0) {
203		warn("ioctl(SIOCGIFALIFETIME_IN6)");
204		close(s6);
205		return;
206	}
207	lifetime = ifr6.ifr_ifru.ifru_lifetime;
208	close(s6);
209
210	error = getnameinfo((struct sockaddr *)sin, sin->sin6_len, addr_buf,
211			    sizeof(addr_buf), NULL, 0, NI_NUMERICHOST);
212	if (error != 0)
213		inet_ntop(AF_INET6, &sin->sin6_addr, addr_buf,
214			  sizeof(addr_buf));
215	printf("\tinet6 %s ", addr_buf);
216
217	if (ifa->ifa_flags & IFF_POINTOPOINT) {
218		sin = (struct sockaddr_in6 *)ifa->ifa_dstaddr;
219		/*
220		 * some of the interfaces do not have valid destination
221		 * address.
222		 */
223		if (sin != NULL && sin->sin6_family == AF_INET6) {
224			int error;
225
226			error = getnameinfo((struct sockaddr *)sin,
227					    sin->sin6_len, addr_buf,
228					    sizeof(addr_buf), NULL, 0,
229					    NI_NUMERICHOST);
230			if (error != 0)
231				inet_ntop(AF_INET6, &sin->sin6_addr, addr_buf,
232					  sizeof(addr_buf));
233			printf("--> %s ", addr_buf);
234		}
235	}
236
237	sin = (struct sockaddr_in6 *)ifa->ifa_netmask;
238	if (sin == NULL)
239		sin = &null_sin;
240	printf("prefixlen %d ", prefix(&sin->sin6_addr,
241		sizeof(struct in6_addr)));
242
243	if ((flags6 & IN6_IFF_ANYCAST) != 0)
244		printf("anycast ");
245	if ((flags6 & IN6_IFF_TENTATIVE) != 0)
246		printf("tentative ");
247	if ((flags6 & IN6_IFF_DUPLICATED) != 0)
248		printf("duplicated ");
249	if ((flags6 & IN6_IFF_DETACHED) != 0)
250		printf("detached ");
251	if ((flags6 & IN6_IFF_DEPRECATED) != 0)
252		printf("deprecated ");
253	if ((flags6 & IN6_IFF_AUTOCONF) != 0)
254		printf("autoconf ");
255	if ((flags6 & IN6_IFF_TEMPORARY) != 0)
256		printf("temporary ");
257
258	if (((struct sockaddr_in6 *)(ifa->ifa_addr))->sin6_scope_id)
259		printf("scopeid 0x%x ",
260		    ((struct sockaddr_in6 *)(ifa->ifa_addr))->sin6_scope_id);
261
262	if (ip6lifetime && (lifetime.ia6t_preferred || lifetime.ia6t_expire)) {
263		printf("pltime ");
264		if (lifetime.ia6t_preferred) {
265			printf("%s ", lifetime.ia6t_preferred < now.tv_sec
266				? "0" : sec2str(lifetime.ia6t_preferred - now.tv_sec));
267		} else
268			printf("infty ");
269
270		printf("vltime ");
271		if (lifetime.ia6t_expire) {
272			printf("%s ", lifetime.ia6t_expire < now.tv_sec
273				? "0" : sec2str(lifetime.ia6t_expire - now.tv_sec));
274		} else
275			printf("infty ");
276	}
277
278	print_vhid(ifa, " ");
279
280	putchar('\n');
281}
282
283#define	SIN6(x) ((struct sockaddr_in6 *) &(x))
284static struct	sockaddr_in6 *sin6tab[] = {
285	SIN6(in6_ridreq.ifr_addr), SIN6(in6_addreq.ifra_addr),
286	SIN6(in6_addreq.ifra_prefixmask), SIN6(in6_addreq.ifra_dstaddr)
287};
288
289static void
290in6_getprefix(const char *plen, int which)
291{
292	struct sockaddr_in6 *sin = sin6tab[which];
293	u_char *cp;
294	int len = atoi(plen);
295
296	if ((len < 0) || (len > 128))
297		errx(1, "%s: bad value", plen);
298	sin->sin6_len = sizeof(*sin);
299	if (which != MASK)
300		sin->sin6_family = AF_INET6;
301	if ((len == 0) || (len == 128)) {
302		memset(&sin->sin6_addr, 0xff, sizeof(struct in6_addr));
303		return;
304	}
305	memset((void *)&sin->sin6_addr, 0x00, sizeof(sin->sin6_addr));
306	for (cp = (u_char *)&sin->sin6_addr; len > 7; len -= 8)
307		*cp++ = 0xff;
308	*cp = 0xff << (8 - len);
309}
310
311static void
312in6_getaddr(const char *s, int which)
313{
314	struct sockaddr_in6 *sin = sin6tab[which];
315	struct addrinfo hints, *res;
316	int error = -1;
317
318	newaddr &= 1;
319
320	sin->sin6_len = sizeof(*sin);
321	if (which != MASK)
322		sin->sin6_family = AF_INET6;
323
324	if (which == ADDR) {
325		char *p = NULL;
326		if((p = strrchr(s, '/')) != NULL) {
327			*p = '\0';
328			in6_getprefix(p + 1, MASK);
329			explicit_prefix = 1;
330		}
331	}
332
333	if (sin->sin6_family == AF_INET6) {
334		bzero(&hints, sizeof(struct addrinfo));
335		hints.ai_family = AF_INET6;
336		error = getaddrinfo(s, NULL, &hints, &res);
337	}
338	if (error != 0) {
339		if (inet_pton(AF_INET6, s, &sin->sin6_addr) != 1)
340			errx(1, "%s: bad value", s);
341	} else
342		bcopy(res->ai_addr, sin, res->ai_addrlen);
343}
344
345static int
346prefix(void *val, int size)
347{
348        u_char *name = (u_char *)val;
349        int byte, bit, plen = 0;
350
351        for (byte = 0; byte < size; byte++, plen += 8)
352                if (name[byte] != 0xff)
353                        break;
354	if (byte == size)
355		return (plen);
356	for (bit = 7; bit != 0; bit--, plen++)
357                if (!(name[byte] & (1 << bit)))
358                        break;
359        for (; bit != 0; bit--)
360                if (name[byte] & (1 << bit))
361                        return(0);
362        byte++;
363        for (; byte < size; byte++)
364                if (name[byte])
365                        return(0);
366        return (plen);
367}
368
369static char *
370sec2str(time_t total)
371{
372	static char result[256];
373	int days, hours, mins, secs;
374	int first = 1;
375	char *p = result;
376
377	if (0) {
378		days = total / 3600 / 24;
379		hours = (total / 3600) % 24;
380		mins = (total / 60) % 60;
381		secs = total % 60;
382
383		if (days) {
384			first = 0;
385			p += sprintf(p, "%dd", days);
386		}
387		if (!first || hours) {
388			first = 0;
389			p += sprintf(p, "%dh", hours);
390		}
391		if (!first || mins) {
392			first = 0;
393			p += sprintf(p, "%dm", mins);
394		}
395		sprintf(p, "%ds", secs);
396	} else
397		sprintf(result, "%lu", (unsigned long)total);
398
399	return(result);
400}
401
402static void
403in6_postproc(int s, const struct afswtch *afp)
404{
405	if (explicit_prefix == 0) {
406		/* Aggregatable address architecture defines all prefixes
407		   are 64. So, it is convenient to set prefixlen to 64 if
408		   it is not specified. */
409		setifprefixlen("64", 0, s, afp);
410		/* in6_getprefix("64", MASK) if MASK is available here... */
411	}
412}
413
414static void
415in6_status_tunnel(int s)
416{
417	char src[NI_MAXHOST];
418	char dst[NI_MAXHOST];
419	struct in6_ifreq in6_ifr;
420	const struct sockaddr *sa = (const struct sockaddr *) &in6_ifr.ifr_addr;
421
422	memset(&in6_ifr, 0, sizeof(in6_ifr));
423	strncpy(in6_ifr.ifr_name, name, IFNAMSIZ);
424
425	if (ioctl(s, SIOCGIFPSRCADDR_IN6, (caddr_t)&in6_ifr) < 0)
426		return;
427	if (sa->sa_family != AF_INET6)
428		return;
429	if (getnameinfo(sa, sa->sa_len, src, sizeof(src), 0, 0,
430	    NI_NUMERICHOST) != 0)
431		src[0] = '\0';
432
433	if (ioctl(s, SIOCGIFPDSTADDR_IN6, (caddr_t)&in6_ifr) < 0)
434		return;
435	if (sa->sa_family != AF_INET6)
436		return;
437	if (getnameinfo(sa, sa->sa_len, dst, sizeof(dst), 0, 0,
438	    NI_NUMERICHOST) != 0)
439		dst[0] = '\0';
440
441	printf("\ttunnel inet6 %s --> %s\n", src, dst);
442}
443
444static void
445in6_set_tunnel(int s, struct addrinfo *srcres, struct addrinfo *dstres)
446{
447	struct in6_aliasreq in6_addreq;
448
449	memset(&in6_addreq, 0, sizeof(in6_addreq));
450	strncpy(in6_addreq.ifra_name, name, IFNAMSIZ);
451	memcpy(&in6_addreq.ifra_addr, srcres->ai_addr, srcres->ai_addr->sa_len);
452	memcpy(&in6_addreq.ifra_dstaddr, dstres->ai_addr,
453	    dstres->ai_addr->sa_len);
454
455	if (ioctl(s, SIOCSIFPHYADDR_IN6, &in6_addreq) < 0)
456		warn("SIOCSIFPHYADDR_IN6");
457}
458
459static struct cmd inet6_cmds[] = {
460	DEF_CMD_ARG("prefixlen",			setifprefixlen),
461	DEF_CMD("anycast",	IN6_IFF_ANYCAST,	setip6flags),
462	DEF_CMD("tentative",	IN6_IFF_TENTATIVE,	setip6flags),
463	DEF_CMD("-tentative",	-IN6_IFF_TENTATIVE,	setip6flags),
464	DEF_CMD("deprecated",	IN6_IFF_DEPRECATED,	setip6flags),
465	DEF_CMD("-deprecated", -IN6_IFF_DEPRECATED,	setip6flags),
466	DEF_CMD("autoconf",	IN6_IFF_AUTOCONF,	setip6flags),
467	DEF_CMD("-autoconf",	-IN6_IFF_AUTOCONF,	setip6flags),
468	DEF_CMD("accept_rtadv",	ND6_IFF_ACCEPT_RTADV,	setnd6flags),
469	DEF_CMD("-accept_rtadv",-ND6_IFF_ACCEPT_RTADV,	setnd6flags),
470	DEF_CMD("no_radr",	ND6_IFF_NO_RADR,	setnd6flags),
471	DEF_CMD("-no_radr",	-ND6_IFF_NO_RADR,	setnd6flags),
472	DEF_CMD("defaultif",	1,			setnd6defif),
473	DEF_CMD("-defaultif",	-1,			setnd6defif),
474	DEF_CMD("ifdisabled",	ND6_IFF_IFDISABLED,	setnd6flags),
475	DEF_CMD("-ifdisabled",	-ND6_IFF_IFDISABLED,	setnd6flags),
476	DEF_CMD("nud",		ND6_IFF_PERFORMNUD,	setnd6flags),
477	DEF_CMD("-nud",		-ND6_IFF_PERFORMNUD,	setnd6flags),
478	DEF_CMD("auto_linklocal",ND6_IFF_AUTO_LINKLOCAL,setnd6flags),
479	DEF_CMD("-auto_linklocal",-ND6_IFF_AUTO_LINKLOCAL,setnd6flags),
480	DEF_CMD("no_prefer_iface",ND6_IFF_NO_PREFER_IFACE,setnd6flags),
481	DEF_CMD("-no_prefer_iface",-ND6_IFF_NO_PREFER_IFACE,setnd6flags),
482	DEF_CMD_ARG("pltime",        			setip6pltime),
483	DEF_CMD_ARG("vltime",        			setip6vltime),
484	DEF_CMD("eui64",	0,			setip6eui64),
485};
486
487static struct afswtch af_inet6 = {
488	.af_name	= "inet6",
489	.af_af		= AF_INET6,
490	.af_status	= in6_status,
491	.af_getaddr	= in6_getaddr,
492	.af_getprefix	= in6_getprefix,
493	.af_other_status = nd6_status,
494	.af_postproc	= in6_postproc,
495	.af_status_tunnel = in6_status_tunnel,
496	.af_settunnel	= in6_set_tunnel,
497	.af_difaddr	= SIOCDIFADDR_IN6,
498	.af_aifaddr	= SIOCAIFADDR_IN6,
499	.af_ridreq	= &in6_addreq,
500	.af_addreq	= &in6_addreq,
501};
502
503static void
504in6_Lopt_cb(const char *optarg __unused)
505{
506	ip6lifetime++;	/* print IPv6 address lifetime */
507}
508static struct option in6_Lopt = { .opt = "L", .opt_usage = "[-L]", .cb = in6_Lopt_cb };
509
510static __constructor void
511inet6_ctor(void)
512{
513#define	N(a)	(sizeof(a) / sizeof(a[0]))
514	size_t i;
515
516#ifndef RESCUE
517	if (!feature_present("inet6"))
518		return;
519#endif
520
521	for (i = 0; i < N(inet6_cmds);  i++)
522		cmd_register(&inet6_cmds[i]);
523	af_register(&af_inet6);
524	opt_register(&in6_Lopt);
525#undef N
526}
527