2000-07-04 16:43:14 +00:00
|
|
|
/* $FreeBSD$ */
|
2003-11-13 16:02:44 +00:00
|
|
|
/* $KAME: ndp.c,v 1.104 2003/06/27 07:48:39 itojun Exp $ */
|
2000-07-04 16:43:14 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
/*
|
|
|
|
* Copyright (C) 1995, 1996, 1997, 1998, and 1999 WIDE Project.
|
|
|
|
* 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 project 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 PROJECT 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 PROJECT 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.
|
|
|
|
*/
|
|
|
|
/*
|
|
|
|
* Copyright (c) 1984, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* This code is derived from software contributed to Berkeley by
|
|
|
|
* Sun Microsystems, Inc.
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
* 4. 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.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Based on:
|
|
|
|
* "@(#) Copyright (c) 1984, 1993\n\
|
|
|
|
* The Regents of the University of California. All rights reserved.\n";
|
|
|
|
*
|
|
|
|
* "@(#)arp.c 8.2 (Berkeley) 1/2/94";
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ndp - display, set, delete and flush neighbor cache
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/file.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/time.h>
|
2001-06-11 12:39:29 +00:00
|
|
|
#include <sys/queue.h>
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/if_var.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_types.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/if_ether.h>
|
|
|
|
|
|
|
|
#include <netinet/icmp6.h>
|
|
|
|
#include <netinet6/in6_var.h>
|
|
|
|
#include <netinet6/nd6.h>
|
|
|
|
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
|
|
|
|
#include <netdb.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <nlist.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <paths.h>
|
|
|
|
#include <err.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include "gmt2local.h"
|
|
|
|
|
|
|
|
/* packing rule for routing socket */
|
2000-07-04 16:43:14 +00:00
|
|
|
#define ROUNDUP(a) \
|
2000-01-06 12:40:54 +00:00
|
|
|
((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
|
2000-07-04 16:43:14 +00:00
|
|
|
#define ADVANCE(x, n) (x += ROUNDUP((n)->sa_len))
|
|
|
|
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#define NEXTADDR(w, s) \
|
|
|
|
if (rtm->rtm_addrs & (w)) { \
|
2009-09-05 16:51:51 +00:00
|
|
|
bcopy((char *)&s, cp, sizeof(s)); cp += SA_SIZE(&s);}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
|
2002-07-25 01:48:19 +00:00
|
|
|
static pid_t pid;
|
2000-07-04 16:43:14 +00:00
|
|
|
static int nflag;
|
|
|
|
static int tflag;
|
|
|
|
static int32_t thiszone; /* time difference with gmt */
|
|
|
|
static int s = -1;
|
|
|
|
static int repeat = 0;
|
|
|
|
|
|
|
|
char ntop_buf[INET6_ADDRSTRLEN]; /* inet_ntop() */
|
|
|
|
char host_buf[NI_MAXHOST]; /* getnameinfo() */
|
|
|
|
char ifix_buf[IFNAMSIZ]; /* if_indextoname() */
|
|
|
|
|
2007-11-07 10:53:41 +00:00
|
|
|
int main(int, char **);
|
|
|
|
int file(char *);
|
|
|
|
void getsocket(void);
|
|
|
|
int set(int, char **);
|
|
|
|
void get(char *);
|
|
|
|
int delete(char *);
|
|
|
|
void dump(struct in6_addr *, int);
|
|
|
|
static struct in6_nbrinfo *getnbrinfo(struct in6_addr *, int, int);
|
|
|
|
static char *ether_str(struct sockaddr_dl *);
|
|
|
|
int ndp_ether_aton(char *, u_char *);
|
|
|
|
void usage(void);
|
|
|
|
int rtmsg(int);
|
|
|
|
void ifinfo(char *, int, char **);
|
|
|
|
void rtrlist(void);
|
|
|
|
void plist(void);
|
|
|
|
void pfx_flush(void);
|
|
|
|
void rtr_flush(void);
|
|
|
|
void harmonize_rtr(void);
|
2000-07-04 16:43:14 +00:00
|
|
|
#ifdef SIOCSDEFIFACE_IN6 /* XXX: check SIOCGDEFIFACE_IN6 as well? */
|
2007-11-07 10:53:41 +00:00
|
|
|
static void getdefif(void);
|
|
|
|
static void setdefif(char *);
|
2000-07-04 16:43:14 +00:00
|
|
|
#endif
|
2007-11-07 10:53:41 +00:00
|
|
|
static char *sec2str(time_t);
|
|
|
|
static char *ether_str(struct sockaddr_dl *);
|
|
|
|
static void ts_print(const struct timeval *);
|
2000-01-06 12:40:54 +00:00
|
|
|
|
2003-11-13 16:02:44 +00:00
|
|
|
#ifdef ICMPV6CTL_ND6_DRLIST
|
2001-06-11 12:39:29 +00:00
|
|
|
static char *rtpref_str[] = {
|
|
|
|
"medium", /* 00 */
|
|
|
|
"high", /* 01 */
|
|
|
|
"rsv", /* 10 */
|
|
|
|
"low" /* 11 */
|
|
|
|
};
|
2003-11-13 16:02:44 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
int mode = 0;
|
|
|
|
char *arg = NULL;
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
int
|
|
|
|
main(argc, argv)
|
|
|
|
int argc;
|
|
|
|
char **argv;
|
|
|
|
{
|
|
|
|
int ch;
|
|
|
|
|
|
|
|
pid = getpid();
|
|
|
|
thiszone = gmt2local(0);
|
2003-11-13 16:02:44 +00:00
|
|
|
while ((ch = getopt(argc, argv, "acd:f:Ii:nprstA:HPR")) != -1)
|
2003-10-17 11:46:40 +00:00
|
|
|
switch (ch) {
|
2000-01-06 12:40:54 +00:00
|
|
|
case 'a':
|
|
|
|
case 'c':
|
2003-11-13 16:02:44 +00:00
|
|
|
case 'p':
|
|
|
|
case 'r':
|
|
|
|
case 'H':
|
|
|
|
case 'P':
|
|
|
|
case 'R':
|
|
|
|
case 's':
|
|
|
|
case 'I':
|
|
|
|
if (mode) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
mode = ch;
|
|
|
|
arg = NULL;
|
2000-01-06 12:40:54 +00:00
|
|
|
break;
|
|
|
|
case 'd':
|
2003-11-13 16:02:44 +00:00
|
|
|
case 'f':
|
2000-01-06 12:40:54 +00:00
|
|
|
case 'i' :
|
2003-11-13 16:02:44 +00:00
|
|
|
if (mode) {
|
2000-01-06 12:40:54 +00:00
|
|
|
usage();
|
2003-11-13 16:02:44 +00:00
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
mode = ch;
|
|
|
|
arg = optarg;
|
|
|
|
break;
|
2000-01-06 12:40:54 +00:00
|
|
|
case 'n':
|
|
|
|
nflag = 1;
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
tflag = 1;
|
|
|
|
break;
|
|
|
|
case 'A':
|
2003-11-13 16:02:44 +00:00
|
|
|
if (mode) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
mode = 'a';
|
2000-01-06 12:40:54 +00:00
|
|
|
repeat = atoi(optarg);
|
2003-11-13 16:02:44 +00:00
|
|
|
if (repeat < 0) {
|
2000-01-06 12:40:54 +00:00
|
|
|
usage();
|
2003-11-13 16:02:44 +00:00
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
usage();
|
|
|
|
}
|
|
|
|
|
|
|
|
argc -= optind;
|
|
|
|
argv += optind;
|
|
|
|
|
2003-11-13 16:02:44 +00:00
|
|
|
switch (mode) {
|
|
|
|
case 'a':
|
|
|
|
case 'c':
|
|
|
|
if (argc != 0) {
|
2000-01-06 12:40:54 +00:00
|
|
|
usage();
|
2003-11-13 16:02:44 +00:00
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
dump(0, mode == 'c');
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
if (argc != 0) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
delete(arg);
|
|
|
|
break;
|
|
|
|
case 'I':
|
|
|
|
#ifdef SIOCSDEFIFACE_IN6 /* XXX: check SIOCGDEFIFACE_IN6 as well? */
|
|
|
|
if (argc > 1) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
} else if (argc == 1) {
|
|
|
|
if (strcmp(*argv, "delete") == 0 ||
|
|
|
|
if_nametoindex(*argv))
|
|
|
|
setdefif(*argv);
|
|
|
|
else
|
|
|
|
errx(1, "invalid interface %s", *argv);
|
|
|
|
}
|
|
|
|
getdefif(); /* always call it to print the result */
|
|
|
|
break;
|
|
|
|
#else
|
|
|
|
errx(1, "not supported yet");
|
|
|
|
/*NOTREACHED*/
|
|
|
|
#endif
|
|
|
|
case 'p':
|
|
|
|
if (argc != 0) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
plist();
|
2003-11-13 16:02:44 +00:00
|
|
|
break;
|
|
|
|
case 'i':
|
|
|
|
ifinfo(arg, argc, argv);
|
|
|
|
break;
|
|
|
|
case 'r':
|
|
|
|
if (argc != 0) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
rtrlist();
|
2003-11-13 16:02:44 +00:00
|
|
|
break;
|
|
|
|
case 's':
|
2000-01-06 12:40:54 +00:00
|
|
|
if (argc < 2 || argc > 4)
|
|
|
|
usage();
|
|
|
|
exit(set(argc, argv) ? 1 : 0);
|
2003-11-13 16:02:44 +00:00
|
|
|
case 'H':
|
|
|
|
if (argc != 0) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
harmonize_rtr();
|
2003-11-13 16:02:44 +00:00
|
|
|
break;
|
|
|
|
case 'P':
|
|
|
|
if (argc != 0) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
pfx_flush();
|
2003-11-13 16:02:44 +00:00
|
|
|
break;
|
|
|
|
case 'R':
|
|
|
|
if (argc != 0) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
rtr_flush();
|
2003-11-13 16:02:44 +00:00
|
|
|
break;
|
|
|
|
case 0:
|
|
|
|
if (argc != 1) {
|
|
|
|
usage();
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
get(argv[0]);
|
|
|
|
break;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
exit(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Process a file to set standard ndp entries
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
file(name)
|
|
|
|
char *name;
|
|
|
|
{
|
|
|
|
FILE *fp;
|
|
|
|
int i, retval;
|
|
|
|
char line[100], arg[5][50], *args[5];
|
|
|
|
|
|
|
|
if ((fp = fopen(name, "r")) == NULL) {
|
|
|
|
fprintf(stderr, "ndp: cannot open %s\n", name);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
args[0] = &arg[0][0];
|
|
|
|
args[1] = &arg[1][0];
|
|
|
|
args[2] = &arg[2][0];
|
|
|
|
args[3] = &arg[3][0];
|
|
|
|
args[4] = &arg[4][0];
|
|
|
|
retval = 0;
|
2007-03-06 09:32:41 +00:00
|
|
|
while (fgets(line, sizeof(line), fp) != NULL) {
|
2003-11-13 16:02:44 +00:00
|
|
|
i = sscanf(line, "%49s %49s %49s %49s %49s",
|
|
|
|
arg[0], arg[1], arg[2], arg[3], arg[4]);
|
2000-01-06 12:40:54 +00:00
|
|
|
if (i < 2) {
|
|
|
|
fprintf(stderr, "ndp: bad line: %s\n", line);
|
|
|
|
retval = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (set(i, args))
|
|
|
|
retval = 1;
|
|
|
|
}
|
|
|
|
fclose(fp);
|
|
|
|
return (retval);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
getsocket()
|
|
|
|
{
|
|
|
|
if (s < 0) {
|
|
|
|
s = socket(PF_ROUTE, SOCK_RAW, 0);
|
|
|
|
if (s < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "socket");
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2000-07-04 16:43:14 +00:00
|
|
|
struct sockaddr_in6 so_mask = {sizeof(so_mask), AF_INET6 };
|
2000-01-06 12:40:54 +00:00
|
|
|
struct sockaddr_in6 blank_sin = {sizeof(blank_sin), AF_INET6 }, sin_m;
|
|
|
|
struct sockaddr_dl blank_sdl = {sizeof(blank_sdl), AF_LINK }, sdl_m;
|
|
|
|
int expire_time, flags, found_entry;
|
|
|
|
struct {
|
|
|
|
struct rt_msghdr m_rtm;
|
|
|
|
char m_space[512];
|
|
|
|
} m_rtmsg;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set an individual neighbor cache entry
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
set(argc, argv)
|
|
|
|
int argc;
|
|
|
|
char **argv;
|
|
|
|
{
|
|
|
|
register struct sockaddr_in6 *sin = &sin_m;
|
|
|
|
register struct sockaddr_dl *sdl;
|
|
|
|
register struct rt_msghdr *rtm = &(m_rtmsg.m_rtm);
|
|
|
|
struct addrinfo hints, *res;
|
|
|
|
int gai_error;
|
|
|
|
u_char *ea;
|
|
|
|
char *host = argv[0], *eaddr = argv[1];
|
|
|
|
|
|
|
|
getsocket();
|
|
|
|
argc -= 2;
|
|
|
|
argv += 2;
|
|
|
|
sdl_m = blank_sdl;
|
|
|
|
sin_m = blank_sin;
|
|
|
|
|
|
|
|
bzero(&hints, sizeof(hints));
|
|
|
|
hints.ai_family = AF_INET6;
|
|
|
|
gai_error = getaddrinfo(host, NULL, &hints, &res);
|
|
|
|
if (gai_error) {
|
|
|
|
fprintf(stderr, "ndp: %s: %s\n", host,
|
|
|
|
gai_strerror(gai_error));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
sin->sin6_addr = ((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
|
2000-07-04 16:43:14 +00:00
|
|
|
#ifdef __KAME__
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {
|
|
|
|
*(u_int16_t *)&sin->sin6_addr.s6_addr[2] =
|
2003-10-17 11:46:40 +00:00
|
|
|
htons(((struct sockaddr_in6 *)res->ai_addr)->sin6_scope_id);
|
2000-07-04 16:43:14 +00:00
|
|
|
}
|
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
ea = (u_char *)LLADDR(&sdl_m);
|
|
|
|
if (ndp_ether_aton(eaddr, ea) == 0)
|
|
|
|
sdl_m.sdl_alen = 6;
|
|
|
|
flags = expire_time = 0;
|
|
|
|
while (argc-- > 0) {
|
|
|
|
if (strncmp(argv[0], "temp", 4) == 0) {
|
|
|
|
struct timeval time;
|
2003-10-17 11:46:40 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
gettimeofday(&time, 0);
|
|
|
|
expire_time = time.tv_sec + 20 * 60;
|
2000-07-04 16:43:14 +00:00
|
|
|
} else if (strncmp(argv[0], "proxy", 5) == 0)
|
|
|
|
flags |= RTF_ANNOUNCE;
|
2000-01-06 12:40:54 +00:00
|
|
|
argv++;
|
|
|
|
}
|
|
|
|
if (rtmsg(RTM_GET) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
errx(1, "RTM_GET(%s) failed", host);
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
sin = (struct sockaddr_in6 *)(rtm + 1);
|
|
|
|
sdl = (struct sockaddr_dl *)(ROUNDUP(sin->sin6_len) + (char *)sin);
|
|
|
|
if (IN6_ARE_ADDR_EQUAL(&sin->sin6_addr, &sin_m.sin6_addr)) {
|
|
|
|
if (sdl->sdl_family == AF_LINK &&
|
2003-11-13 16:02:44 +00:00
|
|
|
!(rtm->rtm_flags & RTF_GATEWAY)) {
|
|
|
|
switch (sdl->sdl_type) {
|
|
|
|
case IFT_ETHER: case IFT_FDDI: case IFT_ISO88023:
|
|
|
|
case IFT_ISO88024: case IFT_ISO88025:
|
|
|
|
goto overwrite;
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
/*
|
|
|
|
* IPv4 arp command retries with sin_other = SIN_PROXY here.
|
|
|
|
*/
|
|
|
|
fprintf(stderr, "set: cannot configure a new entry\n");
|
|
|
|
return 1;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
overwrite:
|
|
|
|
if (sdl->sdl_family != AF_LINK) {
|
|
|
|
printf("cannot intuit interface index and type for %s\n", host);
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
sdl_m.sdl_type = sdl->sdl_type;
|
|
|
|
sdl_m.sdl_index = sdl->sdl_index;
|
|
|
|
return (rtmsg(RTM_ADD));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Display an individual neighbor cache entry
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
get(host)
|
|
|
|
char *host;
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *sin = &sin_m;
|
|
|
|
struct addrinfo hints, *res;
|
|
|
|
int gai_error;
|
|
|
|
|
|
|
|
sin_m = blank_sin;
|
|
|
|
bzero(&hints, sizeof(hints));
|
|
|
|
hints.ai_family = AF_INET6;
|
|
|
|
gai_error = getaddrinfo(host, NULL, &hints, &res);
|
|
|
|
if (gai_error) {
|
|
|
|
fprintf(stderr, "ndp: %s: %s\n", host,
|
2003-10-17 11:46:40 +00:00
|
|
|
gai_strerror(gai_error));
|
2000-01-06 12:40:54 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
sin->sin6_addr = ((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
|
2000-07-04 16:43:14 +00:00
|
|
|
#ifdef __KAME__
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {
|
|
|
|
*(u_int16_t *)&sin->sin6_addr.s6_addr[2] =
|
2003-10-17 11:46:40 +00:00
|
|
|
htons(((struct sockaddr_in6 *)res->ai_addr)->sin6_scope_id);
|
2000-07-04 16:43:14 +00:00
|
|
|
}
|
|
|
|
#endif
|
2003-11-13 16:02:44 +00:00
|
|
|
dump(&sin->sin6_addr, 0);
|
2000-01-06 12:40:54 +00:00
|
|
|
if (found_entry == 0) {
|
|
|
|
getnameinfo((struct sockaddr *)sin, sin->sin6_len, host_buf,
|
2003-10-17 11:46:40 +00:00
|
|
|
sizeof(host_buf), NULL ,0,
|
|
|
|
(nflag ? NI_NUMERICHOST : 0));
|
2000-01-06 12:40:54 +00:00
|
|
|
printf("%s (%s) -- no entry\n", host, host_buf);
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete a neighbor cache entry
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
delete(host)
|
|
|
|
char *host;
|
|
|
|
{
|
|
|
|
struct sockaddr_in6 *sin = &sin_m;
|
|
|
|
register struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
register char *cp = m_rtmsg.m_space;
|
2000-01-06 12:40:54 +00:00
|
|
|
struct sockaddr_dl *sdl;
|
|
|
|
struct addrinfo hints, *res;
|
|
|
|
int gai_error;
|
|
|
|
|
|
|
|
getsocket();
|
|
|
|
sin_m = blank_sin;
|
|
|
|
|
|
|
|
bzero(&hints, sizeof(hints));
|
|
|
|
hints.ai_family = AF_INET6;
|
|
|
|
gai_error = getaddrinfo(host, NULL, &hints, &res);
|
|
|
|
if (gai_error) {
|
|
|
|
fprintf(stderr, "ndp: %s: %s\n", host,
|
2003-10-17 11:46:40 +00:00
|
|
|
gai_strerror(gai_error));
|
2000-01-06 12:40:54 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
sin->sin6_addr = ((struct sockaddr_in6 *)res->ai_addr)->sin6_addr;
|
2000-07-04 16:43:14 +00:00
|
|
|
#ifdef __KAME__
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr)) {
|
|
|
|
*(u_int16_t *)&sin->sin6_addr.s6_addr[2] =
|
2003-10-17 11:46:40 +00:00
|
|
|
htons(((struct sockaddr_in6 *)res->ai_addr)->sin6_scope_id);
|
2000-07-04 16:43:14 +00:00
|
|
|
}
|
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
if (rtmsg(RTM_GET) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
errx(1, "RTM_GET(%s) failed", host);
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
sin = (struct sockaddr_in6 *)(rtm + 1);
|
|
|
|
sdl = (struct sockaddr_dl *)(ROUNDUP(sin->sin6_len) + (char *)sin);
|
|
|
|
if (IN6_ARE_ADDR_EQUAL(&sin->sin6_addr, &sin_m.sin6_addr)) {
|
|
|
|
if (sdl->sdl_family == AF_LINK &&
|
2000-07-04 16:43:14 +00:00
|
|
|
!(rtm->rtm_flags & RTF_GATEWAY)) {
|
2001-06-11 12:39:29 +00:00
|
|
|
goto delete;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
/*
|
|
|
|
* IPv4 arp command retries with sin_other = SIN_PROXY here.
|
|
|
|
*/
|
|
|
|
fprintf(stderr, "delete: cannot delete non-NDP entry\n");
|
|
|
|
return 1;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
delete:
|
|
|
|
if (sdl->sdl_family != AF_LINK) {
|
|
|
|
printf("cannot locate %s\n", host);
|
|
|
|
return (1);
|
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
/*
|
|
|
|
* need to reinit the field because it has rt_key
|
|
|
|
* but we want the actual address
|
|
|
|
*/
|
|
|
|
NEXTADDR(RTA_DST, sin_m);
|
2008-12-26 19:45:24 +00:00
|
|
|
rtm->rtm_flags |= RTF_LLDATA;
|
2000-01-06 12:40:54 +00:00
|
|
|
if (rtmsg(RTM_DELETE) == 0) {
|
2000-07-04 16:43:14 +00:00
|
|
|
struct sockaddr_in6 s6 = *sin; /* XXX: for safety */
|
|
|
|
|
|
|
|
#ifdef __KAME__
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&s6.sin6_addr)) {
|
|
|
|
s6.sin6_scope_id = ntohs(*(u_int16_t *)&s6.sin6_addr.s6_addr[2]);
|
|
|
|
*(u_int16_t *)&s6.sin6_addr.s6_addr[2] = 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
getnameinfo((struct sockaddr *)&s6,
|
2003-10-17 11:46:40 +00:00
|
|
|
s6.sin6_len, host_buf,
|
|
|
|
sizeof(host_buf), NULL, 0,
|
|
|
|
(nflag ? NI_NUMERICHOST : 0));
|
2000-01-06 12:40:54 +00:00
|
|
|
printf("%s (%s) deleted\n", host, host_buf);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2003-11-13 16:02:44 +00:00
|
|
|
#define W_ADDR 36
|
2001-06-11 12:39:29 +00:00
|
|
|
#define W_LL 17
|
|
|
|
#define W_IF 6
|
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
/*
|
|
|
|
* Dump the entire neighbor cache
|
|
|
|
*/
|
|
|
|
void
|
2003-11-13 16:02:44 +00:00
|
|
|
dump(addr, cflag)
|
2000-01-06 12:40:54 +00:00
|
|
|
struct in6_addr *addr;
|
2003-11-13 16:02:44 +00:00
|
|
|
int cflag;
|
2000-01-06 12:40:54 +00:00
|
|
|
{
|
|
|
|
int mib[6];
|
|
|
|
size_t needed;
|
2000-07-04 16:43:14 +00:00
|
|
|
char *lim, *buf, *next;
|
2000-01-06 12:40:54 +00:00
|
|
|
struct rt_msghdr *rtm;
|
|
|
|
struct sockaddr_in6 *sin;
|
|
|
|
struct sockaddr_dl *sdl;
|
|
|
|
extern int h_errno;
|
|
|
|
struct in6_nbrinfo *nbi;
|
|
|
|
struct timeval time;
|
|
|
|
int addrwidth;
|
2001-06-11 12:39:29 +00:00
|
|
|
int llwidth;
|
|
|
|
int ifwidth;
|
2000-07-04 16:43:14 +00:00
|
|
|
char flgbuf[8];
|
2001-06-11 12:39:29 +00:00
|
|
|
char *ifname;
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
/* Print header */
|
2000-10-09 09:28:49 +00:00
|
|
|
if (!tflag && !cflag)
|
2003-11-13 16:02:44 +00:00
|
|
|
printf("%-*.*s %-*.*s %*.*s %-9.9s %1s %5s\n",
|
2001-06-11 12:39:29 +00:00
|
|
|
W_ADDR, W_ADDR, "Neighbor", W_LL, W_LL, "Linklayer Address",
|
2003-11-13 16:02:44 +00:00
|
|
|
W_IF, W_IF, "Netif", "Expire", "S", "Flags");
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
again:;
|
|
|
|
mib[0] = CTL_NET;
|
|
|
|
mib[1] = PF_ROUTE;
|
|
|
|
mib[2] = 0;
|
|
|
|
mib[3] = AF_INET6;
|
|
|
|
mib[4] = NET_RT_FLAGS;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#ifdef RTF_LLINFO
|
2000-01-06 12:40:54 +00:00
|
|
|
mib[5] = RTF_LLINFO;
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
#else
|
|
|
|
mib[5] = 0;
|
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
if (sysctl(mib, 6, NULL, &needed, NULL, 0) < 0)
|
|
|
|
err(1, "sysctl(PF_ROUTE estimate)");
|
|
|
|
if (needed > 0) {
|
|
|
|
if ((buf = malloc(needed)) == NULL)
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "malloc");
|
2000-01-06 12:40:54 +00:00
|
|
|
if (sysctl(mib, 6, buf, &needed, NULL, 0) < 0)
|
|
|
|
err(1, "sysctl(PF_ROUTE, NET_RT_FLAGS)");
|
|
|
|
lim = buf + needed;
|
|
|
|
} else
|
|
|
|
buf = lim = NULL;
|
|
|
|
|
|
|
|
for (next = buf; next && next < lim; next += rtm->rtm_msglen) {
|
|
|
|
int isrouter = 0, prbs = 0;
|
|
|
|
|
|
|
|
rtm = (struct rt_msghdr *)next;
|
|
|
|
sin = (struct sockaddr_in6 *)(rtm + 1);
|
|
|
|
sdl = (struct sockaddr_dl *)((char *)sin + ROUNDUP(sin->sin6_len));
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Some OSes can produce a route that has the LINK flag but
|
|
|
|
* has a non-AF_LINK gateway (e.g. fe80::xx%lo0 on FreeBSD
|
|
|
|
* and BSD/OS, where xx is not the interface identifier on
|
|
|
|
* lo0). Such routes entry would annoy getnbrinfo() below,
|
|
|
|
* so we skip them.
|
|
|
|
* XXX: such routes should have the GATEWAY flag, not the
|
2003-10-17 11:46:40 +00:00
|
|
|
* LINK flag. However, there is rotten routing software
|
2001-06-11 12:39:29 +00:00
|
|
|
* that advertises all routes that have the GATEWAY flag.
|
|
|
|
* Thus, KAME kernel intentionally does not set the LINK flag.
|
|
|
|
* What is to be fixed is not ndp, but such routing software
|
|
|
|
* (and the kernel workaround)...
|
|
|
|
*/
|
|
|
|
if (sdl->sdl_family != AF_LINK)
|
|
|
|
continue;
|
|
|
|
|
2003-11-13 16:02:44 +00:00
|
|
|
if (!(rtm->rtm_flags & RTF_HOST))
|
|
|
|
continue;
|
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
if (addr) {
|
|
|
|
if (!IN6_ARE_ADDR_EQUAL(addr, &sin->sin6_addr))
|
|
|
|
continue;
|
|
|
|
found_entry = 1;
|
|
|
|
} else if (IN6_IS_ADDR_MULTICAST(&sin->sin6_addr))
|
|
|
|
continue;
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&sin->sin6_addr) ||
|
|
|
|
IN6_IS_ADDR_MC_LINKLOCAL(&sin->sin6_addr)) {
|
|
|
|
/* XXX: should scope id be filled in the kernel? */
|
|
|
|
if (sin->sin6_scope_id == 0)
|
|
|
|
sin->sin6_scope_id = sdl->sdl_index;
|
2000-10-09 09:28:49 +00:00
|
|
|
#ifdef __KAME__
|
|
|
|
/* KAME specific hack; removed the embedded id */
|
2000-01-06 12:40:54 +00:00
|
|
|
*(u_int16_t *)&sin->sin6_addr.s6_addr[2] = 0;
|
2000-10-09 09:28:49 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
getnameinfo((struct sockaddr *)sin, sin->sin6_len, host_buf,
|
2003-10-17 11:46:40 +00:00
|
|
|
sizeof(host_buf), NULL, 0, (nflag ? NI_NUMERICHOST : 0));
|
2003-11-13 16:02:44 +00:00
|
|
|
if (cflag) {
|
2001-08-09 19:40:35 +00:00
|
|
|
#ifdef RTF_WASCLONED
|
|
|
|
if (rtm->rtm_flags & RTF_WASCLONED)
|
|
|
|
delete(host_buf);
|
2003-11-13 16:02:44 +00:00
|
|
|
#elif defined(RTF_CLONED)
|
|
|
|
if (rtm->rtm_flags & RTF_CLONED)
|
|
|
|
delete(host_buf);
|
2001-08-09 19:40:35 +00:00
|
|
|
#else
|
2000-10-09 09:28:49 +00:00
|
|
|
delete(host_buf);
|
2001-08-09 19:40:35 +00:00
|
|
|
#endif
|
2000-10-09 09:28:49 +00:00
|
|
|
continue;
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
gettimeofday(&time, 0);
|
|
|
|
if (tflag)
|
|
|
|
ts_print(&time);
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
addrwidth = strlen(host_buf);
|
|
|
|
if (addrwidth < W_ADDR)
|
|
|
|
addrwidth = W_ADDR;
|
|
|
|
llwidth = strlen(ether_str(sdl));
|
|
|
|
if (W_ADDR + W_LL - addrwidth > llwidth)
|
|
|
|
llwidth = W_ADDR + W_LL - addrwidth;
|
|
|
|
ifname = if_indextoname(sdl->sdl_index, ifix_buf);
|
|
|
|
if (!ifname)
|
|
|
|
ifname = "?";
|
|
|
|
ifwidth = strlen(ifname);
|
|
|
|
if (W_ADDR + W_LL + W_IF - addrwidth - llwidth > ifwidth)
|
|
|
|
ifwidth = W_ADDR + W_LL + W_IF - addrwidth - llwidth;
|
|
|
|
|
|
|
|
printf("%-*.*s %-*.*s %*.*s", addrwidth, addrwidth, host_buf,
|
|
|
|
llwidth, llwidth, ether_str(sdl), ifwidth, ifwidth, ifname);
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
/* Print neighbor discovery specific informations */
|
2000-07-04 16:43:14 +00:00
|
|
|
nbi = getnbrinfo(&sin->sin6_addr, sdl->sdl_index, 1);
|
2000-01-06 12:40:54 +00:00
|
|
|
if (nbi) {
|
|
|
|
if (nbi->expire > time.tv_sec) {
|
|
|
|
printf(" %-9.9s",
|
2003-10-17 11:46:40 +00:00
|
|
|
sec2str(nbi->expire - time.tv_sec));
|
2001-06-11 12:39:29 +00:00
|
|
|
} else if (nbi->expire == 0)
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" %-9.9s", "permanent");
|
|
|
|
else
|
|
|
|
printf(" %-9.9s", "expired");
|
|
|
|
|
2003-10-17 11:46:40 +00:00
|
|
|
switch (nbi->state) {
|
|
|
|
case ND6_LLINFO_NOSTATE:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" N");
|
|
|
|
break;
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef ND6_LLINFO_WAITDELETE
|
2003-10-17 11:46:40 +00:00
|
|
|
case ND6_LLINFO_WAITDELETE:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" W");
|
|
|
|
break;
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2003-10-17 11:46:40 +00:00
|
|
|
case ND6_LLINFO_INCOMPLETE:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" I");
|
|
|
|
break;
|
2003-10-17 11:46:40 +00:00
|
|
|
case ND6_LLINFO_REACHABLE:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" R");
|
|
|
|
break;
|
2003-10-17 11:46:40 +00:00
|
|
|
case ND6_LLINFO_STALE:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" S");
|
|
|
|
break;
|
2003-10-17 11:46:40 +00:00
|
|
|
case ND6_LLINFO_DELAY:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" D");
|
|
|
|
break;
|
2003-10-17 11:46:40 +00:00
|
|
|
case ND6_LLINFO_PROBE:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" P");
|
|
|
|
break;
|
2003-10-17 11:46:40 +00:00
|
|
|
default:
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" ?");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
isrouter = nbi->isrouter;
|
|
|
|
prbs = nbi->asked;
|
2001-06-11 12:39:29 +00:00
|
|
|
} else {
|
2000-01-06 12:40:54 +00:00
|
|
|
warnx("failed to get neighbor information");
|
|
|
|
printf(" ");
|
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* other flags. R: router, P: proxy, W: ??
|
|
|
|
*/
|
|
|
|
if ((rtm->rtm_addrs & RTA_NETMASK) == 0) {
|
|
|
|
snprintf(flgbuf, sizeof(flgbuf), "%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
isrouter ? "R" : "",
|
|
|
|
(rtm->rtm_flags & RTF_ANNOUNCE) ? "p" : "");
|
2000-07-04 16:43:14 +00:00
|
|
|
} else {
|
|
|
|
sin = (struct sockaddr_in6 *)
|
2003-10-17 11:46:40 +00:00
|
|
|
(sdl->sdl_len + (char *)sdl);
|
2003-11-13 16:02:44 +00:00
|
|
|
#if 0 /* W and P are mystery even for us */
|
2000-07-04 16:43:14 +00:00
|
|
|
snprintf(flgbuf, sizeof(flgbuf), "%s%s%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
isrouter ? "R" : "",
|
|
|
|
!IN6_IS_ADDR_UNSPECIFIED(&sin->sin6_addr) ? "P" : "",
|
|
|
|
(sin->sin6_len != sizeof(struct sockaddr_in6)) ? "W" : "",
|
|
|
|
(rtm->rtm_flags & RTF_ANNOUNCE) ? "p" : "");
|
2003-11-13 16:02:44 +00:00
|
|
|
#else
|
|
|
|
snprintf(flgbuf, sizeof(flgbuf), "%s%s",
|
|
|
|
isrouter ? "R" : "",
|
|
|
|
(rtm->rtm_flags & RTF_ANNOUNCE) ? "p" : "");
|
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" %s", flgbuf);
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
if (prbs)
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" %d", prbs);
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
printf("\n");
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
if (buf != NULL)
|
|
|
|
free(buf);
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
if (repeat) {
|
|
|
|
printf("\n");
|
2004-02-10 22:50:57 +00:00
|
|
|
fflush(stdout);
|
2000-01-06 12:40:54 +00:00
|
|
|
sleep(repeat);
|
|
|
|
goto again;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct in6_nbrinfo *
|
2000-07-04 16:43:14 +00:00
|
|
|
getnbrinfo(addr, ifindex, warning)
|
2000-01-06 12:40:54 +00:00
|
|
|
struct in6_addr *addr;
|
|
|
|
int ifindex;
|
2000-07-04 16:43:14 +00:00
|
|
|
int warning;
|
2000-01-06 12:40:54 +00:00
|
|
|
{
|
|
|
|
static struct in6_nbrinfo nbi;
|
|
|
|
int s;
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
|
|
|
|
err(1, "socket");
|
|
|
|
|
|
|
|
bzero(&nbi, sizeof(nbi));
|
|
|
|
if_indextoname(ifindex, nbi.ifname);
|
|
|
|
nbi.addr = *addr;
|
|
|
|
if (ioctl(s, SIOCGNBRINFO_IN6, (caddr_t)&nbi) < 0) {
|
2000-07-04 16:43:14 +00:00
|
|
|
if (warning)
|
|
|
|
warn("ioctl(SIOCGNBRINFO_IN6)");
|
2000-01-06 12:40:54 +00:00
|
|
|
close(s);
|
|
|
|
return(NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
close(s);
|
|
|
|
return(&nbi);
|
|
|
|
}
|
|
|
|
|
|
|
|
static char *
|
|
|
|
ether_str(sdl)
|
|
|
|
struct sockaddr_dl *sdl;
|
|
|
|
{
|
2003-10-17 11:46:40 +00:00
|
|
|
static char hbuf[NI_MAXHOST];
|
2000-01-06 12:40:54 +00:00
|
|
|
u_char *cp;
|
|
|
|
|
|
|
|
if (sdl->sdl_alen) {
|
|
|
|
cp = (u_char *)LLADDR(sdl);
|
2003-10-17 11:46:40 +00:00
|
|
|
snprintf(hbuf, sizeof(hbuf), "%x:%x:%x:%x:%x:%x",
|
|
|
|
cp[0], cp[1], cp[2], cp[3], cp[4], cp[5]);
|
|
|
|
} else
|
|
|
|
snprintf(hbuf, sizeof(hbuf), "(incomplete)");
|
2000-01-06 12:40:54 +00:00
|
|
|
|
2003-10-17 11:46:40 +00:00
|
|
|
return(hbuf);
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
ndp_ether_aton(a, n)
|
|
|
|
char *a;
|
|
|
|
u_char *n;
|
|
|
|
{
|
|
|
|
int i, o[6];
|
|
|
|
|
|
|
|
i = sscanf(a, "%x:%x:%x:%x:%x:%x", &o[0], &o[1], &o[2],
|
2003-10-17 11:46:40 +00:00
|
|
|
&o[3], &o[4], &o[5]);
|
2000-01-06 12:40:54 +00:00
|
|
|
if (i != 6) {
|
|
|
|
fprintf(stderr, "ndp: invalid Ethernet address '%s'\n", a);
|
|
|
|
return (1);
|
|
|
|
}
|
2003-10-17 11:46:40 +00:00
|
|
|
for (i = 0; i < 6; i++)
|
2000-01-06 12:40:54 +00:00
|
|
|
n[i] = o[i];
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
usage()
|
|
|
|
{
|
2003-11-13 16:02:44 +00:00
|
|
|
printf("usage: ndp [-nt] hostname\n");
|
|
|
|
printf(" ndp [-nt] -a | -c | -p | -r | -H | -P | -R\n");
|
2001-06-11 12:39:29 +00:00
|
|
|
printf(" ndp [-nt] -A wait\n");
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" ndp [-nt] -d hostname\n");
|
|
|
|
printf(" ndp [-nt] -f filename\n");
|
|
|
|
printf(" ndp [-nt] -i interface [flags...]\n");
|
2000-07-04 16:43:14 +00:00
|
|
|
#ifdef SIOCSDEFIFACE_IN6
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" ndp [-nt] -I [interface|delete]\n");
|
2000-07-04 16:43:14 +00:00
|
|
|
#endif
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" ndp [-nt] -s nodename etheraddr [temp] [proxy]\n");
|
2000-01-06 12:40:54 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
rtmsg(cmd)
|
|
|
|
int cmd;
|
|
|
|
{
|
|
|
|
static int seq;
|
|
|
|
int rlen;
|
|
|
|
register struct rt_msghdr *rtm = &m_rtmsg.m_rtm;
|
|
|
|
register char *cp = m_rtmsg.m_space;
|
|
|
|
register int l;
|
|
|
|
|
|
|
|
errno = 0;
|
|
|
|
if (cmd == RTM_DELETE)
|
|
|
|
goto doit;
|
|
|
|
bzero((char *)&m_rtmsg, sizeof(m_rtmsg));
|
|
|
|
rtm->rtm_flags = flags;
|
|
|
|
rtm->rtm_version = RTM_VERSION;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
default:
|
|
|
|
fprintf(stderr, "ndp: internal wrong cmd\n");
|
|
|
|
exit(1);
|
|
|
|
case RTM_ADD:
|
|
|
|
rtm->rtm_addrs |= RTA_GATEWAY;
|
2003-11-13 16:02:44 +00:00
|
|
|
if (expire_time) {
|
|
|
|
rtm->rtm_rmx.rmx_expire = expire_time;
|
|
|
|
rtm->rtm_inits = RTV_EXPIRE;
|
|
|
|
}
|
2008-12-26 19:45:24 +00:00
|
|
|
rtm->rtm_flags |= (RTF_HOST | RTF_STATIC | RTF_LLDATA);
|
2005-10-19 15:58:23 +00:00
|
|
|
#if 0 /* we don't support ipv6addr/128 type proxying */
|
2000-07-04 16:43:14 +00:00
|
|
|
if (rtm->rtm_flags & RTF_ANNOUNCE) {
|
|
|
|
rtm->rtm_flags &= ~RTF_HOST;
|
2004-01-08 07:25:04 +00:00
|
|
|
rtm->rtm_addrs |= RTA_NETMASK;
|
2000-07-04 16:43:14 +00:00
|
|
|
}
|
2005-10-19 15:58:23 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
/* FALLTHROUGH */
|
|
|
|
case RTM_GET:
|
|
|
|
rtm->rtm_addrs |= RTA_DST;
|
|
|
|
}
|
|
|
|
|
|
|
|
NEXTADDR(RTA_DST, sin_m);
|
|
|
|
NEXTADDR(RTA_GATEWAY, sdl_m);
|
2005-10-19 15:58:23 +00:00
|
|
|
#if 0 /* we don't support ipv6addr/128 type proxying */
|
2000-07-04 16:43:14 +00:00
|
|
|
memset(&so_mask.sin6_addr, 0xff, sizeof(so_mask.sin6_addr));
|
2000-01-06 12:40:54 +00:00
|
|
|
NEXTADDR(RTA_NETMASK, so_mask);
|
2005-10-19 15:58:23 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
rtm->rtm_msglen = cp - (char *)&m_rtmsg;
|
|
|
|
doit:
|
|
|
|
l = rtm->rtm_msglen;
|
|
|
|
rtm->rtm_seq = ++seq;
|
|
|
|
rtm->rtm_type = cmd;
|
|
|
|
if ((rlen = write(s, (char *)&m_rtmsg, l)) < 0) {
|
|
|
|
if (errno != ESRCH || cmd != RTM_DELETE) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "writing to routing socket");
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
do {
|
|
|
|
l = read(s, (char *)&m_rtmsg, sizeof(m_rtmsg));
|
|
|
|
} while (l > 0 && (rtm->rtm_seq != seq || rtm->rtm_pid != pid));
|
|
|
|
if (l < 0)
|
|
|
|
(void) fprintf(stderr, "ndp: read from routing socket: %s\n",
|
|
|
|
strerror(errno));
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2003-11-13 16:02:44 +00:00
|
|
|
ifinfo(ifname, argc, argv)
|
|
|
|
char *ifname;
|
2000-07-04 16:43:14 +00:00
|
|
|
int argc;
|
|
|
|
char **argv;
|
2000-01-06 12:40:54 +00:00
|
|
|
{
|
|
|
|
struct in6_ndireq nd;
|
2000-07-04 16:43:14 +00:00
|
|
|
int i, s;
|
|
|
|
u_int32_t newflags;
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPV6CTL_USETEMPADDR
|
|
|
|
u_int8_t nullbuf[8];
|
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "socket");
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
bzero(&nd, sizeof(nd));
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(nd.ifname, ifname, sizeof(nd.ifname));
|
2000-01-06 12:40:54 +00:00
|
|
|
if (ioctl(s, SIOCGIFINFO_IN6, (caddr_t)&nd) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCGIFINFO_IN6)");
|
|
|
|
/* NOTREACHED */
|
2003-11-13 16:02:44 +00:00
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
#define ND nd.ndi
|
|
|
|
newflags = ND.flags;
|
2003-11-13 16:02:44 +00:00
|
|
|
for (i = 0; i < argc; i++) {
|
2000-07-04 16:43:14 +00:00
|
|
|
int clear = 0;
|
|
|
|
char *cp = argv[i];
|
|
|
|
|
|
|
|
if (*cp == '-') {
|
|
|
|
clear = 1;
|
|
|
|
cp++;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define SETFLAG(s, f) \
|
|
|
|
do {\
|
|
|
|
if (strcmp(cp, (s)) == 0) {\
|
|
|
|
if (clear)\
|
|
|
|
newflags &= ~(f);\
|
|
|
|
else\
|
|
|
|
newflags |= (f);\
|
|
|
|
}\
|
|
|
|
} while (0)
|
2005-10-19 15:05:42 +00:00
|
|
|
/*
|
|
|
|
* XXX: this macro is not 100% correct, in that it matches "nud" against
|
|
|
|
* "nudbogus". But we just let it go since this is minor.
|
|
|
|
*/
|
|
|
|
#define SETVALUE(f, v) \
|
|
|
|
do { \
|
|
|
|
char *valptr; \
|
|
|
|
unsigned long newval; \
|
|
|
|
v = 0; /* unspecified */ \
|
|
|
|
if (strncmp(cp, f, strlen(f)) == 0) { \
|
|
|
|
valptr = strchr(cp, '='); \
|
|
|
|
if (valptr == NULL) \
|
|
|
|
err(1, "syntax error in %s field", (f)); \
|
|
|
|
errno = 0; \
|
|
|
|
newval = strtoul(++valptr, NULL, 0); \
|
|
|
|
if (errno) \
|
|
|
|
err(1, "syntax error in %s's value", (f)); \
|
|
|
|
v = newval; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
2005-10-19 16:20:18 +00:00
|
|
|
SETFLAG("disabled", ND6_IFF_IFDISABLED);
|
2000-07-04 16:43:14 +00:00
|
|
|
SETFLAG("nud", ND6_IFF_PERFORMNUD);
|
2003-08-05 14:57:11 +00:00
|
|
|
#ifdef ND6_IFF_ACCEPT_RTADV
|
|
|
|
SETFLAG("accept_rtadv", ND6_IFF_ACCEPT_RTADV);
|
|
|
|
#endif
|
2009-09-12 22:08:20 +00:00
|
|
|
#ifdef ND6_IFF_AUTO_LINKLOCAL
|
|
|
|
SETFLAG("auto_linklocal", ND6_IFF_AUTO_LINKLOCAL);
|
|
|
|
#endif
|
2003-11-13 16:02:44 +00:00
|
|
|
#ifdef ND6_IFF_PREFER_SOURCE
|
|
|
|
SETFLAG("prefer_source", ND6_IFF_PREFER_SOURCE);
|
|
|
|
#endif
|
2005-10-19 15:05:42 +00:00
|
|
|
SETVALUE("basereachable", ND.basereachable);
|
|
|
|
SETVALUE("retrans", ND.retrans);
|
|
|
|
SETVALUE("curhlim", ND.chlim);
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
ND.flags = newflags;
|
2005-10-19 15:05:42 +00:00
|
|
|
if (ioctl(s, SIOCSIFINFO_IN6, (caddr_t)&nd) < 0) {
|
|
|
|
err(1, "ioctl(SIOCSIFINFO_IN6)");
|
2003-10-17 11:46:40 +00:00
|
|
|
/* NOTREACHED */
|
2000-07-04 16:43:14 +00:00
|
|
|
}
|
|
|
|
#undef SETFLAG
|
2005-10-19 15:05:42 +00:00
|
|
|
#undef SETVALUE
|
2000-07-04 16:43:14 +00:00
|
|
|
}
|
|
|
|
|
2003-10-17 16:17:47 +00:00
|
|
|
if (!ND.initialized) {
|
|
|
|
errx(1, "%s: not initialized yet", ifname);
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
|
|
|
|
2005-10-19 15:05:42 +00:00
|
|
|
if (ioctl(s, SIOCGIFINFO_IN6, (caddr_t)&nd) < 0) {
|
|
|
|
err(1, "ioctl(SIOCGIFINFO_IN6)");
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
2000-01-06 12:40:54 +00:00
|
|
|
printf("linkmtu=%d", ND.linkmtu);
|
2003-10-24 18:00:17 +00:00
|
|
|
printf(", maxmtu=%d", ND.maxmtu);
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(", curhlim=%d", ND.chlim);
|
|
|
|
printf(", basereachable=%ds%dms",
|
2003-10-17 11:46:40 +00:00
|
|
|
ND.basereachable / 1000, ND.basereachable % 1000);
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(", reachable=%ds", ND.reachable);
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(", retrans=%ds%dms", ND.retrans / 1000, ND.retrans % 1000);
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef IPV6CTL_USETEMPADDR
|
|
|
|
memset(nullbuf, 0, sizeof(nullbuf));
|
|
|
|
if (memcmp(nullbuf, ND.randomid, sizeof(nullbuf)) != 0) {
|
|
|
|
int j;
|
|
|
|
u_int8_t *rbuf;
|
|
|
|
|
|
|
|
for (i = 0; i < 3; i++) {
|
2003-10-17 11:46:40 +00:00
|
|
|
switch (i) {
|
2001-06-11 12:39:29 +00:00
|
|
|
case 0:
|
|
|
|
printf("\nRandom seed(0): ");
|
|
|
|
rbuf = ND.randomseed0;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
printf("\nRandom seed(1): ");
|
|
|
|
rbuf = ND.randomseed1;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
printf("\nRandom ID: ");
|
|
|
|
rbuf = ND.randomid;
|
|
|
|
break;
|
2005-10-19 15:52:00 +00:00
|
|
|
default:
|
|
|
|
errx(1, "impossible case for tempaddr display");
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
for (j = 0; j < 8; j++)
|
|
|
|
printf("%02x", rbuf[j]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
2000-07-04 16:43:14 +00:00
|
|
|
if (ND.flags) {
|
|
|
|
printf("\nFlags: ");
|
2005-10-19 16:20:18 +00:00
|
|
|
#ifdef ND6_IFF_IFDISABLED
|
|
|
|
if ((ND.flags & ND6_IFF_IFDISABLED))
|
|
|
|
printf("disabled ");
|
|
|
|
#endif
|
2003-08-05 14:57:11 +00:00
|
|
|
if ((ND.flags & ND6_IFF_PERFORMNUD))
|
|
|
|
printf("nud ");
|
|
|
|
#ifdef ND6_IFF_ACCEPT_RTADV
|
|
|
|
if ((ND.flags & ND6_IFF_ACCEPT_RTADV))
|
|
|
|
printf("accept_rtadv ");
|
|
|
|
#endif
|
2009-09-12 22:08:20 +00:00
|
|
|
#ifdef ND6_IFF_AUTO_LINKLOCAL
|
|
|
|
if ((ND.flags & ND6_IFF_AUTO_LINKLOCAL))
|
|
|
|
printf("auto_linklocal ");
|
|
|
|
#endif
|
2003-11-13 16:02:44 +00:00
|
|
|
#ifdef ND6_IFF_PREFER_SOURCE
|
|
|
|
if ((ND.flags & ND6_IFF_PREFER_SOURCE))
|
|
|
|
printf("prefer_source ");
|
|
|
|
#endif
|
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
putc('\n', stdout);
|
2000-01-06 12:40:54 +00:00
|
|
|
#undef ND
|
2003-10-17 11:46:40 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
close(s);
|
|
|
|
}
|
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifndef ND_RA_FLAG_RTPREF_MASK /* XXX: just for compilation on *BSD release */
|
|
|
|
#define ND_RA_FLAG_RTPREF_MASK 0x18 /* 00011000 */
|
|
|
|
#endif
|
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
void
|
|
|
|
rtrlist()
|
|
|
|
{
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef ICMPV6CTL_ND6_DRLIST
|
|
|
|
int mib[] = { CTL_NET, PF_INET6, IPPROTO_ICMPV6, ICMPV6CTL_ND6_DRLIST };
|
|
|
|
char *buf;
|
|
|
|
struct in6_defrouter *p, *ep;
|
|
|
|
size_t l;
|
|
|
|
struct timeval time;
|
|
|
|
|
|
|
|
if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &l, NULL, 0) < 0) {
|
|
|
|
err(1, "sysctl(ICMPV6CTL_ND6_DRLIST)");
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
2005-10-19 15:52:00 +00:00
|
|
|
if (l == 0)
|
|
|
|
return;
|
2001-06-11 12:39:29 +00:00
|
|
|
buf = malloc(l);
|
|
|
|
if (!buf) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "malloc");
|
2001-06-11 12:39:29 +00:00
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), buf, &l, NULL, 0) < 0) {
|
|
|
|
err(1, "sysctl(ICMPV6CTL_ND6_DRLIST)");
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
ep = (struct in6_defrouter *)(buf + l);
|
|
|
|
for (p = (struct in6_defrouter *)buf; p < ep; p++) {
|
|
|
|
int rtpref;
|
|
|
|
|
|
|
|
if (getnameinfo((struct sockaddr *)&p->rtaddr,
|
|
|
|
p->rtaddr.sin6_len, host_buf, sizeof(host_buf), NULL, 0,
|
2003-10-17 11:46:40 +00:00
|
|
|
(nflag ? NI_NUMERICHOST : 0)) != 0)
|
2001-06-11 12:39:29 +00:00
|
|
|
strlcpy(host_buf, "?", sizeof(host_buf));
|
2003-10-17 11:46:40 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
printf("%s if=%s", host_buf,
|
2003-10-17 11:46:40 +00:00
|
|
|
if_indextoname(p->if_index, ifix_buf));
|
2001-06-11 12:39:29 +00:00
|
|
|
printf(", flags=%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
p->flags & ND_RA_FLAG_MANAGED ? "M" : "",
|
|
|
|
p->flags & ND_RA_FLAG_OTHER ? "O" : "");
|
2001-06-11 12:39:29 +00:00
|
|
|
rtpref = ((p->flags & ND_RA_FLAG_RTPREF_MASK) >> 3) & 0xff;
|
|
|
|
printf(", pref=%s", rtpref_str[rtpref]);
|
2003-10-17 11:46:40 +00:00
|
|
|
|
2001-06-11 12:39:29 +00:00
|
|
|
gettimeofday(&time, 0);
|
|
|
|
if (p->expire == 0)
|
|
|
|
printf(", expire=Never\n");
|
|
|
|
else
|
|
|
|
printf(", expire=%s\n",
|
2003-10-17 11:46:40 +00:00
|
|
|
sec2str(p->expire - time.tv_sec));
|
2001-06-11 12:39:29 +00:00
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
#else
|
2000-01-06 12:40:54 +00:00
|
|
|
struct in6_drlist dr;
|
|
|
|
int s, i;
|
|
|
|
struct timeval time;
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "socket");
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
bzero(&dr, sizeof(dr));
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(dr.ifname, "lo0", sizeof(dr.ifname)); /* dummy */
|
2000-01-06 12:40:54 +00:00
|
|
|
if (ioctl(s, SIOCGDRLST_IN6, (caddr_t)&dr) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCGDRLST_IN6)");
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
#define DR dr.defrouter[i]
|
2001-06-11 12:39:29 +00:00
|
|
|
for (i = 0 ; DR.if_index && i < DRLSTSIZ ; i++) {
|
2000-01-06 12:40:54 +00:00
|
|
|
struct sockaddr_in6 sin6;
|
|
|
|
|
|
|
|
bzero(&sin6, sizeof(sin6));
|
|
|
|
sin6.sin6_family = AF_INET6;
|
|
|
|
sin6.sin6_len = sizeof(sin6);
|
|
|
|
sin6.sin6_addr = DR.rtaddr;
|
|
|
|
getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len, host_buf,
|
2003-10-17 11:46:40 +00:00
|
|
|
sizeof(host_buf), NULL, 0,
|
|
|
|
(nflag ? NI_NUMERICHOST : 0));
|
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
printf("%s if=%s", host_buf,
|
2003-10-17 11:46:40 +00:00
|
|
|
if_indextoname(DR.if_index, ifix_buf));
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(", flags=%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
DR.flags & ND_RA_FLAG_MANAGED ? "M" : "",
|
|
|
|
DR.flags & ND_RA_FLAG_OTHER ? "O" : "");
|
2000-01-06 12:40:54 +00:00
|
|
|
gettimeofday(&time, 0);
|
|
|
|
if (DR.expire == 0)
|
|
|
|
printf(", expire=Never\n");
|
|
|
|
else
|
|
|
|
printf(", expire=%s\n",
|
2003-10-17 11:46:40 +00:00
|
|
|
sec2str(DR.expire - time.tv_sec));
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
#undef DR
|
|
|
|
close(s);
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
plist()
|
|
|
|
{
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef ICMPV6CTL_ND6_PRLIST
|
|
|
|
int mib[] = { CTL_NET, PF_INET6, IPPROTO_ICMPV6, ICMPV6CTL_ND6_PRLIST };
|
|
|
|
char *buf;
|
|
|
|
struct in6_prefix *p, *ep, *n;
|
|
|
|
struct sockaddr_in6 *advrtr;
|
|
|
|
size_t l;
|
|
|
|
struct timeval time;
|
|
|
|
const int niflags = NI_NUMERICHOST;
|
|
|
|
int ninflags = nflag ? NI_NUMERICHOST : 0;
|
|
|
|
char namebuf[NI_MAXHOST];
|
|
|
|
|
|
|
|
if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &l, NULL, 0) < 0) {
|
|
|
|
err(1, "sysctl(ICMPV6CTL_ND6_PRLIST)");
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
buf = malloc(l);
|
|
|
|
if (!buf) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "malloc");
|
2001-06-11 12:39:29 +00:00
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), buf, &l, NULL, 0) < 0) {
|
|
|
|
err(1, "sysctl(ICMPV6CTL_ND6_PRLIST)");
|
|
|
|
/*NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
ep = (struct in6_prefix *)(buf + l);
|
|
|
|
for (p = (struct in6_prefix *)buf; p < ep; p = n) {
|
|
|
|
advrtr = (struct sockaddr_in6 *)(p + 1);
|
|
|
|
n = (struct in6_prefix *)&advrtr[p->advrtrs];
|
|
|
|
|
|
|
|
if (getnameinfo((struct sockaddr *)&p->prefix,
|
|
|
|
p->prefix.sin6_len, namebuf, sizeof(namebuf),
|
|
|
|
NULL, 0, niflags) != 0)
|
|
|
|
strlcpy(namebuf, "?", sizeof(namebuf));
|
|
|
|
printf("%s/%d if=%s\n", namebuf, p->prefixlen,
|
2003-10-17 11:46:40 +00:00
|
|
|
if_indextoname(p->if_index, ifix_buf));
|
2001-06-11 12:39:29 +00:00
|
|
|
|
|
|
|
gettimeofday(&time, 0);
|
|
|
|
/*
|
|
|
|
* meaning of fields, especially flags, is very different
|
|
|
|
* by origin. notify the difference to the users.
|
|
|
|
*/
|
|
|
|
printf("flags=%s%s%s%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
p->raflags.onlink ? "L" : "",
|
|
|
|
p->raflags.autonomous ? "A" : "",
|
|
|
|
(p->flags & NDPRF_ONLINK) != 0 ? "O" : "",
|
|
|
|
(p->flags & NDPRF_DETACHED) != 0 ? "D" : "",
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef NDPRF_HOME
|
2003-10-17 11:46:40 +00:00
|
|
|
(p->flags & NDPRF_HOME) != 0 ? "H" : ""
|
2001-06-11 12:39:29 +00:00
|
|
|
#else
|
2003-10-17 11:46:40 +00:00
|
|
|
""
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2003-10-17 11:46:40 +00:00
|
|
|
);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (p->vltime == ND6_INFINITE_LIFETIME)
|
|
|
|
printf(" vltime=infinity");
|
|
|
|
else
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" vltime=%lu", (unsigned long)p->vltime);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (p->pltime == ND6_INFINITE_LIFETIME)
|
|
|
|
printf(", pltime=infinity");
|
|
|
|
else
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(", pltime=%lu", (unsigned long)p->pltime);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (p->expire == 0)
|
|
|
|
printf(", expire=Never");
|
|
|
|
else if (p->expire >= time.tv_sec)
|
|
|
|
printf(", expire=%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
sec2str(p->expire - time.tv_sec));
|
2001-06-11 12:39:29 +00:00
|
|
|
else
|
|
|
|
printf(", expired");
|
|
|
|
printf(", ref=%d", p->refcnt);
|
|
|
|
printf("\n");
|
|
|
|
/*
|
|
|
|
* "advertising router" list is meaningful only if the prefix
|
|
|
|
* information is from RA.
|
|
|
|
*/
|
|
|
|
if (p->advrtrs) {
|
|
|
|
int j;
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
|
2003-11-13 16:02:44 +00:00
|
|
|
sin6 = advrtr;
|
2001-06-11 12:39:29 +00:00
|
|
|
printf(" advertised by\n");
|
|
|
|
for (j = 0; j < p->advrtrs; j++) {
|
|
|
|
struct in6_nbrinfo *nbi;
|
|
|
|
|
|
|
|
if (getnameinfo((struct sockaddr *)sin6,
|
|
|
|
sin6->sin6_len, namebuf, sizeof(namebuf),
|
|
|
|
NULL, 0, ninflags) != 0)
|
|
|
|
strlcpy(namebuf, "?", sizeof(namebuf));
|
|
|
|
printf(" %s", namebuf);
|
|
|
|
|
2003-10-17 11:46:40 +00:00
|
|
|
nbi = getnbrinfo(&sin6->sin6_addr,
|
|
|
|
p->if_index, 0);
|
2001-06-11 12:39:29 +00:00
|
|
|
if (nbi) {
|
2003-10-17 11:46:40 +00:00
|
|
|
switch (nbi->state) {
|
2001-06-11 12:39:29 +00:00
|
|
|
case ND6_LLINFO_REACHABLE:
|
|
|
|
case ND6_LLINFO_STALE:
|
|
|
|
case ND6_LLINFO_DELAY:
|
|
|
|
case ND6_LLINFO_PROBE:
|
|
|
|
printf(" (reachable)\n");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf(" (unreachable)\n");
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
printf(" (no neighbor state)\n");
|
|
|
|
sin6++;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
printf(" No advertising router\n");
|
|
|
|
}
|
|
|
|
free(buf);
|
|
|
|
#else
|
2000-01-06 12:40:54 +00:00
|
|
|
struct in6_prlist pr;
|
|
|
|
int s, i;
|
|
|
|
struct timeval time;
|
|
|
|
|
|
|
|
gettimeofday(&time, 0);
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "socket");
|
|
|
|
/* NOTREACHED */
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
bzero(&pr, sizeof(pr));
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(pr.ifname, "lo0", sizeof(pr.ifname)); /* dummy */
|
2000-01-06 12:40:54 +00:00
|
|
|
if (ioctl(s, SIOCGPRLST_IN6, (caddr_t)&pr) < 0) {
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCGPRLST_IN6)");
|
|
|
|
/* NOTREACHED */
|
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
#define PR pr.prefix[i]
|
2000-01-06 12:40:54 +00:00
|
|
|
for (i = 0; PR.if_index && i < PRLSTSIZ ; i++) {
|
2001-06-11 12:39:29 +00:00
|
|
|
struct sockaddr_in6 p6;
|
|
|
|
char namebuf[NI_MAXHOST];
|
|
|
|
int niflags;
|
|
|
|
|
|
|
|
#ifdef NDPRF_ONLINK
|
|
|
|
p6 = PR.prefix;
|
|
|
|
#else
|
|
|
|
memset(&p6, 0, sizeof(p6));
|
|
|
|
p6.sin6_family = AF_INET6;
|
|
|
|
p6.sin6_len = sizeof(p6);
|
|
|
|
p6.sin6_addr = PR.prefix;
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* copy link index to sin6_scope_id field.
|
|
|
|
* XXX: KAME specific.
|
|
|
|
*/
|
|
|
|
if (IN6_IS_ADDR_LINKLOCAL(&p6.sin6_addr)) {
|
|
|
|
u_int16_t linkid;
|
|
|
|
|
|
|
|
memcpy(&linkid, &p6.sin6_addr.s6_addr[2],
|
2003-10-17 11:46:40 +00:00
|
|
|
sizeof(linkid));
|
2001-06-11 12:39:29 +00:00
|
|
|
linkid = ntohs(linkid);
|
|
|
|
p6.sin6_scope_id = linkid;
|
|
|
|
p6.sin6_addr.s6_addr[2] = 0;
|
|
|
|
p6.sin6_addr.s6_addr[3] = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
niflags = NI_NUMERICHOST;
|
|
|
|
if (getnameinfo((struct sockaddr *)&p6,
|
2003-10-17 11:46:40 +00:00
|
|
|
sizeof(p6), namebuf, sizeof(namebuf),
|
|
|
|
NULL, 0, niflags)) {
|
2001-06-11 12:39:29 +00:00
|
|
|
warnx("getnameinfo failed");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
printf("%s/%d if=%s\n", namebuf, PR.prefixlen,
|
2003-10-17 11:46:40 +00:00
|
|
|
if_indextoname(PR.if_index, ifix_buf));
|
2001-06-11 12:39:29 +00:00
|
|
|
|
2000-01-06 12:40:54 +00:00
|
|
|
gettimeofday(&time, 0);
|
2000-07-04 16:43:14 +00:00
|
|
|
/*
|
|
|
|
* meaning of fields, especially flags, is very different
|
|
|
|
* by origin. notify the difference to the users.
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
#if 0
|
|
|
|
printf(" %s",
|
2003-10-17 11:46:40 +00:00
|
|
|
PR.origin == PR_ORIG_RA ? "" : "advertise: ");
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
|
|
|
#ifdef NDPRF_ONLINK
|
|
|
|
printf("flags=%s%s%s%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
PR.raflags.onlink ? "L" : "",
|
|
|
|
PR.raflags.autonomous ? "A" : "",
|
|
|
|
(PR.flags & NDPRF_ONLINK) != 0 ? "O" : "",
|
|
|
|
(PR.flags & NDPRF_DETACHED) != 0 ? "D" : "",
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef NDPRF_HOME
|
2003-10-17 11:46:40 +00:00
|
|
|
(PR.flags & NDPRF_HOME) != 0 ? "H" : ""
|
2001-06-11 12:39:29 +00:00
|
|
|
#else
|
2003-10-17 11:46:40 +00:00
|
|
|
""
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2003-10-17 11:46:40 +00:00
|
|
|
);
|
2001-06-11 12:39:29 +00:00
|
|
|
#else
|
2000-07-04 16:43:14 +00:00
|
|
|
printf("flags=%s%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
PR.raflags.onlink ? "L" : "",
|
|
|
|
PR.raflags.autonomous ? "A" : "");
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
if (PR.vltime == ND6_INFINITE_LIFETIME)
|
|
|
|
printf(" vltime=infinity");
|
|
|
|
else
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(" vltime=%lu", PR.vltime);
|
2000-01-06 12:40:54 +00:00
|
|
|
if (PR.pltime == ND6_INFINITE_LIFETIME)
|
|
|
|
printf(", pltime=infinity");
|
|
|
|
else
|
2003-11-13 16:02:44 +00:00
|
|
|
printf(", pltime=%lu", PR.pltime);
|
2000-01-06 12:40:54 +00:00
|
|
|
if (PR.expire == 0)
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(", expire=Never");
|
2000-01-06 12:40:54 +00:00
|
|
|
else if (PR.expire >= time.tv_sec)
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(", expire=%s",
|
2003-10-17 11:46:40 +00:00
|
|
|
sec2str(PR.expire - time.tv_sec));
|
2000-01-06 12:40:54 +00:00
|
|
|
else
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(", expired");
|
2001-06-11 12:39:29 +00:00
|
|
|
#ifdef NDPRF_ONLINK
|
|
|
|
printf(", ref=%d", PR.refcnt);
|
|
|
|
#endif
|
|
|
|
#if 0
|
2000-07-04 16:43:14 +00:00
|
|
|
switch (PR.origin) {
|
|
|
|
case PR_ORIG_RA:
|
|
|
|
printf(", origin=RA");
|
|
|
|
break;
|
|
|
|
case PR_ORIG_RR:
|
|
|
|
printf(", origin=RR");
|
|
|
|
break;
|
|
|
|
case PR_ORIG_STATIC:
|
|
|
|
printf(", origin=static");
|
|
|
|
break;
|
|
|
|
case PR_ORIG_KERNEL:
|
|
|
|
printf(", origin=kernel");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
printf(", origin=?");
|
|
|
|
break;
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2000-07-04 16:43:14 +00:00
|
|
|
printf("\n");
|
|
|
|
/*
|
|
|
|
* "advertising router" list is meaningful only if the prefix
|
|
|
|
* information is from RA.
|
|
|
|
*/
|
2001-06-11 12:39:29 +00:00
|
|
|
if (0 && /* prefix origin is almost obsolted */
|
|
|
|
PR.origin != PR_ORIG_RA)
|
2000-07-04 16:43:14 +00:00
|
|
|
;
|
|
|
|
else if (PR.advrtrs) {
|
2000-01-06 12:40:54 +00:00
|
|
|
int j;
|
|
|
|
printf(" advertised by\n");
|
|
|
|
for (j = 0; j < PR.advrtrs; j++) {
|
|
|
|
struct sockaddr_in6 sin6;
|
2000-07-04 16:43:14 +00:00
|
|
|
struct in6_nbrinfo *nbi;
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
bzero(&sin6, sizeof(sin6));
|
|
|
|
sin6.sin6_family = AF_INET6;
|
|
|
|
sin6.sin6_len = sizeof(sin6);
|
|
|
|
sin6.sin6_addr = PR.advrtr[j];
|
2000-07-04 16:43:14 +00:00
|
|
|
sin6.sin6_scope_id = PR.if_index; /* XXX */
|
2000-01-06 12:40:54 +00:00
|
|
|
getnameinfo((struct sockaddr *)&sin6,
|
2003-10-17 11:46:40 +00:00
|
|
|
sin6.sin6_len, host_buf,
|
|
|
|
sizeof(host_buf), NULL, 0,
|
|
|
|
(nflag ? NI_NUMERICHOST : 0));
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(" %s", host_buf);
|
|
|
|
|
2003-10-17 11:46:40 +00:00
|
|
|
nbi = getnbrinfo(&sin6.sin6_addr,
|
|
|
|
PR.if_index, 0);
|
2000-07-04 16:43:14 +00:00
|
|
|
if (nbi) {
|
2003-10-17 11:46:40 +00:00
|
|
|
switch (nbi->state) {
|
|
|
|
case ND6_LLINFO_REACHABLE:
|
|
|
|
case ND6_LLINFO_STALE:
|
|
|
|
case ND6_LLINFO_DELAY:
|
|
|
|
case ND6_LLINFO_PROBE:
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(" (reachable)\n");
|
|
|
|
break;
|
2003-10-17 11:46:40 +00:00
|
|
|
default:
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(" (unreachable)\n");
|
|
|
|
}
|
2001-06-11 12:39:29 +00:00
|
|
|
} else
|
2000-07-04 16:43:14 +00:00
|
|
|
printf(" (no neighbor state)\n");
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
if (PR.advrtrs > DRLSTSIZ)
|
|
|
|
printf(" and %d routers\n",
|
2003-10-17 11:46:40 +00:00
|
|
|
PR.advrtrs - DRLSTSIZ);
|
2000-07-04 16:43:14 +00:00
|
|
|
} else
|
2000-01-06 12:40:54 +00:00
|
|
|
printf(" No advertising router\n");
|
|
|
|
}
|
|
|
|
#undef PR
|
|
|
|
close(s);
|
2001-06-11 12:39:29 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
pfx_flush()
|
|
|
|
{
|
|
|
|
char dummyif[IFNAMSIZ+8];
|
|
|
|
int s;
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
|
|
|
|
err(1, "socket");
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(dummyif, "lo0", sizeof(dummyif)); /* dummy */
|
2000-01-06 12:40:54 +00:00
|
|
|
if (ioctl(s, SIOCSPFXFLUSH_IN6, (caddr_t)&dummyif) < 0)
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCSPFXFLUSH_IN6)");
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
rtr_flush()
|
|
|
|
{
|
|
|
|
char dummyif[IFNAMSIZ+8];
|
|
|
|
int s;
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
|
|
|
|
err(1, "socket");
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(dummyif, "lo0", sizeof(dummyif)); /* dummy */
|
2000-01-06 12:40:54 +00:00
|
|
|
if (ioctl(s, SIOCSRTRFLUSH_IN6, (caddr_t)&dummyif) < 0)
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCSRTRFLUSH_IN6)");
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
close(s);
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
harmonize_rtr()
|
|
|
|
{
|
|
|
|
char dummyif[IFNAMSIZ+8];
|
|
|
|
int s;
|
|
|
|
|
2000-07-04 16:43:14 +00:00
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
|
|
|
|
err(1, "socket");
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(dummyif, "lo0", sizeof(dummyif)); /* dummy */
|
2000-07-04 16:43:14 +00:00
|
|
|
if (ioctl(s, SIOCSNDFLUSH_IN6, (caddr_t)&dummyif) < 0)
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCSNDFLUSH_IN6)");
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
close(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef SIOCSDEFIFACE_IN6 /* XXX: check SIOCGDEFIFACE_IN6 as well? */
|
|
|
|
static void
|
|
|
|
setdefif(ifname)
|
|
|
|
char *ifname;
|
|
|
|
{
|
|
|
|
struct in6_ndifreq ndifreq;
|
|
|
|
unsigned int ifindex;
|
|
|
|
|
|
|
|
if (strcasecmp(ifname, "delete") == 0)
|
|
|
|
ifindex = 0;
|
|
|
|
else {
|
|
|
|
if ((ifindex = if_nametoindex(ifname)) == 0)
|
|
|
|
err(1, "failed to resolve i/f index for %s", ifname);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
|
|
|
|
err(1, "socket");
|
|
|
|
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(ndifreq.ifname, "lo0", sizeof(ndifreq.ifname)); /* dummy */
|
2000-07-04 16:43:14 +00:00
|
|
|
ndifreq.ifindex = ifindex;
|
|
|
|
|
|
|
|
if (ioctl(s, SIOCSDEFIFACE_IN6, (caddr_t)&ndifreq) < 0)
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCSDEFIFACE_IN6)");
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
close(s);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
getdefif()
|
|
|
|
{
|
|
|
|
struct in6_ndifreq ndifreq;
|
|
|
|
char ifname[IFNAMSIZ+8];
|
|
|
|
|
|
|
|
if ((s = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
|
|
|
|
err(1, "socket");
|
|
|
|
|
|
|
|
memset(&ndifreq, 0, sizeof(ndifreq));
|
2003-10-17 11:46:40 +00:00
|
|
|
strlcpy(ndifreq.ifname, "lo0", sizeof(ndifreq.ifname)); /* dummy */
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
if (ioctl(s, SIOCGDEFIFACE_IN6, (caddr_t)&ndifreq) < 0)
|
2003-10-17 11:46:40 +00:00
|
|
|
err(1, "ioctl(SIOCGDEFIFACE_IN6)");
|
2000-07-04 16:43:14 +00:00
|
|
|
|
|
|
|
if (ndifreq.ifindex == 0)
|
|
|
|
printf("No default interface.\n");
|
|
|
|
else {
|
|
|
|
if ((if_indextoname(ndifreq.ifindex, ifname)) == NULL)
|
|
|
|
err(1, "failed to resolve ifname for index %lu",
|
|
|
|
ndifreq.ifindex);
|
|
|
|
printf("ND default interface = %s\n", ifname);
|
|
|
|
}
|
|
|
|
|
|
|
|
close(s);
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2000-07-04 16:43:14 +00:00
|
|
|
#endif
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
static char *
|
|
|
|
sec2str(total)
|
|
|
|
time_t total;
|
|
|
|
{
|
|
|
|
static char result[256];
|
|
|
|
int days, hours, mins, secs;
|
|
|
|
int first = 1;
|
|
|
|
char *p = result;
|
2003-10-17 11:46:40 +00:00
|
|
|
char *ep = &result[sizeof(result)];
|
|
|
|
int n;
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
days = total / 3600 / 24;
|
|
|
|
hours = (total / 3600) % 24;
|
|
|
|
mins = (total / 60) % 60;
|
|
|
|
secs = total % 60;
|
|
|
|
|
|
|
|
if (days) {
|
|
|
|
first = 0;
|
2003-10-17 11:46:40 +00:00
|
|
|
n = snprintf(p, ep - p, "%dd", days);
|
|
|
|
if (n < 0 || n >= ep - p)
|
|
|
|
return "?";
|
|
|
|
p += n;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
if (!first || hours) {
|
|
|
|
first = 0;
|
2003-10-17 11:46:40 +00:00
|
|
|
n = snprintf(p, ep - p, "%dh", hours);
|
|
|
|
if (n < 0 || n >= ep - p)
|
|
|
|
return "?";
|
|
|
|
p += n;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
|
|
|
if (!first || mins) {
|
|
|
|
first = 0;
|
2003-10-17 11:46:40 +00:00
|
|
|
n = snprintf(p, ep - p, "%dm", mins);
|
|
|
|
if (n < 0 || n >= ep - p)
|
|
|
|
return "?";
|
|
|
|
p += n;
|
2000-01-06 12:40:54 +00:00
|
|
|
}
|
2003-10-17 11:46:40 +00:00
|
|
|
snprintf(p, ep - p, "%ds", secs);
|
2000-01-06 12:40:54 +00:00
|
|
|
|
|
|
|
return(result);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Print the timestamp
|
|
|
|
* from tcpdump/util.c
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ts_print(tvp)
|
|
|
|
const struct timeval *tvp;
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
|
|
|
|
/* Default */
|
|
|
|
s = (tvp->tv_sec + thiszone) % 86400;
|
|
|
|
(void)printf("%02d:%02d:%02d.%06u ",
|
|
|
|
s / 3600, (s % 3600) / 60, s % 60, (u_int32_t)tvp->tv_usec);
|
|
|
|
}
|
This main goals of this project are:
1. separating L2 tables (ARP, NDP) from the L3 routing tables
2. removing as much locking dependencies among these layers as
possible to allow for some parallelism in the search operations
3. simplify the logic in the routing code,
The most notable end result is the obsolescent of the route
cloning (RTF_CLONING) concept, which translated into code reduction
in both IPv4 ARP and IPv6 NDP related modules, and size reduction in
struct rtentry{}. The change in design obsoletes the semantics of
RTF_CLONING, RTF_WASCLONE and RTF_LLINFO routing flags. The userland
applications such as "arp" and "ndp" have been modified to reflect
those changes. The output from "netstat -r" shows only the routing
entries.
Quite a few developers have contributed to this project in the
past: Glebius Smirnoff, Luigi Rizzo, Alessandro Cerri, and
Andre Oppermann. And most recently:
- Kip Macy revised the locking code completely, thus completing
the last piece of the puzzle, Kip has also been conducting
active functional testing
- Sam Leffler has helped me improving/refactoring the code, and
provided valuable reviews
- Julian Elischer setup the perforce tree for me and has helped
me maintaining that branch before the svn conversion
2008-12-15 06:10:57 +00:00
|
|
|
|
|
|
|
#undef NEXTADDR
|