ifmcstat.c revision 237256 
1/*	$KAME: ifmcstat.c,v 1.48 2006/11/15 05:13:59 itojun Exp $	*/
2
3/*
4 * Copyright (c) 2007-2009 Bruce Simpson.
5 * Copyright (C) 1995, 1996, 1997, and 1998 WIDE Project.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 * 3. Neither the name of the project nor the names of its contributors
17 *    may be used to endorse or promote products derived from this software
18 *    without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
24 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD: head/usr.sbin/ifmcstat/ifmcstat.c 237256 2012-06-19 06:10:27Z eadler $");
35
36#include <sys/types.h>
37#include <sys/param.h>
38#include <sys/sysctl.h>
39#include <sys/socket.h>
40#include <sys/queue.h>
41#include <sys/tree.h>
42
43#include <net/if.h>
44#include <net/if_var.h>
45#include <net/if_types.h>
46#include <net/if_dl.h>
47#include <net/route.h>
48
49#include <netinet/in.h>
50#include <netinet/in_var.h>
51#include <netinet/in_systm.h>
52#include <netinet/ip.h>
53#include <netinet/igmp.h>
54#define KERNEL
55# include <netinet/if_ether.h>
56#undef KERNEL
57#define _KERNEL
58#define SYSCTL_DECL(x)
59# include <netinet/igmp_var.h>
60#undef SYSCTL_DECL
61#undef _KERNEL
62
63#ifdef INET6
64#include <netinet/icmp6.h>
65#define _KERNEL
66# include <netinet6/mld6_var.h>
67#undef _KERNEL
68#endif /* INET6 */
69
70#include <arpa/inet.h>
71#include <netdb.h>
72
73#include <stddef.h>
74#include <stdarg.h>
75#include <stdint.h>
76#include <stdio.h>
77#include <stdlib.h>
78#include <string.h>
79
80#include <ctype.h>
81#include <err.h>
82#include <errno.h>
83#include <fcntl.h>
84#include <kvm.h>
85#include <limits.h>
86#include <ifaddrs.h>
87#include <nlist.h>
88#include <sysexits.h>
89#include <unistd.h>
90
91/* XXX: This file currently assumes INET and KVM support in the base system. */
92#ifndef INET
93#define INET
94#endif
95
96extern void	printb(const char *, unsigned int, const char *);
97
98union sockunion {
99	struct sockaddr_storage	ss;
100	struct sockaddr		sa;
101	struct sockaddr_dl	sdl;
102#ifdef INET
103	struct sockaddr_in	sin;
104#endif
105#ifdef INET6
106	struct sockaddr_in6	sin6;
107#endif
108};
109typedef union sockunion sockunion_t;
110
111uint32_t	ifindex = 0;
112int		af = AF_UNSPEC;
113#ifdef WITH_KVM
114int		Kflag = 0;
115#endif
116int		vflag = 0;
117
118#define	sa_equal(a1, a2)	\
119	(bcmp((a1), (a2), ((a1))->sa_len) == 0)
120
121#define	sa_dl_equal(a1, a2)	\
122	((((struct sockaddr_dl *)(a1))->sdl_len ==			\
123	 ((struct sockaddr_dl *)(a2))->sdl_len) &&			\
124	 (bcmp(LLADDR((struct sockaddr_dl *)(a1)),			\
125	       LLADDR((struct sockaddr_dl *)(a2)),			\
126	       ((struct sockaddr_dl *)(a1))->sdl_alen) == 0))
127
128/*
129 * Most of the code in this utility is to support the use of KVM for
130 * post-mortem debugging of the multicast code.
131 */
132#ifdef WITH_KVM
133
134#ifdef INET
135static void		if_addrlist(struct ifaddr *);
136static struct in_multi *
137			in_multientry(struct in_multi *);
138#endif /* INET */
139
140#ifdef INET6
141static void		if6_addrlist(struct ifaddr *);
142static struct in6_multi *
143			in6_multientry(struct in6_multi *);
144#endif /* INET6 */
145
146static void		kread(u_long, void *, int);
147static void		ll_addrlist(struct ifaddr *);
148
149static int		ifmcstat_kvm(const char *kernel, const char *core);
150
151#define	KREAD(addr, buf, type) \
152	kread((u_long)addr, (void *)buf, sizeof(type))
153
154kvm_t	*kvmd;
155struct	nlist nl[] = {
156	{ "_ifnet", 0, 0, 0, 0, },
157	{ "", 0, 0, 0, 0, },
158};
159#define	N_IFNET	0
160
161#endif /* WITH_KVM */
162
163static int		ifmcstat_getifmaddrs(void);
164#ifdef INET
165static void		in_ifinfo(struct igmp_ifinfo *);
166static const char *	inm_mode(u_int mode);
167#endif
168#ifdef INET6
169static void		in6_ifinfo(struct mld_ifinfo *);
170static const char *	inet6_n2a(struct in6_addr *);
171#endif
172int			main(int, char **);
173
174static void
175usage()
176{
177
178	fprintf(stderr,
179	    "usage: ifmcstat [-i interface] [-f address family]"
180	    " [-v]"
181#ifdef WITH_KVM
182	    " [-K] [-M core] [-N system]"
183#endif
184	    "\n");
185	exit(EX_USAGE);
186}
187
188static const char *options = "i:f:vM:N:"
189#ifdef WITH_KVM
190	"K"
191#endif
192	;
193
194int
195main(int argc, char **argv)
196{
197	int c, error;
198#ifdef WITH_KVM
199	const char *kernel = NULL;
200	const char *core = NULL;
201#endif
202
203	while ((c = getopt(argc, argv, options)) != -1) {
204		switch (c) {
205		case 'i':
206			if ((ifindex = if_nametoindex(optarg)) == 0) {
207				fprintf(stderr, "%s: unknown interface\n",
208				    optarg);
209				exit(EX_NOHOST);
210			}
211			break;
212
213		case 'f':
214#ifdef INET
215			if (strcmp(optarg, "inet") == 0) {
216				af = AF_INET;
217				break;
218			}
219#endif
220#ifdef INET6
221			if (strcmp(optarg, "inet6") == 0) {
222				af = AF_INET6;
223				break;
224			}
225#endif
226			if (strcmp(optarg, "link") == 0) {
227				af = AF_LINK;
228				break;
229			}
230			fprintf(stderr, "%s: unknown address family\n", optarg);
231			exit(EX_USAGE);
232			/*NOTREACHED*/
233			break;
234
235#ifdef WITH_KVM
236		case 'K':
237			++Kflag;
238			break;
239#endif
240
241		case 'v':
242			++vflag;
243			break;
244
245#ifdef WITH_KVM
246		case 'M':
247			core = strdup(optarg);
248			break;
249
250		case 'N':
251			kernel = strdup(optarg);
252			break;
253#endif
254
255		default:
256			usage();
257			break;
258			/*NOTREACHED*/
259		}
260	}
261
262	if (af == AF_LINK && vflag)
263		usage();
264
265#ifdef WITH_KVM
266	if (Kflag)
267		error = ifmcstat_kvm(kernel, core);
268	/*
269	 * If KVM failed, and user did not explicitly specify a core file,
270	 * or force KVM backend to be disabled, try the sysctl backend.
271	 */
272	if (!Kflag || (error != 0 && (core == NULL && kernel == NULL)))
273#endif
274	error = ifmcstat_getifmaddrs();
275	if (error != 0)
276		exit(EX_OSERR);
277
278	exit(EX_OK);
279	/*NOTREACHED*/
280}
281
282#ifdef INET
283
284static void
285in_ifinfo(struct igmp_ifinfo *igi)
286{
287
288	printf("\t");
289	switch (igi->igi_version) {
290	case IGMP_VERSION_1:
291	case IGMP_VERSION_2:
292	case IGMP_VERSION_3:
293		printf("igmpv%d", igi->igi_version);
294		break;
295	default:
296		printf("igmpv?(%d)", igi->igi_version);
297		break;
298	}
299	printb(" flags", igi->igi_flags, "\020\1SILENT\2LOOPBACK");
300	if (igi->igi_version == IGMP_VERSION_3) {
301		printf(" rv %u qi %u qri %u uri %u",
302		    igi->igi_rv, igi->igi_qi, igi->igi_qri, igi->igi_uri);
303	}
304	if (vflag >= 2) {
305		printf(" v1timer %u v2timer %u v3timer %u",
306		    igi->igi_v1_timer, igi->igi_v2_timer, igi->igi_v3_timer);
307	}
308	printf("\n");
309}
310
311static const char *inm_modes[] = {
312	"undefined",
313	"include",
314	"exclude",
315};
316
317static const char *
318inm_mode(u_int mode)
319{
320
321	if (mode >= MCAST_UNDEFINED && mode <= MCAST_EXCLUDE)
322		return (inm_modes[mode]);
323	return (NULL);
324}
325
326#endif /* INET */
327
328#ifdef WITH_KVM
329
330static int
331ifmcstat_kvm(const char *kernel, const char *core)
332{
333	char	buf[_POSIX2_LINE_MAX], ifname[IFNAMSIZ];
334	struct	ifnet	*ifp, *nifp, ifnet;
335
336	if ((kvmd = kvm_openfiles(kernel, core, NULL, O_RDONLY, buf)) ==
337	    NULL) {
338		perror("kvm_openfiles");
339		return (-1);
340	}
341	if (kvm_nlist(kvmd, nl) < 0) {
342		perror("kvm_nlist");
343		return (-1);
344	}
345	if (nl[N_IFNET].n_value == 0) {
346		printf("symbol %s not found\n", nl[N_IFNET].n_name);
347		return (-1);
348	}
349	KREAD(nl[N_IFNET].n_value, &ifp, struct ifnet *);
350	while (ifp) {
351		KREAD(ifp, &ifnet, struct ifnet);
352		nifp = ifnet.if_link.tqe_next;
353		if (ifindex && ifindex != ifnet.if_index)
354			goto next;
355
356		printf("%s:\n", if_indextoname(ifnet.if_index, ifname));
357#ifdef INET
358		if_addrlist(TAILQ_FIRST(&ifnet.if_addrhead));
359#endif
360#ifdef INET6
361		if6_addrlist(TAILQ_FIRST(&ifnet.if_addrhead));
362#endif
363		if (vflag)
364			ll_addrlist(TAILQ_FIRST(&ifnet.if_addrhead));
365	next:
366		ifp = nifp;
367	}
368
369	return (0);
370}
371
372static void
373kread(u_long addr, void *buf, int len)
374{
375
376	if (kvm_read(kvmd, addr, buf, len) != len) {
377		perror("kvm_read");
378		exit(EX_OSERR);
379	}
380}
381
382static void
383ll_addrlist(struct ifaddr *ifap)
384{
385	char addrbuf[NI_MAXHOST];
386	struct ifaddr ifa;
387	struct sockaddr sa;
388	struct sockaddr_dl sdl;
389	struct ifaddr *ifap0;
390
391	if (af && af != AF_LINK)
392		return;
393
394	ifap0 = ifap;
395	while (ifap) {
396		KREAD(ifap, &ifa, struct ifaddr);
397		if (ifa.ifa_addr == NULL)
398			goto nextifap;
399		KREAD(ifa.ifa_addr, &sa, struct sockaddr);
400		if (sa.sa_family != PF_LINK)
401			goto nextifap;
402		KREAD(ifa.ifa_addr, &sdl, struct sockaddr_dl);
403		if (sdl.sdl_alen == 0)
404			goto nextifap;
405		addrbuf[0] = '\0';
406		getnameinfo((struct sockaddr *)&sdl, sdl.sdl_len,
407		    addrbuf, sizeof(addrbuf), NULL, 0, NI_NUMERICHOST);
408		printf("\tlink %s\n", addrbuf);
409	nextifap:
410		ifap = ifa.ifa_link.tqe_next;
411	}
412	if (ifap0) {
413		struct ifnet ifnet;
414		struct ifmultiaddr ifm, *ifmp = 0;
415
416		KREAD(ifap0, &ifa, struct ifaddr);
417		KREAD(ifa.ifa_ifp, &ifnet, struct ifnet);
418		if (TAILQ_FIRST(&ifnet.if_multiaddrs))
419			ifmp = TAILQ_FIRST(&ifnet.if_multiaddrs);
420		while (ifmp) {
421			KREAD(ifmp, &ifm, struct ifmultiaddr);
422			if (ifm.ifma_addr == NULL)
423				goto nextmulti;
424			KREAD(ifm.ifma_addr, &sa, struct sockaddr);
425			if (sa.sa_family != AF_LINK)
426				goto nextmulti;
427			KREAD(ifm.ifma_addr, &sdl, struct sockaddr_dl);
428			addrbuf[0] = '\0';
429			getnameinfo((struct sockaddr *)&sdl,
430			    sdl.sdl_len, addrbuf, sizeof(addrbuf),
431			    NULL, 0, NI_NUMERICHOST);
432			printf("\t\tgroup %s refcnt %d\n",
433			    addrbuf, ifm.ifma_refcount);
434		nextmulti:
435			ifmp = TAILQ_NEXT(&ifm, ifma_link);
436		}
437	}
438}
439
440#ifdef INET6
441
442static void
443if6_addrlist(struct ifaddr *ifap)
444{
445	struct ifnet ifnet;
446	struct ifaddr ifa;
447	struct sockaddr sa;
448	struct in6_ifaddr if6a;
449	struct ifaddr *ifap0;
450
451	if (af && af != AF_INET6)
452		return;
453	ifap0 = ifap;
454	while (ifap) {
455		KREAD(ifap, &ifa, struct ifaddr);
456		if (ifa.ifa_addr == NULL)
457			goto nextifap;
458		KREAD(ifa.ifa_addr, &sa, struct sockaddr);
459		if (sa.sa_family != PF_INET6)
460			goto nextifap;
461		KREAD(ifap, &if6a, struct in6_ifaddr);
462		printf("\tinet6 %s\n", inet6_n2a(&if6a.ia_addr.sin6_addr));
463		/*
464		 * Print per-link MLD information, if available.
465		 */
466		if (ifa.ifa_ifp != NULL) {
467			struct in6_ifextra ie;
468			struct mld_ifinfo mli;
469
470			KREAD(ifa.ifa_ifp, &ifnet, struct ifnet);
471			KREAD(ifnet.if_afdata[AF_INET6], &ie,
472			    struct in6_ifextra);
473			if (ie.mld_ifinfo != NULL) {
474				KREAD(ie.mld_ifinfo, &mli, struct mld_ifinfo);
475				in6_ifinfo(&mli);
476			}
477		}
478	nextifap:
479		ifap = ifa.ifa_link.tqe_next;
480	}
481	if (ifap0) {
482		struct ifnet ifnet;
483		struct ifmultiaddr ifm, *ifmp = 0;
484		struct sockaddr_dl sdl;
485
486		KREAD(ifap0, &ifa, struct ifaddr);
487		KREAD(ifa.ifa_ifp, &ifnet, struct ifnet);
488		if (TAILQ_FIRST(&ifnet.if_multiaddrs))
489			ifmp = TAILQ_FIRST(&ifnet.if_multiaddrs);
490		while (ifmp) {
491			KREAD(ifmp, &ifm, struct ifmultiaddr);
492			if (ifm.ifma_addr == NULL)
493				goto nextmulti;
494			KREAD(ifm.ifma_addr, &sa, struct sockaddr);
495			if (sa.sa_family != AF_INET6)
496				goto nextmulti;
497			(void)in6_multientry((struct in6_multi *)
498					     ifm.ifma_protospec);
499			if (ifm.ifma_lladdr == 0)
500				goto nextmulti;
501			KREAD(ifm.ifma_lladdr, &sdl, struct sockaddr_dl);
502			printf("\t\t\tmcast-macaddr %s refcnt %d\n",
503			       ether_ntoa((struct ether_addr *)LLADDR(&sdl)),
504			       ifm.ifma_refcount);
505		    nextmulti:
506			ifmp = TAILQ_NEXT(&ifm, ifma_link);
507		}
508	}
509}
510
511static struct in6_multi *
512in6_multientry(struct in6_multi *mc)
513{
514	struct in6_multi multi;
515
516	KREAD(mc, &multi, struct in6_multi);
517	printf("\t\tgroup %s", inet6_n2a(&multi.in6m_addr));
518	printf(" refcnt %u\n", multi.in6m_refcount);
519
520	return (multi.in6m_entry.le_next);
521}
522
523#endif /* INET6 */
524
525#ifdef INET
526
527static void
528if_addrlist(struct ifaddr *ifap)
529{
530	struct ifaddr ifa;
531	struct ifnet ifnet;
532	struct sockaddr sa;
533	struct in_ifaddr ia;
534	struct ifaddr *ifap0;
535
536	if (af && af != AF_INET)
537		return;
538	ifap0 = ifap;
539	while (ifap) {
540		KREAD(ifap, &ifa, struct ifaddr);
541		if (ifa.ifa_addr == NULL)
542			goto nextifap;
543		KREAD(ifa.ifa_addr, &sa, struct sockaddr);
544		if (sa.sa_family != PF_INET)
545			goto nextifap;
546		KREAD(ifap, &ia, struct in_ifaddr);
547		printf("\tinet %s\n", inet_ntoa(ia.ia_addr.sin_addr));
548		/*
549		 * Print per-link IGMP information, if available.
550		 */
551		if (ifa.ifa_ifp != NULL) {
552			struct in_ifinfo ii;
553			struct igmp_ifinfo igi;
554
555			KREAD(ifa.ifa_ifp, &ifnet, struct ifnet);
556			KREAD(ifnet.if_afdata[AF_INET], &ii, struct in_ifinfo);
557			if (ii.ii_igmp != NULL) {
558				KREAD(ii.ii_igmp, &igi, struct igmp_ifinfo);
559				in_ifinfo(&igi);
560			}
561		}
562	nextifap:
563		ifap = ifa.ifa_link.tqe_next;
564	}
565	if (ifap0) {
566		struct ifmultiaddr ifm, *ifmp = 0;
567		struct sockaddr_dl sdl;
568
569		KREAD(ifap0, &ifa, struct ifaddr);
570		KREAD(ifa.ifa_ifp, &ifnet, struct ifnet);
571		if (TAILQ_FIRST(&ifnet.if_multiaddrs))
572			ifmp = TAILQ_FIRST(&ifnet.if_multiaddrs);
573		while (ifmp) {
574			KREAD(ifmp, &ifm, struct ifmultiaddr);
575			if (ifm.ifma_addr == NULL)
576				goto nextmulti;
577			KREAD(ifm.ifma_addr, &sa, struct sockaddr);
578			if (sa.sa_family != AF_INET)
579				goto nextmulti;
580			(void)in_multientry((struct in_multi *)
581					    ifm.ifma_protospec);
582			if (ifm.ifma_lladdr == 0)
583				goto nextmulti;
584			KREAD(ifm.ifma_lladdr, &sdl, struct sockaddr_dl);
585			printf("\t\t\tmcast-macaddr %s refcnt %d\n",
586			       ether_ntoa((struct ether_addr *)LLADDR(&sdl)),
587			       ifm.ifma_refcount);
588		    nextmulti:
589			ifmp = TAILQ_NEXT(&ifm, ifma_link);
590		}
591	}
592}
593
594static const char *inm_states[] = {
595	"not-member",
596	"silent",
597	"idle",
598	"lazy",
599	"sleeping",
600	"awakening",
601	"query-pending",
602	"sg-query-pending",
603	"leaving"
604};
605
606static const char *
607inm_state(u_int state)
608{
609
610	if (state >= IGMP_NOT_MEMBER && state <= IGMP_LEAVING_MEMBER)
611		return (inm_states[state]);
612	return (NULL);
613}
614
615#if 0
616static struct ip_msource *
617ims_min_kvm(struct in_multi *pinm)
618{
619	struct ip_msource ims0;
620	struct ip_msource *tmp, *parent;
621
622	parent = NULL;
623	tmp = RB_ROOT(&pinm->inm_srcs);
624	while (tmp) {
625		parent = tmp;
626		KREAD(tmp, &ims0, struct ip_msource);
627		tmp = RB_LEFT(&ims0, ims_link);
628	}
629	return (parent); /* kva */
630}
631
632/* XXX This routine is buggy. See RB_NEXT in sys/tree.h. */
633static struct ip_msource *
634ims_next_kvm(struct ip_msource *ims)
635{
636	struct ip_msource ims0, ims1;
637	struct ip_msource *tmp;
638
639	KREAD(ims, &ims0, struct ip_msource);
640	if (RB_RIGHT(&ims0, ims_link)) {
641		ims = RB_RIGHT(&ims0, ims_link);
642		KREAD(ims, &ims1, struct ip_msource);
643		while ((tmp = RB_LEFT(&ims1, ims_link))) {
644			KREAD(tmp, &ims0, struct ip_msource);
645			ims = RB_LEFT(&ims0, ims_link);
646		}
647	} else {
648		tmp = RB_PARENT(&ims0, ims_link);
649		if (tmp) {
650			KREAD(tmp, &ims1, struct ip_msource);
651			if (ims == RB_LEFT(&ims1, ims_link))
652				ims = tmp;
653		} else {
654			while ((tmp = RB_PARENT(&ims0, ims_link))) {
655				KREAD(tmp, &ims1, struct ip_msource);
656				if (ims == RB_RIGHT(&ims1, ims_link)) {
657					ims = tmp;
658					KREAD(ims, &ims0, struct ip_msource);
659				} else
660					break;
661			}
662			ims = RB_PARENT(&ims0, ims_link);
663		}
664	}
665	return (ims); /* kva */
666}
667
668static void
669inm_print_sources_kvm(struct in_multi *pinm)
670{
671	struct ip_msource ims0;
672	struct ip_msource *ims;
673	struct in_addr src;
674	int cnt;
675	uint8_t fmode;
676
677	cnt = 0;
678	fmode = pinm->inm_st[1].iss_fmode;
679	if (fmode == MCAST_UNDEFINED)
680		return;
681	for (ims = ims_min_kvm(pinm); ims != NULL; ims = ims_next_kvm(ims)) {
682		if (cnt == 0)
683			printf(" srcs ");
684		KREAD(ims, &ims0, struct ip_msource);
685		/* Only print sources in-mode at t1. */
686		if (fmode != ims_get_mode(pinm, ims, 1))
687			continue;
688		src.s_addr = htonl(ims0.ims_haddr);
689		printf("%s%s", (cnt++ == 0 ? "" : ","), inet_ntoa(src));
690	}
691}
692#endif
693
694static struct in_multi *
695in_multientry(struct in_multi *pinm)
696{
697	struct in_multi inm;
698	const char *state, *mode;
699
700	KREAD(pinm, &inm, struct in_multi);
701	printf("\t\tgroup %s", inet_ntoa(inm.inm_addr));
702	printf(" refcnt %u", inm.inm_refcount);
703
704	state = inm_state(inm.inm_state);
705	if (state)
706		printf(" state %s", state);
707	else
708		printf(" state (%d)", inm.inm_state);
709
710	mode = inm_mode(inm.inm_st[1].iss_fmode);
711	if (mode)
712		printf(" mode %s", mode);
713	else
714		printf(" mode (%d)", inm.inm_st[1].iss_fmode);
715
716	if (vflag >= 2) {
717		printf(" asm %u ex %u in %u rec %u",
718		    (u_int)inm.inm_st[1].iss_asm,
719		    (u_int)inm.inm_st[1].iss_ex,
720		    (u_int)inm.inm_st[1].iss_in,
721		    (u_int)inm.inm_st[1].iss_rec);
722	}
723
724#if 0
725	/* Buggy. */
726	if (vflag)
727		inm_print_sources_kvm(&inm);
728#endif
729
730	printf("\n");
731	return (NULL);
732}
733
734#endif /* INET */
735
736#endif /* WITH_KVM */
737
738#ifdef INET6
739
740static void
741in6_ifinfo(struct mld_ifinfo *mli)
742{
743
744	printf("\t");
745	switch (mli->mli_version) {
746	case MLD_VERSION_1:
747	case MLD_VERSION_2:
748		printf("mldv%d", mli->mli_version);
749		break;
750	default:
751		printf("mldv?(%d)", mli->mli_version);
752		break;
753	}
754	printb(" flags", mli->mli_flags, "\020\1SILENT");
755	if (mli->mli_version == MLD_VERSION_2) {
756		printf(" rv %u qi %u qri %u uri %u",
757		    mli->mli_rv, mli->mli_qi, mli->mli_qri, mli->mli_uri);
758	}
759	if (vflag >= 2) {
760		printf(" v1timer %u v2timer %u", mli->mli_v1_timer,
761		   mli->mli_v2_timer);
762	}
763	printf("\n");
764}
765
766static const char *
767inet6_n2a(struct in6_addr *p)
768{
769	static char buf[NI_MAXHOST];
770	struct sockaddr_in6 sin6;
771	u_int32_t scopeid;
772	const int niflags = NI_NUMERICHOST;
773
774	memset(&sin6, 0, sizeof(sin6));
775	sin6.sin6_family = AF_INET6;
776	sin6.sin6_len = sizeof(struct sockaddr_in6);
777	sin6.sin6_addr = *p;
778	if (IN6_IS_ADDR_LINKLOCAL(p) || IN6_IS_ADDR_MC_LINKLOCAL(p) ||
779	    IN6_IS_ADDR_MC_NODELOCAL(p)) {
780		scopeid = ntohs(*(u_int16_t *)&sin6.sin6_addr.s6_addr[2]);
781		if (scopeid) {
782			sin6.sin6_scope_id = scopeid;
783			sin6.sin6_addr.s6_addr[2] = 0;
784			sin6.sin6_addr.s6_addr[3] = 0;
785		}
786	}
787	if (getnameinfo((struct sockaddr *)&sin6, sin6.sin6_len,
788	    buf, sizeof(buf), NULL, 0, niflags) == 0) {
789		return (buf);
790	} else {
791		return ("(invalid)");
792	}
793}
794#endif /* INET6 */
795
796#ifdef INET
797/*
798 * Retrieve per-group source filter mode and lists via sysctl.
799 */
800static void
801inm_print_sources_sysctl(uint32_t ifindex, struct in_addr gina)
802{
803#define	MAX_SYSCTL_TRY	5
804	int mib[7];
805	int ntry = 0;
806	size_t mibsize;
807	size_t len;
808	size_t needed;
809	size_t cnt;
810	int i;
811	char *buf;
812	struct in_addr *pina;
813	uint32_t *p;
814	uint32_t fmode;
815	const char *modestr;
816
817	mibsize = sizeof(mib) / sizeof(mib[0]);
818	if (sysctlnametomib("net.inet.ip.mcast.filters", mib, &mibsize) == -1) {
819		perror("sysctlnametomib");
820		return;
821	}
822
823	needed = 0;
824	mib[5] = ifindex;
825	mib[6] = gina.s_addr;	/* 32 bits wide */
826	mibsize = sizeof(mib) / sizeof(mib[0]);
827	do {
828		if (sysctl(mib, mibsize, NULL, &needed, NULL, 0) == -1) {
829			perror("sysctl net.inet.ip.mcast.filters");
830			return;
831		}
832		if ((buf = malloc(needed)) == NULL) {
833			perror("malloc");
834			return;
835		}
836		if (sysctl(mib, mibsize, buf, &needed, NULL, 0) == -1) {
837			if (errno != ENOMEM || ++ntry >= MAX_SYSCTL_TRY) {
838				perror("sysctl");
839				goto out_free;
840			}
841			free(buf);
842			buf = NULL;
843		}
844	} while (buf == NULL);
845
846	len = needed;
847	if (len < sizeof(uint32_t)) {
848		perror("sysctl");
849		goto out_free;
850	}
851
852	p = (uint32_t *)buf;
853	fmode = *p++;
854	len -= sizeof(uint32_t);
855
856	modestr = inm_mode(fmode);
857	if (modestr)
858		printf(" mode %s", modestr);
859	else
860		printf(" mode (%u)", fmode);
861
862	if (vflag == 0)
863		goto out_free;
864
865	cnt = len / sizeof(struct in_addr);
866	pina = (struct in_addr *)p;
867
868	for (i = 0; i < cnt; i++) {
869		if (i == 0)
870			printf(" srcs ");
871		fprintf(stdout, "%s%s", (i == 0 ? "" : ","),
872		    inet_ntoa(*pina++));
873		len -= sizeof(struct in_addr);
874	}
875	if (len > 0) {
876		fprintf(stderr, "warning: %u trailing bytes from %s\n",
877		    (unsigned int)len, "net.inet.ip.mcast.filters");
878	}
879
880out_free:
881	free(buf);
882#undef	MAX_SYSCTL_TRY
883}
884
885#endif /* INET */
886
887#ifdef INET6
888/*
889 * Retrieve MLD per-group source filter mode and lists via sysctl.
890 *
891 * Note: The 128-bit IPv6 group address needs to be segmented into
892 * 32-bit pieces for marshaling to sysctl. So the MIB name ends
893 * up looking like this:
894 *  a.b.c.d.e.ifindex.g[0].g[1].g[2].g[3]
895 * Assumes that pgroup originated from the kernel, so its components
896 * are already in network-byte order.
897 */
898static void
899in6m_print_sources_sysctl(uint32_t ifindex, struct in6_addr *pgroup)
900{
901#define	MAX_SYSCTL_TRY	5
902	char addrbuf[INET6_ADDRSTRLEN];
903	int mib[10];
904	int ntry = 0;
905	int *pi;
906	size_t mibsize;
907	size_t len;
908	size_t needed;
909	size_t cnt;
910	int i;
911	char *buf;
912	struct in6_addr *pina;
913	uint32_t *p;
914	uint32_t fmode;
915	const char *modestr;
916
917	mibsize = sizeof(mib) / sizeof(mib[0]);
918	if (sysctlnametomib("net.inet6.ip6.mcast.filters", mib,
919	    &mibsize) == -1) {
920		perror("sysctlnametomib");
921		return;
922	}
923
924	needed = 0;
925	mib[5] = ifindex;
926	pi = (int *)pgroup;
927	for (i = 0; i < 4; i++)
928		mib[6 + i] = *pi++;
929
930	mibsize = sizeof(mib) / sizeof(mib[0]);
931	do {
932		if (sysctl(mib, mibsize, NULL, &needed, NULL, 0) == -1) {
933			perror("sysctl net.inet6.ip6.mcast.filters");
934			return;
935		}
936		if ((buf = malloc(needed)) == NULL) {
937			perror("malloc");
938			return;
939		}
940		if (sysctl(mib, mibsize, buf, &needed, NULL, 0) == -1) {
941			if (errno != ENOMEM || ++ntry >= MAX_SYSCTL_TRY) {
942				perror("sysctl");
943				goto out_free;
944			}
945			free(buf);
946			buf = NULL;
947		}
948	} while (buf == NULL);
949
950	len = needed;
951	if (len < sizeof(uint32_t)) {
952		perror("sysctl");
953		goto out_free;
954	}
955
956	p = (uint32_t *)buf;
957	fmode = *p++;
958	len -= sizeof(uint32_t);
959
960	modestr = inm_mode(fmode);
961	if (modestr)
962		printf(" mode %s", modestr);
963	else
964		printf(" mode (%u)", fmode);
965
966	if (vflag == 0)
967		goto out_free;
968
969	cnt = len / sizeof(struct in6_addr);
970	pina = (struct in6_addr *)p;
971
972	for (i = 0; i < cnt; i++) {
973		if (i == 0)
974			printf(" srcs ");
975		inet_ntop(AF_INET6, (const char *)pina++, addrbuf,
976		    INET6_ADDRSTRLEN);
977		fprintf(stdout, "%s%s", (i == 0 ? "" : ","), addrbuf);
978		len -= sizeof(struct in6_addr);
979	}
980	if (len > 0) {
981		fprintf(stderr, "warning: %u trailing bytes from %s\n",
982		    (unsigned int)len, "net.inet6.ip6.mcast.filters");
983	}
984
985out_free:
986	free(buf);
987#undef	MAX_SYSCTL_TRY
988}
989#endif /* INET6 */
990
991static int
992ifmcstat_getifmaddrs(void)
993{
994	char			 thisifname[IFNAMSIZ];
995	char			 addrbuf[NI_MAXHOST];
996	struct ifaddrs		*ifap, *ifa;
997	struct ifmaddrs		*ifmap, *ifma;
998	sockunion_t		 lastifasa;
999	sockunion_t		*psa, *pgsa, *pllsa, *pifasa;
1000	char			*pcolon;
1001	char			*pafname;
1002	uint32_t		 lastifindex, thisifindex;
1003	int			 error;
1004
1005	error = 0;
1006	ifap = NULL;
1007	ifmap = NULL;
1008	lastifindex = 0;
1009	thisifindex = 0;
1010	lastifasa.ss.ss_family = AF_UNSPEC;
1011
1012	if (getifaddrs(&ifap) != 0) {
1013		warn("getifmaddrs");
1014		return (-1);
1015	}
1016
1017	if (getifmaddrs(&ifmap) != 0) {
1018		warn("getifmaddrs");
1019		error = -1;
1020		goto out;
1021	}
1022
1023	for (ifma = ifmap; ifma; ifma = ifma->ifma_next) {
1024		error = 0;
1025		if (ifma->ifma_name == NULL || ifma->ifma_addr == NULL)
1026			continue;
1027
1028		psa = (sockunion_t *)ifma->ifma_name;
1029		if (psa->sa.sa_family != AF_LINK) {
1030			fprintf(stderr,
1031			    "WARNING: Kernel returned invalid data.\n");
1032			error = -1;
1033			break;
1034		}
1035
1036		/* Filter on interface name. */
1037		thisifindex = psa->sdl.sdl_index;
1038		if (ifindex != 0 && thisifindex != ifindex)
1039			continue;
1040
1041		/* Filter on address family. */
1042		pgsa = (sockunion_t *)ifma->ifma_addr;
1043		if (af != 0 && pgsa->sa.sa_family != af)
1044			continue;
1045
1046		strlcpy(thisifname, link_ntoa(&psa->sdl), IFNAMSIZ);
1047		pcolon = strchr(thisifname, ':');
1048		if (pcolon)
1049			*pcolon = '\0';
1050
1051		/* Only print the banner for the first ifmaddrs entry. */
1052		if (lastifindex == 0 || lastifindex != thisifindex) {
1053			lastifindex = thisifindex;
1054			fprintf(stdout, "%s:\n", thisifname);
1055		}
1056
1057		/*
1058		 * Currently, multicast joins only take place on the
1059		 * primary IPv4 address, and only on the link-local IPv6
1060		 * address, as per IGMPv2/3 and MLDv1/2 semantics.
1061		 * Therefore, we only look up the primary address on
1062		 * the first pass.
1063		 */
1064		pifasa = NULL;
1065		for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1066			if ((strcmp(ifa->ifa_name, thisifname) != 0) ||
1067			    (ifa->ifa_addr == NULL) ||
1068			    (ifa->ifa_addr->sa_family != pgsa->sa.sa_family))
1069				continue;
1070			/*
1071			 * For AF_INET6 only the link-local address should
1072			 * be returned. If built without IPv6 support,
1073			 * skip this address entirely.
1074			 */
1075			pifasa = (sockunion_t *)ifa->ifa_addr;
1076			if (pifasa->sa.sa_family == AF_INET6
1077#ifdef INET6
1078			    && !IN6_IS_ADDR_LINKLOCAL(&pifasa->sin6.sin6_addr)
1079#endif
1080			) {
1081				pifasa = NULL;
1082				continue;
1083			}
1084			break;
1085		}
1086		if (pifasa == NULL)
1087			continue;	/* primary address not found */
1088
1089		if (!vflag && pifasa->sa.sa_family == AF_LINK)
1090			continue;
1091
1092		/* Parse and print primary address, if not already printed. */
1093		if (lastifasa.ss.ss_family == AF_UNSPEC ||
1094		    ((lastifasa.ss.ss_family == AF_LINK &&
1095		      !sa_dl_equal(&lastifasa.sa, &pifasa->sa)) ||
1096		     !sa_equal(&lastifasa.sa, &pifasa->sa))) {
1097
1098			switch (pifasa->sa.sa_family) {
1099			case AF_INET:
1100				pafname = "inet";
1101				break;
1102			case AF_INET6:
1103				pafname = "inet6";
1104				break;
1105			case AF_LINK:
1106				pafname = "link";
1107				break;
1108			default:
1109				pafname = "unknown";
1110				break;
1111			}
1112
1113			switch (pifasa->sa.sa_family) {
1114			case AF_INET6:
1115#ifdef INET6
1116			{
1117				const char *p =
1118				    inet6_n2a(&pifasa->sin6.sin6_addr);
1119				strlcpy(addrbuf, p, sizeof(addrbuf));
1120				break;
1121			}
1122#else
1123			/* FALLTHROUGH */
1124#endif
1125			case AF_INET:
1126			case AF_LINK:
1127				error = getnameinfo(&pifasa->sa,
1128				    pifasa->sa.sa_len,
1129				    addrbuf, sizeof(addrbuf), NULL, 0,
1130				    NI_NUMERICHOST);
1131				if (error)
1132					perror("getnameinfo");
1133				break;
1134			default:
1135				addrbuf[0] = '\0';
1136				break;
1137			}
1138
1139			fprintf(stdout, "\t%s %s\n", pafname, addrbuf);
1140#ifdef INET
1141			/*
1142			 * Print per-link IGMP information, if available.
1143			 */
1144			if (pifasa->sa.sa_family == AF_INET) {
1145				struct igmp_ifinfo igi;
1146				size_t mibsize, len;
1147				int mib[5];
1148
1149				mibsize = sizeof(mib) / sizeof(mib[0]);
1150				if (sysctlnametomib("net.inet.igmp.ifinfo",
1151				    mib, &mibsize) == -1) {
1152					perror("sysctlnametomib");
1153					goto next_ifnet;
1154				}
1155				mib[mibsize] = thisifindex;
1156				len = sizeof(struct igmp_ifinfo);
1157				if (sysctl(mib, mibsize + 1, &igi, &len, NULL,
1158				    0) == -1) {
1159					perror("sysctl net.inet.igmp.ifinfo");
1160					goto next_ifnet;
1161				}
1162				in_ifinfo(&igi);
1163			}
1164#endif /* INET */
1165#ifdef INET6
1166			/*
1167			 * Print per-link MLD information, if available.
1168			 */
1169			if (pifasa->sa.sa_family == AF_INET6) {
1170				struct mld_ifinfo mli;
1171				size_t mibsize, len;
1172				int mib[5];
1173
1174				mibsize = sizeof(mib) / sizeof(mib[0]);
1175				if (sysctlnametomib("net.inet6.mld.ifinfo",
1176				    mib, &mibsize) == -1) {
1177					perror("sysctlnametomib");
1178					goto next_ifnet;
1179				}
1180				mib[mibsize] = thisifindex;
1181				len = sizeof(struct mld_ifinfo);
1182				if (sysctl(mib, mibsize + 1, &mli, &len, NULL,
1183				    0) == -1) {
1184					perror("sysctl net.inet6.mld.ifinfo");
1185					goto next_ifnet;
1186				}
1187				in6_ifinfo(&mli);
1188			}
1189#endif /* INET6 */
1190#if defined(INET) || defined(INET6)
1191next_ifnet:
1192#endif
1193			lastifasa = *pifasa;
1194		}
1195
1196		/* Print this group address. */
1197#ifdef INET6
1198		if (pgsa->sa.sa_family == AF_INET6) {
1199			const char *p = inet6_n2a(&pgsa->sin6.sin6_addr);
1200			strlcpy(addrbuf, p, sizeof(addrbuf));
1201		} else
1202#endif
1203		{
1204			error = getnameinfo(&pgsa->sa, pgsa->sa.sa_len,
1205			    addrbuf, sizeof(addrbuf), NULL, 0, NI_NUMERICHOST);
1206			if (error)
1207				perror("getnameinfo");
1208		}
1209
1210		fprintf(stdout, "\t\tgroup %s", addrbuf);
1211#ifdef INET
1212		if (pgsa->sa.sa_family == AF_INET) {
1213			inm_print_sources_sysctl(thisifindex,
1214			    pgsa->sin.sin_addr);
1215		}
1216#endif
1217#ifdef INET6
1218		if (pgsa->sa.sa_family == AF_INET6) {
1219			in6m_print_sources_sysctl(thisifindex,
1220			    &pgsa->sin6.sin6_addr);
1221		}
1222#endif
1223		fprintf(stdout, "\n");
1224
1225		/* Link-layer mapping, if present. */
1226		pllsa = (sockunion_t *)ifma->ifma_lladdr;
1227		if (pllsa != NULL) {
1228			error = getnameinfo(&pllsa->sa, pllsa->sa.sa_len,
1229			    addrbuf, sizeof(addrbuf), NULL, 0, NI_NUMERICHOST);
1230			fprintf(stdout, "\t\t\tmcast-macaddr %s\n", addrbuf);
1231		}
1232	}
1233out:
1234	if (ifmap != NULL)
1235		freeifmaddrs(ifmap);
1236	if (ifap != NULL)
1237		freeifaddrs(ifap);
1238
1239	return (error);
1240}
1241