1 | /* vi: set sw=4 ts=4: */
|
---|
2 | /*
|
---|
3 | * Licensed under GPLv2 or later, see file LICENSE in this source tree.
|
---|
4 | *
|
---|
5 | * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
---|
6 | *
|
---|
7 | * Ported to Busybox by: Curt Brune <curt@cumulusnetworks.com>
|
---|
8 | */
|
---|
9 |
|
---|
10 | #include "ip_common.h" /* #include "libbb.h" is inside */
|
---|
11 | #include "common_bufsiz.h"
|
---|
12 | #include "rt_names.h"
|
---|
13 | #include "utils.h"
|
---|
14 | #include <linux/neighbour.h>
|
---|
15 | #include <net/if_arp.h>
|
---|
16 |
|
---|
17 | //static int xshow_stats = 3;
|
---|
18 | enum { xshow_stats = 3 };
|
---|
19 |
|
---|
20 | static inline uint32_t rta_getattr_u32(const struct rtattr *rta)
|
---|
21 | {
|
---|
22 | return *(uint32_t *)RTA_DATA(rta);
|
---|
23 | }
|
---|
24 |
|
---|
25 | #ifndef RTAX_RTTVAR
|
---|
26 | #define RTAX_RTTVAR RTAX_HOPS
|
---|
27 | #endif
|
---|
28 |
|
---|
29 |
|
---|
30 | struct filter_t {
|
---|
31 | int family;
|
---|
32 | int index;
|
---|
33 | int state;
|
---|
34 | int unused_only;
|
---|
35 | inet_prefix pfx;
|
---|
36 | int flushed;
|
---|
37 | char *flushb;
|
---|
38 | int flushp;
|
---|
39 | int flushe;
|
---|
40 | struct rtnl_handle *rth;
|
---|
41 | } FIX_ALIASING;
|
---|
42 | typedef struct filter_t filter_t;
|
---|
43 |
|
---|
44 | #define G_filter (*(filter_t*)bb_common_bufsiz1)
|
---|
45 | #define INIT_G() do { setup_common_bufsiz(); } while (0)
|
---|
46 |
|
---|
47 | static int flush_update(void)
|
---|
48 | {
|
---|
49 | if (rtnl_send(G_filter.rth, G_filter.flushb, G_filter.flushp) < 0) {
|
---|
50 | bb_perror_msg("can't send flush request");
|
---|
51 | return -1;
|
---|
52 | }
|
---|
53 | G_filter.flushp = 0;
|
---|
54 | return 0;
|
---|
55 | }
|
---|
56 |
|
---|
57 | static unsigned nud_state_a2n(char *arg)
|
---|
58 | {
|
---|
59 | static const char keywords[] ALIGN1 =
|
---|
60 | /* "ip neigh show/flush" parameters: */
|
---|
61 | "permanent\0" "reachable\0" "noarp\0" "none\0"
|
---|
62 | "stale\0" "incomplete\0" "delay\0" "probe\0"
|
---|
63 | "failed\0"
|
---|
64 | ;
|
---|
65 | static uint8_t nuds[] ALIGN1 = {
|
---|
66 | NUD_PERMANENT,NUD_REACHABLE, NUD_NOARP,NUD_NONE,
|
---|
67 | NUD_STALE, NUD_INCOMPLETE,NUD_DELAY,NUD_PROBE,
|
---|
68 | NUD_FAILED
|
---|
69 | };
|
---|
70 | int id;
|
---|
71 |
|
---|
72 | BUILD_BUG_ON(
|
---|
73 | (NUD_PERMANENT|NUD_REACHABLE| NUD_NOARP|NUD_NONE|
|
---|
74 | NUD_STALE| NUD_INCOMPLETE|NUD_DELAY|NUD_PROBE|
|
---|
75 | NUD_FAILED) > 0xff
|
---|
76 | );
|
---|
77 |
|
---|
78 | id = index_in_substrings(keywords, arg);
|
---|
79 | if (id < 0)
|
---|
80 | bb_error_msg_and_die(bb_msg_invalid_arg_to, arg, "nud state");
|
---|
81 | return nuds[id];
|
---|
82 | }
|
---|
83 |
|
---|
84 | #ifndef NDA_RTA
|
---|
85 | #define NDA_RTA(r) \
|
---|
86 | ((struct rtattr*)(((char*)(r)) + NLMSG_ALIGN(sizeof(struct ndmsg))))
|
---|
87 | #endif
|
---|
88 |
|
---|
89 |
|
---|
90 | static int FAST_FUNC print_neigh(const struct sockaddr_nl *who UNUSED_PARAM,
|
---|
91 | struct nlmsghdr *n, void *arg UNUSED_PARAM)
|
---|
92 | {
|
---|
93 | struct ndmsg *r = NLMSG_DATA(n);
|
---|
94 | int len = n->nlmsg_len;
|
---|
95 | struct rtattr *tb[NDA_MAX+1];
|
---|
96 |
|
---|
97 | if (n->nlmsg_type != RTM_NEWNEIGH && n->nlmsg_type != RTM_DELNEIGH) {
|
---|
98 | bb_error_msg_and_die("not RTM_NEWNEIGH: %08x %08x %08x",
|
---|
99 | n->nlmsg_len, n->nlmsg_type,
|
---|
100 | n->nlmsg_flags);
|
---|
101 | }
|
---|
102 | len -= NLMSG_LENGTH(sizeof(*r));
|
---|
103 | if (len < 0) {
|
---|
104 | bb_error_msg_and_die("BUG: wrong nlmsg len %d", len);
|
---|
105 | }
|
---|
106 |
|
---|
107 | if (G_filter.flushb && n->nlmsg_type != RTM_NEWNEIGH)
|
---|
108 | return 0;
|
---|
109 |
|
---|
110 | if (G_filter.family && G_filter.family != r->ndm_family)
|
---|
111 | return 0;
|
---|
112 | if (G_filter.index && G_filter.index != r->ndm_ifindex)
|
---|
113 | return 0;
|
---|
114 | if (!(G_filter.state&r->ndm_state) &&
|
---|
115 | !(r->ndm_flags & NTF_PROXY) &&
|
---|
116 | (r->ndm_state || !(G_filter.state & 0x100)) &&
|
---|
117 | (r->ndm_family != AF_DECnet))
|
---|
118 | return 0;
|
---|
119 |
|
---|
120 | parse_rtattr(tb, NDA_MAX, NDA_RTA(r), n->nlmsg_len - NLMSG_LENGTH(sizeof(*r)));
|
---|
121 |
|
---|
122 | if (tb[NDA_DST]) {
|
---|
123 | if (G_filter.pfx.family) {
|
---|
124 | inet_prefix dst;
|
---|
125 | memset(&dst, 0, sizeof(dst));
|
---|
126 | dst.family = r->ndm_family;
|
---|
127 | memcpy(&dst.data, RTA_DATA(tb[NDA_DST]), RTA_PAYLOAD(tb[NDA_DST]));
|
---|
128 | if (inet_addr_match(&dst, &G_filter.pfx, G_filter.pfx.bitlen))
|
---|
129 | return 0;
|
---|
130 | }
|
---|
131 | }
|
---|
132 | if (G_filter.unused_only && tb[NDA_CACHEINFO]) {
|
---|
133 | struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
|
---|
134 | if (ci->ndm_refcnt)
|
---|
135 | return 0;
|
---|
136 | }
|
---|
137 |
|
---|
138 | if (G_filter.flushb) {
|
---|
139 | struct nlmsghdr *fn;
|
---|
140 | if (NLMSG_ALIGN(G_filter.flushp) + n->nlmsg_len > G_filter.flushe) {
|
---|
141 | if (flush_update())
|
---|
142 | return -1;
|
---|
143 | }
|
---|
144 | fn = (struct nlmsghdr*)(G_filter.flushb + NLMSG_ALIGN(G_filter.flushp));
|
---|
145 | memcpy(fn, n, n->nlmsg_len);
|
---|
146 | fn->nlmsg_type = RTM_DELNEIGH;
|
---|
147 | fn->nlmsg_flags = NLM_F_REQUEST;
|
---|
148 | fn->nlmsg_seq = ++(G_filter.rth->seq);
|
---|
149 | G_filter.flushp = (((char*)fn) + n->nlmsg_len) - G_filter.flushb;
|
---|
150 | G_filter.flushed++;
|
---|
151 | if (xshow_stats < 2)
|
---|
152 | return 0;
|
---|
153 | }
|
---|
154 |
|
---|
155 | if (tb[NDA_DST]) {
|
---|
156 | printf("%s ",
|
---|
157 | format_host(r->ndm_family,
|
---|
158 | RTA_PAYLOAD(tb[NDA_DST]),
|
---|
159 | RTA_DATA(tb[NDA_DST]))
|
---|
160 | );
|
---|
161 | }
|
---|
162 | if (!G_filter.index && r->ndm_ifindex)
|
---|
163 | printf("dev %s ", ll_index_to_name(r->ndm_ifindex));
|
---|
164 | if (tb[NDA_LLADDR]) {
|
---|
165 | SPRINT_BUF(b1);
|
---|
166 | printf("lladdr %s", ll_addr_n2a(RTA_DATA(tb[NDA_LLADDR]),
|
---|
167 | RTA_PAYLOAD(tb[NDA_LLADDR]),
|
---|
168 | ARPHRD_ETHER,
|
---|
169 | b1, sizeof(b1)));
|
---|
170 | }
|
---|
171 | if (r->ndm_flags & NTF_ROUTER) {
|
---|
172 | printf(" router");
|
---|
173 | }
|
---|
174 | if (r->ndm_flags & NTF_PROXY) {
|
---|
175 | printf(" proxy");
|
---|
176 | }
|
---|
177 | if (tb[NDA_CACHEINFO] && xshow_stats) {
|
---|
178 | struct nda_cacheinfo *ci = RTA_DATA(tb[NDA_CACHEINFO]);
|
---|
179 | int hz = get_hz();
|
---|
180 |
|
---|
181 | if (ci->ndm_refcnt)
|
---|
182 | printf(" ref %d", ci->ndm_refcnt);
|
---|
183 | printf(" used %d/%d/%d", ci->ndm_used/hz,
|
---|
184 | ci->ndm_confirmed/hz, ci->ndm_updated/hz);
|
---|
185 | }
|
---|
186 |
|
---|
187 | if (tb[NDA_PROBES] && xshow_stats) {
|
---|
188 | uint32_t p = rta_getattr_u32(tb[NDA_PROBES]);
|
---|
189 | printf(" probes %u", p);
|
---|
190 | }
|
---|
191 |
|
---|
192 | /*if (r->ndm_state)*/ {
|
---|
193 | int nud = r->ndm_state;
|
---|
194 | char c = ' ';
|
---|
195 | #define PRINT_FLAG(f) \
|
---|
196 | if (nud & NUD_##f) { \
|
---|
197 | printf("%c"#f, c); \
|
---|
198 | c = ','; \
|
---|
199 | }
|
---|
200 | PRINT_FLAG(INCOMPLETE);
|
---|
201 | PRINT_FLAG(REACHABLE);
|
---|
202 | PRINT_FLAG(STALE);
|
---|
203 | PRINT_FLAG(DELAY);
|
---|
204 | PRINT_FLAG(PROBE);
|
---|
205 | PRINT_FLAG(FAILED);
|
---|
206 | PRINT_FLAG(NOARP);
|
---|
207 | PRINT_FLAG(PERMANENT);
|
---|
208 | #undef PRINT_FLAG
|
---|
209 | }
|
---|
210 | bb_putchar('\n');
|
---|
211 |
|
---|
212 | return 0;
|
---|
213 | }
|
---|
214 |
|
---|
215 | static void ipneigh_reset_filter(void)
|
---|
216 | {
|
---|
217 | memset(&G_filter, 0, sizeof(G_filter));
|
---|
218 | G_filter.state = ~0;
|
---|
219 | }
|
---|
220 |
|
---|
221 | #define MAX_ROUNDS 10
|
---|
222 | /* Return value becomes exitcode. It's okay to not return at all */
|
---|
223 | static int FAST_FUNC ipneigh_list_or_flush(char **argv, int flush)
|
---|
224 | {
|
---|
225 | static const char keywords[] ALIGN1 =
|
---|
226 | /* "ip neigh show/flush" parameters: */
|
---|
227 | "to\0" "dev\0" "nud\0";
|
---|
228 | enum {
|
---|
229 | KW_to, KW_dev, KW_nud,
|
---|
230 | };
|
---|
231 | struct rtnl_handle rth;
|
---|
232 | struct ndmsg ndm = { 0 };
|
---|
233 | char *filter_dev = NULL;
|
---|
234 | int state_given = 0;
|
---|
235 | int arg;
|
---|
236 |
|
---|
237 | ipneigh_reset_filter();
|
---|
238 |
|
---|
239 | if (flush && !*argv)
|
---|
240 | bb_error_msg_and_die(bb_msg_requires_arg, "\"ip neigh flush\"");
|
---|
241 |
|
---|
242 | if (!G_filter.family)
|
---|
243 | G_filter.family = preferred_family;
|
---|
244 |
|
---|
245 | G_filter.state = (flush) ?
|
---|
246 | ~(NUD_PERMANENT|NUD_NOARP) : 0xFF & ~NUD_NOARP;
|
---|
247 |
|
---|
248 | while (*argv) {
|
---|
249 | arg = index_in_substrings(keywords, *argv);
|
---|
250 | if (arg == KW_dev) {
|
---|
251 | NEXT_ARG();
|
---|
252 | filter_dev = *argv;
|
---|
253 | } else if (arg == KW_nud) {
|
---|
254 | unsigned state;
|
---|
255 | NEXT_ARG();
|
---|
256 | if (!state_given) {
|
---|
257 | state_given = 1;
|
---|
258 | G_filter.state = 0;
|
---|
259 | }
|
---|
260 | if (strcmp(*argv, "all") == 0) {
|
---|
261 | state = ~0;
|
---|
262 | if (flush)
|
---|
263 | state &= ~NUD_NOARP;
|
---|
264 | } else {
|
---|
265 | state = nud_state_a2n(*argv);
|
---|
266 | }
|
---|
267 | if (state == 0)
|
---|
268 | state = 0x100;
|
---|
269 | G_filter.state |= state;
|
---|
270 | } else {
|
---|
271 | if (arg == KW_to) {
|
---|
272 | NEXT_ARG();
|
---|
273 | }
|
---|
274 | get_prefix(&G_filter.pfx, *argv, G_filter.family);
|
---|
275 | if (G_filter.family == AF_UNSPEC)
|
---|
276 | G_filter.family = G_filter.pfx.family;
|
---|
277 | }
|
---|
278 | argv++;
|
---|
279 | }
|
---|
280 |
|
---|
281 | xrtnl_open(&rth);
|
---|
282 | ll_init_map(&rth);
|
---|
283 |
|
---|
284 | if (filter_dev) {
|
---|
285 | G_filter.index = xll_name_to_index(filter_dev);
|
---|
286 | if (G_filter.index == 0) {
|
---|
287 | bb_error_msg_and_die("can't find device '%s'", filter_dev);
|
---|
288 | }
|
---|
289 | }
|
---|
290 |
|
---|
291 | if (flush) {
|
---|
292 | int round = 0;
|
---|
293 | char flushb[4096-512];
|
---|
294 | G_filter.flushb = flushb;
|
---|
295 | G_filter.flushp = 0;
|
---|
296 | G_filter.flushe = sizeof(flushb);
|
---|
297 | G_filter.state &= ~NUD_FAILED;
|
---|
298 | G_filter.rth = &rth;
|
---|
299 |
|
---|
300 | while (round < MAX_ROUNDS) {
|
---|
301 | if (xrtnl_wilddump_request(&rth, G_filter.family, RTM_GETNEIGH) < 0) {
|
---|
302 | bb_perror_msg_and_die("can't send dump request");
|
---|
303 | }
|
---|
304 | G_filter.flushed = 0;
|
---|
305 | if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
|
---|
306 | bb_perror_msg_and_die("flush terminated");
|
---|
307 | }
|
---|
308 | if (G_filter.flushed == 0) {
|
---|
309 | if (round == 0)
|
---|
310 | puts("Nothing to flush");
|
---|
311 | else
|
---|
312 | printf("*** Flush is complete after %d round(s) ***\n", round);
|
---|
313 | return 0;
|
---|
314 | }
|
---|
315 | round++;
|
---|
316 | if (flush_update() < 0)
|
---|
317 | xfunc_die();
|
---|
318 | printf("\n*** Round %d, deleting %d entries ***\n", round, G_filter.flushed);
|
---|
319 | }
|
---|
320 | bb_error_msg_and_die("*** Flush not complete bailing out after %d rounds", MAX_ROUNDS);
|
---|
321 | }
|
---|
322 |
|
---|
323 | ndm.ndm_family = G_filter.family;
|
---|
324 |
|
---|
325 | if (rtnl_dump_request(&rth, RTM_GETNEIGH, &ndm, sizeof(struct ndmsg)) < 0) {
|
---|
326 | bb_perror_msg_and_die("can't send dump request");
|
---|
327 | }
|
---|
328 |
|
---|
329 | if (xrtnl_dump_filter(&rth, print_neigh, NULL) < 0) {
|
---|
330 | bb_error_msg_and_die("dump terminated");
|
---|
331 | }
|
---|
332 |
|
---|
333 | return 0;
|
---|
334 | }
|
---|
335 |
|
---|
336 | /* Return value becomes exitcode. It's okay to not return at all */
|
---|
337 | int FAST_FUNC do_ipneigh(char **argv)
|
---|
338 | {
|
---|
339 | static const char ip_neigh_commands[] ALIGN1 =
|
---|
340 | /*0-1*/ "show\0" "flush\0";
|
---|
341 | int command_num;
|
---|
342 |
|
---|
343 | INIT_G();
|
---|
344 |
|
---|
345 | if (!*argv)
|
---|
346 | return ipneigh_list_or_flush(argv, 0);
|
---|
347 |
|
---|
348 | command_num = index_in_substrings(ip_neigh_commands, *argv);
|
---|
349 | switch (command_num) {
|
---|
350 | case 0: /* show */
|
---|
351 | return ipneigh_list_or_flush(argv + 1, 0);
|
---|
352 | case 1: /* flush */
|
---|
353 | return ipneigh_list_or_flush(argv + 1, 1);
|
---|
354 | }
|
---|
355 | invarg_1_to_2(*argv, applet_name);
|
---|
356 | return 1;
|
---|
357 | }
|
---|