1 /* vi: set sw=4 ts=4: */
3 * Licensed under GPLv2 or later, see file LICENSE in this source tree.
5 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
7 * Ported to Busybox by: Curt Brune <curt@cumulusnetworks.com>
10 #include "ip_common.h" /* #include "libbb.h" is inside */
11 #include "common_bufsiz.h"
14 #include <linux/neighbour.h>
15 #include <net/if_arp.h>
17 //static int xshow_stats = 3;
18 enum { xshow_stats = 3 };
20 static inline uint32_t rta_getattr_u32(const struct rtattr *rta)
22 return *(uint32_t *)RTA_DATA(rta);
26 #define RTAX_RTTVAR RTAX_HOPS
40 struct rtnl_handle *rth;
42 typedef struct filter_t filter_t;
44 #define G_filter (*(filter_t*)bb_common_bufsiz1)
46 static int flush_update(void)
48 if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
49 bb_perror_msg("can't send flush request");
56 static unsigned nud_state_a2n(char *arg)
58 static const char keywords[] ALIGN1 =
59 /* "ip neigh show/flush" parameters: */
60 "permanent\0" "reachable\0" "noarp\0" "none\0"
61 "stale\0" "incomplete\0" "delay\0" "probe\0"
64 static uint8_t nuds[] = {
65 NUD_PERMANENT,NUD_REACHABLE, NUD_NOARP,NUD_NONE,
66 NUD_STALE, NUD_INCOMPLETE,NUD_DELAY,NUD_PROBE,
72 (NUD_PERMANENT|NUD_REACHABLE| NUD_NOARP|NUD_NONE|
73 NUD_STALE| NUD_INCOMPLETE|NUD_DELAY|NUD_PROBE|
77 id = index_in_substrings(keywords, arg);
79 bb_error_msg_and_die(bb_msg_invalid_arg_to, arg, "nud state");
85 ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
89 static int FAST_FUNC print_neigh(const struct sockaddr_nl *who UNUSED_PARAM,
90 struct nlmsghdr *n, void *arg UNUSED_PARAM)
92 struct ndmsg *r = NLMSG_DATA(n);
93 int len = n->nlmsg_len;
94 struct rtattr *tb[NDA_MAX+1];
96 if (n->nlmsg_type != RTM_NEWNEIGH && n->nlmsg_type != RTM_DELNEIGH) {
97 bb_error_msg_and_die("not RTM_NEWNEIGH: %08x %08x %08x",
98 n->nlmsg_len, n->nlmsg_type,
101 len -= NLMSG_LENGTH(sizeof(*r));
103 bb_error_msg_and_die("BUG: wrong nlmsg len %d", len);
106 if (G_filter.flushb && n->nlmsg_type != RTM_NEWNEIGH)
109 if (G_filter.family && G_filter.family != r->ndm_family)
111 if (G_filter.index && G_filter.index != r->ndm_ifindex)
113 if (!(G_filter.state&r->ndm_state) &&
114 !(r->ndm_flags & NTF_PROXY) &&
115 (r->ndm_state || !(G_filter.state & 0x100)) &&
116 (r->ndm_family != AF_DECnet))
119 parse_rtattr(tb, NDA_MAX, NDA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
122 if (G_filter.pfx.family) {
124 memset(&dst, 0, sizeof(dst));
125 dst.family = r->ndm_family;
126 memcpy(&dst.data, RTA_DATA(tb[NDA_DST]), RTA_PAYLOAD(tb[NDA_DST]));
127 if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
131 if (G_filter.unused_only && tb[NDA_CACHEINFO]) {
132 struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
137 if (G_filter.flushb) {
139 if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
143 fn = (struct nlmsghdr*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
144 memcpy(fn, n, n->nlmsg_len);
145 fn->nlmsg_type = RTM_DELNEIGH;
146 fn->nlmsg_flags = NLM_F_REQUEST;
147 fn->nlmsg_seq = ++(G_filter.rth->seq);
148 G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
156 format_host(r->ndm_family,
157 RTA_PAYLOAD(tb[NDA_DST]),
158 RTA_DATA(tb[NDA_DST]))
161 if (!G_filter.index && r->ndm_ifindex)
162 printf("dev %s ", ll_index_to_name(r->ndm_ifindex));
163 if (tb[NDA_LLADDR]) {
165 printf("lladdr %s", ll_addr_n2a(RTA_DATA(tb[NDA_LLADDR]),
166 RTA_PAYLOAD(tb[NDA_LLADDR]),
170 if (r->ndm_flags & NTF_ROUTER) {
173 if (r->ndm_flags & NTF_PROXY) {
176 if (tb[NDA_CACHEINFO] && xshow_stats) {
177 struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
181 printf(" ref %d", ci->ndm_refcnt);
182 printf(" used %d/%d/%d", ci->ndm_used/hz,
183 ci->ndm_confirmed/hz, ci->ndm_updated/hz);
186 if (tb[NDA_PROBES] && xshow_stats) {
187 uint32_t p = rta_getattr_u32(tb[NDA_PROBES]);
188 printf(" probes %u", p);
191 /*if (r->ndm_state)*/ {
192 int nud = r->ndm_state;
194 #define PRINT_FLAG(f) \
195 if (nud & NUD_##f) { \
199 PRINT_FLAG(INCOMPLETE);
200 PRINT_FLAG(REACHABLE);
206 PRINT_FLAG(PERMANENT);
214 static void ipneigh_reset_filter(void)
216 memset(&G_filter, 0, sizeof(G_filter));
220 #define MAX_ROUNDS 10
221 /* Return value becomes exitcode. It's okay to not return at all */
222 static int FAST_FUNC ipneigh_list_or_flush(char **argv, int flush)
224 static const char keywords[] ALIGN1 =
225 /* "ip neigh show/flush" parameters: */
226 "to\0" "dev\0" "nud\0";
228 KW_to, KW_dev, KW_nud,
230 struct rtnl_handle rth;
231 struct ndmsg ndm = { 0 };
232 char *filter_dev = NULL;
236 ipneigh_reset_filter();
239 bb_error_msg_and_die(bb_msg_requires_arg, "\"ip neigh flush\"");
241 if (!G_filter.family)
242 G_filter.family = preferred_family;
244 G_filter.state = (flush) ?
245 ~(NUD_PERMANENT|NUD_NOARP) : 0xFF & ~NUD_NOARP;
248 arg = index_in_substrings(keywords, *argv);
252 } else if (arg == KW_nud) {
259 if (strcmp(*argv, "all") == 0) {
264 state = nud_state_a2n(*argv);
268 G_filter.state |= state;
273 get_prefix(&G_filter.pfx, *argv, G_filter.family);
274 if (G_filter.family == AF_UNSPEC)
275 G_filter.family = G_filter.pfx.family;
284 G_filter.index = xll_name_to_index(filter_dev);
285 if (G_filter.index == 0) {
286 bb_error_msg_and_die("can't find device '%s'", filter_dev);
292 char flushb[4096-512];
293 G_filter.flushb = flushb;
295 G_filter.flushe = sizeof(flushb);
296 G_filter.state &= ~NUD_FAILED;
299 while (round < MAX_ROUNDS) {
300 if (xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETNEIGH) < 0) {
301 bb_perror_msg_and_die("can't send dump request");
303 G_filter.flushed = 0;
304 if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
305 bb_perror_msg_and_die("flush terminated");
307 if (G_filter.flushed == 0) {
309 puts("Nothing to flush");
311 printf("*** Flush is complete after %d round(s) ***\n", round);
315 if (flush_update() < 0)
317 printf("\n*** Round %d, deleting %d entries ***\n", round, G_filter.flushed);
319 bb_error_msg_and_die("*** Flush not complete bailing out after %d rounds", MAX_ROUNDS);
322 ndm.ndm_family = G_filter.family;
324 if (rtnl_dump_request(&rth, RTM_GETNEIGH, &ndm, sizeof(struct ndmsg)) < 0) {
325 bb_perror_msg_and_die("can't send dump request");
328 if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
329 bb_error_msg_and_die("dump terminated");
335 /* Return value becomes exitcode. It's okay to not return at all */
336 int FAST_FUNC do_ipneigh(char **argv)
338 static const char ip_neigh_commands[] ALIGN1 =
339 /*0-1*/ "show\0" "flush\0";
343 return ipneigh_list_or_flush(argv, 0);
345 command_num = index_in_substrings(ip_neigh_commands, *argv);
346 switch (command_num) {
348 return ipneigh_list_or_flush(argv + 1, 0);
350 return ipneigh_list_or_flush(argv + 1, 1);
352 invarg_1_to_2(*argv, applet_name);