route: Seperate route messages from creation/lookup.
[dragonfly.git] / sys / netinet / if_ether.c
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 #include <sys/mplock2.h>
101
102 #ifdef CARP
103 #include <netinet/ip_carp.h>
104 #endif
105
106 #define SIN(s) ((struct sockaddr_in *)s)
107 #define SDL(s) ((struct sockaddr_dl *)s)
108
109 MALLOC_DEFINE(M_ARP, "arp", "ARP");
110
111 SYSCTL_DECL(_net_link_ether);
112 SYSCTL_NODE(_net_link_ether, PF_INET, inet, CTLFLAG_RW, 0, "");
113
114 /* timer values */
115 static int arpt_prune = (5*60*1); /* walk list every 5 minutes */
116 static int arpt_keep = (20*60); /* once resolved, good for 20 more minutes */
117 static int arpt_down = 20;      /* once declared down, don't send for 20 sec */
118
119 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, prune_intvl, CTLFLAG_RW,
120            &arpt_prune, 0, "");
121 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, max_age, CTLFLAG_RW,
122            &arpt_keep, 0, "");
123 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, host_down_time, CTLFLAG_RW,
124            &arpt_down, 0, "");
125
126 #define rt_expire       rt_rmx.rmx_expire
127
128 struct llinfo_arp {
129         LIST_ENTRY(llinfo_arp) la_le;
130         struct  rtentry *la_rt;
131         struct  mbuf *la_hold;  /* last packet until resolved/timeout */
132         u_short la_preempt;     /* countdown for pre-expiry arps */
133         u_short la_asked;       /* #times we QUERIED following expiration */
134 };
135
136 static int      arp_maxtries = 5;
137 static int      useloopback = 1; /* use loopback interface for local traffic */
138 static int      arp_proxyall = 0;
139 static int      arp_refresh = 60; /* refresh arp cache ~60 (not impl yet) */
140 static int      arp_restricted_match = 0;
141 static int      arp_ignore_probes = 1;
142
143 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, maxtries, CTLFLAG_RW,
144            &arp_maxtries, 0, "ARP resolution attempts before returning error");
145 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, useloopback, CTLFLAG_RW,
146            &useloopback, 0, "Use the loopback interface for local traffic");
147 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, proxyall, CTLFLAG_RW,
148            &arp_proxyall, 0, "Enable proxy ARP for all suitable requests");
149 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, restricted_match, CTLFLAG_RW,
150            &arp_restricted_match, 0, "Only match against the sender");
151 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, refresh, CTLFLAG_RW,
152            &arp_refresh, 0, "Preemptively refresh the ARP");
153 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, ignore_probes, CTLFLAG_RW,
154            &arp_ignore_probes, 0, "Ignore ARP probes");
155
156 static void     arp_rtrequest(int, struct rtentry *);
157 static void     arprequest(struct ifnet *, const struct in_addr *,
158                            const struct in_addr *, const u_char *);
159 static void     arprequest_async(struct ifnet *, const struct in_addr *,
160                                  const struct in_addr *, const u_char *);
161 static void     arpintr(netmsg_t msg);
162 static void     arptfree(struct llinfo_arp *);
163 static void     arptimer(void *);
164 static struct llinfo_arp *
165                 arplookup(in_addr_t, boolean_t, boolean_t);
166 #ifdef INET
167 static void     in_arpinput(struct mbuf *);
168 static void     in_arpreply(struct mbuf *m, in_addr_t, in_addr_t);
169 static void     arp_update_msghandler(netmsg_t);
170 static void     arp_reply_msghandler(netmsg_t);
171 #endif
172
173 struct arp_pcpu_data {
174         LIST_HEAD(, llinfo_arp) llinfo_list;
175         struct callout          timer_ch;
176         struct netmsg_base      timer_nmsg;
177 };
178
179 static struct arp_pcpu_data     *arp_data[MAXCPU];
180
181 /*
182  * Timeout routine.  Age arp_tab entries periodically.
183  */
184 static void
185 arptimer_dispatch(netmsg_t nmsg)
186 {
187         struct arp_pcpu_data *ad = nmsg->lmsg.u.ms_resultp;
188         struct llinfo_arp *la, *nla;
189
190         ASSERT_NETISR_NCPUS(mycpuid);
191
192         /* Reply ASAP */
193         crit_enter();
194         netisr_replymsg(&nmsg->base, 0);
195         crit_exit();
196
197         LIST_FOREACH_MUTABLE(la, &ad->llinfo_list, la_le, nla) {
198                 if (la->la_rt->rt_expire && la->la_rt->rt_expire <= time_uptime)
199                         arptfree(la);
200         }
201         callout_reset(&ad->timer_ch, arpt_prune * hz, arptimer, &ad->timer_nmsg);
202 }
203
204 static void
205 arptimer(void *xnm)
206 {
207         struct netmsg_base *nm = xnm;
208
209         KKASSERT(mycpuid < netisr_ncpus);
210
211         crit_enter();
212         if (nm->lmsg.ms_flags & MSGF_DONE)
213                 netisr_sendmsg_oncpu(nm);
214         crit_exit();
215 }
216
217 /*
218  * Parallel to llc_rtrequest.
219  *
220  * Called after a route is successfully added to the tree to fix-up the
221  * route and initiate arp operations if required.
222  */
223 static void
224 arp_rtrequest(int req, struct rtentry *rt)
225 {
226         struct sockaddr *gate = rt->rt_gateway;
227         struct llinfo_arp *la = rt->rt_llinfo;
228
229         struct sockaddr_dl null_sdl = { sizeof null_sdl, AF_LINK };
230
231         if (rt->rt_flags & RTF_GATEWAY)
232                 return;
233
234         switch (req) {
235         case RTM_ADD:
236                 /*
237                  * XXX: If this is a manually added route to interface
238                  * such as older version of routed or gated might provide,
239                  * restore cloning bit.
240                  */
241                 if (!(rt->rt_flags & RTF_HOST) &&
242                     SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
243                         rt->rt_flags |= RTF_CLONING;
244                 if (rt->rt_flags & RTF_CLONING) {
245                         /*
246                          * Case 1: This route should come from a route to iface.
247                          */
248                         rt_setgate(rt, rt_key(rt),
249                                    (struct sockaddr *)&null_sdl);
250                         gate = rt->rt_gateway;
251                         SDL(gate)->sdl_type = rt->rt_ifp->if_type;
252                         SDL(gate)->sdl_index = rt->rt_ifp->if_index;
253                         rt->rt_expire = time_uptime;
254                         break;
255                 }
256                 /*
257                  * Announce a new entry if requested, and only announce it
258                  * once on cpu0.
259                  */
260                 if ((rt->rt_flags & RTF_ANNOUNCE) && mycpuid == 0) {
261                         arprequest(rt->rt_ifp,
262                             &SIN(rt_key(rt))->sin_addr,
263                             &SIN(rt_key(rt))->sin_addr,
264                             LLADDR(SDL(gate)));
265                 }
266                 /*FALLTHROUGH*/
267         case RTM_RESOLVE:
268                 if (gate->sa_family != AF_LINK ||
269                     gate->sa_len < sizeof(struct sockaddr_dl)) {
270                         log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
271                         break;
272                 }
273                 SDL(gate)->sdl_type = rt->rt_ifp->if_type;
274                 SDL(gate)->sdl_index = rt->rt_ifp->if_index;
275                 if (la != NULL)
276                         break; /* This happens on a route change */
277                 /*
278                  * Case 2:  This route may come from cloning, or a manual route
279                  * add with a LL address.
280                  */
281                 R_Malloc(la, struct llinfo_arp *, sizeof *la);
282                 rt->rt_llinfo = la;
283                 if (la == NULL) {
284                         log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
285                         break;
286                 }
287                 bzero(la, sizeof *la);
288                 la->la_rt = rt;
289                 rt->rt_flags |= RTF_LLINFO;
290                 LIST_INSERT_HEAD(&arp_data[mycpuid]->llinfo_list, la, la_le);
291
292 #ifdef INET
293                 /*
294                  * This keeps the multicast addresses from showing up
295                  * in `arp -a' listings as unresolved.  It's not actually
296                  * functional.  Then the same for broadcast.
297                  */
298                 if (IN_MULTICAST(ntohl(SIN(rt_key(rt))->sin_addr.s_addr))) {
299                         ETHER_MAP_IP_MULTICAST(&SIN(rt_key(rt))->sin_addr,
300                                                LLADDR(SDL(gate)));
301                         SDL(gate)->sdl_alen = 6;
302                         rt->rt_expire = 0;
303                 }
304                 if (in_broadcast(SIN(rt_key(rt))->sin_addr, rt->rt_ifp)) {
305                         memcpy(LLADDR(SDL(gate)), rt->rt_ifp->if_broadcastaddr,
306                                rt->rt_ifp->if_addrlen);
307                         SDL(gate)->sdl_alen = rt->rt_ifp->if_addrlen;
308                         rt->rt_expire = 0;
309                 }
310 #endif
311
312                 /*
313                  * This fixes up the routing interface for local addresses.
314                  * The route is adjusted to point at lo0 and the expiration
315                  * timer is disabled.
316                  *
317                  * NOTE: This prevents locally targetted traffic from going
318                  *       out the hardware interface, which is inefficient
319                  *       and might not work if the hardware cannot listen
320                  *       to its own transmitted packets.   Setting
321                  *       net.link.ether.inet.useloopback to 0 will force
322                  *       packets for local addresses out the hardware (and
323                  *       it is expected to receive its own packet).
324                  *
325                  * XXX We should just be able to test RTF_LOCAL here instead
326                  *     of having to compare IPs.
327                  */
328                 if (SIN(rt_key(rt))->sin_addr.s_addr ==
329                     (IA_SIN(rt->rt_ifa))->sin_addr.s_addr) {
330                         rt->rt_expire = 0;
331                         bcopy(IF_LLADDR(rt->rt_ifp), LLADDR(SDL(gate)),
332                               SDL(gate)->sdl_alen = 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                 Free(la);
347                 break;
348         }
349 }
350
351 static struct mbuf *
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
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
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
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
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
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
515         if (m->m_flags & M_BCAST) {     /* broadcast */
516                 memcpy(desten, ifp->if_broadcastaddr, ifp->if_addrlen);
517                 return (1);
518         }
519         if (m->m_flags & M_MCAST) {/* multicast */
520                 ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
521                 return (1);
522         }
523         if (rt0 != NULL) {
524                 if (rt_llroute(dst, rt0, &rt) != 0) {
525                         m_freem(m);
526                         return 0;
527                 }
528                 la = rt->rt_llinfo;
529         }
530         if (la == NULL) {
531                 la = arplookup(SIN(dst)->sin_addr.s_addr, TRUE, FALSE);
532                 if (la != NULL)
533                         rt = la->la_rt;
534         }
535         if (la == NULL || rt == NULL) {
536                 char addr[INET_ADDRSTRLEN];
537
538                 log(LOG_DEBUG, "arpresolve: can't allocate llinfo for %s%s%s\n",
539                     kinet_ntoa(SIN(dst)->sin_addr, addr), la ? "la" : " ",
540                     rt ? "rt" : "");
541                 m_freem(m);
542                 return (0);
543         }
544         sdl = SDL(rt->rt_gateway);
545         /*
546          * Check the address family and length is valid, the address
547          * is resolved; otherwise, try to resolve.
548          */
549         if ((rt->rt_expire == 0 || rt->rt_expire > time_uptime) &&
550             sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
551                 /*
552                  * If entry has an expiry time and it is approaching,
553                  * see if we need to send an ARP request within this
554                  * arpt_down interval.
555                  */
556                 if ((rt->rt_expire != 0) &&
557                     (time_uptime + la->la_preempt > rt->rt_expire)) {
558                         arprequest(ifp,
559                                    &SIN(rt->rt_ifa->ifa_addr)->sin_addr,
560                                    &SIN(dst)->sin_addr,
561                                    NULL);
562                         la->la_preempt--;
563                 }
564
565                 bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
566                 return 1;
567         }
568         /*
569          * If ARP is disabled or static on this interface, stop.
570          * XXX
571          * Probably should not allocate empty llinfo struct if we are
572          * not going to be sending out an arp request.
573          */
574         if (ifp->if_flags & (IFF_NOARP | IFF_STATICARP)) {
575                 m_freem(m);
576                 return (0);
577         }
578         /*
579          * There is an arptab entry, but no ethernet address
580          * response yet.  Replace the held mbuf with this
581          * latest one.
582          */
583         if (la->la_hold != NULL)
584                 m_freem(la->la_hold);
585         la->la_hold = m;
586         if (rt->rt_expire || ((rt->rt_flags & RTF_STATIC) && !sdl->sdl_alen)) {
587                 rt->rt_flags &= ~RTF_REJECT;
588                 if (la->la_asked == 0 || rt->rt_expire != time_uptime) {
589                         rt->rt_expire = time_uptime;
590                         if (la->la_asked++ < arp_maxtries) {
591                                 arprequest(ifp,
592                                            &SIN(rt->rt_ifa->ifa_addr)->sin_addr,
593                                            &SIN(dst)->sin_addr,
594                                            NULL);
595                         } else {
596                                 rt->rt_flags |= RTF_REJECT;
597                                 rt->rt_expire += arpt_down;
598                                 la->la_asked = 0;
599                                 la->la_preempt = arp_maxtries;
600                                 rt_rtmsg(RTM_MISS, rt, rt->rt_ifp, 0);
601                         }
602                 }
603         }
604         return (0);
605 }
606
607 /*
608  * Common length and type checks are done here,
609  * then the protocol-specific routine is called.
610  */
611 static void
612 arpintr(netmsg_t msg)
613 {
614         struct mbuf *m = msg->packet.nm_packet;
615         struct arphdr *ar;
616         u_short ar_hrd;
617         char hexstr[6];
618
619         if (m->m_len < sizeof(struct arphdr) &&
620             (m = m_pullup(m, sizeof(struct arphdr))) == NULL) {
621                 log(LOG_ERR, "arp: runt packet -- m_pullup failed\n");
622                 return;
623         }
624         ar = mtod(m, struct arphdr *);
625
626         ar_hrd = ntohs(ar->ar_hrd);
627         if (ar_hrd != ARPHRD_ETHER && ar_hrd != ARPHRD_IEEE802) {
628                 hexncpy((unsigned char *)&ar->ar_hrd, 2, hexstr, 5, NULL);
629                 log(LOG_ERR, "arp: unknown hardware address format (0x%s)\n",
630                     hexstr);
631                 m_freem(m);
632                 return;
633         }
634
635         if (m->m_pkthdr.len < arphdr_len(ar)) {
636                 if ((m = m_pullup(m, arphdr_len(ar))) == NULL) {
637                         log(LOG_ERR, "arp: runt packet\n");
638                         return;
639                 }
640                 ar = mtod(m, struct arphdr *);
641         }
642
643         switch (ntohs(ar->ar_pro)) {
644 #ifdef INET
645         case ETHERTYPE_IP:
646                 in_arpinput(m);
647                 return;
648 #endif
649         }
650         m_freem(m);
651         /* msg was embedded in the mbuf, do not reply! */
652 }
653
654 #ifdef INET
655 /*
656  * ARP for Internet protocols on 10 Mb/s Ethernet.
657  * Algorithm is that given in RFC 826.
658  * In addition, a sanity check is performed on the sender
659  * protocol address, to catch impersonators.
660  * We no longer handle negotiations for use of trailer protocol:
661  * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
662  * along with IP replies if we wanted trailers sent to us,
663  * and also sent them in response to IP replies.
664  * This allowed either end to announce the desire to receive
665  * trailer packets.
666  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
667  * but formerly didn't normally send requests.
668  */
669
670 static int      log_arp_wrong_iface = 1;
671 static int      log_arp_movements = 1;
672 static int      log_arp_permanent_modify = 1;
673 static int      log_arp_creation_failure = 1;
674
675 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_wrong_iface, CTLFLAG_RW,
676            &log_arp_wrong_iface, 0,
677            "Log arp packets arriving on the wrong interface");
678 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_movements, CTLFLAG_RW,
679            &log_arp_movements, 0,
680            "Log arp replies from MACs different than the one in the cache");
681 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_permanent_modify, CTLFLAG_RW,
682            &log_arp_permanent_modify, 0,
683            "Log arp replies from MACs different than the one "
684            "in the permanent arp entry");
685 SYSCTL_INT(_net_link_ether_inet, OID_AUTO, log_arp_creation_failure, CTLFLAG_RW,
686            &log_arp_creation_failure, 0, "Log arp creation failure");
687
688 /*
689  * Returns non-zero if the routine updated anything.
690  */
691 static int
692 arp_update_oncpu(struct mbuf *m, in_addr_t saddr, boolean_t create,
693                  boolean_t dologging)
694 {
695         struct arphdr *ah = mtod(m, struct arphdr *);
696         struct ifnet *ifp = m->m_pkthdr.rcvif;
697         struct llinfo_arp *la;
698         struct sockaddr_dl *sdl;
699         struct rtentry *rt;
700         char hexstr[2][64];
701         char sbuf[INET_ADDRSTRLEN];
702         int changed = create;
703
704         KASSERT(curthread->td_type == TD_TYPE_NETISR,
705             ("arp update not in netisr"));
706
707         la = arplookup(saddr, create, FALSE);
708         if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
709                 struct in_addr isaddr = { saddr };
710                 int rt_cmd = sdl->sdl_alen == 0 ? RTM_ADD : RTM_CHANGE;
711                 bool do_rtmsg = false;
712
713                 /*
714                  * Normally arps coming in on the wrong interface are ignored,
715                  * but if we are bridging and the two interfaces belong to
716                  * the same bridge, or one is a member of the bridge which
717                  * is the other, then it isn't an error.
718                  */
719                 if (rt->rt_ifp != ifp) {
720                         /*
721                          * (1) ifp and rt_ifp both members of same bridge
722                          * (2) rt_ifp member of bridge ifp
723                          * (3) ifp member of bridge rt_ifp
724                          *
725                          * Always replace rt_ifp with the bridge ifc.
726                          */
727                         struct ifnet *nifp;
728
729                         if (ifp->if_bridge &&
730                             rt->rt_ifp->if_bridge == ifp->if_bridge) {
731                                 nifp = ether_bridge_interface(ifp);
732                         } else if (rt->rt_ifp->if_bridge &&
733                                    ether_bridge_interface(rt->rt_ifp) == ifp) {
734                                 nifp = ifp;
735                         } else if (ifp->if_bridge &&
736                                    ether_bridge_interface(ifp) == rt->rt_ifp) {
737                                 nifp = rt->rt_ifp;
738                         } else {
739                                 nifp = NULL;
740                         }
741
742                         if ((log_arp_wrong_iface == 1 && nifp == NULL) ||
743                             log_arp_wrong_iface == 2) {
744                                 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
745                                     hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
746                                 log(LOG_ERR,
747                                     "arp: %s is on %s "
748                                     "but got reply from %s on %s\n",
749                                     kinet_ntoa(isaddr, sbuf),
750                                     rt->rt_ifp->if_xname, hexstr[0],
751                                     ifp->if_xname);
752                         }
753                         if (nifp == NULL)
754                                 return 0;
755
756                         /*
757                          * nifp is our man!  Replace rt_ifp and adjust
758                          * the sdl.
759                          */
760                         ifp = rt->rt_ifp = nifp;
761                         if (sdl->sdl_type != ifp->if_type) {
762                                 sdl->sdl_type = ifp->if_type;
763                                 changed = 1;
764                                 do_rtmsg = true;
765                         }
766                         if (sdl->sdl_index != ifp->if_index) {
767                                 sdl->sdl_index = ifp->if_index;
768                                 changed = 1;
769                                 do_rtmsg = true;
770                         }
771                 }
772                 if (sdl->sdl_alen &&
773                     bcmp(ar_sha(ah), LLADDR(sdl), sdl->sdl_alen)) {
774                         changed = 1;
775                         if (rt->rt_expire != 0) {
776                                 if (dologging && log_arp_movements) {
777                                         hexncpy((u_char *)LLADDR(sdl), ifp->if_addrlen,
778                                             hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
779                                         hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
780                                             hexstr[1], HEX_NCPYLEN(ifp->if_addrlen), ":");
781                                         log(LOG_INFO,
782                                             "arp: %s moved from %s to %s on %s\n",
783                                             kinet_ntoa(isaddr, sbuf), hexstr[0], hexstr[1],
784                                             ifp->if_xname);
785                                 }
786                         } else {
787                                 if (dologging && log_arp_permanent_modify) {
788                                         hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
789                                             hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
790                                         log(LOG_ERR,
791                                         "arp: %s attempts to modify "
792                                         "permanent entry for %s on %s\n",
793                                         hexstr[0], kinet_ntoa(isaddr, sbuf), ifp->if_xname);
794                                 }
795                                 return changed;
796                         }
797                         do_rtmsg = true;
798                 }
799                 /*
800                  * sanity check for the address length.
801                  * XXX this does not work for protocols with variable address
802                  * length. -is
803                  */
804                 if (dologging && sdl->sdl_alen && sdl->sdl_alen != ah->ar_hln) {
805                         hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
806                             hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
807                         log(LOG_WARNING,
808                             "arp from %s: new addr len %d, was %d",
809                             hexstr[0], ah->ar_hln, sdl->sdl_alen);
810                 }
811                 if (ifp->if_addrlen != ah->ar_hln) {
812                         if (dologging) {
813                                 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
814                                     hexstr[0], HEX_NCPYLEN(ifp->if_addrlen), ":");
815                                 log(LOG_WARNING,
816                                 "arp from %s: addr len: new %d, i/f %d "
817                                 "(ignored)", hexstr[0],
818                                 ah->ar_hln, ifp->if_addrlen);
819                         }
820                         return changed;
821                 }
822                 if (sdl->sdl_alen == 0)
823                         do_rtmsg = true;
824                 memcpy(LLADDR(sdl), ar_sha(ah), sdl->sdl_alen = ah->ar_hln);
825                 if (rt->rt_expire != 0) {
826                         if (rt->rt_expire != time_uptime + arpt_keep &&
827                             rt->rt_expire != time_uptime + arpt_keep - 1) {
828                                 rt->rt_expire = time_uptime + arpt_keep;
829                                 changed = 1;
830                         }
831                 }
832                 if (rt->rt_flags & RTF_REJECT) {
833                         rt->rt_flags &= ~RTF_REJECT;
834                         changed = 1;
835                 }
836                 if (la->la_asked != 0) {
837                         la->la_asked = 0;
838                         changed = 1;
839                 }
840                 if (la->la_preempt != arp_maxtries) {
841                         la->la_preempt = arp_maxtries;
842                         changed = 1;
843                 }
844
845                 /*
846                  * This particular cpu might have been holding an mbuf
847                  * pending ARP resolution.  If so, transmit the mbuf now.
848                  */
849                 if (la->la_hold != NULL) {
850                         struct mbuf *m = la->la_hold;
851
852                         la->la_hold = NULL;
853                         m_adj(m, sizeof(struct ether_header));
854                         ifp->if_output(ifp, m, rt_key(rt), rt);
855                         changed = 1;
856                 }
857
858                 if (do_rtmsg && mycpuid == 0)
859                         rt_rtmsg(rt_cmd, rt, rt->rt_ifp, 0);
860         }
861         return changed;
862 }
863
864 /*
865  * Called from arpintr() - this routine is run from a single cpu.
866  */
867 static void
868 in_arpinput(struct mbuf *m)
869 {
870         struct arphdr *ah;
871         struct ifnet *ifp = m->m_pkthdr.rcvif;
872         struct ifaddr_container *ifac;
873         struct in_ifaddr_container *iac;
874         struct in_ifaddr *ia = NULL;
875         struct in_addr isaddr, itaddr, myaddr;
876         uint8_t *enaddr = NULL;
877         int req_len;
878         int changed;
879         char hexstr[64], sbuf[INET_ADDRSTRLEN];
880
881         req_len = arphdr_len2(ifp->if_addrlen, sizeof(struct in_addr));
882         if (m->m_len < req_len && (m = m_pullup(m, req_len)) == NULL) {
883                 log(LOG_ERR, "in_arp: runt packet -- m_pullup failed\n");
884                 return;
885         }
886
887         ah = mtod(m, struct arphdr *);
888         memcpy(&isaddr, ar_spa(ah), sizeof isaddr);
889         memcpy(&itaddr, ar_tpa(ah), sizeof itaddr);
890
891         /*
892          * Check both target and sender IP addresses:
893          *
894          * If we receive the packet on the interface owning the address,
895          * then accept the address.
896          *
897          * For a bridge, we accept the address if the receive interface and
898          * the interface owning the address are on the same bridge, and
899          * use the bridge MAC as the is-at response.  The bridge will be
900          * responsible for handling the packet.
901          *
902          * (0) Check target IP against CARP IPs
903          */
904 #ifdef CARP
905         LIST_FOREACH(iac, INADDR_HASH(itaddr.s_addr), ia_hash) {
906                 int is_match = 0, is_parent = 0;
907
908                 ia = iac->ia;
909
910                 /* Skip all ia's which don't match */
911                 if (itaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
912                         continue;
913
914                 if (ia->ia_ifp->if_type != IFT_CARP)
915                         continue;
916
917                 if (carp_parent(ia->ia_ifp) == ifp)
918                         is_parent = 1;
919                 if (is_parent || ia->ia_ifp == ifp)
920                         is_match = carp_iamatch(ia);
921
922                 if (is_match) {
923                         if (is_parent) {
924                                 /*
925                                  * The parent interface will also receive
926                                  * the ethernet broadcast packets, e.g. ARP
927                                  * REQUEST, so if we could find a CARP
928                                  * interface of the parent that could match
929                                  * the target IP address, we then drop the
930                                  * packets, which is delieverd to us through
931                                  * the parent interface.
932                                  */
933                                 m_freem(m);
934                                 return;
935                         }
936                         goto match;
937                 }
938         }
939 #endif  /* CARP */
940
941         /*
942          * (1) Check target IP against our local IPs
943          */
944         LIST_FOREACH(iac, INADDR_HASH(itaddr.s_addr), ia_hash) {
945                 ia = iac->ia;
946
947                 /* Skip all ia's which don't match */
948                 if (itaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
949                         continue;
950
951 #ifdef CARP
952                 /* CARP interfaces are checked in (0) */
953                 if (ia->ia_ifp->if_type == IFT_CARP)
954                         continue;
955 #endif
956
957                 if (ifp->if_bridge && ia->ia_ifp &&
958                     ifp->if_bridge == ia->ia_ifp->if_bridge) {
959                         ifp = ether_bridge_interface(ifp);
960                         goto match;
961                 }
962                 if (ia->ia_ifp && ia->ia_ifp->if_bridge &&
963                     ether_bridge_interface(ia->ia_ifp) == ifp) {
964                         goto match;
965                 }
966                 if (ifp->if_bridge && ether_bridge_interface(ifp) ==
967                     ia->ia_ifp) {
968                         goto match;
969                 }
970                 if (ia->ia_ifp == ifp) {
971                         goto match;
972                 }
973         }
974
975         /*
976          * (2) Check sender IP against our local IPs
977          */
978         LIST_FOREACH(iac, INADDR_HASH(isaddr.s_addr), ia_hash) {
979                 ia = iac->ia;
980
981                 /* Skip all ia's which don't match */
982                 if (isaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
983                         continue;
984
985                 if (ifp->if_bridge && ia->ia_ifp &&
986                     ifp->if_bridge == ia->ia_ifp->if_bridge) {
987                         ifp = ether_bridge_interface(ifp);
988                         goto match;
989                 }
990                 if (ia->ia_ifp && ia->ia_ifp->if_bridge &&
991                     ether_bridge_interface(ia->ia_ifp) == ifp) {
992                         goto match;
993                 }
994                 if (ifp->if_bridge && ether_bridge_interface(ifp) ==
995                     ia->ia_ifp) {
996                         goto match;
997                 }
998
999                 if (ia->ia_ifp == ifp)
1000                         goto match;
1001         }
1002
1003         /*
1004          * No match, use the first inet address on the receive interface
1005          * as a dummy address for the rest of the function.
1006          */
1007         TAILQ_FOREACH(ifac, &ifp->if_addrheads[mycpuid], ifa_link) {
1008                 struct ifaddr *ifa = ifac->ifa;
1009
1010                 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET) {
1011                         ia = ifatoia(ifa);
1012                         goto match;
1013                 }
1014         }
1015
1016         /*
1017          * If we got here, we didn't find any suitable interface,
1018          * so drop the packet.
1019          */
1020         m_freem(m);
1021         return;
1022
1023 match:
1024         if (!enaddr)
1025                 enaddr = (uint8_t *)IF_LLADDR(ifp);
1026         myaddr = ia->ia_addr.sin_addr;
1027         if (!bcmp(ar_sha(ah), enaddr, ifp->if_addrlen)) {
1028                 m_freem(m);     /* it's from me, ignore it. */
1029                 return;
1030         }
1031         if (!bcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
1032                 log(LOG_ERR,
1033                     "arp: link address is broadcast for IP address %s!\n",
1034                     kinet_ntoa(isaddr, sbuf));
1035                 m_freem(m);
1036                 return;
1037         }
1038         if (isaddr.s_addr == myaddr.s_addr && myaddr.s_addr != 0) {
1039                 hexncpy((u_char *)ar_sha(ah), ifp->if_addrlen,
1040                     hexstr, HEX_NCPYLEN(ifp->if_addrlen), ":");
1041                 log(LOG_ERR,
1042                    "arp: %s is using my IP address %s!\n",
1043                     hexstr, kinet_ntoa(isaddr, sbuf));
1044                 itaddr = myaddr;
1045                 goto reply;
1046         }
1047         if (ifp->if_flags & IFF_STATICARP)
1048                 goto reply;
1049
1050         /*
1051          * When arp_restricted_match is true and the ARP response is not
1052          * specifically targetted to me, ignore it.  Otherwise the entry
1053          * timeout may be updated for an old MAC.
1054          */
1055         if (arp_restricted_match && itaddr.s_addr != myaddr.s_addr) {
1056                 m_freem(m);
1057                 return;
1058         }
1059
1060         /*
1061          * Update all CPU's routing tables with this ARP packet.
1062          *
1063          * However, we only need to generate rtmsg on CPU0.
1064          */
1065         ASSERT_NETISR0;
1066         changed = arp_update_oncpu(m, isaddr.s_addr,
1067                                    itaddr.s_addr == myaddr.s_addr,
1068                                    TRUE);
1069
1070         if (netisr_ncpus > 1 && changed) {
1071                 struct netmsg_inarp *msg = &m->m_hdr.mh_arpmsg;
1072
1073                 netmsg_init(&msg->base, NULL, &netisr_apanic_rport,
1074                             0, arp_update_msghandler);
1075                 msg->m = m;
1076                 msg->saddr = isaddr.s_addr;
1077                 msg->taddr = itaddr.s_addr;
1078                 msg->myaddr = myaddr.s_addr;
1079                 lwkt_sendmsg(netisr_cpuport(1), &msg->base.lmsg);
1080         } else {
1081                 goto reply;
1082         }
1083
1084         /*
1085          * Just return here; after all CPUs's routing tables are
1086          * properly updated by this ARP packet, an ARP reply will
1087          * be generated if appropriate.
1088          */
1089         return;
1090 reply:
1091         in_arpreply(m, itaddr.s_addr, myaddr.s_addr);
1092 }
1093
1094 static void
1095 arp_reply_msghandler(netmsg_t msg)
1096 {
1097         struct netmsg_inarp *rmsg = (struct netmsg_inarp *)msg;
1098
1099         in_arpreply(rmsg->m, rmsg->taddr, rmsg->myaddr);
1100         /* Don't reply this netmsg; netmsg_inarp is embedded in mbuf */
1101 }
1102
1103 static void
1104 arp_update_msghandler(netmsg_t msg)
1105 {
1106         struct netmsg_inarp *rmsg = (struct netmsg_inarp *)msg;
1107         int nextcpu;
1108
1109         ASSERT_NETISR_NCPUS(mycpuid);
1110
1111         /*
1112          * This message handler will be called on all of the APs;
1113          * no need to generate rtmsg on them.
1114          */
1115         KASSERT(mycpuid > 0, ("arp update msg on cpu%d", mycpuid));
1116         arp_update_oncpu(rmsg->m, rmsg->saddr,
1117                          rmsg->taddr == rmsg->myaddr,
1118                          FALSE);
1119
1120         nextcpu = mycpuid + 1;
1121         if (nextcpu < netisr_ncpus) {
1122                 lwkt_forwardmsg(netisr_cpuport(nextcpu), &rmsg->base.lmsg);
1123         } else {
1124                 struct mbuf *m = rmsg->m;
1125                 in_addr_t saddr = rmsg->saddr;
1126                 in_addr_t taddr = rmsg->taddr;
1127                 in_addr_t myaddr = rmsg->myaddr;
1128
1129                 /*
1130                  * Dispatch this mbuf to netisr0 to perform ARP reply,
1131                  * if appropriate.
1132                  * NOTE: netmsg_inarp is embedded in this mbuf.
1133                  */
1134                 netmsg_init(&rmsg->base, NULL, &netisr_apanic_rport,
1135                     0, arp_reply_msghandler);
1136                 rmsg->m = m;
1137                 rmsg->saddr = saddr;
1138                 rmsg->taddr = taddr;
1139                 rmsg->myaddr = myaddr;
1140                 lwkt_sendmsg(netisr_cpuport(0), &rmsg->base.lmsg);
1141         }
1142 }
1143
1144 /*
1145  * Reply to an arp request
1146  */
1147 static void
1148 in_arpreply(struct mbuf *m, in_addr_t taddr, in_addr_t myaddr)
1149 {
1150         struct ifnet *ifp = m->m_pkthdr.rcvif;
1151         const uint8_t *enaddr;
1152         struct arphdr *ah;
1153         struct sockaddr sa;
1154         struct ether_header *eh;
1155
1156         ASSERT_NETISR0;
1157
1158         ah = mtod(m, struct arphdr *);
1159         if (ntohs(ah->ar_op) != ARPOP_REQUEST) {
1160                 m_freem(m);
1161                 return;
1162         }
1163
1164         enaddr = (const uint8_t *)IF_LLADDR(ifp);
1165         if (taddr == myaddr) {
1166                 /* I am the target */
1167                 memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1168                 memcpy(ar_sha(ah), enaddr, ah->ar_hln);
1169         } else {
1170                 struct llinfo_arp *la;
1171                 struct rtentry *rt;
1172
1173                 la = arplookup(taddr, FALSE, SIN_PROXY);
1174                 if (la == NULL) {
1175                         struct sockaddr_in sin;
1176 #ifdef DEBUG_PROXY
1177                         char tbuf[INET_ADDRSTRLEN];
1178 #endif
1179
1180                         if (!arp_proxyall) {
1181                                 m_freem(m);
1182                                 return;
1183                         }
1184
1185                         bzero(&sin, sizeof sin);
1186                         sin.sin_family = AF_INET;
1187                         sin.sin_len = sizeof sin;
1188                         sin.sin_addr.s_addr = taddr;
1189
1190                         rt = rtpurelookup((struct sockaddr *)&sin);
1191                         if (rt == NULL) {
1192                                 m_freem(m);
1193                                 return;
1194                         }
1195                         --rt->rt_refcnt;
1196
1197                         /*
1198                          * Don't send proxies for nodes on the same interface
1199                          * as this one came out of, or we'll get into a fight
1200                          * over who claims what Ether address.
1201                          *
1202                          * If the rt entry is associated with a bridge, we
1203                          * count it as the 'same' interface if ifp is
1204                          * associated with the bridge.
1205                          */
1206                         if (rt->rt_ifp == ifp || rt->rt_ifp == ifp->if_bridge) {
1207                                 m_freem(m);
1208                                 return;
1209                         }
1210                         memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1211                         memcpy(ar_sha(ah), enaddr, ah->ar_hln);
1212 #ifdef DEBUG_PROXY
1213                         kprintf("arp: proxying for %s\n",
1214                             kinet_ntoa(itaddr, tbuf));
1215 #endif
1216                 } else {
1217                         struct sockaddr_dl *sdl;
1218
1219                         rt = la->la_rt;
1220                         memcpy(ar_tha(ah), ar_sha(ah), ah->ar_hln);
1221                         sdl = SDL(rt->rt_gateway);
1222                         memcpy(ar_sha(ah), LLADDR(sdl), ah->ar_hln);
1223                 }
1224         }
1225
1226         memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
1227         memcpy(ar_spa(ah), &taddr, ah->ar_pln);
1228         ah->ar_op = htons(ARPOP_REPLY);
1229         ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
1230         switch (ifp->if_type) {
1231         case IFT_ETHER:
1232                 /*
1233                  * May not be correct for types not explictly
1234                  * listed, but it is our best guess.
1235                  */
1236         default:
1237                 eh = (struct ether_header *)sa.sa_data;
1238                 memcpy(eh->ether_dhost, ar_tha(ah), sizeof eh->ether_dhost);
1239                 eh->ether_type = htons(ETHERTYPE_ARP);
1240                 break;
1241         }
1242         sa.sa_family = AF_UNSPEC;
1243         sa.sa_len = sizeof sa;
1244         ifp->if_output(ifp, m, &sa, NULL);
1245 }
1246
1247 #endif  /* INET */
1248
1249 /*
1250  * Free an arp entry.  If the arp entry is actively referenced or represents
1251  * a static entry we only clear it back to an unresolved state, otherwise
1252  * we destroy the entry entirely.
1253  *
1254  * Note that static entries are created when route add ... -interface is used
1255  * to create an interface route to a (direct) destination.
1256  */
1257 static void
1258 arptfree(struct llinfo_arp *la)
1259 {
1260         struct rtentry *rt = la->la_rt, *nrt;
1261         struct sockaddr_dl *sdl;
1262         int error;
1263
1264         if (rt == NULL)
1265                 panic("arptfree");
1266         sdl = SDL(rt->rt_gateway);
1267         if (sdl != NULL &&
1268             ((rt->rt_refcnt > 0 && sdl->sdl_family == AF_LINK) ||
1269              (rt->rt_flags & RTF_STATIC))) {
1270                 sdl->sdl_alen = 0;
1271                 la->la_preempt = la->la_asked = 0;
1272                 rt->rt_flags &= ~RTF_REJECT;
1273                 return;
1274         }
1275         error = rtrequest(RTM_DELETE, rt_key(rt), NULL, rt_mask(rt), 0, &nrt);
1276         if (error == 0 && nrt != NULL) {
1277                 rt_rtmsg(RTM_DELETE, nrt, nrt->rt_ifp, 0);
1278                 rtfree(nrt);
1279         }
1280 }
1281
1282 /*
1283  * Lookup or enter a new address in arptab.
1284  */
1285 static struct llinfo_arp *
1286 arplookup(in_addr_t addr, boolean_t create,
1287           boolean_t proxy)
1288 {
1289         struct rtentry *rt;
1290         struct sockaddr_inarp sin = { sizeof sin, AF_INET };
1291         const char *why = NULL;
1292
1293         /* Check ARP probes, e.g. from Cisco switches. */
1294         if (addr == INADDR_ANY && arp_ignore_probes)
1295                 return (NULL);
1296
1297         sin.sin_addr.s_addr = addr;
1298         sin.sin_other = proxy ? SIN_PROXY : 0;
1299         if (create) {
1300                 rt = rtlookup((struct sockaddr *)&sin);
1301         } else {
1302                 rt = rtpurelookup((struct sockaddr *)&sin);
1303         }
1304         if (rt == NULL)
1305                 return (NULL);
1306         rt->rt_refcnt--;
1307
1308         if (rt->rt_flags & RTF_GATEWAY)
1309                 why = "host is not on local network";
1310         else if (!(rt->rt_flags & RTF_LLINFO))
1311                 why = "could not allocate llinfo";
1312         else if (rt->rt_gateway->sa_family != AF_LINK)
1313                 why = "gateway route is not ours";
1314
1315         if (why) {
1316                 if (create && log_arp_creation_failure) {
1317                         char abuf[INET_ADDRSTRLEN];
1318
1319                         log(LOG_DEBUG, "arplookup %s failed: %s\n",
1320                             kinet_ntoa(sin.sin_addr, abuf), why);
1321                 }
1322                 if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_WASCLONED)) {
1323                         /* No references to this route.  Purge it. */
1324                         rtrequest(RTM_DELETE, rt_key(rt), rt->rt_gateway,
1325                                   rt_mask(rt), rt->rt_flags, NULL);
1326                 }
1327                 return (NULL);
1328         }
1329         return (rt->rt_llinfo);
1330 }
1331
1332 void
1333 arp_ifinit(struct ifnet *ifp, struct ifaddr *ifa)
1334 {
1335         ifa->ifa_rtrequest = arp_rtrequest;
1336         ifa->ifa_flags |= RTF_CLONING;
1337 }
1338
1339 void
1340 arp_gratuitous(struct ifnet *ifp, struct ifaddr *ifa)
1341 {
1342         if (IA_SIN(ifa)->sin_addr.s_addr != INADDR_ANY) {
1343                 if (IN_NETISR_NCPUS(mycpuid)) {
1344                         arprequest(ifp, &IA_SIN(ifa)->sin_addr,
1345                             &IA_SIN(ifa)->sin_addr, NULL);
1346                 } else {
1347                         arprequest_async(ifp, &IA_SIN(ifa)->sin_addr,
1348                             &IA_SIN(ifa)->sin_addr, NULL);
1349                 }
1350         }
1351 }
1352
1353 static void
1354 arp_ifaddr(void *arg __unused, struct ifnet *ifp,
1355     enum ifaddr_event event, struct ifaddr *ifa)
1356 {
1357         if (ifa->ifa_rtrequest != arp_rtrequest) /* XXX need a generic way */
1358                 return;
1359         if (ifa->ifa_addr->sa_family != AF_INET)
1360                 return;
1361         if (event == IFADDR_EVENT_DELETE)
1362                 return;
1363
1364         /*
1365          * - CARP interfaces will take care of gratuitous ARP themselves.
1366          * - If we are the CARP interface's parent, don't send gratuitous
1367          *   ARP to avoid unnecessary confusion.
1368          */
1369 #ifdef CARP
1370         if (ifp->if_type != IFT_CARP && ifp->if_carp == NULL)
1371 #endif
1372         {
1373                 arp_gratuitous(ifp, ifa);
1374         }
1375 }
1376
1377 static void
1378 arp_init_dispatch(netmsg_t nm)
1379 {
1380         struct arp_pcpu_data *ad;
1381
1382         ASSERT_NETISR_NCPUS(mycpuid);
1383
1384         ad = kmalloc(sizeof(*ad), M_ARP, M_WAITOK | M_ZERO);
1385
1386         LIST_INIT(&ad->llinfo_list);
1387         callout_init_mp(&ad->timer_ch);
1388         netmsg_init(&ad->timer_nmsg, NULL, &netisr_adone_rport,
1389             MSGF_PRIORITY, arptimer_dispatch);
1390         ad->timer_nmsg.lmsg.u.ms_resultp = ad;
1391
1392         arp_data[mycpuid] = ad;
1393
1394         callout_reset(&ad->timer_ch, hz, arptimer, &ad->timer_nmsg);
1395
1396         netisr_forwardmsg(&nm->base, mycpuid + 1);
1397 }
1398
1399 static void
1400 arp_init(void)
1401 {
1402         struct netmsg_base nm;
1403
1404         netmsg_init(&nm, NULL, &curthread->td_msgport, 0, arp_init_dispatch);
1405         netisr_domsg_global(&nm);
1406
1407         netisr_register(NETISR_ARP, arpintr, NULL);
1408
1409         EVENTHANDLER_REGISTER(ifaddr_event, arp_ifaddr, NULL,
1410             EVENTHANDLER_PRI_LAST);
1411 }
1412 SYSINIT(arp, SI_SUB_PROTO_DOMAIN, SI_ORDER_ANY, arp_init, 0);