xref: /illumos-gate/usr/src/cmd/cmd-inet/usr.sbin/arp.c (revision 2545d10d)
1 /*
2  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
3  * Use is subject to license terms.
4  */
5 /*
6  * Copyright (c) 1984 Regents of the University of California.
7  * All rights reserved.
8  *
9  * This code is derived from software contributed to Berkeley by
10  * Sun Microsystems, Inc.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  * 3. All advertising materials mentioning features or use of this software
21  *    must display the following acknowledgement:
22  *      This product includes software developed by the University of
23  *      California, Berkeley and its contributors.
24  * 4. Neither the name of the University nor the names of its contributors
25  *    may be used to endorse or promote products derived from this software
26  *    without specific prior written permission.
27  *
28  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
29  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
30  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
31  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
32  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
33  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
34  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
35  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
36  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
37  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
38  * SUCH DAMAGE.
39  */
40 
41 
42 /*
43  * arp - display, set, and delete arp table entries
44  */
45 
46 #include <stdio.h>
47 #include <sys/types.h>
48 #include <sys/socket.h>
49 #include <netinet/in.h>
50 #include <sys/ioctl.h>
51 #include <errno.h>
52 #include <netdb.h>
53 #include <net/if.h>
54 #include <net/if_arp.h>
55 #include <stdlib.h>
56 #include <unistd.h>
57 #include <string.h>
58 #include <arpa/inet.h>
59 #include <net/if_types.h>
60 #include <net/if_dl.h>
61 
62 static int file(char *);
63 static int set(int, char *[]);
64 static void get(char *);
65 static void delete(char *);
66 static void usage(void);
67 
68 int
main(int argc,char * argv[])69 main(int argc, char *argv[])
70 {
71 	int c, nflags = 0, argsleft;
72 	int n_flag, a_flag, d_flag, f_flag, s_flag;
73 
74 	n_flag = a_flag = d_flag = f_flag = s_flag = 0;
75 
76 #define	CASE(x, y)				\
77 		case x:				\
78 			if (nflags > 0) {	\
79 				usage();	\
80 				exit(1);	\
81 			} else			\
82 				y##_flag = 1;	\
83 				nflags++;	\
84 			break
85 
86 	while ((c = getopt(argc, argv, "nadfs")) != EOF) {
87 		switch (c) {
88 		case '?':
89 			usage();
90 			exit(1);
91 			/* NOTREACHED */
92 			break;
93 		case 'n':
94 			n_flag = 1;
95 			break;
96 		CASE('a', a);
97 		CASE('d', d);
98 		CASE('f', f);
99 		CASE('s', s);
100 		}
101 	}
102 
103 #undef CASE
104 
105 	/*
106 	 * -n only allowed with -a
107 	 */
108 	if (n_flag && !a_flag) {
109 		usage();
110 		exit(1);
111 	}
112 
113 	argsleft = argc - optind;
114 
115 	if (a_flag && (argsleft == 0)) {
116 		/*
117 		 * the easiest way to get the complete arp table
118 		 * is to let netstat, which prints it as part of
119 		 * the MIB statistics, do it.
120 		 */
121 		(void) execl("/usr/bin/netstat", "netstat",
122 		    (n_flag ? "-np" : "-p"),
123 		    "-f", "inet", (char *)0);
124 		(void) fprintf(stderr, "failed to exec netstat: %s\n",
125 		    strerror(errno));
126 		exit(1);
127 
128 	} else if (s_flag && (argsleft >= 2)) {
129 		if (set(argsleft, &argv[optind]) != 0)
130 			exit(1);
131 
132 	} else if (d_flag && (argsleft == 1)) {
133 		delete(argv[optind]);
134 
135 	} else if (f_flag && (argsleft == 1)) {
136 		if (file(argv[optind]) != 0)
137 			exit(1);
138 
139 	} else if ((nflags == 0) && (argsleft == 1)) {
140 		get(argv[optind]);
141 
142 	} else {
143 		usage();
144 		exit(1);
145 	}
146 	return (0);
147 }
148 
149 /*
150  * Process a file to set standard arp entries
151  */
152 static int
file(char * name)153 file(char *name)
154 {
155 	/*
156 	 * A line of input can be:
157 	 * <hostname> <macaddr> ["temp"] ["pub"] ["trail"] ["permanent"]
158 	 */
159 #define	MAX_LINE_LEN	(MAXHOSTNAMELEN + \
160 	sizeof (" xx:xx:xx:xx:xx:xx temp pub trail permanent\n"))
161 #define	MIN_ARGS	2
162 #define	MAX_ARGS	5
163 
164 	FILE *fp;
165 	char line[MAX_LINE_LEN];
166 	int retval;
167 
168 	if ((fp = fopen(name, "r")) == NULL) {
169 		(void) fprintf(stderr, "arp: cannot open %s\n", name);
170 		exit(1);
171 	}
172 
173 	retval = 0;
174 	while (fgets(line, MAX_LINE_LEN, fp) != NULL) {
175 		char line_copy[MAX_LINE_LEN];
176 		char *args[MAX_ARGS];
177 		char *start;
178 		int i;
179 
180 		/*
181 		 * Keep a copy of the un-altered line for error
182 		 * reporting.
183 		 */
184 		(void) strlcpy(line_copy, line, MAX_LINE_LEN);
185 
186 		start = line_copy;
187 		for (i = 0; i < MAX_ARGS; i++) {
188 			if ((args[i] = strtok(start, " \t\n")) == NULL)
189 				break;
190 
191 			start = NULL;
192 		}
193 
194 		if (i < MIN_ARGS) {
195 			(void) fprintf(stderr, "arp: bad line: %s\n",
196 			    line);
197 			retval = 1;
198 			continue;
199 		}
200 
201 		if (set(i, args) != 0)
202 			retval = 1;
203 	}
204 
205 #undef	MAX_LINE_LEN
206 #undef	MIN_ARGS
207 #undef	MAX_ARGS
208 
209 	(void) fclose(fp);
210 	return (retval);
211 }
212 
213 /*
214  * Set an individual arp entry
215  */
216 static int
set(int argc,char * argv[])217 set(int argc, char *argv[])
218 {
219 	struct xarpreq ar;
220 	struct hostent *hp;
221 	struct sockaddr_in *sin;
222 	uchar_t *ea;
223 	int s;
224 	char *host = argv[0], *eaddr = argv[1];
225 
226 	argc -= 2;
227 	argv += 2;
228 	(void) memset(&ar, 0, sizeof (ar));
229 	sin = (struct sockaddr_in *)&ar.xarp_pa;
230 	sin->sin_family = AF_INET;
231 	sin->sin_addr.s_addr = inet_addr(host);
232 	if (sin->sin_addr.s_addr == (in_addr_t)-1) {
233 		hp = gethostbyname(host);
234 		if (hp == NULL) {
235 			(void) fprintf(stderr, "arp: %s: unknown host\n",
236 			    host);
237 			return (1);
238 		}
239 		(void) memcpy(&sin->sin_addr, hp->h_addr,
240 		    sizeof (sin->sin_addr));
241 	}
242 	ea = _link_aton(eaddr, &s);
243 	if (ea == NULL) {
244 		if (s == -1) {
245 			(void) fprintf(stderr,
246 			    "arp: invalid link layer address '%s'\n", eaddr);
247 			return (1);
248 		}
249 		perror("arp: nomem");
250 		exit(1);
251 	}
252 	ar.xarp_ha.sdl_alen = s;
253 	(void) memcpy(LLADDR(&ar.xarp_ha), ea, ar.xarp_ha.sdl_alen);
254 	free(ea);
255 	ar.xarp_ha.sdl_family = AF_LINK;
256 	ar.xarp_flags = ATF_PERM;
257 	while (argc-- > 0) {
258 		if (strncmp(argv[0], "temp", 4) == 0) {
259 			ar.xarp_flags &= ~ATF_PERM;
260 		} else if (strncmp(argv[0], "pub", 3) == 0) {
261 			ar.xarp_flags |= ATF_PUBL;
262 		} else if (strncmp(argv[0], "trail", 5) == 0) {
263 			ar.xarp_flags |= ATF_USETRAILERS;
264 		} else if (strcmp(argv[0], "permanent") == 0) {
265 			ar.xarp_flags |= ATF_AUTHORITY;
266 		} else {
267 			(void) fprintf(stderr,
268 			    "arp: unknown keyword '%s'\n", argv[0]);
269 			return (1);
270 		}
271 		argv++;
272 	}
273 
274 	if ((ar.xarp_flags & (ATF_PERM|ATF_AUTHORITY)) == ATF_AUTHORITY) {
275 		(void) fprintf(stderr, "arp: 'temp' and 'permanent' flags are "
276 		    "not usable together.\n");
277 		return (1);
278 	}
279 
280 	s = socket(AF_INET, SOCK_DGRAM, 0);
281 	if (s < 0) {
282 		perror("arp: socket");
283 		exit(1);
284 	}
285 	if (ioctl(s, SIOCSXARP, (caddr_t)&ar) < 0) {
286 		perror(host);
287 		exit(1);
288 	}
289 	(void) close(s);
290 	return (0);
291 }
292 
293 /*
294  * Display an individual arp entry
295  */
296 static void
get(char * host)297 get(char *host)
298 {
299 	struct xarpreq ar;
300 	struct hostent *hp;
301 	struct sockaddr_in *sin;
302 	uchar_t *ea;
303 	int s;
304 	char *str = NULL;
305 
306 	(void) memset(&ar, 0, sizeof (ar));
307 	sin = (struct sockaddr_in *)&ar.xarp_pa;
308 	sin->sin_family = AF_INET;
309 	sin->sin_addr.s_addr = inet_addr(host);
310 	if (sin->sin_addr.s_addr == (in_addr_t)-1) {
311 		hp = gethostbyname(host);
312 		if (hp == NULL) {
313 			(void) fprintf(stderr, "arp: %s: unknown host\n",
314 			    host);
315 			exit(1);
316 		}
317 		(void) memcpy(&sin->sin_addr, hp->h_addr,
318 		    sizeof (sin->sin_addr));
319 	}
320 	s = socket(AF_INET, SOCK_DGRAM, 0);
321 	if (s < 0) {
322 		perror("arp: socket");
323 		exit(1);
324 	}
325 	ar.xarp_ha.sdl_family = AF_LINK;
326 	if (ioctl(s, SIOCGXARP, (caddr_t)&ar) < 0) {
327 		if (errno == ENXIO)
328 			(void) printf("%s (%s) -- no entry\n",
329 			    host, inet_ntoa(sin->sin_addr));
330 		else
331 			perror("SIOCGXARP");
332 		exit(1);
333 	}
334 	(void) close(s);
335 	ea = (uchar_t *)LLADDR(&ar.xarp_ha);
336 	if (ar.xarp_flags & ATF_COM) {
337 		str = _link_ntoa(ea, str, ar.xarp_ha.sdl_alen, IFT_OTHER);
338 		if (str != NULL) {
339 			(void) printf("%s (%s) at %s", host,
340 			    inet_ntoa(sin->sin_addr), str);
341 			free(str);
342 		} else {
343 			perror("arp: nomem");
344 			exit(1);
345 		}
346 	} else {
347 		(void) printf("%s (%s) at (incomplete)", host,
348 		    inet_ntoa(sin->sin_addr));
349 	}
350 	if (!(ar.xarp_flags & ATF_PERM))
351 		(void) printf(" temp");
352 	if (ar.xarp_flags & ATF_PUBL)
353 		(void) printf(" pub");
354 	if (ar.xarp_flags & ATF_USETRAILERS)
355 		(void) printf(" trail");
356 	if (ar.xarp_flags & ATF_AUTHORITY)
357 		(void) printf(" permanent");
358 	(void) printf("\n");
359 }
360 
361 /*
362  * Delete an arp entry
363  */
364 static void
delete(char * host)365 delete(char *host)
366 {
367 	struct xarpreq ar;
368 	struct hostent *hp;
369 	struct sockaddr_in *sin;
370 	int s;
371 
372 	(void) memset(&ar, 0, sizeof (ar));
373 	sin = (struct sockaddr_in *)&ar.xarp_pa;
374 	sin->sin_family = AF_INET;
375 	sin->sin_addr.s_addr = inet_addr(host);
376 	if (sin->sin_addr.s_addr == (in_addr_t)-1) {
377 		hp = gethostbyname(host);
378 		if (hp == NULL) {
379 			(void) fprintf(stderr, "arp: %s: unknown host\n",
380 			    host);
381 			exit(1);
382 		}
383 		(void) memcpy(&sin->sin_addr, hp->h_addr,
384 		    sizeof (sin->sin_addr));
385 	}
386 	s = socket(AF_INET, SOCK_DGRAM, 0);
387 	if (s < 0) {
388 		perror("arp: socket");
389 		exit(1);
390 	}
391 	ar.xarp_ha.sdl_family = AF_LINK;
392 	if (ioctl(s, SIOCDXARP, (caddr_t)&ar) < 0) {
393 		if (errno == ENXIO)
394 			(void) printf("%s (%s) -- no entry\n",
395 			    host, inet_ntoa(sin->sin_addr));
396 		else
397 			perror("SIOCDXARP");
398 		exit(1);
399 	}
400 	(void) close(s);
401 	(void) printf("%s (%s) deleted\n", host, inet_ntoa(sin->sin_addr));
402 }
403 
404 static void
usage(void)405 usage(void)
406 {
407 	(void) printf("Usage: arp hostname\n");
408 	(void) printf("       arp -a [-n]\n");
409 	(void) printf("       arp -d hostname\n");
410 	(void) printf("       arp -s hostname ether_addr "
411 	    "[temp] [pub] [trail] [permanent]\n");
412 	(void) printf("       arp -f filename\n");
413 }
414