blob: a62a3761c5c97f743f2e1249bb25ce9c1f898ec2
1 | /* vi: set sw=4 ts=4: */ |
2 | /* |
3 | * arp.c - Manipulate the system ARP cache |
4 | * |
5 | * This program is free software; you can redistribute it and/or |
6 | * modify it under the terms of the GNU General Public License |
7 | * as published by the Free Software Foundation; either version |
8 | * 2 of the License, or (at your option) any later version. |
9 | * |
10 | * Author: Fred N. van Kempen, <waltje at uwalt.nl.mugnet.org> |
11 | * Busybox port: Paul van Gool <pvangool at mimotech.com> |
12 | * |
13 | * modified for getopt32 by Arne Bernin <arne [at] alamut.de> |
14 | */ |
15 | //config:config ARP |
16 | //config: bool "arp" |
17 | //config: default y |
18 | //config: select PLATFORM_LINUX |
19 | //config: help |
20 | //config: Manipulate the system ARP cache. |
21 | |
22 | //applet:IF_ARP(APPLET(arp, BB_DIR_SBIN, BB_SUID_DROP)) |
23 | |
24 | //kbuild:lib-$(CONFIG_ARP) += arp.o interface.o |
25 | |
26 | //usage:#define arp_trivial_usage |
27 | //usage: "\n[-vn] [-H HWTYPE] [-i IF] -a [HOSTNAME]" |
28 | //usage: "\n[-v] [-i IF] -d HOSTNAME [pub]" |
29 | //usage: "\n[-v] [-H HWTYPE] [-i IF] -s HOSTNAME HWADDR [temp]" |
30 | //usage: "\n[-v] [-H HWTYPE] [-i IF] -s HOSTNAME HWADDR [netmask MASK] pub" |
31 | //usage: "\n[-v] [-H HWTYPE] [-i IF] -Ds HOSTNAME IFACE [netmask MASK] pub" |
32 | //usage:#define arp_full_usage "\n\n" |
33 | //usage: "Manipulate ARP cache\n" |
34 | //usage: "\n -a Display (all) hosts" |
35 | //usage: "\n -d Delete ARP entry" |
36 | //usage: "\n -s Set new entry" |
37 | //usage: "\n -v Verbose" |
38 | //usage: "\n -n Don't resolve names" |
39 | //usage: "\n -i IF Network interface" |
40 | //usage: "\n -D Read HWADDR from IFACE" |
41 | //usage: "\n -A,-p AF Protocol family" |
42 | //usage: "\n -H HWTYPE Hardware address type" |
43 | |
44 | #include "libbb.h" |
45 | #include "common_bufsiz.h" |
46 | #include "inet_common.h" |
47 | |
48 | #include <arpa/inet.h> |
49 | #include <net/if.h> |
50 | #include <net/if_arp.h> |
51 | #include <netinet/ether.h> |
52 | #include <netpacket/packet.h> |
53 | |
54 | #define DEBUG 0 |
55 | |
56 | #define DFLT_AF "inet" |
57 | #define DFLT_HW "ether" |
58 | |
59 | enum { |
60 | ARP_OPT_A = (1 << 0), |
61 | ARP_OPT_p = (1 << 1), |
62 | ARP_OPT_H = (1 << 2), |
63 | ARP_OPT_t = (1 << 3), |
64 | ARP_OPT_i = (1 << 4), |
65 | ARP_OPT_a = (1 << 5), |
66 | ARP_OPT_d = (1 << 6), |
67 | ARP_OPT_n = (1 << 7), /* do not resolve addresses */ |
68 | ARP_OPT_D = (1 << 8), /* HW-address is devicename */ |
69 | ARP_OPT_s = (1 << 9), |
70 | ARP_OPT_v = (1 << 10) * DEBUG, /* debugging output flag */ |
71 | }; |
72 | |
73 | enum { |
74 | sockfd = 3, /* active socket descriptor */ |
75 | }; |
76 | |
77 | struct globals { |
78 | const struct aftype *ap; /* current address family */ |
79 | const struct hwtype *hw; /* current hardware type */ |
80 | const char *device; /* current device */ |
81 | smallint hw_set; /* flag if hw-type was set (-H) */ |
82 | } FIX_ALIASING; |
83 | #define G (*(struct globals*)bb_common_bufsiz1) |
84 | #define ap (G.ap ) |
85 | #define hw (G.hw ) |
86 | #define device (G.device ) |
87 | #define hw_set (G.hw_set ) |
88 | #define INIT_G() do { \ |
89 | setup_common_bufsiz(); \ |
90 | device = ""; \ |
91 | } while (0) |
92 | |
93 | |
94 | static const char options[] ALIGN1 = |
95 | "pub\0" |
96 | "priv\0" |
97 | "temp\0" |
98 | "trail\0" |
99 | "dontpub\0" |
100 | "auto\0" |
101 | "dev\0" |
102 | "netmask\0"; |
103 | |
104 | /* Delete an entry from the ARP cache. */ |
105 | /* Called only from main, once */ |
106 | static int arp_del(char **args) |
107 | { |
108 | char *host; |
109 | struct arpreq req; |
110 | struct sockaddr sa; |
111 | int flags = 0; |
112 | int err; |
113 | |
114 | memset(&req, 0, sizeof(req)); |
115 | |
116 | /* Resolve the host name. */ |
117 | host = *args; |
118 | if (ap->input(host, &sa) < 0) { |
119 | bb_herror_msg_and_die("%s", host); |
120 | } |
121 | |
122 | /* If a host has more than one address, use the correct one! */ |
123 | memcpy(&req.arp_pa, &sa, sizeof(struct sockaddr)); |
124 | |
125 | if (hw_set) |
126 | req.arp_ha.sa_family = hw->type; |
127 | |
128 | req.arp_flags = ATF_PERM; |
129 | args++; |
130 | while (*args != NULL) { |
131 | switch (index_in_strings(options, *args)) { |
132 | case 0: /* "pub" */ |
133 | flags |= 1; |
134 | args++; |
135 | break; |
136 | case 1: /* "priv" */ |
137 | flags |= 2; |
138 | args++; |
139 | break; |
140 | case 2: /* "temp" */ |
141 | req.arp_flags &= ~ATF_PERM; |
142 | args++; |
143 | break; |
144 | case 3: /* "trail" */ |
145 | req.arp_flags |= ATF_USETRAILERS; |
146 | args++; |
147 | break; |
148 | case 4: /* "dontpub" */ |
149 | #ifdef HAVE_ATF_DONTPUB |
150 | req.arp_flags |= ATF_DONTPUB; |
151 | #else |
152 | bb_error_msg("feature ATF_DONTPUB is not supported"); |
153 | #endif |
154 | args++; |
155 | break; |
156 | case 5: /* "auto" */ |
157 | #ifdef HAVE_ATF_MAGIC |
158 | req.arp_flags |= ATF_MAGIC; |
159 | #else |
160 | bb_error_msg("feature ATF_MAGIC is not supported"); |
161 | #endif |
162 | args++; |
163 | break; |
164 | case 6: /* "dev" */ |
165 | if (*++args == NULL) |
166 | bb_show_usage(); |
167 | device = *args; |
168 | args++; |
169 | break; |
170 | case 7: /* "netmask" */ |
171 | if (*++args == NULL) |
172 | bb_show_usage(); |
173 | if (strcmp(*args, "255.255.255.255") != 0) { |
174 | host = *args; |
175 | if (ap->input(host, &sa) < 0) { |
176 | bb_herror_msg_and_die("%s", host); |
177 | } |
178 | memcpy(&req.arp_netmask, &sa, sizeof(struct sockaddr)); |
179 | req.arp_flags |= ATF_NETMASK; |
180 | } |
181 | args++; |
182 | break; |
183 | default: |
184 | bb_show_usage(); |
185 | break; |
186 | } |
187 | } |
188 | if (flags == 0) |
189 | flags = 3; |
190 | |
191 | strncpy_IFNAMSIZ(req.arp_dev, device); |
192 | |
193 | err = -1; |
194 | |
195 | /* Call the kernel. */ |
196 | if (flags & 2) { |
197 | if (option_mask32 & ARP_OPT_v) |
198 | bb_error_msg("SIOCDARP(nopub)"); |
199 | err = ioctl(sockfd, SIOCDARP, &req); |
200 | if (err < 0) { |
201 | if (errno == ENXIO) { |
202 | if (flags & 1) |
203 | goto nopub; |
204 | printf("No ARP entry for %s\n", host); |
205 | return -1; |
206 | } |
207 | bb_perror_msg_and_die("SIOCDARP(priv)"); |
208 | } |
209 | } |
210 | if ((flags & 1) && err) { |
211 | nopub: |
212 | req.arp_flags |= ATF_PUBL; |
213 | if (option_mask32 & ARP_OPT_v) |
214 | bb_error_msg("SIOCDARP(pub)"); |
215 | if (ioctl(sockfd, SIOCDARP, &req) < 0) { |
216 | if (errno == ENXIO) { |
217 | printf("No ARP entry for %s\n", host); |
218 | return -1; |
219 | } |
220 | bb_perror_msg_and_die("SIOCDARP(pub)"); |
221 | } |
222 | } |
223 | return 0; |
224 | } |
225 | |
226 | /* Get the hardware address to a specified interface name */ |
227 | static void arp_getdevhw(char *ifname, struct sockaddr *sa) |
228 | { |
229 | struct ifreq ifr; |
230 | const struct hwtype *xhw; |
231 | |
232 | strncpy_IFNAMSIZ(ifr.ifr_name, ifname); |
233 | ioctl_or_perror_and_die(sockfd, SIOCGIFHWADDR, &ifr, |
234 | "can't get HW-Address for '%s'", ifname); |
235 | if (hw_set && (ifr.ifr_hwaddr.sa_family != hw->type)) { |
236 | bb_error_msg_and_die("protocol type mismatch"); |
237 | } |
238 | memcpy(sa, &(ifr.ifr_hwaddr), sizeof(struct sockaddr)); |
239 | |
240 | if (option_mask32 & ARP_OPT_v) { |
241 | xhw = get_hwntype(ifr.ifr_hwaddr.sa_family); |
242 | if (!xhw || !xhw->print) { |
243 | xhw = get_hwntype(-1); |
244 | } |
245 | bb_error_msg("device '%s' has HW address %s '%s'", |
246 | ifname, xhw->name, |
247 | xhw->print((unsigned char *) &ifr.ifr_hwaddr.sa_data)); |
248 | } |
249 | } |
250 | |
251 | /* Set an entry in the ARP cache. */ |
252 | /* Called only from main, once */ |
253 | static int arp_set(char **args) |
254 | { |
255 | char *host; |
256 | struct arpreq req; |
257 | struct sockaddr sa; |
258 | int flags; |
259 | |
260 | memset(&req, 0, sizeof(req)); |
261 | |
262 | host = *args++; |
263 | if (ap->input(host, &sa) < 0) { |
264 | bb_herror_msg_and_die("%s", host); |
265 | } |
266 | /* If a host has more than one address, use the correct one! */ |
267 | memcpy(&req.arp_pa, &sa, sizeof(struct sockaddr)); |
268 | |
269 | /* Fetch the hardware address. */ |
270 | if (*args == NULL) { |
271 | bb_error_msg_and_die("need hardware address"); |
272 | } |
273 | if (option_mask32 & ARP_OPT_D) { |
274 | arp_getdevhw(*args++, &req.arp_ha); |
275 | } else { |
276 | if (hw->input(*args++, &req.arp_ha) < 0) { |
277 | bb_error_msg_and_die("invalid hardware address"); |
278 | } |
279 | } |
280 | |
281 | /* Check out any modifiers. */ |
282 | flags = ATF_PERM | ATF_COM; |
283 | while (*args != NULL) { |
284 | switch (index_in_strings(options, *args)) { |
285 | case 0: /* "pub" */ |
286 | flags |= ATF_PUBL; |
287 | args++; |
288 | break; |
289 | case 1: /* "priv" */ |
290 | flags &= ~ATF_PUBL; |
291 | args++; |
292 | break; |
293 | case 2: /* "temp" */ |
294 | flags &= ~ATF_PERM; |
295 | args++; |
296 | break; |
297 | case 3: /* "trail" */ |
298 | flags |= ATF_USETRAILERS; |
299 | args++; |
300 | break; |
301 | case 4: /* "dontpub" */ |
302 | #ifdef HAVE_ATF_DONTPUB |
303 | flags |= ATF_DONTPUB; |
304 | #else |
305 | bb_error_msg("feature ATF_DONTPUB is not supported"); |
306 | #endif |
307 | args++; |
308 | break; |
309 | case 5: /* "auto" */ |
310 | #ifdef HAVE_ATF_MAGIC |
311 | flags |= ATF_MAGIC; |
312 | #else |
313 | bb_error_msg("feature ATF_MAGIC is not supported"); |
314 | #endif |
315 | args++; |
316 | break; |
317 | case 6: /* "dev" */ |
318 | if (*++args == NULL) |
319 | bb_show_usage(); |
320 | device = *args; |
321 | args++; |
322 | break; |
323 | case 7: /* "netmask" */ |
324 | if (*++args == NULL) |
325 | bb_show_usage(); |
326 | if (strcmp(*args, "255.255.255.255") != 0) { |
327 | host = *args; |
328 | if (ap->input(host, &sa) < 0) { |
329 | bb_herror_msg_and_die("%s", host); |
330 | } |
331 | memcpy(&req.arp_netmask, &sa, sizeof(struct sockaddr)); |
332 | flags |= ATF_NETMASK; |
333 | } |
334 | args++; |
335 | break; |
336 | default: |
337 | bb_show_usage(); |
338 | break; |
339 | } |
340 | } |
341 | |
342 | /* Fill in the remainder of the request. */ |
343 | req.arp_flags = flags; |
344 | |
345 | strncpy_IFNAMSIZ(req.arp_dev, device); |
346 | |
347 | /* Call the kernel. */ |
348 | if (option_mask32 & ARP_OPT_v) |
349 | bb_error_msg("SIOCSARP()"); |
350 | xioctl(sockfd, SIOCSARP, &req); |
351 | return 0; |
352 | } |
353 | |
354 | |
355 | /* Print the contents of an ARP request block. */ |
356 | static void |
357 | arp_disp(const char *name, char *ip, int type, int arp_flags, |
358 | char *hwa, char *mask, char *dev) |
359 | { |
360 | static const int arp_masks[] = { |
361 | ATF_PERM, ATF_PUBL, |
362 | #ifdef HAVE_ATF_MAGIC |
363 | ATF_MAGIC, |
364 | #endif |
365 | #ifdef HAVE_ATF_DONTPUB |
366 | ATF_DONTPUB, |
367 | #endif |
368 | ATF_USETRAILERS, |
369 | }; |
370 | static const char arp_labels[] ALIGN1 = "PERM\0""PUP\0" |
371 | #ifdef HAVE_ATF_MAGIC |
372 | "AUTO\0" |
373 | #endif |
374 | #ifdef HAVE_ATF_DONTPUB |
375 | "DONTPUB\0" |
376 | #endif |
377 | "TRAIL\0" |
378 | ; |
379 | |
380 | const struct hwtype *xhw; |
381 | |
382 | xhw = get_hwntype(type); |
383 | if (xhw == NULL) |
384 | xhw = get_hwtype(DFLT_HW); |
385 | |
386 | printf("%s (%s) at ", name, ip); |
387 | |
388 | if (!(arp_flags & ATF_COM)) { |
389 | if (arp_flags & ATF_PUBL) |
390 | printf("* "); |
391 | else |
392 | printf("<incomplete> "); |
393 | } else { |
394 | printf("%s [%s] ", hwa, xhw->name); |
395 | } |
396 | |
397 | if (arp_flags & ATF_NETMASK) |
398 | printf("netmask %s ", mask); |
399 | |
400 | print_flags_separated(arp_masks, arp_labels, arp_flags, " "); |
401 | printf(" on %s\n", dev); |
402 | } |
403 | |
404 | /* Display the contents of the ARP cache in the kernel. */ |
405 | /* Called only from main, once */ |
406 | static int arp_show(char *name) |
407 | { |
408 | const char *host; |
409 | const char *hostname; |
410 | FILE *fp; |
411 | struct sockaddr sa; |
412 | int type, flags; |
413 | int num; |
414 | unsigned entries = 0, shown = 0; |
415 | char ip[128]; |
416 | char hwa[128]; |
417 | char mask[128]; |
418 | char line[128]; |
419 | char dev[128]; |
420 | |
421 | host = NULL; |
422 | if (name != NULL) { |
423 | /* Resolve the host name. */ |
424 | if (ap->input(name, &sa) < 0) { |
425 | bb_herror_msg_and_die("%s", name); |
426 | } |
427 | host = xstrdup(ap->sprint(&sa, 1)); |
428 | } |
429 | fp = xfopen_for_read("/proc/net/arp"); |
430 | /* Bypass header -- read one line */ |
431 | fgets(line, sizeof(line), fp); |
432 | |
433 | /* Read the ARP cache entries. */ |
434 | while (fgets(line, sizeof(line), fp)) { |
435 | |
436 | mask[0] = '-'; mask[1] = '\0'; |
437 | dev[0] = '-'; dev[1] = '\0'; |
438 | /* All these strings can't overflow |
439 | * because fgets above reads limited amount of data */ |
440 | num = sscanf(line, "%s 0x%x 0x%x %s %s %s\n", |
441 | ip, &type, &flags, hwa, mask, dev); |
442 | if (num < 4) |
443 | break; |
444 | |
445 | entries++; |
446 | /* if the user specified hw-type differs, skip it */ |
447 | if (hw_set && (type != hw->type)) |
448 | continue; |
449 | |
450 | /* if the user specified address differs, skip it */ |
451 | if (host && strcmp(ip, host) != 0) |
452 | continue; |
453 | |
454 | /* if the user specified device differs, skip it */ |
455 | if (device[0] && strcmp(dev, device) != 0) |
456 | continue; |
457 | |
458 | shown++; |
459 | /* This IS ugly but it works -be */ |
460 | hostname = "?"; |
461 | if (!(option_mask32 & ARP_OPT_n)) { |
462 | if (ap->input(ip, &sa) < 0) |
463 | hostname = ip; |
464 | else |
465 | hostname = ap->sprint(&sa, (option_mask32 & ARP_OPT_n) | 0x8000); |
466 | if (strcmp(hostname, ip) == 0) |
467 | hostname = "?"; |
468 | } |
469 | |
470 | arp_disp(hostname, ip, type, flags, hwa, mask, dev); |
471 | } |
472 | if (option_mask32 & ARP_OPT_v) |
473 | printf("Entries: %u\tSkipped: %u\tFound: %u\n", |
474 | entries, entries - shown, shown); |
475 | |
476 | if (!shown) { |
477 | if (hw_set || host || device[0]) |
478 | printf("No match found in %u entries\n", entries); |
479 | } |
480 | if (ENABLE_FEATURE_CLEAN_UP) { |
481 | free((char*)host); |
482 | fclose(fp); |
483 | } |
484 | return 0; |
485 | } |
486 | |
487 | int arp_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE; |
488 | int arp_main(int argc UNUSED_PARAM, char **argv) |
489 | { |
490 | const char *hw_type; |
491 | const char *protocol; |
492 | unsigned opts; |
493 | |
494 | INIT_G(); |
495 | |
496 | xmove_fd(xsocket(AF_INET, SOCK_DGRAM, 0), sockfd); |
497 | |
498 | ap = get_aftype(DFLT_AF); |
499 | /* Defaults are always supported */ |
500 | //if (!ap) |
501 | // bb_error_msg_and_die("%s: %s not supported", DFLT_AF, "address family"); |
502 | hw = get_hwtype(DFLT_HW); |
503 | //if (!hw) |
504 | // bb_error_msg_and_die("%s: %s not supported", DFLT_HW, "hardware type"); |
505 | |
506 | opts = getopt32(argv, "A:p:H:t:i:adnDsv", &protocol, &protocol, |
507 | &hw_type, &hw_type, &device); |
508 | argv += optind; |
509 | if (opts & (ARP_OPT_A | ARP_OPT_p)) { |
510 | ap = get_aftype(protocol); |
511 | if (!ap) |
512 | bb_error_msg_and_die("%s: unknown %s", protocol, "address family"); |
513 | } |
514 | if (opts & (ARP_OPT_H | ARP_OPT_t)) { |
515 | hw = get_hwtype(hw_type); |
516 | if (!hw) |
517 | bb_error_msg_and_die("%s: unknown %s", hw_type, "hardware type"); |
518 | hw_set = 1; |
519 | } |
520 | //if (opts & ARP_OPT_i)... -i |
521 | |
522 | if (ap->af != AF_INET) { |
523 | bb_error_msg_and_die("%s: kernel only supports 'inet'", ap->name); |
524 | } |
525 | if (hw->alen <= 0) { |
526 | bb_error_msg_and_die("%s: %s without ARP support", |
527 | hw->name, "hardware type"); |
528 | } |
529 | |
530 | /* Now see what we have to do here... */ |
531 | if (opts & (ARP_OPT_d | ARP_OPT_s)) { |
532 | if (argv[0] == NULL) |
533 | bb_error_msg_and_die("need host name"); |
534 | if (opts & ARP_OPT_s) |
535 | return arp_set(argv); |
536 | return arp_del(argv); |
537 | } |
538 | |
539 | //if (opts & ARP_OPT_a) - default |
540 | return arp_show(argv[0]); |
541 | } |
542 |