1 /*
2 * This file and its contents are supplied under the terms of the
3 * Common Development and Distribution License ("CDDL"), version 1.0.
4 * You may only use this file in accordance with the terms of version
5 * 1.0 of the CDDL.
6 *
7 * A full copy of the text of the CDDL should have accompanied this
8 * source. A copy of the CDDL is also available via the Internet at
9 * http://www.illumos.org/license/CDDL.
10 */
11
12 /*
13 * Copyright 2015 Joyent, Inc. All rights reserved.
14 */
15
16 /*
17 * ndp - display and manipulate Neighbor Cache Entries from NDP
18 */
19
20 #include <stdio.h>
21 #include <stdarg.h>
22 #include <signal.h>
23 #include <time.h>
24 #include <err.h>
25 #include <errno.h>
26 #include <stdlib.h>
27 #include <strings.h>
28 #include <unistd.h>
29 #include <libgen.h>
30 #include <sys/ioctl.h>
31 #include <sys/types.h>
32 #include <wait.h>
33 #include <sys/mac.h>
34 #include <sys/socket.h>
35 #include <sys/sockio.h>
36 #include <netdb.h>
37 #include <net/if_types.h>
38 #include <netinet/in.h>
39 #include <arpa/inet.h>
40 #include <inet/ip.h>
41 #include <net/if_dl.h>
42 #include <net/route.h>
43
44 typedef struct sockaddr_in6 sin6_t;
45
46 #define BUF_SIZE 2048
47 typedef struct rtmsg_pkt {
48 struct rt_msghdr m_rtm;
49 char m_space[BUF_SIZE];
50 } rtmsg_pkt_t;
51
52 enum ndp_action {
53 NDP_A_DEFAULT,
54 NDP_A_GET, /* Show a single NDP entry */
55 NDP_A_GET_ALL, /* Show NDP entries */
56 NDP_A_GET_FOREVER, /* Repeatedly show entries */
57 NDP_A_DELETE, /* Delete an NDP entry */
58 NDP_A_SET_NCE, /* Set NDP entry */
59 NDP_A_SET_FILE /* Read in & set NDP entries */
60 };
61
62 typedef int (ndp_addr_f)(int, struct lifreq *, void *);
63 typedef void (ndp_void_f)(void);
64
65 static void ndp_usage(const char *, ...);
66 static void ndp_fatal(const char *, ...);
67 static void ndp_badflag(enum ndp_action);
68 static void ndp_missingarg(char);
69
70 static void ndp_run_in_child(ndp_void_f *);
71 static void ndp_do_run(void);
72 static void ndp_setup_handler(sigset_t *);
73 static void ndp_start_timer(time_t period);
74 static void ndp_run_periodically(time_t, ndp_void_f *);
75
76 static int ndp_salen(const struct sockaddr *sa);
77 static int ndp_extract_sockaddrs(struct rt_msghdr *, struct sockaddr **,
78 struct sockaddr **, struct sockaddr **, struct sockaddr **,
79 struct sockaddr_dl **);
80 static int ndp_rtmsg_get(int, rtmsg_pkt_t *, struct sockaddr *);
81 static int ndp_find_interface(int, struct sockaddr *, char *, int);
82
83 static int ndp_initialize_lifreq(int, struct lifreq *, struct sockaddr *);
84 static int ndp_host_enumerate(char *, ndp_addr_f *, void *);
85
86 static int ndp_display(struct lifreq *);
87 static int ndp_display_missing(struct lifreq *);
88 static void ndp_lifr2ip(struct lifreq *, char *, int);
89
90 static int ndp_get(int, struct lifreq *, void *);
91 static void ndp_get_all(void);
92 static int ndp_delete(int, struct lifreq *, void *);
93 static int ndp_set(int, struct lifreq *, void *);
94 static int ndp_set_nce(char *, char *, char *[], int);
95 static int ndp_set_file(char *);
96
97 static char *ndp_iface = NULL;
98 static char *netstat_path = "/usr/bin/netstat";
99 static pid_t ndp_pid;
100 static boolean_t ndp_noresolve = B_FALSE; /* Don't lookup addresses */
101 static boolean_t ndp_run = B_TRUE;
102
103 #define MAX_ATTEMPTS 5
104 #define MAX_OPTS 5
105 #define WORDSEPS " \t\r\n"
106
107 /*
108 * Macros borrowed from route(1M) for working with PF_ROUTE messages
109 */
110 #define RT_ADVANCE(x, n) ((x) += ndp_salen(n))
111 #define RT_NEXTADDR(cp, w, u) \
112 l = ndp_salen(u); \
113 (void) memmove(cp, u, l); \
114 cp += l;
115
116 /*
117 * Print an error to stderr and then exit non-zero.
118 */
119 static void
120 ndp_fatal(const char *format, ...)
121 {
122 va_list ap;
123
124 va_start(ap, format);
125 vwarnx(format, ap);
126 va_end(ap);
127 exit(EXIT_FAILURE);
128 }
129
130 /*
131 * Print out the command usage to stderr, along with any reason why it's being
132 * printed, and then exit non-zero.
133 */
134 static void
135 ndp_usage(const char *reason, ...)
136 {
137 va_list ap;
138 const char *ndp_progname = getprogname();
139
140 if (reason != NULL) {
141 va_start(ap, reason);
142 (void) fprintf(stderr, "%s: ", ndp_progname);
143 (void) vfprintf(stderr, reason, ap);
144 (void) fprintf(stderr, "\n");
145 va_end(ap);
146 }
147
148 (void) fprintf(stderr,
149 "Usage: %s [-n] [-i iface] hostname\n"
150 " %s [-n] [-i iface] -s nodeaddr etheraddr [temp] [proxy]\n"
151 " %s [-n] [-i iface] -d nodeaddr\n"
152 " %s [-n] [-i iface] -f filename\n"
153 " %s [-n] -a\n"
154 " %s [-n] -A period\n",
155 ndp_progname, ndp_progname, ndp_progname,
156 ndp_progname, ndp_progname, ndp_progname);
157 exit(EXIT_FAILURE);
158 }
159
160 static void
161 ndp_badflag(enum ndp_action action)
162 {
163 switch (action) {
164 case NDP_A_DEFAULT:
165 case NDP_A_GET:
166 ndp_usage("Already going to print an entry, "
167 "but extra -%c given", optopt);
168 break;
169 case NDP_A_GET_ALL:
170 ndp_usage("Already going to print all entries (-a), "
171 "but extra -%c given", optopt);
172 break;
173 case NDP_A_GET_FOREVER:
174 ndp_usage("Already going to repeatedly print all entries (-A), "
175 "but extra -%c given", optopt);
176 break;
177 case NDP_A_DELETE:
178 ndp_usage("Already going to delete an entry (-d), "
179 "but extra -%c given", optopt);
180 break;
181 case NDP_A_SET_NCE:
182 ndp_usage("Already going to set an entry (-s), "
183 "but extra -%c given", optopt);
184 break;
185 case NDP_A_SET_FILE:
186 ndp_usage("Already going to set from file (-f), "
187 "but extra -%c given", optopt);
188 break;
189 }
190 }
191
192 static void
193 ndp_missingarg(char flag)
194 {
195 switch (flag) {
196 case 'A':
197 ndp_usage("Missing time period after -%c", flag);
198 break;
199 case 'd':
200 ndp_usage("Missing node name after -%c", flag);
201 break;
202 case 'f':
203 ndp_usage("Missing filename after -%c", flag);
204 break;
205 case 's':
206 ndp_usage("Missing node name after -%c", flag);
207 break;
208 case 'i':
209 ndp_usage("Missing interface name after -%c", flag);
210 break;
211 default:
212 ndp_usage("Missing option argument after -%c", flag);
213 break;
214 }
215 }
216
217 /*
218 * Run a function that's going to exec in a child process, and don't return
219 * until it exits.
220 */
221 static void
222 ndp_run_in_child(ndp_void_f *func)
223 {
224 pid_t child_pid;
225 int childstat = 0, status = 0;
226
227 child_pid = fork();
228 if (child_pid == (pid_t)-1) {
229 ndp_fatal("Unable to fork: %s", strerror(errno));
230 } else if (child_pid == (pid_t)0) {
231 func();
232 exit(EXIT_FAILURE);
233 }
234
235 while (waitpid(child_pid, &childstat, 0) == -1) {
236 if (errno == EINTR)
237 continue;
238
239 ndp_fatal("Failed to wait on child: %s", strerror(errno));
240 }
241
242 status = WEXITSTATUS(childstat);
243 if (status != 0) {
244 ndp_fatal("Child process exited with %d", status);
245 }
246 }
247
248 /*
249 * SIGALRM handler to schedule a run.
250 */
251 static void
252 ndp_do_run(void)
253 {
254 ndp_run = B_TRUE;
255 }
256
257
258 /*
259 * Prepare signal masks, and install the SIGALRM handler. Return old signal
260 * masks through the first argument.
261 */
262 static void
263 ndp_setup_handler(sigset_t *oset)
264 {
265 struct sigaction sa;
266
267 /*
268 * Mask off SIGALRM so we only trigger the handler when we're ready
269 * using sigsuspend(3C), in case the child process takes longer to
270 * run than the alarm interval.
271 */
272 if (sigprocmask(0, NULL, oset) != 0) {
273 ndp_fatal("Unable to set signal mask: %s", strerror(errno));
274 }
275
276 if (sighold(SIGALRM) != 0) {
277 ndp_fatal("Unable to add SIGALRM to signal mask: %s",
278 strerror(errno));
279 }
280
281 sa.sa_flags = 0;
282 sa.sa_handler = ndp_do_run;
283
284 if (sigemptyset(&sa.sa_mask) != 0) {
285 ndp_fatal("Unable to prepare empty signal set: %s",
286 strerror(errno));
287 }
288
289 if (sigaction(SIGALRM, &sa, NULL) != 0) {
290 ndp_fatal("Unable to install timer handler: %s",
291 strerror(errno));
292 }
293 }
294
295 /*
296 * Start the printing timer.
297 */
298 static void
299 ndp_start_timer(time_t period)
300 {
301 timer_t timer;
302 struct itimerspec interval;
303 interval.it_value.tv_sec = interval.it_interval.tv_sec = period;
304 interval.it_value.tv_nsec = interval.it_interval.tv_nsec = 0;
305
306 if (timer_create(CLOCK_REALTIME, NULL, &timer) != 0) {
307 ndp_fatal("Unable to create timer: %s", strerror(errno));
308 }
309
310 if (timer_settime(timer, 0, &interval, NULL) != 0) {
311 ndp_fatal("Unable to set time on timer: %s", strerror(errno));
312 }
313 }
314
315
316 /*
317 * Run a given function forever periodically in a child process.
318 */
319 static void
320 ndp_run_periodically(time_t period, ndp_void_f *func)
321 {
322 sigset_t oset;
323
324 ndp_setup_handler(&oset);
325 ndp_start_timer(period);
326
327 do {
328 if (ndp_run) {
329 ndp_run = B_FALSE;
330 ndp_run_in_child(func);
331 }
332 (void) sigsuspend(&oset);
333 } while (errno == EINTR);
334
335 /*
336 * Only an EFAULT should get us here. Abort so we get a core dump.
337 */
338 warnx("Failure while waiting on timer: %s", strerror(errno));
339 abort();
340 }
341
342 /*
343 * Given an address, return its size.
344 */
345 static int
346 ndp_salen(const struct sockaddr *sa)
347 {
348 switch (sa->sa_family) {
349 case AF_INET:
350 return (sizeof (struct sockaddr_in));
351 case AF_LINK:
352 return (sizeof (struct sockaddr_dl));
353 case AF_INET6:
354 return (sizeof (struct sockaddr_in6));
355 default:
356 warnx("Unrecognized sockaddr with address family %d!",
357 sa->sa_family);
358 abort();
359 }
360 /*NOTREACHED*/
361 }
362
363 /*
364 * Extract all socket addresses from a routing message, and return them
365 * through the pointers given as arguments to ndp_extract_sockaddrs. None
366 * of the pointers should be null.
367 */
368 static int
369 ndp_extract_sockaddrs(struct rt_msghdr *rtm, struct sockaddr **dst,
370 struct sockaddr **gate, struct sockaddr **mask, struct sockaddr **src,
371 struct sockaddr_dl **ifp)
372 {
373 struct sockaddr *sa;
374 char *cp;
375 int i;
376
377 if (rtm->rtm_version != RTM_VERSION) {
378 warnx("Routing message version %d not understood",
379 rtm->rtm_version);
380 return (-1);
381 }
382
383 if (rtm->rtm_errno != 0) {
384 warnx("Routing message couldn't be processed: %s",
385 strerror(rtm->rtm_errno));
386 return (-1);
387 }
388
389 cp = ((char *)(rtm + 1));
390 if (rtm->rtm_addrs != 0) {
391 for (i = 1; i != 0; i <<= 1) {
392 if ((i & rtm->rtm_addrs) == 0)
393 continue;
394
395 /*LINTED*/
396 sa = (struct sockaddr *)cp;
397 switch (i) {
398 case RTA_DST:
399 *dst = sa;
400 break;
401 case RTA_GATEWAY:
402 *gate = sa;
403 break;
404 case RTA_NETMASK:
405 *mask = sa;
406 break;
407 case RTA_IFP:
408 if (sa->sa_family == AF_LINK &&
409 ((struct sockaddr_dl *)sa)->sdl_nlen != 0)
410 *ifp = (struct sockaddr_dl *)sa;
411 break;
412 case RTA_SRC:
413 *src = sa;
414 break;
415 }
416 RT_ADVANCE(cp, sa);
417 }
418 }
419
420 return (0);
421 }
422
423 /*
424 * Given an IPv6 address, use routing information to look up
425 * the destination and interface it would pass through.
426 */
427 static int
428 ndp_rtmsg_get(int fd, rtmsg_pkt_t *msg, struct sockaddr *sin6p)
429 {
430 static int seq = 0;
431 struct sockaddr_dl sdl;
432 int mlen, l;
433 char ipaddr[INET6_ADDRSTRLEN];
434 char *cp = msg->m_space;
435 struct rt_msghdr *m_rtm = &msg->m_rtm;
436
437 bzero(msg, sizeof (rtmsg_pkt_t));
438 bzero(&sdl, sizeof (struct sockaddr_dl));
439
440 m_rtm->rtm_type = RTM_GET;
441 m_rtm->rtm_version = RTM_VERSION;
442 m_rtm->rtm_seq = ++seq;
443 m_rtm->rtm_addrs = RTA_DST | RTA_IFP;
444 m_rtm->rtm_msglen = sizeof (rtmsg_pkt_t);
445
446 /* Place the address we're looking up after the header */
447 RT_NEXTADDR(cp, RTA_DST, sin6p);
448
449 /* Load an empty link-level address, so we get an interface back */
450 sdl.sdl_family = AF_LINK;
451 RT_NEXTADDR(cp, RTA_IFP, (struct sockaddr *)&sdl);
452
453 m_rtm->rtm_msglen = cp - (char *)msg;
454
455 if ((mlen = write(fd, (char *)msg, m_rtm->rtm_msglen)) < 0) {
456 if (errno == ESRCH) {
457 /*LINTED*/
458 if (inet_ntop(AF_INET6, &((sin6_t *)sin6p)->sin6_addr,
459 ipaddr, sizeof (ipaddr)) == NULL) {
460 (void) snprintf(ipaddr, sizeof (ipaddr),
461 "(failed to format IP)");
462 };
463 warnx("An appropriate interface for the address %s "
464 "is not in the routing table; use -i to force an "
465 "interface", ipaddr);
466 return (-1);
467 } else {
468 warnx("Failed to send routing message: %s",
469 strerror(errno));
470 return (-1);
471 }
472 } else if (mlen < (int)m_rtm->rtm_msglen) {
473 warnx("Failed to write all bytes to routing socket");
474 return (-1);
475 }
476
477 /*
478 * Keep reading routing messages until we find the response to the one
479 * we just sent. Note that we depend on the sequence number being unique
480 * to the running program.
481 */
482 do {
483 mlen = read(fd, (char *)msg, sizeof (rtmsg_pkt_t));
484 } while (mlen > 0 &&
485 (m_rtm->rtm_seq != seq || m_rtm->rtm_pid != ndp_pid));
486 if (mlen < 0) {
487 warnx("Failed to read from routing socket: %s",
488 strerror(errno));
489 return (-1);
490 }
491
492 return (0);
493 }
494
495 /*
496 * Find the interface that the IPv6 address would be routed through, and store
497 * the name of the interface in the buffer passed in.
498 */
499 static int
500 ndp_find_interface(int fd, struct sockaddr *sin6p, char *buf, int buflen)
501 {
502 struct sockaddr *dst = NULL, *gate = NULL, *mask = NULL, *src = NULL;
503 struct sockaddr_dl *ifp = NULL;
504 rtmsg_pkt_t msg;
505
506 if (ndp_rtmsg_get(fd, &msg, sin6p) != 0) {
507 return (-1);
508 }
509
510 if (ndp_extract_sockaddrs(&msg.m_rtm, &dst, &gate,
511 &mask, &src, &ifp) != 0) {
512 return (-1);
513 }
514
515 if (ifp == NULL) {
516 warnx("Unable to find appropriate interface for address");
517 return (-1);
518 } else {
519 if (ifp->sdl_nlen >= buflen) {
520 warnx("The interface name \"%.*s\" is too big for the "
521 "available buffer", ifp->sdl_nlen, ifp->sdl_data);
522 return (-1);
523 } else {
524 (void) snprintf(buf, buflen, "%.*s", ifp->sdl_nlen,
525 ifp->sdl_data);
526 }
527 }
528
529 return (0);
530 }
531
532 /*
533 * Zero out a lifreq struct for a SIOCLIF*ND ioctl, set the address, and fetch
534 * the appropriate interface using the given routing socket.
535 */
536 static int
537 ndp_initialize_lifreq(int route, struct lifreq *lifrp, struct sockaddr *sap)
538 {
539 struct sockaddr_storage *lnr_addr;
540 /* LINTED E_BAD_PTR_CAST_ALIGN */
541 struct sockaddr_in6 *sin6p = (sin6_t *)sap;
542 char *lifr_name = lifrp->lifr_name;
543
544 bzero(lifrp, sizeof (struct lifreq));
545 lnr_addr = &lifrp->lifr_nd.lnr_addr;
546
547 if (ndp_iface != NULL) {
548 (void) strlcpy(lifr_name, ndp_iface, LIFNAMSIZ);
549 } else if (sin6p->sin6_scope_id != 0) {
550 int zone_id = sin6p->sin6_scope_id;
551 if (if_indextoname(zone_id, lifr_name) == NULL) {
552 warnx("Invalid zone identifier: %d", zone_id);
553 return (-1);
554 }
555 } else if (IN6_IS_ADDR_LINKSCOPE(&sin6p->sin6_addr)) {
556 warnx("Link-scope addresses should specify an interface with "
557 "a zone ID, or with -i.");
558 return (-1);
559 } else {
560 if (ndp_find_interface(route, sap, lifr_name, LIFNAMSIZ) != 0)
561 return (-1);
562 }
563
564 (void) memcpy(lnr_addr, sap, sizeof (struct sockaddr_storage));
565
566 return (0);
567 }
568
569 /*
570 * Take a host identifier, find the corresponding IPv6 addresses and then pass
571 * them to the specified function, along with any desired data.
572 */
573 static int
574 ndp_host_enumerate(char *host, ndp_addr_f *addr_func, void *data)
575 {
576 struct lifreq lifr;
577 struct addrinfo hints, *serverinfo, *p;
578 int err, attempts = 0;
579 int inet6, route;
580
581 bzero(&hints, sizeof (struct addrinfo));
582 hints.ai_family = AF_INET6;
583 hints.ai_protocol = IPPROTO_IPV6;
584
585 while (attempts < MAX_ATTEMPTS) {
586 err = getaddrinfo(host, NULL, &hints, &serverinfo);
587
588 if (err == 0) {
589 break;
590 } else if (err == EAI_AGAIN) {
591 attempts++;
592 } else {
593 warnx("Unable to lookup %s: %s", host,
594 gai_strerror(err));
595 return (-1);
596 }
597 }
598
599 if (attempts == MAX_ATTEMPTS) {
600 warnx("Failed multiple times to lookup %s", host);
601 return (-1);
602 }
603
604 inet6 = socket(PF_INET6, SOCK_DGRAM, 0);
605 if (inet6 < 0) {
606 warnx("Failed to open IPv6 socket: %s", strerror(errno));
607 err = -1;
608 }
609
610 route = socket(PF_ROUTE, SOCK_RAW, 0);
611 if (route < 0) {
612 warnx("Failed to open routing socket: %s", strerror(errno));
613 err = -1;
614 }
615
616 if (err == 0) {
617 for (p = serverinfo; p != NULL; p = p->ai_next) {
618 if (ndp_initialize_lifreq(route, &lifr, p->ai_addr)
619 != 0) {
620 err = -1;
621 continue;
622 }
623
624 if (addr_func(inet6, &lifr, data) != 0) {
625 err = -1;
626 continue;
627 }
628 }
629 }
630
631 if (close(route) != 0) {
632 warnx("Failed to close routing socket: %s", strerror(errno));
633 err = -1;
634 }
635
636 if (close(inet6) != 0) {
637 warnx("Failed to close IPv6 socket: %s", strerror(errno));
638 err = -1;
639 }
640
641 /* Clean up linked list */
642 freeaddrinfo(serverinfo);
643
644 return (err);
645 }
646
647 static int
648 ndp_display(struct lifreq *lifrp)
649 {
650 struct sockaddr_in6 *lnr_addr;
651 char ipaddr[INET6_ADDRSTRLEN];
652 char *lladdr = NULL;
653 char hostname[NI_MAXHOST];
654 int flags, gni_flags;
655
656 lnr_addr = (struct sockaddr_in6 *)&lifrp->lifr_nd.lnr_addr;
657 flags = lifrp->lifr_nd.lnr_flags;
658
659 if (inet_ntop(AF_INET6, &lnr_addr->sin6_addr, ipaddr,
660 sizeof (ipaddr)) == NULL) {
661 warnx("Couldn't convert IPv6 address to string: %s",
662 strerror(errno));
663 return (-1);
664 };
665
666 if ((lladdr = _link_ntoa((uchar_t *)lifrp->lifr_nd.lnr_hdw_addr,
667 NULL, lifrp->lifr_nd.lnr_hdw_len, IFT_ETHER)) == NULL) {
668 warnx("Couldn't convert link-layer address to string: %s",
669 strerror(errno));
670 return (-1);
671 }
672
673 gni_flags = ndp_noresolve ? NI_NUMERICHOST : 0;
674
675 if (getnameinfo((struct sockaddr *)lnr_addr, sizeof (sin6_t), hostname,
676 sizeof (hostname), NULL, 0, gni_flags) != 0) {
677 warnx("Unable to lookup hostname for %s", ipaddr);
678 free(lladdr);
679 return (-1);
680 }
681
682 (void) printf("%s (%s) at %s", ipaddr, hostname, lladdr);
683
684 if (flags & NDF_ISROUTER_ON) {
685 (void) printf(" router");
686 }
687
688 if (flags & NDF_ANYCAST_ON) {
689 (void) printf(" any");
690 }
691
692 if (!(flags & NDF_STATIC)) {
693 (void) printf(" temp");
694 }
695
696 if (flags & NDF_PROXY_ON) {
697 (void) printf(" proxy");
698 }
699
700 (void) printf("\n");
701
702 free(lladdr);
703 return (0);
704 }
705
706 static int
707 ndp_display_missing(struct lifreq *lifrp)
708 {
709 struct sockaddr_in6 *lnr_addr;
710 char ipaddr[INET6_ADDRSTRLEN];
711 char hostname[NI_MAXHOST];
712 int flags = ndp_noresolve ? NI_NUMERICHOST : 0;
713 lnr_addr = (struct sockaddr_in6 *)&lifrp->lifr_nd.lnr_addr;
714
715 if (inet_ntop(AF_INET6, &lnr_addr->sin6_addr, ipaddr,
716 sizeof (ipaddr)) == NULL) {
717 warnx("Couldn't convert IPv6 address to string: %s",
718 strerror(errno));
719 return (-1);
720 };
721
722 if (getnameinfo((struct sockaddr *)lnr_addr, sizeof (sin6_t), hostname,
723 sizeof (hostname), NULL, 0, flags) != 0) {
724 warnx("Unable to lookup hostname for %s", ipaddr);
725 return (-1);
726 }
727
728 (void) printf("%s (%s) -- no entry\n", ipaddr, hostname);
729 return (0);
730 }
731
732 static void
733 ndp_lifr2ip(struct lifreq *lifrp, char *ipaddr, int buflen)
734 {
735 sin6_t *lnr_addr = (sin6_t *)&lifrp->lifr_nd.lnr_addr;
736 if (inet_ntop(AF_INET6, &lnr_addr->sin6_addr, ipaddr,
737 buflen) == NULL) {
738 (void) snprintf(ipaddr, buflen, "(failed to format IP)");
739 };
740 }
741
742 /*
743 * Perform a SIOCLIFGETND and print out information about it
744 */
745 /*ARGSUSED*/
746 static int
747 ndp_get(int fd, struct lifreq *lifrp, void *unused)
748 {
749 char ipaddr[INET6_ADDRSTRLEN];
750 if (ioctl(fd, SIOCLIFGETND, lifrp) < 0) {
751 if (errno == ESRCH) {
752 return (ndp_display_missing(lifrp));
753 } else {
754 ndp_lifr2ip(lifrp, ipaddr, sizeof (ipaddr));
755 warnx("Couldn't lookup %s: %s",
756 ipaddr, strerror(errno));
757 return (-1);
758 }
759 }
760
761 return (ndp_display(lifrp));
762 }
763
764 /*
765 * Print out all NDP entries
766 */
767 static void
768 ndp_get_all(void)
769 {
770 (void) execl(netstat_path, "netstat",
771 (ndp_noresolve ? "-np" : "-p"),
772 "-f", "inet6", (char *)0);
773 ndp_fatal("Coudn't exec %s: %s", netstat_path, strerror(errno));
774 }
775
776 /*
777 * Perform a SIOCLIFDELND ioctl
778 */
779 /*ARGSUSED*/
780 static int
781 ndp_delete(int fd, struct lifreq *lifrp, void *unused)
782 {
783 char ipaddr[INET6_ADDRSTRLEN];
784
785 if (ioctl(fd, SIOCLIFDELND, lifrp) < 0) {
786 ndp_lifr2ip(lifrp, ipaddr, sizeof (ipaddr));
787 if (errno == ESRCH) {
788 warnx("No entry for %s", ipaddr);
789 return (-1);
790 } else if (errno == EPERM) {
791 warnx("Permission denied, "
792 "could not delete entry for %s", ipaddr);
793 return (-1);
794 } else {
795 warnx("Couldn't delete mapping for %s: %s",
796 ipaddr, strerror(errno));
797 return (-1);
798 }
799 }
800
801 return (0);
802 }
803
804 /*
805 * Perform a SIOCLIFSETND ioctl using properties from the example structure.
806 */
807 static int
808 ndp_set(int fd, struct lifreq *lifrp, void *data)
809 {
810 char ipaddr[INET6_ADDRSTRLEN];
811 const lif_nd_req_t *nd_attrs = data;
812
813 (void) memcpy(lifrp->lifr_nd.lnr_hdw_addr, nd_attrs->lnr_hdw_addr,
814 ND_MAX_HDW_LEN);
815 lifrp->lifr_nd.lnr_hdw_len = nd_attrs->lnr_hdw_len;
816 lifrp->lifr_nd.lnr_flags = nd_attrs->lnr_flags;
817
818 lifrp->lifr_nd.lnr_state_create = nd_attrs->lnr_state_create;
819 lifrp->lifr_nd.lnr_state_same_lla = nd_attrs->lnr_state_same_lla;
820 lifrp->lifr_nd.lnr_state_diff_lla = nd_attrs->lnr_state_diff_lla;
821
822 if (ioctl(fd, SIOCLIFSETND, lifrp) < 0) {
823 ndp_lifr2ip(lifrp, ipaddr, sizeof (ipaddr));
824 if (errno == EPERM) {
825 warnx("Permission denied, "
826 "could not set entry for %s", ipaddr);
827 return (-1);
828 } else {
829 warnx("Failed to set mapping for %s: %s",
830 ipaddr, strerror(errno));
831 return (-1);
832 }
833 }
834
835 return (0);
836 }
837
838 /*
839 * Given a host identifier, a link-layer address and possible options,
840 * add/update the NDP mappings.
841 */
842 static int
843 ndp_set_nce(char *host, char *lladdr, char *opts[], int optlen)
844 {
845 lif_nd_req_t nd_attrs;
846 uchar_t *ea;
847 char *opt;
848 int i;
849 boolean_t temp = B_FALSE;
850 boolean_t any = B_FALSE;
851 boolean_t router = B_FALSE;
852
853 bzero(&nd_attrs, sizeof (lif_nd_req_t));
854
855 ea = _link_aton(lladdr, &nd_attrs.lnr_hdw_len);
856
857 if (ea == NULL) {
858 warnx("Unable to parse link-layer address \"%s\"", lladdr);
859 return (-1);
860 }
861
862 if (nd_attrs.lnr_hdw_len > sizeof (nd_attrs.lnr_hdw_addr)) {
863 warnx("The size of the link-layer address is "
864 "too large to set\n");
865 free(ea);
866 return (-1);
867 }
868
869 (void) memcpy(nd_attrs.lnr_hdw_addr, ea, nd_attrs.lnr_hdw_len);
870
871 free(ea);
872
873 nd_attrs.lnr_state_create = ND_REACHABLE;
874 nd_attrs.lnr_state_same_lla = ND_UNCHANGED;
875 nd_attrs.lnr_state_diff_lla = ND_STALE;
876
877 for (i = 0; i < optlen; i++) {
878 opt = opts[i];
879 if (strcmp(opt, "temp") == 0) {
880 temp = B_TRUE;
881 } else if (strcmp(opt, "any") == 0) {
882 any = B_TRUE;
883 } else if (strcmp(opt, "router") == 0) {
884 router = B_TRUE;
885 } else if (strcmp(opt, "proxy") == 0) {
886 warnx("NDP proxying is currently not supported");
887 return (-1);
888 } else {
889 warnx("Unrecognized option \"%s\"", opt);
890 return (-1);
891 }
892 }
893
894 if (!temp) {
895 nd_attrs.lnr_flags |= NDF_STATIC;
896 }
897
898 if (any) {
899 nd_attrs.lnr_flags |= NDF_ANYCAST_ON;
900 } else {
901 nd_attrs.lnr_flags |= NDF_ANYCAST_OFF;
902 }
903
904 if (router) {
905 nd_attrs.lnr_flags |= NDF_ISROUTER_OFF;
906 } else {
907 nd_attrs.lnr_flags |= NDF_ISROUTER_OFF;
908 }
909
910 return (ndp_host_enumerate(host, ndp_set, &nd_attrs));
911 }
912
913 /*
914 * Read in a file and set the mappings from each line.
915 */
916 static int
917 ndp_set_file(char *filename)
918 {
919 char *line = NULL, *lasts = NULL, *curr;
920 char *host, *lladdr;
921 char *opts[MAX_OPTS];
922 int optlen = 0, lineno = 0;
923 size_t cap = 0;
924 boolean_t failed_line = B_FALSE;
925 FILE *stream = fopen(filename, "r");
926
927 if (stream == NULL) {
928 ndp_fatal("Error while opening file %s: %s",
929 filename, strerror(errno));
930 }
931
932 errno = 0;
933 while (getline(&line, &cap, stream) != -1) {
934 lineno++;
935
936 if (line[0] == '#')
937 continue;
938
939 host = strtok_r(line, WORDSEPS, &lasts);
940 if (host == NULL) {
941 warnx("Line %d incomplete, skipping: "
942 "missing host identifier", lineno);
943 failed_line = B_TRUE;
944 continue;
945 }
946
947 lladdr = strtok_r(NULL, WORDSEPS, &lasts);
948 if (lladdr == NULL) {
949 warnx("Line %d incomplete, skipping: "
950 "missing link-layer address", lineno);
951 failed_line = B_TRUE;
952 continue;
953 }
954
955 for (optlen = 0; optlen < MAX_OPTS; optlen++) {
956 curr = strtok_r(NULL, WORDSEPS, &lasts);
957 if (curr == NULL)
958 break;
959 opts[optlen] = curr;
960 }
961
962 if (ndp_set_nce(host, lladdr, opts, optlen) != 0) {
963 failed_line = B_TRUE;
964 continue;
965 }
966 }
967
968 free(line);
969
970 if (errno != 0 || ferror(stream)) {
971 ndp_fatal("Error while reading from file %s: %s", filename,
972 strerror(errno));
973 }
974
975 if (fclose(stream) != 0) {
976 ndp_fatal("Error close file %s: %s", filename, strerror(errno));
977 }
978
979 return (failed_line ? -1 : 0);
980 }
981
982 int
983 main(int argc, char *argv[])
984 {
985 char *flagarg = NULL, *lladdr = NULL;
986 char **opts;
987 char *endptr;
988 int c, argsleft, optlen = 0, err = 0;
989 long long period;
990 enum ndp_action action = NDP_A_DEFAULT;
991
992 setprogname(basename(argv[0]));
993
994 if (argc < 2) {
995 ndp_usage("No arguments given.");
996 }
997
998 while ((c = getopt(argc, argv, ":naA:d:f:i:s:")) != -1) {
999 switch (c) {
1000 case 'n':
1001 ndp_noresolve = B_TRUE;
1002 break;
1003 case 'i':
1004 ndp_iface = optarg;
1005 break;
1006 case 's':
1007 if (action != NDP_A_DEFAULT)
1008 ndp_badflag(action);
1009 action = NDP_A_SET_NCE;
1010 flagarg = optarg;
1011
1012 if ((argc - optind) < 1) {
1013 ndp_usage("Missing link-layer address after "
1014 "the node address, \"%s\"", flagarg);
1015 }
1016 lladdr = argv[optind++];
1017
1018 /*
1019 * Grab any following keywords up to the next flag
1020 */
1021 opts = argv + optind;
1022 while ((argc - optind) > 0) {
1023 if (argv[optind][0] == '-')
1024 ndp_usage("Encountered \"%s\" after "
1025 "flag parsing is done",
1026 argv[optind]);
1027 optind++;
1028 optlen++;
1029 }
1030 break;
1031 case 'a':
1032 if (action != NDP_A_DEFAULT)
1033 ndp_badflag(action);
1034 action = NDP_A_GET_ALL;
1035 break;
1036 case 'A':
1037 if (action != NDP_A_DEFAULT)
1038 ndp_badflag(action);
1039 action = NDP_A_GET_FOREVER;
1040 flagarg = optarg;
1041 break;
1042 case 'd':
1043 if (action != NDP_A_DEFAULT)
1044 ndp_badflag(action);
1045 action = NDP_A_DELETE;
1046 flagarg = optarg;
1047 break;
1048 case 'f':
1049 if (action != NDP_A_DEFAULT)
1050 ndp_badflag(action);
1051 action = NDP_A_SET_FILE;
1052 flagarg = optarg;
1053 break;
1054 case ':':
1055 ndp_missingarg(optopt);
1056 break;
1057 case '?':
1058 ndp_usage("Unrecognized flag \"-%c\"", optopt);
1059 default:
1060 ndp_usage(NULL);
1061 }
1062 }
1063
1064 argsleft = argc - optind;
1065 ndp_pid = getpid();
1066
1067 if (action != NDP_A_DEFAULT && argsleft != 0) {
1068 ndp_usage("Extra arguments leftover after parsing flags");
1069 }
1070
1071 switch (action) {
1072 case NDP_A_DEFAULT:
1073 case NDP_A_GET:
1074 if (argsleft != 1) {
1075 ndp_usage("Multiple arguments given without any flags");
1076 }
1077 err = ndp_host_enumerate(argv[optind], ndp_get, NULL);
1078 break;
1079 case NDP_A_GET_ALL:
1080 ndp_get_all();
1081 /*NOTREACHED*/
1082 break;
1083 case NDP_A_GET_FOREVER:
1084 errno = 0;
1085 period = strtoll(flagarg, &endptr, 10);
1086 if ((period == 0 && errno != 0) ||
1087 (endptr[0] != '\0') ||
1088 (period < 0)) {
1089 ndp_usage("Given period should be a positive integer,"
1090 " not \"%s\"", flagarg);
1091 }
1092 if (period > 86400) {
1093 ndp_usage("Given period should be shorter than a day;"
1094 " given \"%s\" seconds", flagarg);
1095 }
1096 ndp_run_periodically(period, ndp_get_all);
1097 /*NOTREACHED*/
1098 break;
1099 case NDP_A_DELETE:
1100 err = ndp_host_enumerate(flagarg, ndp_delete, NULL);
1101 break;
1102 case NDP_A_SET_NCE:
1103 err = ndp_set_nce(flagarg, lladdr, opts, optlen);
1104 break;
1105 case NDP_A_SET_FILE:
1106 err = ndp_set_file(flagarg);
1107 break;
1108 }
1109
1110 return (err == 0 ? 0 : 1);
1111 }