root/netinet/if_ether.c

DEFINITIONS

1. arptimer
2. arp_rtrequest
3. arprequest
4. arpresolve
5. arpintr
6. in_arpinput
7. arptfree
8. arplookup
9. arpioctl
10. arp_ifinit
11. revarpinput
12. in_revarpinput
13. revarprequest
14. revarpwhoarewe
15. revarpwhoami
16. db_print_sa
17. db_print_ifa
18. db_print_llinfo
19. db_show_radix_node
20. db_show_arptab

    1 /*      $OpenBSD: if_ether.c,v 1.68 2007/03/25 16:43:22 claudio Exp $   */
    2 /*      $NetBSD: if_ether.c,v 1.31 1996/05/11 12:59:58 mycroft Exp $    */
    4 /*
    5  * Copyright (c) 1982, 1986, 1988, 1993
    6  *      The Regents of the University of California.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   11  * 1. Redistributions of source code must retain the above copyright
   12  *    notice, this list of conditions and the following disclaimer.
   13  * 2. Redistributions in binary form must reproduce the above copyright
   14  *    notice, this list of conditions and the following disclaimer in the
   15  *    documentation and/or other materials provided with the distribution.
   16  * 3. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      @(#)if_ether.c  8.1 (Berkeley) 6/10/93
   33  */
   35 /*
   36  * Ethernet address resolution protocol.
   37  * TODO:
   38  *      add "inuse/lock" bit (or ref. count) along with valid bit
   39  */
   41 #ifdef INET
   42 #include "carp.h"
   44 #include "bridge.h"
   46 #include <sys/param.h>
   47 #include <sys/systm.h>
   48 #include <sys/mbuf.h>
   49 #include <sys/socket.h>
   50 #include <sys/kernel.h>
   51 #include <sys/syslog.h>
   52 #include <sys/proc.h>
   54 #include <net/if.h>
   55 #include <net/if_dl.h>
   56 #include <net/route.h>
   57 #include <net/if_fddi.h>
   58 #include <net/if_types.h>
   60 #include <netinet/in.h>
   61 #include <netinet/in_var.h>
   62 #include <netinet/if_ether.h>
   63 #if NCARP > 0
   64 #include <netinet/ip_carp.h>
   65 #endif
   67 #define SIN(s) ((struct sockaddr_in *)s)
   68 #define SDL(s) ((struct sockaddr_dl *)s)
   69 #define SRP(s) ((struct sockaddr_inarp *)s)
   71 /*
   72  * ARP trailer negotiation.  Trailer protocol is not IP specific,
   73  * but ARP request/response use IP addresses.
   74  */
   75 #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
   77 /* timer values */
   78 int     arpt_prune = (5*60*1);  /* walk list every 5 minutes */
   79 int     arpt_keep = (20*60);    /* once resolved, good for 20 more minutes */
   80 int     arpt_down = 20;         /* once declared down, don't send for 20 secs */
   81 #define rt_expire rt_rmx.rmx_expire
   83 void arptfree(struct llinfo_arp *);
   84 void arptimer(void *);
   85 struct llinfo_arp *arplookup(u_int32_t, int, int);
   86 void in_arpinput(struct mbuf *);
LIST_HEAD(, llinfo_arp) llinfo_arp;
   89 struct  ifqueue arpintrq = {0, 0, 0, 50};
   90 int     arp_inuse, arp_allocated, arp_intimer;
   91 int     arp_maxtries = 5;
   92 int     useloopback = 1;        /* use loopback interface for local traffic */
   93 int     arpinit_done = 0;
   95 /* revarp state */
   96 struct in_addr myip, srv_ip;
   97 int myip_initialized = 0;
   98 int revarp_in_progress = 0;
   99 struct ifnet *myip_ifp = NULL;
  101 #ifdef DDB
  102 #include <uvm/uvm_extern.h>
  104 void    db_print_sa(struct sockaddr *);
  105 void    db_print_ifa(struct ifaddr *);
  106 void    db_print_llinfo(caddr_t);
  107 int     db_show_radix_node(struct radix_node *, void *);
  108 #endif
  110 /*
  111  * Timeout routine.  Age arp_tab entries periodically.
  112  */
  113 /* ARGSUSED */
  114 void
arptimer(arg)
  116         void *arg;
  117 {
  118         struct timeout *to = (struct timeout *)arg;
  119         int s;
  120         struct llinfo_arp *la, *nla;
s = splsoftnet();
timeout_add(to, arpt_prune * hz);
  124         for (la = LIST_FIRST(&llinfo_arp); la != LIST_END(&llinfo_arp);
la = nla) {
  126                 struct rtentry *rt = la->la_rt;
nla = LIST_NEXT(la, la_list);
  129                 if (rt->rt_expire && rt->rt_expire <= time_second)
arptfree(la); /* timer has expired; clear */
  131         }
splx(s);
  133 }
  135 /*
  136  * Parallel to llc_rtrequest.
  137  */
  138 void
arp_rtrequest(req, rt, info)
  140         int req;
  141         struct rtentry *rt;
  142         struct rt_addrinfo *info;
  143 {
  144         struct sockaddr *gate = rt->rt_gateway;
  145         struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
  146         static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};
  147         struct in_ifaddr *ia;
  148         struct ifaddr *ifa;
  150         if (!arpinit_done) {
  151                 static struct timeout arptimer_to;
arpinit_done = 1;
  154                 /*
  155                  * We generate expiration times from time.tv_sec
  156                  * so avoid accidently creating permanent routes.
  157                  */
  158                 if (time_second == 0) {
time_second++;
  160                 }
timeout_set(&arptimer_to, arptimer, &arptimer_to);
timeout_add(&arptimer_to, hz);
  164         }
  166         if (rt->rt_flags & RTF_GATEWAY) {
  167                 if (req != RTM_ADD)
  168                         return;
  170                 /*
  171                  * linklayers with particular link MTU limitation.  it is a bit
  172                  * awkward to have FDDI handling here, we should split ARP from
  173                  * netinet/if_ether.c like NetBSD does.
  174                  */
  175                 switch (rt->rt_ifp->if_type) {
  176                 case IFT_FDDI:
  177                         if (rt->rt_ifp->if_mtu > FDDIIPMTU)
rt->rt_rmx.rmx_mtu = FDDIIPMTU;
  179                         break;
  180                 }
  182                 return;
  183         }
  185         switch (req) {
  187         case RTM_ADD:
  188                 /*
  189                  * XXX: If this is a manually added route to interface
  190                  * such as older version of routed or gated might provide,
  191                  * restore cloning bit.
  192                  */
  193                 if ((rt->rt_flags & RTF_HOST) == 0 &&
SIN(rt_mask(rt))->sin_addr.s_addr != 0xffffffff)
rt->rt_flags |= RTF_CLONING;
  196                 if (rt->rt_flags & RTF_CLONING) {
  197                         /*
  198                          * Case 1: This route should come from a route to iface.
  199                          */
rt_setgate(rt, rt_key(rt),
  201                             (struct sockaddr *)&null_sdl, 0);
gate = rt->rt_gateway;
SDL(gate)->sdl_type = rt->rt_ifp->if_type;
SDL(gate)->sdl_index = rt->rt_ifp->if_index;
  205                         /*
  206                          * Give this route an expiration time, even though
  207                          * it's a "permanent" route, so that routes cloned
  208                          * from it do not need their expiration time set.
  209                          */
rt->rt_expire = time_second;
  211                         /*
  212                          * linklayers with particular link MTU limitation.
  213                          */
  214                         switch (rt->rt_ifp->if_type) {
  215                         case IFT_FDDI:
  216                                 if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
  217                                     (rt->rt_rmx.rmx_mtu > FDDIIPMTU ||
  218                                      (rt->rt_rmx.rmx_mtu == 0 &&
rt->rt_ifp->if_mtu > FDDIIPMTU)))
rt->rt_rmx.rmx_mtu = FDDIIPMTU;
  221                                 break;
  222                         }
  223                         break;
  224                 }
  225                 /* Announce a new entry if requested. */
  226                 if (rt->rt_flags & RTF_ANNOUNCE)
arprequest(rt->rt_ifp,
  228                             &SIN(rt_key(rt))->sin_addr.s_addr,
  229                             &SIN(rt_key(rt))->sin_addr.s_addr,
  230                             (u_char *)LLADDR(SDL(gate)));
  231                 /*FALLTHROUGH*/
  232         case RTM_RESOLVE:
  233                 if (gate->sa_family != AF_LINK ||
gate->sa_len < sizeof(null_sdl)) {
log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
  236                         break;
  237                 }
SDL(gate)->sdl_type = rt->rt_ifp->if_type;
SDL(gate)->sdl_index = rt->rt_ifp->if_index;
  240                 if (la != 0)
  241                         break; /* This happens on a route change */
  242                 /*
  243                  * Case 2:  This route may come from cloning, or a manual route
  244                  * add with a LL address.
  245                  */
R_Malloc(la, struct llinfo_arp *, sizeof(*la));
rt->rt_llinfo = (caddr_t)la;
  248                 if (la == 0) {
log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
  250                         break;
  251                 }
arp_inuse++, arp_allocated++;
Bzero(la, sizeof(*la));
la->la_rt = rt;
rt->rt_flags |= RTF_LLINFO;
LIST_INSERT_HEAD(&llinfo_arp, la, la_list);
TAILQ_FOREACH(ia, &in_ifaddr, ia_list) {
  259                         if (ia->ia_ifp == rt->rt_ifp &&
SIN(rt_key(rt))->sin_addr.s_addr ==
  261                             (IA_SIN(ia))->sin_addr.s_addr)
  262                                 break;
  263                 }
  264                 if (ia) {
  265                         /*
  266                          * This test used to be
  267                          *      if (lo0ifp->if_flags & IFF_UP)
  268                          * It allowed local traffic to be forced through
  269                          * the hardware by configuring the loopback down.
  270                          * However, it causes problems during network
  271                          * configuration for boards that can't receive
  272                          * packets they send.  It is now necessary to clear
  273                          * "useloopback" and remove the route to force
  274                          * traffic out to the hardware.
  275                          *
  276                          * In 4.4BSD, the above "if" statement checked
  277                          * rt->rt_ifa against rt_key(rt).  It was changed
  278                          * to the current form so that we can provide a
  279                          * better support for multiple IPv4 addresses on a
  280                          * interface.
  281                          */
rt->rt_expire = 0;
Bcopy(((struct arpcom *)rt->rt_ifp)->ac_enaddr,
LLADDR(SDL(gate)),
SDL(gate)->sdl_alen = ETHER_ADDR_LEN);
  286                         if (useloopback)
rt->rt_ifp = lo0ifp;
  288                         /*
  289                          * make sure to set rt->rt_ifa to the interface
  290                          * address we are using, otherwise we will have trouble
  291                          * with source address selection.
  292                          */
ifa = &ia->ia_ifa;
  294                         if (ifa != rt->rt_ifa) {
IFAFREE(rt->rt_ifa);
ifa->ifa_refcnt++;
rt->rt_ifa = ifa;
  298                         }
  299                 }
  300                 break;
  302         case RTM_DELETE:
  303                 if (la == 0)
  304                         break;
arp_inuse--;
LIST_REMOVE(la, la_list);
rt->rt_llinfo = 0;
rt->rt_flags &= ~RTF_LLINFO;
  309                 if (la->la_hold)
m_freem(la->la_hold);
Free((caddr_t)la);
  312         }
  313 }
  315 /*
  316  * Broadcast an ARP request. Caller specifies:
  317  *      - arp header source ip address
  318  *      - arp header target ip address
  319  *      - arp header source ethernet address
  320  */
  321 void
arprequest(ifp, sip, tip, enaddr)
  323         struct ifnet *ifp;
u_int32_t *sip, *tip;
u_int8_t *enaddr;
  326 {
  327         struct mbuf *m;
  328         struct ether_header *eh;
  329         struct ether_arp *ea;
  330         struct sockaddr sa;
  332         if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
  333                 return;
m->m_len = sizeof(*ea);
m->m_pkthdr.len = sizeof(*ea);
MH_ALIGN(m, sizeof(*ea));
ea = mtod(m, struct ether_arp *);
eh = (struct ether_header *)sa.sa_data;
bzero((caddr_t)ea, sizeof (*ea));
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  341             sizeof(eh->ether_dhost));
eh->ether_type = htons(ETHERTYPE_ARP);  /* if_output will not swap */
ea->arp_hrd = htons(ARPHRD_ETHER);
ea->arp_pro = htons(ETHERTYPE_IP);
ea->arp_hln = sizeof(ea->arp_sha);      /* hardware address length */
ea->arp_pln = sizeof(ea->arp_spa);      /* protocol address length */
ea->arp_op = htons(ARPOP_REQUEST);
bcopy((caddr_t)enaddr, (caddr_t)eh->ether_shost,
  349               sizeof(eh->ether_shost));
bcopy((caddr_t)enaddr, (caddr_t)ea->arp_sha, sizeof(ea->arp_sha));
bcopy((caddr_t)sip, (caddr_t)ea->arp_spa, sizeof(ea->arp_spa));
bcopy((caddr_t)tip, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa));
sa.sa_family = pseudo_AF_HDRCMPLT;
sa.sa_len = sizeof(sa);
  355         (*ifp->if_output)(ifp, m, &sa, (struct rtentry *)0);
  356 }
  358 /*
  359  * Resolve an IP address into an ethernet address.  If success,
  360  * desten is filled in.  If there is no entry in arptab,
  361  * set one up and broadcast a request for the IP address.
  362  * Hold onto this mbuf and resend it once the address
  363  * is finally resolved.  A return value of 1 indicates
  364  * that desten has been filled in and the packet should be sent
  365  * normally; a 0 return indicates that the packet has been
  366  * taken over here, either now or for later transmission.
  367  */
  368 int
arpresolve(ac, rt, m, dst, desten)
  370         struct arpcom *ac;
  371         struct rtentry *rt;
  372         struct mbuf *m;
  373         struct sockaddr *dst;
u_char *desten;
  375 {
  376         struct llinfo_arp *la;
  377         struct sockaddr_dl *sdl;
  379         if (m->m_flags & M_BCAST) {     /* broadcast */
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten,
  381                     sizeof(etherbroadcastaddr));
  382                 return (1);
  383         }
  384         if (m->m_flags & M_MCAST) {     /* multicast */
ETHER_MAP_IP_MULTICAST(&SIN(dst)->sin_addr, desten);
  386                 return (1);
  387         }
  388         if (rt) {
la = (struct llinfo_arp *)rt->rt_llinfo;
  390                 if (la == NULL)
log(LOG_DEBUG, "arpresolve: %s: route without link "
  392                             "local address\n", inet_ntoa(SIN(dst)->sin_addr));
  393         } else {
  394                 if ((la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0)) != NULL)
rt = la->la_rt;
  396                 else
log(LOG_DEBUG,
  398                             "arpresolve: %s: can't allocate llinfo\n",
inet_ntoa(SIN(dst)->sin_addr));
  400         }
  401         if (la == 0 || rt == 0) {
m_freem(m);
  403                 return (0);
  404         }
sdl = SDL(rt->rt_gateway);
  406         /*
  407          * Check the address family and length is valid, the address
  408          * is resolved; otherwise, try to resolve.
  409          */
  410         if ((rt->rt_expire == 0 || rt->rt_expire > time_second) &&
sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
  413                 return 1;
  414         }
  415         if (((struct ifnet *)ac)->if_flags & IFF_NOARP)
  416                 return 0;
  418         /*
  419          * There is an arptab entry, but no ethernet address
  420          * response yet.  Replace the held mbuf with this
  421          * latest one.
  422          */
  423         if (la->la_hold)
m_freem(la->la_hold);
la->la_hold = m;
  426         /*
  427          * Re-send the ARP request when appropriate.
  428          */
  429 #ifdef  DIAGNOSTIC
  430         if (rt->rt_expire == 0) {
  431                 /* This should never happen. (Should it? -gwr) */
printf("arpresolve: unresolved and rt_expire == 0\n");
  433                 /* Set expiration time to now (expired). */
rt->rt_expire = time_second;
  435         }
  436 #endif
  437         if (rt->rt_expire) {
rt->rt_flags &= ~RTF_REJECT;
  439                 if (la->la_asked == 0 || rt->rt_expire != time_second) {
rt->rt_expire = time_second;
  441                         if (la->la_asked++ < arp_maxtries)
arprequest(&ac->ac_if,
  443                                     &(SIN(rt->rt_ifa->ifa_addr)->sin_addr.s_addr),
  444                                     &(SIN(dst)->sin_addr.s_addr),
  445 #if NCARP > 0
  446                                     (rt->rt_ifp->if_type == IFT_CARP) ?
  447                                         ((struct arpcom *) rt->rt_ifp->if_softc
  448                                         )->ac_enaddr :
  449 #endif
ac->ac_enaddr);
  451                         else {
rt->rt_flags |= RTF_REJECT;
rt->rt_expire += arpt_down;
la->la_asked = 0;
  455                         }
  456                 }
  457         }
  458         return (0);
  459 }
  461 /*
  462  * Common length and type checks are done here,
  463  * then the protocol-specific routine is called.
  464  */
  465 void
arpintr()
  467 {
  468         struct mbuf *m;
  469         struct arphdr *ar;
  470         int s, len;
  472         while (arpintrq.ifq_head) {
s = splnet();
IF_DEQUEUE(&arpintrq, m);
splx(s);
  476                 if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
panic("arpintr");
len = sizeof(struct arphdr);
  480                 if (m->m_len < len && (m = m_pullup(m, len)) == NULL)
  481                         continue;
ar = mtod(m, struct arphdr *);
  484                 if (ntohs(ar->ar_hrd) != ARPHRD_ETHER) {
m_freem(m);
  486                         continue;
  487                 }
len += 2 * (ar->ar_hln + ar->ar_pln);
  490                 if (m->m_len < len && (m = m_pullup(m, len)) == NULL)
  491                         continue;
  493                 switch (ntohs(ar->ar_pro)) {
  494                 case ETHERTYPE_IP:
  495                 case ETHERTYPE_IPTRAILERS:
in_arpinput(m);
  497                         continue;
  498                 }
m_freem(m);
  500         }
  501 }
  503 /*
  504  * ARP for Internet protocols on Ethernet.
  505  * Algorithm is that given in RFC 826.
  506  * In addition, a sanity check is performed on the sender
  507  * protocol address, to catch impersonators.
  508  * We no longer handle negotiations for use of trailer protocol:
  509  * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
  510  * along with IP replies if we wanted trailers sent to us,
  511  * and also sent them in response to IP replies.
  512  * This allowed either end to announce the desire to receive
  513  * trailer packets.
  514  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
  515  * but formerly didn't normally send requests.
  516  */
  517 void
in_arpinput(m)
  519         struct mbuf *m;
  520 {
  521         struct ether_arp *ea;
  522         struct arpcom *ac = (struct arpcom *)m->m_pkthdr.rcvif;
  523         struct ether_header *eh;
  524         struct llinfo_arp *la = 0;
  525         struct rtentry *rt;
  526         struct in_ifaddr *ia;
  527 #if NBRIDGE > 0
  528         struct in_ifaddr *bridge_ia = NULL;
  529 #endif
  530 #if NCARP > 0
u_int32_t count = 0, index = 0;
  532 #endif
  533         struct sockaddr_dl *sdl;
  534         struct sockaddr sa;
  535         struct in_addr isaddr, itaddr, myaddr;
u_int8_t *enaddr = NULL;
  537         int op;
ea = mtod(m, struct ether_arp *);
op = ntohs(ea->arp_op);
  541         if ((op != ARPOP_REQUEST) && (op != ARPOP_REPLY))
  542                 goto out;
  543 #if notyet
  544         if ((op == ARPOP_REPLY) && (m->m_flags & (M_BCAST|M_MCAST))) {
log(LOG_ERR,
  546                     "arp: received reply to broadcast or multicast address\n");
  547                 goto out;
  548         }
  549 #endif
bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof(itaddr));
bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof(isaddr));
TAILQ_FOREACH(ia, &in_ifaddr, ia_list) {
  555                 if (itaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
  556                         continue;
  558 #if NCARP > 0
  559                 if (ia->ia_ifp->if_type == IFT_CARP &&
  560                     ((ia->ia_ifp->if_flags & (IFF_UP|IFF_RUNNING)) ==
  561                     (IFF_UP|IFF_RUNNING))) {
index++;
  563                         if (ia->ia_ifp == m->m_pkthdr.rcvif &&
carp_iamatch(ia, ea->arp_sha,
  565                             &count, index))
  566                                 break;
  567                 } else
  568 #endif
  569                         if (ia->ia_ifp == m->m_pkthdr.rcvif)
  570                                 break;
  571 #if NBRIDGE > 0
  572                 /*
  573                  * If the interface we received the packet on
  574                  * is part of a bridge, check to see if we need
  575                  * to "bridge" the packet to ourselves at this
  576                  * layer.  Note we still prefer a perfect match,
  577                  * but allow this weaker match if necessary.
  578                  */
  579                 if (m->m_pkthdr.rcvif->if_bridge != NULL) {
  580                         if (m->m_pkthdr.rcvif->if_bridge ==
ia->ia_ifp->if_bridge)
bridge_ia = ia;
  583 #if NCARP > 0
  584                         else if (ia->ia_ifp->if_carpdev != NULL &&
m->m_pkthdr.rcvif->if_bridge ==
ia->ia_ifp->if_carpdev->if_bridge &&
carp_iamatch(ia, ea->arp_sha,
  588                             &count, index))
bridge_ia = ia;
  590 #endif
  591                 }
  592 #endif
  593         }
  595 #if NBRIDGE > 0
  596         if (ia == NULL && bridge_ia != NULL) {
ia = bridge_ia;
ac = (struct arpcom *)bridge_ia->ia_ifp;
  599         }
  600 #endif
  602         if (ia == NULL) {
TAILQ_FOREACH(ia, &in_ifaddr, ia_list) {
  604                         if (isaddr.s_addr != ia->ia_addr.sin_addr.s_addr)
  605                                 continue;
  606                         if (ia->ia_ifp == m->m_pkthdr.rcvif)
  607                                 break;
  608                 }
  609         }
  611         if (ia == NULL && m->m_pkthdr.rcvif->if_type != IFT_CARP) {
  612                 struct ifaddr *ifa;
TAILQ_FOREACH(ifa, &m->m_pkthdr.rcvif->if_addrlist, ifa_list) {
  615                         if (ifa->ifa_addr->sa_family == AF_INET)
  616                                 break;
  617                 }
  618                 if (ifa)
ia = (struct in_ifaddr *)ifa;
  620         }
  622         if (ia == NULL)
  623                 goto out;
  625         if (!enaddr)
enaddr = ac->ac_enaddr;
myaddr = ia->ia_addr.sin_addr;
  629         if (!bcmp((caddr_t)ea->arp_sha, enaddr, sizeof (ea->arp_sha)))
  630                 goto out;       /* it's from me, ignore it. */
  631         if (ETHER_IS_MULTICAST (&ea->arp_sha[0]))
  632                 if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr,
  633                     sizeof (ea->arp_sha))) {
log(LOG_ERR, "arp: ether address is broadcast for "
  635                             "IP address %s!\n", inet_ntoa(isaddr));
  636                         goto out;
  637                 }
  638         if (myaddr.s_addr && isaddr.s_addr == myaddr.s_addr) {
log(LOG_ERR,
  640                    "duplicate IP address %s sent from ethernet address %s\n",
inet_ntoa(isaddr), ether_sprintf(ea->arp_sha));
itaddr = myaddr;
  643                 goto reply;
  644         }
la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0);
  646         if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
  647                 if (sdl->sdl_alen) {
  648                     if (bcmp(ea->arp_sha, LLADDR(sdl), sdl->sdl_alen)) {
  649                         if (rt->rt_flags & RTF_PERMANENT_ARP) {
log(LOG_WARNING,
  651                                    "arp: attempt to overwrite permanent "
  652                                    "entry for %s by %s on %s\n",
inet_ntoa(isaddr),
ether_sprintf(ea->arp_sha),
ac->ac_if.if_xname);
  656                                 goto out;
  657                         } else if (rt->rt_ifp != &ac->ac_if) {
log(LOG_WARNING,
  659                                    "arp: attempt to overwrite entry for %s "
  660                                    "on %s by %s on %s\n",
inet_ntoa(isaddr), rt->rt_ifp->if_xname,
ether_sprintf(ea->arp_sha),
ac->ac_if.if_xname);
  664                                 goto out;
  665                         } else {
log(LOG_INFO,
  667                                    "arp info overwritten for %s by %s on %s\n",
inet_ntoa(isaddr),
ether_sprintf(ea->arp_sha),
ac->ac_if.if_xname);
rt->rt_expire = 1; /* no longer static */
  672                         }
  673                     }
  674                 } else if (rt->rt_ifp != &ac->ac_if && !(ac->ac_if.if_bridge &&
  675                     (rt->rt_ifp->if_bridge == ac->ac_if.if_bridge)) &&
  676                     !(rt->rt_ifp->if_type == IFT_CARP &&
rt->rt_ifp->if_carpdev == &ac->ac_if) &&
  678                     !(ac->ac_if.if_type == IFT_CARP &&
ac->ac_if.if_carpdev == rt->rt_ifp)) {
log(LOG_WARNING,
  681                         "arp: attempt to add entry for %s "
  682                         "on %s by %s on %s\n",
inet_ntoa(isaddr), rt->rt_ifp->if_xname,
ether_sprintf(ea->arp_sha),
ac->ac_if.if_xname);
  686                     goto out;
  687                 }
bcopy(ea->arp_sha, LLADDR(sdl),
sdl->sdl_alen = sizeof(ea->arp_sha));
  690                 if (rt->rt_expire)
rt->rt_expire = time_second + arpt_keep;
rt->rt_flags &= ~RTF_REJECT;
la->la_asked = 0;
  694                 if (la->la_hold) {
  695                         (*ac->ac_if.if_output)(&ac->ac_if, la->la_hold,
rt_key(rt), rt);
la->la_hold = 0;
  698                 }
  699         }
reply:
  701         if (op != ARPOP_REQUEST) {
out:
m_freem(m);
  704                 return;
  705         }
  706         if (itaddr.s_addr == myaddr.s_addr) {
  707                 /* I am the target */
bcopy(ea->arp_sha, ea->arp_tha, sizeof(ea->arp_sha));
bcopy(enaddr, ea->arp_sha, sizeof(ea->arp_sha));
  710         } else {
la = arplookup(itaddr.s_addr, 0, SIN_PROXY);
  712                 if (la == 0)
  713                         goto out;
rt = la->la_rt;
  715                 if (rt->rt_ifp->if_type == IFT_CARP &&
m->m_pkthdr.rcvif->if_type != IFT_CARP)
  717                         goto out;
bcopy(ea->arp_sha, ea->arp_tha, sizeof(ea->arp_sha));
sdl = SDL(rt->rt_gateway);
bcopy(LLADDR(sdl), ea->arp_sha, sizeof(ea->arp_sha));
  721         }
bcopy(ea->arp_spa, ea->arp_tpa, sizeof(ea->arp_spa));
bcopy(&itaddr, ea->arp_spa, sizeof(ea->arp_spa));
ea->arp_op = htons(ARPOP_REPLY);
ea->arp_pro = htons(ETHERTYPE_IP); /* let's be sure! */
eh = (struct ether_header *)sa.sa_data;
bcopy(ea->arp_tha, eh->ether_dhost, sizeof(eh->ether_dhost));
  729 #if NCARP > 0
  730         if (ac->ac_if.if_type == IFT_CARP && ac->ac_if.if_flags & IFF_LINK1)
bcopy(((struct arpcom *)ac->ac_if.if_carpdev)->ac_enaddr,
eh->ether_shost, sizeof(eh->ether_shost));
  733         else
  734 #endif
bcopy(enaddr, eh->ether_shost, sizeof(eh->ether_shost));
eh->ether_type = htons(ETHERTYPE_ARP);
sa.sa_family = pseudo_AF_HDRCMPLT;
sa.sa_len = sizeof(sa);
  740         (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
  741         return;
  742 }
  744 /*
  745  * Free an arp entry.
  746  */
  747 void
arptfree(la)
  749         struct llinfo_arp *la;
  750 {
  751         struct rtentry *rt = la->la_rt;
  752         struct sockaddr_dl *sdl;
  754         if (rt == 0)
panic("arptfree");
  756         if (rt->rt_refcnt > 0 && (sdl = SDL(rt->rt_gateway)) &&
sdl->sdl_family == AF_LINK) {
sdl->sdl_alen = 0;
la->la_asked = 0;
rt->rt_flags &= ~RTF_REJECT;
  761                 return;
  762         }
rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt),
  764             0, (struct rtentry **)0, 0);
  765 }
  767 /*
  768  * Lookup or enter a new address in arptab.
  769  */
  770 struct llinfo_arp *
arplookup(addr, create, proxy)
u_int32_t addr;
  773         int create, proxy;
  774 {
  775         struct rtentry *rt;
  776         static struct sockaddr_inarp sin;
sin.sin_len = sizeof(sin);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = addr;
sin.sin_other = proxy ? SIN_PROXY : 0;
rt = rtalloc1(sintosa(&sin), create, 0);
  783         if (rt == 0)
  784                 return (0);
rt->rt_refcnt--;
  786         if ((rt->rt_flags & RTF_GATEWAY) || (rt->rt_flags & RTF_LLINFO) == 0 ||
rt->rt_gateway->sa_family != AF_LINK) {
  788                 if (create) {
  789                         if (rt->rt_refcnt <= 0 &&
  790                             (rt->rt_flags & RTF_CLONED) != 0) {
rtrequest(RTM_DELETE,
  792                                     (struct sockaddr *)rt_key(rt),
rt->rt_gateway, rt_mask(rt), rt->rt_flags,
  794                                     0, 0);
  795                         }
  796                 }
  797                 return (0);
  798         }
  799         return ((struct llinfo_arp *)rt->rt_llinfo);
  800 }
  802 int
arpioctl(cmd, data)
u_long cmd;
caddr_t data;
  806 {
  808         return (EOPNOTSUPP);
  809 }
  811 void
arp_ifinit(ac, ifa)
  813         struct arpcom *ac;
  814         struct ifaddr *ifa;
  815 {
  817         /* Warn the user if another station has this IP address. */
arprequest(&ac->ac_if,
  819             &(IA_SIN(ifa)->sin_addr.s_addr),
  820             &(IA_SIN(ifa)->sin_addr.s_addr),
ac->ac_enaddr);
ifa->ifa_rtrequest = arp_rtrequest;
ifa->ifa_flags |= RTF_CLONING;
  824 }
  826 /*
  827  * Called from Ethernet interrupt handlers
  828  * when ether packet type ETHERTYPE_REVARP
  829  * is received.  Common length and type checks are done here,
  830  * then the protocol-specific routine is called.
  831  */
  832 void
revarpinput(m)
  834         struct mbuf *m;
  835 {
  836         struct arphdr *ar;
  838         if (m->m_len < sizeof(struct arphdr))
  839                 goto out;
ar = mtod(m, struct arphdr *);
  841         if (ntohs(ar->ar_hrd) != ARPHRD_ETHER)
  842                 goto out;
  843         if (m->m_len < sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln))
  844                 goto out;
  845         switch (ntohs(ar->ar_pro)) {
  847         case ETHERTYPE_IP:
  848         case ETHERTYPE_IPTRAILERS:
in_revarpinput(m);
  850                 return;
  852         default:
  853                 break;
  854         }
out:
m_freem(m);
  857 }
  859 /*
  860  * RARP for Internet protocols on Ethernet.
  861  * Algorithm is that given in RFC 903.
  862  * We are only using for bootstrap purposes to get an ip address for one of
  863  * our interfaces.  Thus we support no user-interface.
  864  *
  865  * Since the contents of the RARP reply are specific to the interface that
  866  * sent the request, this code must ensure that they are properly associated.
  867  *
  868  * Note: also supports ARP via RARP packets, per the RFC.
  869  */
  870 void
in_revarpinput(m)
  872         struct mbuf *m;
  873 {
  874         struct ifnet *ifp;
  875         struct ether_arp *ar;
  876         int op;
ar = mtod(m, struct ether_arp *);
op = ntohs(ar->arp_op);
  880         switch (op) {
  881         case ARPOP_REQUEST:
  882         case ARPOP_REPLY:       /* per RFC */
in_arpinput(m);
  884                 return;
  885         case ARPOP_REVREPLY:
  886                 break;
  887         case ARPOP_REVREQUEST:  /* handled by rarpd(8) */
  888         default:
  889                 goto out;
  890         }
  891         if (!revarp_in_progress)
  892                 goto out;
ifp = m->m_pkthdr.rcvif;
  894         if (ifp != myip_ifp) /* !same interface */
  895                 goto out;
  896         if (myip_initialized)
  897                 goto wake;
  898         if (bcmp(ar->arp_tha, ((struct arpcom *)ifp)->ac_enaddr,
  899             sizeof(ar->arp_tha)))
  900                 goto out;
bcopy((caddr_t)ar->arp_spa, (caddr_t)&srv_ip, sizeof(srv_ip));
bcopy((caddr_t)ar->arp_tpa, (caddr_t)&myip, sizeof(myip));
myip_initialized = 1;
wake:   /* Do wakeup every time in case it was missed. */
wakeup((caddr_t)&myip);
out:
m_freem(m);
  909 }
  911 /*
  912  * Send a RARP request for the ip address of the specified interface.
  913  * The request should be RFC 903-compliant.
  914  */
  915 void
revarprequest(ifp)
  917         struct ifnet *ifp;
  918 {
  919         struct sockaddr sa;
  920         struct mbuf *m;
  921         struct ether_header *eh;
  922         struct ether_arp *ea;
  923         struct arpcom *ac = (struct arpcom *)ifp;
  925         if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
  926                 return;
m->m_len = sizeof(*ea);
m->m_pkthdr.len = sizeof(*ea);
MH_ALIGN(m, sizeof(*ea));
ea = mtod(m, struct ether_arp *);
eh = (struct ether_header *)sa.sa_data;
bzero((caddr_t)ea, sizeof(*ea));
bcopy((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
  934             sizeof(eh->ether_dhost));
eh->ether_type = htons(ETHERTYPE_REVARP);
ea->arp_hrd = htons(ARPHRD_ETHER);
ea->arp_pro = htons(ETHERTYPE_IP);
ea->arp_hln = sizeof(ea->arp_sha);      /* hardware address length */
ea->arp_pln = sizeof(ea->arp_spa);      /* protocol address length */
ea->arp_op = htons(ARPOP_REVREQUEST);
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)eh->ether_shost,
  942            sizeof(ea->arp_tha));
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
  944            sizeof(ea->arp_sha));
bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_tha,
  946            sizeof(ea->arp_tha));
sa.sa_family = pseudo_AF_HDRCMPLT;
sa.sa_len = sizeof(sa);
ifp->if_output(ifp, m, &sa, (struct rtentry *)0);
  950 }
  952 /*
  953  * RARP for the ip address of the specified interface, but also
  954  * save the ip address of the server that sent the answer.
  955  * Timeout if no response is received.
  956  */
  957 int
revarpwhoarewe(ifp, serv_in, clnt_in)
  959         struct ifnet *ifp;
  960         struct in_addr *serv_in;
  961         struct in_addr *clnt_in;
  962 {
  963         int result, count = 20;
  965         if (myip_initialized)
  966                 return EIO;
myip_ifp = ifp;
revarp_in_progress = 1;
  970         while (count--) {
revarprequest(ifp);
result = tsleep((caddr_t)&myip, PSOCK, "revarp", hz/2);
  973                 if (result != EWOULDBLOCK)
  974                         break;
  975         }
revarp_in_progress = 0;
  977         if (!myip_initialized)
  978                 return ENETUNREACH;
bcopy((caddr_t)&srv_ip, serv_in, sizeof(*serv_in));
bcopy((caddr_t)&myip, clnt_in, sizeof(*clnt_in));
  982         return 0;
  983 }
  985 /* For compatibility: only saves interface address. */
  986 int
revarpwhoami(in, ifp)
  988         struct in_addr *in;
  989         struct ifnet *ifp;
  990 {
  991         struct in_addr server;
  992         return (revarpwhoarewe(ifp, &server, in));
  993 }
  996 #ifdef DDB
  998 #include <machine/db_machdep.h>
  999 #include <ddb/db_interface.h>
 1000 #include <ddb/db_output.h>
 1002 void
db_print_sa(sa)
 1004         struct sockaddr *sa;
 1005 {
 1006         int len;
u_char *p;
 1009         if (sa == 0) {
db_printf("[NULL]");
 1011                 return;
 1012         }
p = (u_char *)sa;
len = sa->sa_len;
db_printf("[");
 1017         while (len > 0) {
db_printf("%d", *p);
p++;
len--;
 1021                 if (len)
db_printf(",");
 1023         }
db_printf("]\n");
 1025 }
 1027 void
db_print_ifa(ifa)
 1029         struct ifaddr *ifa;
 1030 {
 1031         if (ifa == 0)
 1032                 return;
db_printf("  ifa_addr=");
db_print_sa(ifa->ifa_addr);
db_printf("  ifa_dsta=");
db_print_sa(ifa->ifa_dstaddr);
db_printf("  ifa_mask=");
db_print_sa(ifa->ifa_netmask);
db_printf("  flags=0x%x, refcnt=%d, metric=%d\n",
ifa->ifa_flags, ifa->ifa_refcnt, ifa->ifa_metric);
 1041 }
 1043 void
db_print_llinfo(li)
caddr_t li;
 1046 {
 1047         struct llinfo_arp *la;
 1049         if (li == 0)
 1050                 return;
la = (struct llinfo_arp *)li;
db_printf("  la_rt=%p la_hold=%p, la_asked=0x%lx\n",
la->la_rt, la->la_hold, la->la_asked);
 1054 }
 1056 /*
 1057  * Function to pass to rn_walktree().
 1058  * Return non-zero error to abort walk.
 1059  */
 1060 int
db_show_radix_node(rn, w)
 1062         struct radix_node *rn;
 1063         void *w;
 1064 {
 1065         struct rtentry *rt = (struct rtentry *)rn;
db_printf("rtentry=%p", rt);
db_printf(" flags=0x%x refcnt=%d use=%ld expire=%ld\n",
rt->rt_flags, rt->rt_refcnt, rt->rt_use, rt->rt_expire);
db_printf(" key="); db_print_sa(rt_key(rt));
db_printf(" mask="); db_print_sa(rt_mask(rt));
db_printf(" gw="); db_print_sa(rt->rt_gateway);
db_printf(" ifp=%p ", rt->rt_ifp);
 1077         if (rt->rt_ifp)
db_printf("(%s)", rt->rt_ifp->if_xname);
 1079         else
db_printf("(NULL)");
db_printf(" ifa=%p\n", rt->rt_ifa);
db_print_ifa(rt->rt_ifa);
db_printf(" genmask="); db_print_sa(rt->rt_genmask);
db_printf(" gwroute=%p llinfo=%p\n", rt->rt_gwroute, rt->rt_llinfo);
db_print_llinfo(rt->rt_llinfo);
 1089         return (0);
 1090 }
 1092 /*
 1093  * Function to print all the route trees.
 1094  * Use this from ddb:  "call db_show_arptab"
 1095  */
 1096 int
db_show_arptab()
 1098 {
 1099         struct radix_node_head *rnh;
rnh = rt_gettable(AF_INET, 0);
db_printf("Route tree for AF_INET\n");
 1102         if (rnh == NULL) {
db_printf(" (not initialized)\n");
 1104                 return (0);
 1105         }
rn_walktree(rnh, db_show_radix_node, NULL);
 1107         return (0);
 1108 }
 1109 #endif
 1110 #endif /* INET */