1 /*
2 * Copyright (c) 2004, 2005 The DragonFly Project. All rights reserved.
3 *
4 * This code is derived from software contributed to The DragonFly Project
5 * by Jeffrey M. Hsu.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of The DragonFly Project nor the names of its
16 * contributors may be used to endorse or promote products derived
17 * from this software without specific, prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
23 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
24 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
25 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
27 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
28 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
29 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30 * SUCH DAMAGE.
31 */
32
33 /*
34 * Copyright (c) 1982, 1986, 1988, 1993
35 * The Regents of the University of California. All rights reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 * 3. Neither the name of the University nor the names of its contributors
46 * may be used to endorse or promote products derived from this software
47 * without specific prior written permission.
48 *
49 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59 * SUCH DAMAGE.
60 *
61 * @(#)if_ether.c 8.1 (Berkeley) 6/10/93
62 * $FreeBSD: src/sys/netinet/if_ether.c,v 1.64.2.23 2003/04/11 07:23:15 fjoe Exp $
63 */
64
65 /*
66 * Ethernet address resolution protocol.
67 * TODO:
68 * add "inuse/lock" bit (or ref. count) along with valid bit
69 */
70
71 #include "opt_inet.h"
72 #include "opt_carp.h"
73
74 #include <sys/param.h>
75 #include <sys/kernel.h>
76 #include <sys/queue.h>
77 #include <sys/sysctl.h>
78 #include <sys/systm.h>
79 #include <sys/mbuf.h>
80 #include <sys/malloc.h>
81 #include <sys/socket.h>
82 #include <sys/syslog.h>
83 #include <sys/lock.h>
84
85 #include <net/if.h>
86 #include <net/if_dl.h>
87 #include <net/if_types.h>
88 #include <net/route.h>
89 #include <net/netisr.h>
90 #include <net/if_llc.h>
91
92 #include <netinet/in.h>
93 #include <netinet/in_var.h>
94 #include <netinet/if_ether.h>
95
96 #include <sys/thread2.h>
97 #include <sys/msgport2.h>
98 #include <net/netmsg2.h>
99 #include <net/netisr2.h>
100
101 #ifdef CARP
102 #include <netinet/ip_carp.h>
103 #endif
104
105 #define SIN(s) ((struct sockaddr_in *)s)
106 #define SDL(s) ((struct sockaddr_dl *)s)
107
108 MALLOC_DEFINE(M_ARP, "arp", "ARP");
109
110 SYSCTL_DECL(_net_link_ether);
111 SYSCTL_NODE(_net_link_ether, PF_INET, inet, CTLFLAG_RW, 0, "");
112
113 /* timer values */
114 static int arpt_prune = (5*60*1); /* walk list every 5 minutes */
115 static int arpt_keep = (20*60); /* once resolved, good for 20 more minutes */
116 static int arpt_down = 20; /* once declared down, don't send for 20 sec */
117
118 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, prune_intvl, CTLFLAG_RW,
119 &arpt_prune, 0, "");
120 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, max_age, CTLFLAG_RW,
121 &arpt_keep, 0, "");
122 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, host_down_time, CTLFLAG_RW,
123 &arpt_down, 0, "");
124
125 #define rt_expire rt_rmx.rmx_expire
126
127 struct llinfo_arp {
128 LIST_ENTRY(llinfo_arp) la_le;
129 struct rtentry *la_rt;
130 struct mbuf *la_hold; /* last packet until resolved/timeout */
131 u_short la_preempt; /* countdown for pre-expiry arps */
132 u_short la_asked; /* #times we QUERIED following expiration */
133 };
134
135 static int arp_maxtries = 5;
136 static int useloopback = 1; /* use loopback interface for local traffic */
137 static int arp_proxyall = 0;
138 static int arp_refresh = 60; /* refresh arp cache ~60 (not impl yet) */
139 static int arp_restricted_match = 0;
140 static int arp_ignore_probes = 1;
141
142 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, maxtries, CTLFLAG_RW,
143 &arp_maxtries, 0, "ARP resolution attempts before returning error");
144 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, useloopback, CTLFLAG_RW,
145 &useloopback, 0, "Use the loopback interface for local traffic");
146 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, proxyall, CTLFLAG_RW,
147 &arp_proxyall, 0, "Enable proxy ARP for all suitable requests");
148 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, restricted_match, CTLFLAG_RW,
149 &arp_restricted_match, 0, "Only match against the sender");
150 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, refresh, CTLFLAG_RW,
151 &arp_refresh, 0, "Preemptively refresh the ARP");
152 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, ignore_probes, CTLFLAG_RW,
153 &arp_ignore_probes, 0, "Ignore ARP probes");
154
155 static void arp_rtrequest(int, struct rtentry *);
156 static void arprequest(struct ifnet *, const struct in_addr *,
157 const struct in_addr *, const u_char *);
158 static void arprequest_async(struct ifnet *, const struct in_addr *,
159 const struct in_addr *, const u_char *);
160 static void arpintr(netmsg_t msg);
161 static void arptfree(struct llinfo_arp *);
162 static void arptimer(void *);
163 static struct llinfo_arp *
164 arplookup(in_addr_t, boolean_t, boolean_t);
165 #ifdef INET
166 static void in_arpinput(struct mbuf *);
167 static void in_arpreply(struct mbuf *m, in_addr_t, in_addr_t);
168 static void arp_update_msghandler(netmsg_t);
169 static void arp_reply_msghandler(netmsg_t);
170 #endif
171
172 struct arp_pcpu_data {
173 LIST_HEAD(, llinfo_arp) llinfo_list;
174 struct callout timer_ch;
175 struct netmsg_base timer_nmsg;
176 };
177
178 static struct arp_pcpu_data *arp_data[MAXCPU];
179
180 /*
181 * Timeout routine. Age arp_tab entries periodically.
182 */
183 static void
arptimer_dispatch(netmsg_t nmsg)184 arptimer_dispatch(netmsg_t nmsg)
185 {
186 struct arp_pcpu_data *ad = nmsg->lmsg.u.ms_resultp;
187 struct llinfo_arp *la, *nla;
188
189 ASSERT_NETISR_NCPUS(mycpuid);
190
191 /* Reply ASAP */
192 crit_enter();
193 netisr_replymsg(&nmsg->base, 0);
194 crit_exit();
195
196 LIST_FOREACH_MUTABLE(la, &ad->llinfo_list, la_le, nla) {
197 if (la->la_rt->rt_expire && la->la_rt->rt_expire <= time_uptime)
198 arptfree(la);
199 }
200 callout_reset(&ad->timer_ch, arpt_prune * hz, arptimer, &ad->timer_nmsg);
201 }
202
203 static void
arptimer(void * xnm)204 arptimer(void *xnm)
205 {
206 struct netmsg_base *nm = xnm;
207
208 KKASSERT(mycpuid < netisr_ncpus);
209
210 crit_enter();
211 if (nm->lmsg.ms_flags & MSGF_DONE)
212 netisr_sendmsg_oncpu(nm);
213 crit_exit();
214 }
215
216 /*
217 * Parallel to llc_rtrequest.
218 *
219 * Called after a route is successfully added to the tree to fix-up the
220 * route and initiate arp operations if required.
221 */
222 static void
arp_rtrequest(int req,struct rtentry * rt)223 arp_rtrequest(int req, struct rtentry *rt)
224 {
225 struct sockaddr *gate = rt->rt_gateway;
226 struct llinfo_arp *la = rt->rt_llinfo;
227
228 struct sockaddr_dl null_sdl = { sizeof null_sdl, AF_LINK };
229
230 if (rt->rt_flags & RTF_GATEWAY)
231 return;
232
233 switch (req) {
234 case RTM_ADD:
235 /*
236 * XXX: If this is a manually added route to interface
237 * such as older version of routed or gated might provide,
238 * restore cloning bit.
239 */
240 if (!(rt->rt_flags & RTF_HOST) &&
241 SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
242 rt->rt_flags |= RTF_CLONING;
243 if (rt->rt_flags & RTF_CLONING) {
244 /*
245 * Case 1: This route should come from a route to iface.
246 */
247 rt_setgate(rt, rt_key(rt),
248 (struct sockaddr *)&null_sdl);
249 gate = rt->rt_gateway;
250 SDL(gate)->sdl_type = rt->rt_ifp->if_type;
251 SDL(gate)->sdl_index = rt->rt_ifp->if_index;
252 rt->rt_expire = time_uptime;
253 break;
254 }
255 /*
256 * Announce a new entry if requested, and only announce it
257 * once on cpu0.
258 */
259 if ((rt->rt_flags & RTF_ANNOUNCE) && mycpuid == 0) {
260 arprequest(rt->rt_ifp,
261 &SIN(rt_key(rt))->sin_addr,
262 &SIN(rt_key(rt))->sin_addr,
263 LLADDR(SDL(gate)));
264 }
265 /*FALLTHROUGH*/
266 case RTM_RESOLVE:
267 if (gate->sa_family != AF_LINK ||
268 gate->sa_len < sizeof(struct sockaddr_dl)) {
269 log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
270 break;
271 }
272 SDL(gate)->sdl_type = rt->rt_ifp->if_type;
273 SDL(gate)->sdl_index = rt->rt_ifp->if_index;
274 if (la != NULL)
275 break; /* This happens on a route change */
276 /*
277 * Case 2: This route may come from cloning, or a manual route
278 * add with a LL address.
279 */
280 R_Malloc(la, struct llinfo_arp *, sizeof *la);
281 rt->rt_llinfo = la;
282 if (la == NULL) {
283 log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
284 break;
285 }
286 bzero(la, sizeof *la);
287 la->la_rt = rt;
288 rt->rt_flags |= RTF_LLINFO;
289 LIST_INSERT_HEAD(&arp_data[mycpuid]->llinfo_list, la, la_le);
290
291 #ifdef INET
292 /*
293 * This keeps the multicast addresses from showing up
294 * in `arp -a' listings as unresolved. It's not actually
295 * functional. Then the same for broadcast.
296 */
297 if (IN_MULTICAST(ntohl(SIN(rt_key(rt))->sin_addr.s_addr))) {
298 ETHER_MAP_IP_MULTICAST(&SIN(rt_key(rt))->sin_addr,
299 LLADDR(SDL(gate)));
300 SDL(gate)->sdl_alen = 6;
301 rt->rt_expire = 0;
302 }
303 if (in_broadcast(SIN(rt_key(rt))->sin_addr, rt->rt_ifp)) {
304 memcpy(LLADDR(SDL(gate)), rt->rt_ifp->if_broadcastaddr,
305 rt->rt_ifp->if_addrlen);
306 SDL(gate)->sdl_alen = rt->rt_ifp->if_addrlen;
307 rt->rt_expire = 0;
308 }
309 #endif
310
311 /*
312 * This fixes up the routing interface for local addresses.
313 * The route is adjusted to point at lo0 and the expiration
314 * timer is disabled.
315 *
316 * NOTE: This prevents locally targetted traffic from going
317 * out the hardware interface, which is inefficient
318 * and might not work if the hardware cannot listen
319 * to its own transmitted packets. Setting
320 * net.link.ether.inet.useloopback to 0 will force
321 * packets for local addresses out the hardware (and
322 * it is expected to receive its own packet).
323 *
324 * XXX We should just be able to test RTF_LOCAL here instead
325 * of having to compare IPs.
326 */
327 if (SIN(rt_key(rt))->sin_addr.s_addr ==
328 (IA_SIN(rt->rt_ifa))->sin_addr.s_addr) {
329 rt->rt_expire = 0;
330 SDL(gate)->sdl_alen = rt->rt_ifp->if_addrlen;
331 bcopy(IF_LLADDR(rt->rt_ifp), LLADDR(SDL(gate)),
332 rt->rt_ifp->if_addrlen);
333 if (useloopback)
334 rt->rt_ifp = loif;
335 }
336 break;
337
338 case RTM_DELETE:
339 if (la == NULL)
340 break;
341 LIST_REMOVE(la, la_le);
342 rt->rt_llinfo = NULL;
343 rt->rt_flags &= ~RTF_LLINFO;
344 if (la->la_hold != NULL)
345 m_freem(la->la_hold);
346 R_Free(la);
347 break;
348 }
349 }
350
351 static struct mbuf *
arpreq_alloc(struct ifnet * ifp,const struct in_addr * sip,const struct in_addr * tip,const u_char * enaddr)352 arpreq_alloc(struct ifnet *ifp, const struct in_addr *sip,
353 const struct in_addr *tip, const u_char *enaddr)
354 {
355 struct mbuf *m;
356 struct arphdr *ah;
357 u_short ar_hrd;
358
359 if ((m = m_gethdr(M_NOWAIT, MT_DATA)) == NULL)
360 return NULL;
361 m->m_pkthdr.rcvif = NULL;
362
363 switch (ifp->if_type) {
364 case IFT_ETHER:
365 /*
366 * This may not be correct for types not explicitly
367 * listed, but this is our best guess
368 */
369 default:
370 ar_hrd = htons(ARPHRD_ETHER);
371
372 m->m_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
373 m->m_pkthdr.len = m->m_len;
374 MH_ALIGN(m, m->m_len);
375
376 ah = mtod(m, struct arphdr *);
377 break;
378 }
379
380 ah->ar_hrd = ar_hrd;
381 ah->ar_pro = htons(ETHERTYPE_IP);
382 ah->ar_hln = ifp->if_addrlen; /* hardware address length */
383 ah->ar_pln = sizeof(struct in_addr); /* protocol address length */
384 ah->ar_op = htons(ARPOP_REQUEST);
385 memcpy(ar_sha(ah), enaddr, ah->ar_hln);
386 memset(ar_tha(ah), 0, ah->ar_hln);
387 memcpy(ar_spa(ah), sip, ah->ar_pln);
388 memcpy(ar_tpa(ah), tip, ah->ar_pln);
389
390 return m;
391 }
392
393 static void
arpreq_send(struct ifnet * ifp,struct mbuf * m)394 arpreq_send(struct ifnet *ifp, struct mbuf *m)
395 {
396 struct sockaddr sa;
397 struct ether_header *eh;
398
399 ASSERT_NETISR_NCPUS(mycpuid);
400
401 switch (ifp->if_type) {
402 case IFT_ETHER:
403 /*
404 * This may not be correct for types not explicitly
405 * listed, but this is our best guess
406 */
407 default:
408 eh = (struct ether_header *)sa.sa_data;
409 /* if_output() will not swap */
410 eh->ether_type = htons(ETHERTYPE_ARP);
411 memcpy(eh->ether_dhost, ifp->if_broadcastaddr, ifp->if_addrlen);
412 break;
413 }
414
415 sa.sa_family = AF_UNSPEC;
416 sa.sa_len = sizeof(sa);
417 ifp->if_output(ifp, m, &sa, NULL);
418 }
419
420 static void
arpreq_send_handler(netmsg_t msg)421 arpreq_send_handler(netmsg_t msg)
422 {
423 struct mbuf *m = msg->packet.nm_packet;
424 struct ifnet *ifp = msg->lmsg.u.ms_resultp;
425
426 arpreq_send(ifp, m);
427 /* nmsg was embedded in the mbuf, do not reply! */
428 }
429
430 /*
431 * Broadcast an ARP request. Caller specifies:
432 * - arp header source ip address
433 * - arp header target ip address
434 * - arp header source ethernet address
435 *
436 * NOTE: Caller MUST NOT hold ifp's serializer
437 */
438 static void
arprequest(struct ifnet * ifp,const struct in_addr * sip,const struct in_addr * tip,const u_char * enaddr)439 arprequest(struct ifnet *ifp, const struct in_addr *sip,
440 const struct in_addr *tip, const u_char *enaddr)
441 {
442 struct mbuf *m;
443
444 ASSERT_NETISR_NCPUS(mycpuid);
445
446 if (enaddr == NULL) {
447 if (ifp->if_bridge) {
448 enaddr = IF_LLADDR(ether_bridge_interface(ifp));
449 } else {
450 enaddr = IF_LLADDR(ifp);
451 }
452 }
453
454 m = arpreq_alloc(ifp, sip, tip, enaddr);
455 if (m == NULL)
456 return;
457 arpreq_send(ifp, m);
458 }
459
460 /*
461 * Same as arprequest(), except:
462 * - Caller is allowed to hold ifp's serializer
463 * - Network output is done in protocol thead
464 */
465 static void
arprequest_async(struct ifnet * ifp,const struct in_addr * sip,const struct in_addr * tip,const u_char * enaddr)466 arprequest_async(struct ifnet *ifp, const struct in_addr *sip,
467 const struct in_addr *tip, const u_char *enaddr)
468 {
469 struct mbuf *m;
470 struct netmsg_packet *pmsg;
471 int cpu;
472
473 if (enaddr == NULL) {
474 if (ifp->if_bridge) {
475 enaddr = IF_LLADDR(ether_bridge_interface(ifp));
476 } else {
477 enaddr = IF_LLADDR(ifp);
478 }
479 }
480 m = arpreq_alloc(ifp, sip, tip, enaddr);
481 if (m == NULL)
482 return;
483
484 pmsg = &m->m_hdr.mh_netmsg;
485 netmsg_init(&pmsg->base, NULL, &netisr_apanic_rport,
486 0, arpreq_send_handler);
487 pmsg->nm_packet = m;
488 pmsg->base.lmsg.u.ms_resultp = ifp;
489
490 if (mycpuid < netisr_ncpus)
491 cpu = mycpuid;
492 else
493 cpu = 0;
494 lwkt_sendmsg(netisr_cpuport(cpu), &pmsg->base.lmsg);
495 }
496
497 /*
498 * Resolve an IP address into an ethernet address. If success,
499 * desten is filled in. If there is no entry in arptab,
500 * set one up and broadcast a request for the IP address.
501 * Hold onto this mbuf and resend it once the address
502 * is finally resolved. A return value of 1 indicates
503 * that desten has been filled in and the packet should be sent
504 * normally; a 0 return indicates that the packet has been
505 * taken over here, either now or for later transmission.
506 */
507 int
arpresolve(struct ifnet * ifp,struct rtentry * rt0,struct mbuf * m,struct sockaddr * dst,u_char * desten)508 arpresolve(struct ifnet *ifp, struct rtentry *rt0, struct mbuf *m,
509 struct sockaddr *dst, u_char *desten)
510 {
511 struct rtentry *rt = NULL;
512 struct llinfo_arp *la = NULL;
513 struct sockaddr_dl *sdl;
514 int error;
515
516 if (m->m_flags & M_BCAST) { /* broadcast */
517 memcpy(desten, ifp->if_broadcastaddr, ifp->if_addrlen);
518 return 0;
519 }
520 if (m->m_flags & M_MCAST) {/* multicast */
521 ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
522 return 0;
523 }
524 if (rt0 != NULL) {
525 error = rt_llroute(dst, rt0, &rt);
526 if (error != 0) {
527 m_freem(m);
528 return error;
529 }
530 la = rt->rt_llinfo;
531 }
532 if (la == NULL) {
533 la = arplookup(SIN(dst)->sin_addr.s_addr, TRUE, FALSE);
534 if (la != NULL)
535 rt = la->la_rt;
536 }
537 if (la == NULL || rt == NULL) {
538 char addr[INET_ADDRSTRLEN];
539
540 log(LOG_DEBUG, "arpresolve: can't allocate llinfo for %s%s%s\n",
541 kinet_ntoa(SIN(dst)->sin_addr, addr), la ? "la" : " ",
542 rt ? "rt" : "");
543 m_freem(m);
544 return ENOBUFS;
545 }
546
547 /*
548 * Check the address family and length is valid, the address
549 * is resolved; otherwise, try to resolve.
550 */
551 sdl = SDL(rt->rt_gateway);
552 if ((rt->rt_expire == 0 || rt->rt_expire > time_uptime) &&
553 sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
554 /*
555 * If entry has an expiry time and it is approaching,
556 * see if we need to send an ARP request within this
557 * arpt_down interval.
558 */
559 if ((rt->rt_expire != 0) &&
560 (time_uptime + la->la_preempt > rt->rt_expire)) {
561 arprequest(ifp,
562 &SIN(rt->rt_ifa->ifa_addr)->sin_addr,
563 &SIN(dst)->sin_addr,
564 NULL);
565 la->la_preempt--;
566 }
567
568 bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
569 return 0;
570 }
571
572 /*
573 * If ARP is disabled or static on this interface, stop.
574 * XXX
575 * Probably should not allocate empty llinfo struct if we are
576 * not going to be sending out an arp request.
577 */
578 if (ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) {
579 m_freem(m);
580 return ifp->if_flags & IFF_NOARP ? ENOTSUP : EINVAL;
581 }
582
583 /*
584 * There is an arptab entry, but no ethernet address
585 * response yet. Replace the held mbuf with this
586 * latest one.
587 */
588 if (la->la_hold != NULL)
589 m_freem(la->la_hold);
590 la->la_hold = m;
591
592 /*
593 * Return EWOULDBLOCK if we have tried less than arp_maxtries. It
594 * will be masked by ether_output(). Return EHOSTDOWN/EHOSTUNREACH
595 * if we have already sent arp_maxtries ARP requests. Retransmit the
596 * ARP request, but not faster than one request per second.
597 */
598 if (la->la_asked < arp_maxtries)
599 error = EWOULDBLOCK;
600 else
601 error = (rt != NULL && rt->rt_flags & RTF_GATEWAY) ?
602 EHOSTUNREACH : EHOSTDOWN;
603
604 if (rt->rt_expire || ((rt->rt_flags & RTF_STATIC) && !sdl->sdl_alen)) {
605 rt->rt_flags &= ~RTF_REJECT;
606 if (la->la_asked == 0 || rt->rt_expire != time_uptime) {
607 rt->rt_expire = time_uptime;
608 arprequest(ifp,
609 &SIN(rt->rt_ifa->ifa_addr)->sin_addr,
610 &SIN(dst)->sin_addr,
611 NULL);
612 if (la->la_asked++ >= arp_maxtries) {
613 rt->rt_expire += arpt_down;
614 la->la_preempt = arp_maxtries;
615 rt_rtmsg(RTM_MISS, rt, rt->rt_ifp, 0);
616 }
617 }
618 }
619 return error;
620 }
621
622 /*
623 * Common length and type checks are done here,
624 * then the protocol-specific routine is called.
625 */
626 static void
arpintr(netmsg_t msg)627 arpintr(netmsg_t msg)
628 {
629 struct mbuf *m = msg->packet.nm_packet;
630 struct arphdr *ar;
631 u_short ar_hrd;
632 char hexstr[6];
633
634 if (m->m_len < sizeof(struct arphdr) &&
635 (m = m_pullup(m, sizeof(struct arphdr))) == NULL) {
636 log(LOG_ERR, "arp: runt packet -- m_pullup failed\n");
637 return;
638 }
639 ar = mtod(m, struct arphdr *);
640
641 ar_hrd = ntohs(ar->ar_hrd);
642 if (ar_hrd != ARPHRD_ETHER && ar_hrd != ARPHRD_IEEE802) {
643 hexncpy((unsigned char *)&ar->ar_hrd, 2, hexstr, 5, NULL);
644 log(LOG_ERR, "arp: unknown hardware address format (0x%s)\n",
645 hexstr);
646 m_freem(m);
647 return;
648 }
649
650 if (m->m_pkthdr.len < arphdr_len(ar)) {
651 if ((m = m_pullup(m, arphdr_len(ar))) == NULL) {
652 log(LOG_ERR, "arp: runt packet\n");
653 return;
654 }
655 ar = mtod(m, struct arphdr *);
656 }
657
658 switch (ntohs(ar->ar_pro)) {
659 #ifdef INET
660 case ETHERTYPE_IP:
661 in_arpinput(m);
662 return;
663 #endif
664 }
665 m_freem(m);
666 /* msg was embedded in the mbuf, do not reply! */
667 }
668
669 #ifdef INET
670 /*
671 * ARP for Internet protocols on 10 Mb/s Ethernet.
672 * Algorithm is that given in RFC 826.
673 * In addition, a sanity check is performed on the sender
674 * protocol address, to catch impersonators.
675 * We no longer handle negotiations for use of trailer protocol:
676 * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
677 * along with IP replies if we wanted trailers sent to us,
678 * and also sent them in response to IP replies.
679 * This allowed either end to announce the desire to receive
680 * trailer packets.
681 * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
682 * but formerly didn't normally send requests.
683 */
684
685 static int log_arp_wrong_iface = 1;
686 static int log_arp_movements = 1;
687 static int log_arp_permanent_modify = 1;
688 static int log_arp_creation_failure = 1;
689
690 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_wrong_iface, CTLFLAG_RW,
691 &log_arp_wrong_iface, 0,
692 "Log arp packets arriving on the wrong interface");
693 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_movements, CTLFLAG_RW,
694 &log_arp_movements, 0,
695 "Log arp replies from MACs different than the one in the cache");
696 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_permanent_modify, CTLFLAG_RW,
697 &log_arp_permanent_modify, 0,
698 "Log arp replies from MACs different than the one "
699 "in the permanent arp entry");
700 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_creation_failure, CTLFLAG_RW,
701 &log_arp_creation_failure, 0, "Log arp creation failure");
702
703 /*
704 * Returns non-zero if the routine updated anything.
705 */
706 static int
arp_update_oncpu(struct mbuf * m,in_addr_t saddr,boolean_t create,boolean_t dologging)707 arp_update_oncpu(struct mbuf *m, in_addr_t saddr, boolean_t create,
708 boolean_t dologging)
709 {
710 struct arphdr *ah = mtod(m, struct arphdr *);
711 struct ifnet *ifp = m->m_pkthdr.rcvif;
712 struct llinfo_arp *la;
713 struct sockaddr_dl *sdl;
714 struct rtentry *rt;
715 char hexstr[2][64];
716 char sbuf[INET_ADDRSTRLEN];
717 int changed = create;
718
719 KASSERT(curthread->td_type == TD_TYPE_NETISR,
720 ("arp update not in netisr"));
721
722 la = arplookup(saddr, create, FALSE);
723 if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
724 struct in_addr isaddr = { saddr };
725 int rt_cmd = sdl->sdl_alen == 0 ? RTM_ADD : RTM_CHANGE;
726 bool do_rtmsg = false;
727
728 /*
729 * Normally arps coming in on the wrong interface are ignored,
730 * but if we are bridging and the two interfaces belong to
731 * the same bridge, or one is a member of the bridge which
732 * is the other, then it isn't an error.
733 */
734 if (rt->rt_ifp != ifp) {
735 /*
736 * (1) ifp and rt_ifp both members of same bridge
737 * (2) rt_ifp member of bridge ifp
738 * (3) ifp member of bridge rt_ifp
739 *
740 * Always replace rt_ifp with the bridge ifc.
741 */
742 struct ifnet *nifp;
743
744 if (ifp->if_bridge &&
745 rt->rt_ifp->if_bridge == ifp->if_bridge) {
746 nifp = ether_bridge_interface(ifp);
747 } else if (rt->rt_ifp->if_bridge &&
748 ether_bridge_interface(rt->rt_ifp) == ifp) {
749 nifp = ifp;
750 } else if (ifp->if_bridge &&
751 ether_bridge_interface(ifp) == rt->rt_ifp) {
752 nifp = rt->rt_ifp;
753 } else {
754 nifp = NULL;
755 }
756
757 if ((log_arp_wrong_iface == 1 && nifp == NULL) ||
758 log_arp_wrong_iface == 2) {
759 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
760 hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
761 log(LOG_ERR,
762 "arp: %s is on %s "
763 "but got reply from %s on %s\n",
764 kinet_ntoa(isaddr, sbuf),
765 rt->rt_ifp->if_xname, hexstr[0],
766 ifp->if_xname);
767 }
768 if (nifp == NULL)
769 return 0;
770
771 /*
772 * nifp is our man! Replace rt_ifp and adjust
773 * the sdl.
774 */
775 ifp = rt->rt_ifp = nifp;
776 if (sdl->sdl_type != ifp->if_type) {
777 sdl->sdl_type = ifp->if_type;
778 changed = 1;
779 do_rtmsg = true;
780 }
781 if (sdl->sdl_index != ifp->if_index) {
782 sdl->sdl_index = ifp->if_index;
783 changed = 1;
784 do_rtmsg = true;
785 }
786 }
787 if (sdl->sdl_alen &&
788 bcmp(ar_sha(ah), LLADDR(sdl), sdl->sdl_alen)) {
789 changed = 1;
790 if (rt->rt_expire != 0) {
791 if (dologging && log_arp_movements) {
792 hexncpy((u_char *)LLADDR(sdl), ifp->if_addrlen,
793 hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
794 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
795 hexstr[1], HEX_NCPYLEN(ifp->if_addrlen), ":");
796 log(LOG_INFO,
797 "arp: %s moved from %s to %s on %s\n",
798 kinet_ntoa(isaddr, sbuf), hexstr[0], hexstr[1],
799 ifp->if_xname);
800 }
801 } else {
802 if (dologging && log_arp_permanent_modify) {
803 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
804 hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
805 log(LOG_ERR,
806 "arp: %s attempts to modify "
807 "permanent entry for %s on %s\n",
808 hexstr[0], kinet_ntoa(isaddr, sbuf), ifp->if_xname);
809 }
810 return changed;
811 }
812 do_rtmsg = true;
813 }
814 /*
815 * sanity check for the address length.
816 * XXX this does not work for protocols with variable address
817 * length. -is
818 */
819 if (dologging && sdl->sdl_alen && sdl->sdl_alen != ah->ar_hln) {
820 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
821 hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
822 log(LOG_WARNING,
823 "arp from %s: new addr len %d, was %d",
824 hexstr[0], ah->ar_hln, sdl->sdl_alen);
825 }
826 if (ifp->if_addrlen != ah->ar_hln) {
827 if (dologging) {
828 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
829 hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
830 log(LOG_WARNING,
831 "arp from %s: addr len: new %d, i/f %d "
832 "(ignored)", hexstr[0],
833 ah->ar_hln, ifp->if_addrlen);
834 }
835 return changed;
836 }
837 if (sdl->sdl_alen == 0)
838 do_rtmsg = true;
839 memcpy(LLADDR(sdl), ar_sha(ah), sdl->sdl_alen = ah->ar_hln);
840 if (rt->rt_expire != 0) {
841 if (rt->rt_expire != time_uptime + arpt_keep &&
842 rt->rt_expire != time_uptime + arpt_keep - 1) {
843 rt->rt_expire = time_uptime + arpt_keep;
844 changed = 1;
845 }
846 }
847 if (rt->rt_flags & RTF_REJECT) {
848 rt->rt_flags &= ~RTF_REJECT;
849 changed = 1;
850 }
851 if (la->la_asked != 0) {
852 la->la_asked = 0;
853 changed = 1;
854 }
855 if (la->la_preempt != arp_maxtries) {
856 la->la_preempt = arp_maxtries;
857 changed = 1;
858 }
859
860 /*
861 * This particular cpu might have been holding an mbuf
862 * pending ARP resolution. If so, transmit the mbuf now.
863 */
864 if (la->la_hold != NULL) {
865 struct mbuf *m = la->la_hold;
866
867 la->la_hold = NULL;
868 m_adj(m, sizeof(struct ether_header));
869 ifp->if_output(ifp, m, rt_key(rt), rt);
870 changed = 1;
871 }
872
873 if (do_rtmsg && mycpuid == 0)
874 rt_rtmsg(rt_cmd, rt, rt->rt_ifp, 0);
875 }
876 return changed;
877 }
878
879 /*
880 * Called from arpintr() - this routine is run from a single cpu.
881 */
882 static void
in_arpinput(struct mbuf * m)883 in_arpinput(struct mbuf *m)
884 {
885 struct arphdr *ah;
886 struct ifnet *ifp = m->m_pkthdr.rcvif;
887 struct ifaddr_container *ifac;
888 struct in_ifaddr_container *iac;
889 struct in_ifaddr *ia = NULL;
890 struct in_addr isaddr, itaddr, myaddr;
891 uint8_t *enaddr = NULL;
892 int req_len;
893 int changed;
894 char hexstr[64], sbuf[INET_ADDRSTRLEN];
895
896 req_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
897 if (m->m_len < req_len && (m = m_pullup(m, req_len)) == NULL) {
898 log(LOG_ERR, "in_arp: runt packet -- m_pullup failed\n");
899 return;
900 }
901
902 ah = mtod(m, struct arphdr *);
903 memcpy(&isaddr, ar_spa(ah), sizeof isaddr);
904 memcpy(&itaddr, ar_tpa(ah), sizeof itaddr);
905
906 /*
907 * Check both target and sender IP addresses:
908 *
909 * If we receive the packet on the interface owning the address,
910 * then accept the address.
911 *
912 * For a bridge, we accept the address if the receive interface and
913 * the interface owning the address are on the same bridge, and
914 * use the bridge MAC as the is-at response. The bridge will be
915 * responsible for handling the packet.
916 *
917 * (0) Check target IP against CARP IPs
918 */
919 #ifdef CARP
920 LIST_FOREACH(iac, INADDR_HASH(itaddr.s_addr), ia_hash) {
921 int is_match = 0, is_parent = 0;
922
923 ia = iac->ia;
924
925 /* Skip all ia's which don't match */
926 if (itaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
927 continue;
928
929 if (ia->ia_ifp->if_type != IFT_CARP)
930 continue;
931
932 if (carp_parent(ia->ia_ifp) == ifp)
933 is_parent = 1;
934 if (is_parent || ia->ia_ifp == ifp)
935 is_match = carp_iamatch(ia);
936
937 if (is_match) {
938 if (is_parent) {
939 /*
940 * The parent interface will also receive
941 * the ethernet broadcast packets, e.g. ARP
942 * REQUEST, so if we could find a CARP
943 * interface of the parent that could match
944 * the target IP address, we then drop the
945 * packets, which is delieverd to us through
946 * the parent interface.
947 */
948 m_freem(m);
949 return;
950 }
951 goto match;
952 }
953 }
954 #endif /* CARP */
955
956 /*
957 * (1) Check target IP against our local IPs
958 */
959 LIST_FOREACH(iac, INADDR_HASH(itaddr.s_addr), ia_hash) {
960 ia = iac->ia;
961
962 /* Skip all ia's which don't match */
963 if (itaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
964 continue;
965
966 #ifdef CARP
967 /* CARP interfaces are checked in (0) */
968 if (ia->ia_ifp->if_type == IFT_CARP)
969 continue;
970 #endif
971
972 if (ifp->if_bridge && ia->ia_ifp &&
973 ifp->if_bridge == ia->ia_ifp->if_bridge) {
974 ifp = ether_bridge_interface(ifp);
975 goto match;
976 }
977 if (ia->ia_ifp && ia->ia_ifp->if_bridge &&
978 ether_bridge_interface(ia->ia_ifp) == ifp) {
979 goto match;
980 }
981 if (ifp->if_bridge && ether_bridge_interface(ifp) ==
982 ia->ia_ifp) {
983 goto match;
984 }
985 if (ia->ia_ifp == ifp) {
986 goto match;
987 }
988 }
989
990 /*
991 * (2) Check sender IP against our local IPs
992 */
993 LIST_FOREACH(iac, INADDR_HASH(isaddr.s_addr), ia_hash) {
994 ia = iac->ia;
995
996 /* Skip all ia's which don't match */
997 if (isaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
998 continue;
999
1000 if (ifp->if_bridge && ia->ia_ifp &&
1001 ifp->if_bridge == ia->ia_ifp->if_bridge) {
1002 ifp = ether_bridge_interface(ifp);
1003 goto match;
1004 }
1005 if (ia->ia_ifp && ia->ia_ifp->if_bridge &&
1006 ether_bridge_interface(ia->ia_ifp) == ifp) {
1007 goto match;
1008 }
1009 if (ifp->if_bridge && ether_bridge_interface(ifp) ==
1010 ia->ia_ifp) {
1011 goto match;
1012 }
1013
1014 if (ia->ia_ifp == ifp)
1015 goto match;
1016 }
1017
1018 /*
1019 * No match, use the first inet address on the receive interface
1020 * as a dummy address for the rest of the function.
1021 */
1022 TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) {
1023 struct ifaddr *ifa = ifac->ifa;
1024
1025 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) {
1026 ia = ifatoia(ifa);
1027 goto match;
1028 }
1029 }
1030
1031 /*
1032 * If we got here, we didn't find any suitable interface,
1033 * so drop the packet.
1034 */
1035 m_freem(m);
1036 return;
1037
1038 match:
1039 if (!enaddr)
1040 enaddr = (uint8_t *)IF_LLADDR(ifp);
1041 myaddr = ia->ia_addr.sin_addr;
1042 if (!bcmp(ar_sha(ah), enaddr, ifp->if_addrlen)) {
1043 m_freem(m); /* it's from me, ignore it. */
1044 return;
1045 }
1046 if (!bcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
1047 log(LOG_ERR,
1048 "arp: link address is broadcast for IP address %s!\n",
1049 kinet_ntoa(isaddr, sbuf));
1050 m_freem(m);
1051 return;
1052 }
1053 if (isaddr.s_addr == myaddr.s_addr && myaddr.s_addr != 0) {
1054 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
1055 hexstr, HEX_NCPYLEN(ifp->if_addrlen), ":");
1056 log(LOG_ERR,
1057 "arp: %s is using my IP address %s!\n",
1058 hexstr, kinet_ntoa(isaddr, sbuf));
1059 itaddr = myaddr;
1060 goto reply;
1061 }
1062 if (ifp->if_flags & IFF_STATICARP)
1063 goto reply;
1064
1065 /*
1066 * When arp_restricted_match is true and the ARP response is not
1067 * specifically targetted to me, ignore it. Otherwise the entry
1068 * timeout may be updated for an old MAC.
1069 */
1070 if (arp_restricted_match && itaddr.s_addr != myaddr.s_addr) {
1071 m_freem(m);
1072 return;
1073 }
1074
1075 /*
1076 * Update all CPU's routing tables with this ARP packet.
1077 *
1078 * However, we only need to generate rtmsg on CPU0.
1079 */
1080 ASSERT_NETISR0;
1081 changed = arp_update_oncpu(m, isaddr.s_addr,
1082 itaddr.s_addr == myaddr.s_addr,
1083 TRUE);
1084
1085 if (netisr_ncpus > 1 && changed) {
1086 struct netmsg_inarp *msg = &m->m_hdr.mh_arpmsg;
1087
1088 netmsg_init(&msg->base, NULL, &netisr_apanic_rport,
1089 0, arp_update_msghandler);
1090 msg->m = m;
1091 msg->saddr = isaddr.s_addr;
1092 msg->taddr = itaddr.s_addr;
1093 msg->myaddr = myaddr.s_addr;
1094 lwkt_sendmsg(netisr_cpuport(1), &msg->base.lmsg);
1095 } else {
1096 goto reply;
1097 }
1098
1099 /*
1100 * Just return here; after all CPUs's routing tables are
1101 * properly updated by this ARP packet, an ARP reply will
1102 * be generated if appropriate.
1103 */
1104 return;
1105 reply:
1106 in_arpreply(m, itaddr.s_addr, myaddr.s_addr);
1107 }
1108
1109 static void
arp_reply_msghandler(netmsg_t msg)1110 arp_reply_msghandler(netmsg_t msg)
1111 {
1112 struct netmsg_inarp *rmsg = (struct netmsg_inarp *)msg;
1113
1114 in_arpreply(rmsg->m, rmsg->taddr, rmsg->myaddr);
1115 /* Don't reply this netmsg; netmsg_inarp is embedded in mbuf */
1116 }
1117
1118 static void
arp_update_msghandler(netmsg_t msg)1119 arp_update_msghandler(netmsg_t msg)
1120 {
1121 struct netmsg_inarp *rmsg = (struct netmsg_inarp *)msg;
1122 int nextcpu;
1123
1124 ASSERT_NETISR_NCPUS(mycpuid);
1125
1126 /*
1127 * This message handler will be called on all of the APs;
1128 * no need to generate rtmsg on them.
1129 */
1130 KASSERT(mycpuid > 0, ("arp update msg on cpu%d", mycpuid));
1131 arp_update_oncpu(rmsg->m, rmsg->saddr,
1132 rmsg->taddr == rmsg->myaddr,
1133 FALSE);
1134
1135 nextcpu = mycpuid + 1;
1136 if (nextcpu < netisr_ncpus) {
1137 lwkt_forwardmsg(netisr_cpuport(nextcpu), &rmsg->base.lmsg);
1138 } else {
1139 struct mbuf *m = rmsg->m;
1140 in_addr_t saddr = rmsg->saddr;
1141 in_addr_t taddr = rmsg->taddr;
1142 in_addr_t myaddr = rmsg->myaddr;
1143
1144 /*
1145 * Dispatch this mbuf to netisr0 to perform ARP reply,
1146 * if appropriate.
1147 * NOTE: netmsg_inarp is embedded in this mbuf.
1148 */
1149 netmsg_init(&rmsg->base, NULL, &netisr_apanic_rport,
1150 0, arp_reply_msghandler);
1151 rmsg->m = m;
1152 rmsg->saddr = saddr;
1153 rmsg->taddr = taddr;
1154 rmsg->myaddr = myaddr;
1155 lwkt_sendmsg(netisr_cpuport(0), &rmsg->base.lmsg);
1156 }
1157 }
1158
1159 /*
1160 * Reply to an arp request
1161 */
1162 static void
in_arpreply(struct mbuf * m,in_addr_t taddr,in_addr_t myaddr)1163 in_arpreply(struct mbuf *m, in_addr_t taddr, in_addr_t myaddr)
1164 {
1165 struct ifnet *ifp = m->m_pkthdr.rcvif;
1166 const uint8_t *enaddr;
1167 struct arphdr *ah;
1168 struct sockaddr sa;
1169 struct ether_header *eh;
1170
1171 ASSERT_NETISR0;
1172
1173 ah = mtod(m, struct arphdr *);
1174 if (ntohs(ah->ar_op) != ARPOP_REQUEST) {
1175 m_freem(m);
1176 return;
1177 }
1178
1179 enaddr = (const uint8_t *)IF_LLADDR(ifp);
1180 if (taddr == myaddr) {
1181 /* I am the target */
1182 memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1183 memcpy(ar_sha(ah), enaddr, ah->ar_hln);
1184 } else {
1185 struct llinfo_arp *la;
1186 struct rtentry *rt;
1187
1188 la = arplookup(taddr, FALSE, SIN_PROXY);
1189 if (la == NULL) {
1190 struct sockaddr_in sin;
1191 #ifdef DEBUG_PROXY
1192 char tbuf[INET_ADDRSTRLEN];
1193 #endif
1194
1195 if (!arp_proxyall) {
1196 m_freem(m);
1197 return;
1198 }
1199
1200 bzero(&sin, sizeof sin);
1201 sin.sin_family = AF_INET;
1202 sin.sin_len = sizeof sin;
1203 sin.sin_addr.s_addr = taddr;
1204
1205 rt = rtpurelookup((struct sockaddr *)&sin);
1206 if (rt == NULL) {
1207 m_freem(m);
1208 return;
1209 }
1210 --rt->rt_refcnt;
1211
1212 /*
1213 * Don't send proxies for nodes on the same interface
1214 * as this one came out of, or we'll get into a fight
1215 * over who claims what Ether address.
1216 *
1217 * If the rt entry is associated with a bridge, we
1218 * count it as the 'same' interface if ifp is
1219 * associated with the bridge.
1220 */
1221 if (rt->rt_ifp == ifp || rt->rt_ifp == ifp->if_bridge) {
1222 m_freem(m);
1223 return;
1224 }
1225 memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1226 memcpy(ar_sha(ah), enaddr, ah->ar_hln);
1227 #ifdef DEBUG_PROXY
1228 kprintf("arp: proxying for %s\n",
1229 kinet_ntoa(itaddr, tbuf));
1230 #endif
1231 } else {
1232 struct sockaddr_dl *sdl;
1233
1234 rt = la->la_rt;
1235 memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1236 sdl = SDL(rt->rt_gateway);
1237 memcpy(ar_sha(ah), LLADDR(sdl), ah->ar_hln);
1238 }
1239 }
1240
1241 memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
1242 memcpy(ar_spa(ah), &taddr, ah->ar_pln);
1243 ah->ar_op = htons(ARPOP_REPLY);
1244 ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
1245 switch (ifp->if_type) {
1246 case IFT_ETHER:
1247 /*
1248 * May not be correct for types not explictly
1249 * listed, but it is our best guess.
1250 */
1251 default:
1252 eh = (struct ether_header *)sa.sa_data;
1253 memcpy(eh->ether_dhost, ar_tha(ah), sizeof eh->ether_dhost);
1254 eh->ether_type = htons(ETHERTYPE_ARP);
1255 break;
1256 }
1257 sa.sa_family = AF_UNSPEC;
1258 sa.sa_len = sizeof sa;
1259 ifp->if_output(ifp, m, &sa, NULL);
1260 }
1261
1262 #endif /* INET */
1263
1264 /*
1265 * Free an arp entry. If the arp entry is actively referenced or represents
1266 * a static entry we only clear it back to an unresolved state, otherwise
1267 * we destroy the entry entirely.
1268 *
1269 * Note that static entries are created when route add ... -interface is used
1270 * to create an interface route to a (direct) destination.
1271 */
1272 static void
arptfree(struct llinfo_arp * la)1273 arptfree(struct llinfo_arp *la)
1274 {
1275 struct rtentry *rt = la->la_rt;
1276 struct sockaddr_dl *sdl;
1277
1278 if (rt == NULL)
1279 panic("arptfree");
1280 sdl = SDL(rt->rt_gateway);
1281 if (sdl != NULL &&
1282 ((rt->rt_refcnt > 0 && sdl->sdl_family == AF_LINK) ||
1283 (rt->rt_flags & RTF_STATIC))) {
1284 sdl->sdl_alen = 0;
1285 la->la_preempt = la->la_asked = 0;
1286 rt->rt_flags &= ~RTF_REJECT;
1287 return;
1288 }
1289
1290 /*
1291 * ARP expiry happens under one big timer.
1292 * To avoid overflowing the route socket, don't report this.
1293 * Now that RTM_MISS is reported when an address is unresolvable
1294 * the benefit of reporting this deletion is questionable.
1295 */
1296 rtrequest(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt), 0, NULL);
1297 }
1298
1299 /*
1300 * Lookup or enter a new address in arptab.
1301 */
1302 static struct llinfo_arp *
arplookup(in_addr_t addr,boolean_t create,boolean_t proxy)1303 arplookup(in_addr_t addr, boolean_t create,
1304 boolean_t proxy)
1305 {
1306 struct rtentry *rt;
1307 struct sockaddr_inarp sin = { sizeof sin, AF_INET };
1308 const char *why = NULL;
1309
1310 /* Check ARP probes, e.g. from Cisco switches. */
1311 if (addr == INADDR_ANY && arp_ignore_probes)
1312 return (NULL);
1313
1314 sin.sin_addr.s_addr = addr;
1315 sin.sin_other = proxy ? SIN_PROXY : 0;
1316 if (create) {
1317 rt = rtlookup((struct sockaddr *)&sin);
1318 } else {
1319 rt = rtpurelookup((struct sockaddr *)&sin);
1320 }
1321 if (rt == NULL)
1322 return (NULL);
1323 rt->rt_refcnt--;
1324
1325 if (rt->rt_flags & RTF_GATEWAY)
1326 why = "host is not on local network";
1327 else if (!(rt->rt_flags & RTF_LLINFO))
1328 why = "could not allocate llinfo";
1329 else if (rt->rt_gateway->sa_family != AF_LINK)
1330 why = "gateway route is not ours";
1331
1332 if (why) {
1333 if (create && log_arp_creation_failure) {
1334 char abuf[INET_ADDRSTRLEN];
1335
1336 log(LOG_DEBUG, "arplookup %s failed: %s\n",
1337 kinet_ntoa(sin.sin_addr, abuf), why);
1338 }
1339 if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_WASCLONED)) {
1340 /* No references to this route. Purge it. */
1341 rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway,
1342 rt_mask(rt), rt->rt_flags, NULL);
1343 }
1344 return (NULL);
1345 }
1346 return (rt->rt_llinfo);
1347 }
1348
1349 void
arp_ifinit(struct ifnet * ifp,struct ifaddr * ifa)1350 arp_ifinit(struct ifnet *ifp, struct ifaddr *ifa)
1351 {
1352 ifa->ifa_rtrequest = arp_rtrequest;
1353 ifa->ifa_flags |= RTF_CLONING;
1354 }
1355
1356 void
arp_gratuitous(struct ifnet * ifp,struct ifaddr * ifa)1357 arp_gratuitous(struct ifnet *ifp, struct ifaddr *ifa)
1358 {
1359 if (IA_SIN(ifa)->sin_addr.s_addr != INADDR_ANY) {
1360 if (IN_NETISR_NCPUS(mycpuid)) {
1361 arprequest(ifp, &IA_SIN(ifa)->sin_addr,
1362 &IA_SIN(ifa)->sin_addr, NULL);
1363 } else {
1364 arprequest_async(ifp, &IA_SIN(ifa)->sin_addr,
1365 &IA_SIN(ifa)->sin_addr, NULL);
1366 }
1367 }
1368 }
1369
1370 static void
arp_ifaddr(void * arg __unused,struct ifnet * ifp,enum ifaddr_event event,struct ifaddr * ifa)1371 arp_ifaddr(void *arg __unused, struct ifnet *ifp,
1372 enum ifaddr_event event, struct ifaddr *ifa)
1373 {
1374 if (ifa->ifa_rtrequest != arp_rtrequest) /* XXX need a generic way */
1375 return;
1376 if (ifa->ifa_addr->sa_family != AF_INET)
1377 return;
1378 if (event == IFADDR_EVENT_DELETE)
1379 return;
1380
1381 /*
1382 * - CARP interfaces will take care of gratuitous ARP themselves.
1383 * - If we are the CARP interface's parent, don't send gratuitous
1384 * ARP to avoid unnecessary confusion.
1385 */
1386 #ifdef CARP
1387 if (ifp->if_type != IFT_CARP && ifp->if_carp == NULL)
1388 #endif
1389 {
1390 arp_gratuitous(ifp, ifa);
1391 }
1392 }
1393
1394 static void
arp_init_dispatch(netmsg_t nm)1395 arp_init_dispatch(netmsg_t nm)
1396 {
1397 struct arp_pcpu_data *ad;
1398
1399 ASSERT_NETISR_NCPUS(mycpuid);
1400
1401 ad = kmalloc(sizeof(*ad), M_ARP, M_WAITOK | M_ZERO);
1402
1403 LIST_INIT(&ad->llinfo_list);
1404 callout_init_mp(&ad->timer_ch);
1405 netmsg_init(&ad->timer_nmsg, NULL, &netisr_adone_rport,
1406 MSGF_PRIORITY, arptimer_dispatch);
1407 ad->timer_nmsg.lmsg.u.ms_resultp = ad;
1408
1409 arp_data[mycpuid] = ad;
1410
1411 callout_reset(&ad->timer_ch, hz, arptimer, &ad->timer_nmsg);
1412
1413 netisr_forwardmsg(&nm->base, mycpuid + 1);
1414 }
1415
1416 static void
arp_init(void)1417 arp_init(void)
1418 {
1419 struct netmsg_base nm;
1420
1421 netmsg_init(&nm, NULL, &curthread->td_msgport, 0, arp_init_dispatch);
1422 netisr_domsg_global(&nm);
1423
1424 netisr_register(NETISR_ARP, arpintr, NULL);
1425
1426 EVENTHANDLER_REGISTER(ifaddr_event, arp_ifaddr, NULL,
1427 EVENTHANDLER_PRI_LAST);
1428 }
1429 SYSINIT(arp, SI_SUB_PROTO_DOMAIN, SI_ORDER_ANY, arp_init, 0);
1430