The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/netinet/if_arp.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    1 /*      $NetBSD: if_arp.c,v 1.143.4.2 2009/11/21 19:43:41 snj Exp $     */
    2 
    3 /*-
    4  * Copyright (c) 1998, 2000, 2008 The NetBSD Foundation, Inc.
    5  * All rights reserved.
    6  *
    7  * This code is derived from software contributed to The NetBSD Foundation
    8  * by Public Access Networks Corporation ("Panix").  It was developed under
    9  * contract to Panix by Eric Haszlakiewicz and Thor Lancelot Simon.
   10  *
   11  * Redistribution and use in source and binary forms, with or without
   12  * modification, are permitted provided that the following conditions
   13  * are met:
   14  * 1. Redistributions of source code must retain the above copyright
   15  *    notice, this list of conditions and the following disclaimer.
   16  * 2. Redistributions in binary form must reproduce the above copyright
   17  *    notice, this list of conditions and the following disclaimer in the
   18  *    documentation and/or other materials provided with the distribution.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   30  * POSSIBILITY OF 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.2 (Berkeley) 9/26/94
   62  */
   63 
   64 /*
   65  * Ethernet address resolution protocol.
   66  * TODO:
   67  *      add "inuse/lock" bit (or ref. count) along with valid bit
   68  */
   69 
   70 #include <sys/cdefs.h>
   71 __KERNEL_RCSID(0, "$NetBSD: if_arp.c,v 1.143.4.2 2009/11/21 19:43:41 snj Exp $");
   72 
   73 #include "opt_ddb.h"
   74 #include "opt_inet.h"
   75 
   76 #ifdef INET
   77 
   78 #include "bridge.h"
   79 
   80 #include <sys/param.h>
   81 #include <sys/systm.h>
   82 #include <sys/callout.h>
   83 #include <sys/malloc.h>
   84 #include <sys/mbuf.h>
   85 #include <sys/socket.h>
   86 #include <sys/time.h>
   87 #include <sys/timetc.h>
   88 #include <sys/kernel.h>
   89 #include <sys/errno.h>
   90 #include <sys/ioctl.h>
   91 #include <sys/syslog.h>
   92 #include <sys/proc.h>
   93 #include <sys/protosw.h>
   94 #include <sys/domain.h>
   95 #include <sys/sysctl.h>
   96 #include <sys/socketvar.h>
   97 #include <sys/percpu.h>
   98 
   99 #include <net/ethertypes.h>
  100 #include <net/if.h>
  101 #include <net/if_dl.h>
  102 #include <net/if_token.h>
  103 #include <net/if_types.h>
  104 #include <net/if_ether.h>
  105 #include <net/route.h>
  106 #include <net/net_stats.h>
  107 
  108 #include <netinet/in.h>
  109 #include <netinet/in_systm.h>
  110 #include <netinet/in_var.h>
  111 #include <netinet/ip.h>
  112 #include <netinet/if_inarp.h>
  113 
  114 #include "arcnet.h"
  115 #if NARCNET > 0
  116 #include <net/if_arc.h>
  117 #endif
  118 #include "fddi.h"
  119 #if NFDDI > 0
  120 #include <net/if_fddi.h>
  121 #endif
  122 #include "token.h"
  123 #include "carp.h"
  124 #if NCARP > 0
  125 #include <netinet/ip_carp.h>
  126 #endif
  127 
  128 #define SIN(s) ((struct sockaddr_in *)s)
  129 #define SRP(s) ((struct sockaddr_inarp *)s)
  130 
  131 /*
  132  * ARP trailer negotiation.  Trailer protocol is not IP specific,
  133  * but ARP request/response use IP addresses.
  134  */
  135 #define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
  136 
  137 /* timer values */
  138 int     arpt_prune = (5*60*1);  /* walk list every 5 minutes */
  139 int     arpt_keep = (20*60);    /* once resolved, good for 20 more minutes */
  140 int     arpt_down = 20;         /* once declared down, don't send for 20 secs */
  141 int     arpt_refresh = (5*60);  /* time left before refreshing */
  142 #define rt_expire rt_rmx.rmx_expire
  143 #define rt_pksent rt_rmx.rmx_pksent
  144 
  145 static  struct sockaddr *arp_setgate(struct rtentry *, struct sockaddr *,
  146             const struct sockaddr *);
  147 static  void arptfree(struct llinfo_arp *);
  148 static  void arptimer(void *);
  149 static  struct llinfo_arp *arplookup1(struct mbuf *, const struct in_addr *,
  150                                       int, int, struct rtentry *);
  151 static  struct llinfo_arp *arplookup(struct mbuf *, const struct in_addr *,
  152                                           int, int);
  153 static  void in_arpinput(struct mbuf *);
  154 
  155 LIST_HEAD(, llinfo_arp) llinfo_arp;
  156 struct  ifqueue arpintrq = {
  157         .ifq_head = NULL,
  158         .ifq_tail = NULL,
  159         .ifq_len = 0,
  160         .ifq_maxlen = 50,
  161         .ifq_drops = 0,
  162 };
  163 int     arp_inuse, arp_allocated, arp_intimer;
  164 int     arp_maxtries = 5;
  165 int     useloopback = 1;        /* use loopback interface for local traffic */
  166 int     arpinit_done = 0;
  167 
  168 static percpu_t *arpstat_percpu;
  169 
  170 #define ARP_STAT_GETREF()       _NET_STAT_GETREF(arpstat_percpu)
  171 #define ARP_STAT_PUTREF()       _NET_STAT_PUTREF(arpstat_percpu)
  172 
  173 #define ARP_STATINC(x)          _NET_STATINC(arpstat_percpu, x)
  174 #define ARP_STATADD(x, v)       _NET_STATADD(arpstat_percpu, x, v)
  175 
  176 struct  callout arptimer_ch;
  177 
  178 /* revarp state */
  179 struct  in_addr myip, srv_ip;
  180 int     myip_initialized = 0;
  181 int     revarp_in_progress = 0;
  182 struct  ifnet *myip_ifp = NULL;
  183 
  184 #ifdef DDB
  185 static void db_print_sa(const struct sockaddr *);
  186 static void db_print_ifa(struct ifaddr *);
  187 static void db_print_llinfo(void *);
  188 static int db_show_rtentry(struct rtentry *, void *);
  189 #endif
  190 
  191 /*
  192  * this should be elsewhere.
  193  */
  194 
  195 static char *
  196 lla_snprintf(u_int8_t *, int);
  197 
  198 static char *
  199 lla_snprintf(u_int8_t *adrp, int len)
  200 {
  201 #define NUMBUFS 3
  202         static char buf[NUMBUFS][16*3];
  203         static int bnum = 0;
  204 
  205         int i;
  206         char *p;
  207 
  208         p = buf[bnum];
  209 
  210         *p++ = hexdigits[(*adrp)>>4];
  211         *p++ = hexdigits[(*adrp++)&0xf];
  212 
  213         for (i=1; i<len && i<16; i++) {
  214                 *p++ = ':';
  215                 *p++ = hexdigits[(*adrp)>>4];
  216                 *p++ = hexdigits[(*adrp++)&0xf];
  217         }
  218 
  219         *p = 0;
  220         p = buf[bnum];
  221         bnum = (bnum + 1) % NUMBUFS;
  222         return p;
  223 }
  224 
  225 DOMAIN_DEFINE(arpdomain);       /* forward declare and add to link set */
  226 
  227 const struct protosw arpsw[] = {
  228         { .pr_type = 0,
  229           .pr_domain = &arpdomain,
  230           .pr_protocol = 0,
  231           .pr_flags = 0,
  232           .pr_input = 0,
  233           .pr_output = 0,
  234           .pr_ctlinput = 0,
  235           .pr_ctloutput = 0,
  236           .pr_usrreq =  0,
  237           .pr_init = arp_init,
  238           .pr_fasttimo = 0,
  239           .pr_slowtimo = 0,
  240           .pr_drain = arp_drain,
  241         }
  242 };
  243 
  244 
  245 struct domain arpdomain = {
  246         .dom_family = PF_ARP,
  247         .dom_name = "arp",
  248         .dom_protosw = arpsw,
  249         .dom_protoswNPROTOSW = &arpsw[__arraycount(arpsw)],
  250 };
  251 
  252 /*
  253  * ARP table locking.
  254  *
  255  * to prevent lossage vs. the arp_drain routine (which may be called at
  256  * any time, including in a device driver context), we do two things:
  257  *
  258  * 1) manipulation of la->la_hold is done at splnet() (for all of
  259  * about two instructions).
  260  *
  261  * 2) manipulation of the arp table's linked list is done under the
  262  * protection of the ARP_LOCK; if arp_drain() or arptimer is called
  263  * while the arp table is locked, we punt and try again later.
  264  */
  265 
  266 static int      arp_locked;
  267 static inline int arp_lock_try(int);
  268 static inline void arp_unlock(void);
  269 
  270 static inline int
  271 arp_lock_try(int recurse)
  272 {
  273         int s;
  274 
  275         /*
  276          * Use splvm() -- we're blocking things that would cause
  277          * mbuf allocation.
  278          */
  279         s = splvm();
  280         if (!recurse && arp_locked) {
  281                 splx(s);
  282                 return 0;
  283         }
  284         arp_locked++;
  285         splx(s);
  286         return 1;
  287 }
  288 
  289 static inline void
  290 arp_unlock(void)
  291 {
  292         int s;
  293 
  294         s = splvm();
  295         arp_locked--;
  296         splx(s);
  297 }
  298 
  299 #ifdef DIAGNOSTIC
  300 #define ARP_LOCK(recurse)                                               \
  301 do {                                                                    \
  302         if (arp_lock_try(recurse) == 0) {                               \
  303                 printf("%s:%d: arp already locked\n", __FILE__, __LINE__); \
  304                 panic("arp_lock");                                      \
  305         }                                                               \
  306 } while (/*CONSTCOND*/ 0)
  307 #define ARP_LOCK_CHECK()                                                \
  308 do {                                                                    \
  309         if (arp_locked == 0) {                                          \
  310                 printf("%s:%d: arp lock not held\n", __FILE__, __LINE__); \
  311                 panic("arp lock check");                                \
  312         }                                                               \
  313 } while (/*CONSTCOND*/ 0)
  314 #else
  315 #define ARP_LOCK(x)             (void) arp_lock_try(x)
  316 #define ARP_LOCK_CHECK()        /* nothing */
  317 #endif
  318 
  319 #define ARP_UNLOCK()            arp_unlock()
  320 
  321 void
  322 arp_init(void)
  323 {
  324 
  325         arpstat_percpu = percpu_alloc(sizeof(uint64_t) * ARP_NSTATS);
  326 }
  327 
  328 /*
  329  * ARP protocol drain routine.  Called when memory is in short supply.
  330  * Called at splvm();  don't acquire softnet_lock as can be called from
  331  * hardware interrupt handlers.
  332  */
  333 void
  334 arp_drain(void)
  335 {
  336         struct llinfo_arp *la, *nla;
  337         int count = 0;
  338         struct mbuf *mold;
  339 
  340         KERNEL_LOCK(1, NULL);
  341 
  342         if (arp_lock_try(0) == 0) {
  343                 KERNEL_UNLOCK_ONE(NULL);
  344                 return;
  345         }
  346 
  347         for (la = LIST_FIRST(&llinfo_arp); la != NULL; la = nla) {
  348                 nla = LIST_NEXT(la, la_list);
  349 
  350                 mold = la->la_hold;
  351                 la->la_hold = 0;
  352 
  353                 if (mold) {
  354                         m_freem(mold);
  355                         count++;
  356                 }
  357         }
  358         ARP_UNLOCK();
  359         ARP_STATADD(ARP_STAT_DFRDROPPED, count);
  360         KERNEL_UNLOCK_ONE(NULL);
  361 }
  362 
  363 
  364 /*
  365  * Timeout routine.  Age arp_tab entries periodically.
  366  */
  367 /* ARGSUSED */
  368 static void
  369 arptimer(void *arg)
  370 {
  371         struct llinfo_arp *la, *nla;
  372 
  373         mutex_enter(softnet_lock);
  374         KERNEL_LOCK(1, NULL);
  375 
  376         if (arp_lock_try(0) == 0) {
  377                 /* get it later.. */
  378                 KERNEL_UNLOCK_ONE(NULL);
  379                 mutex_exit(softnet_lock);
  380                 return;
  381         }
  382 
  383         callout_reset(&arptimer_ch, arpt_prune * hz, arptimer, NULL);
  384         for (la = LIST_FIRST(&llinfo_arp); la != NULL; la = nla) {
  385                 struct rtentry *rt = la->la_rt;
  386 
  387                 nla = LIST_NEXT(la, la_list);
  388                 if (rt->rt_expire == 0)
  389                         continue;
  390                 if ((rt->rt_expire - time_second) < arpt_refresh &&
  391                     rt->rt_pksent > (time_second - arpt_keep)) {
  392                         /*
  393                          * If the entry has been used during since last
  394                          * refresh, try to renew it before deleting.
  395                          */
  396                         arprequest(rt->rt_ifp,
  397                             &satocsin(rt->rt_ifa->ifa_addr)->sin_addr,
  398                             &satocsin(rt_getkey(rt))->sin_addr,
  399                             CLLADDR(rt->rt_ifp->if_sadl));
  400                 } else if (rt->rt_expire <= time_second)
  401                         arptfree(la); /* timer has expired; clear */
  402         }
  403 
  404         ARP_UNLOCK();
  405 
  406         KERNEL_UNLOCK_ONE(NULL);
  407         mutex_exit(softnet_lock);
  408 }
  409 
  410 /*
  411  * We set the gateway for RTF_CLONING routes to a "prototype"
  412  * link-layer sockaddr whose interface type (if_type) and interface
  413  * index (if_index) fields are prepared.
  414  */
  415 static struct sockaddr *
  416 arp_setgate(struct rtentry *rt, struct sockaddr *gate,
  417     const struct sockaddr *netmask)
  418 {
  419         const struct ifnet *ifp = rt->rt_ifp;
  420         uint8_t namelen = strlen(ifp->if_xname);
  421         uint8_t addrlen = ifp->if_addrlen;
  422 
  423         /*
  424          * XXX: If this is a manually added route to interface
  425          * such as older version of routed or gated might provide,
  426          * restore cloning bit.
  427          */
  428         if ((rt->rt_flags & RTF_HOST) == 0 && netmask != NULL &&
  429             satocsin(netmask)->sin_addr.s_addr != 0xffffffff)
  430                 rt->rt_flags |= RTF_CLONING;
  431         if (rt->rt_flags & RTF_CLONING) {
  432                 union {
  433                         struct sockaddr sa;
  434                         struct sockaddr_storage ss;
  435                         struct sockaddr_dl sdl;
  436                 } u;
  437                 /*
  438                  * Case 1: This route should come from a route to iface.
  439                  */
  440                 sockaddr_dl_init(&u.sdl, sizeof(u.ss),
  441                     ifp->if_index, ifp->if_type, NULL, namelen, NULL, addrlen);
  442                 rt_setgate(rt, &u.sa);
  443                 gate = rt->rt_gateway;
  444         }
  445         return gate;
  446 }
  447 
  448 /*
  449  * Parallel to llc_rtrequest.
  450  */
  451 void
  452 arp_rtrequest(int req, struct rtentry *rt, const struct rt_addrinfo *info)
  453 {
  454         struct sockaddr *gate = rt->rt_gateway;
  455         struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
  456         size_t allocsize;
  457         struct mbuf *mold;
  458         int s;
  459         struct in_ifaddr *ia;
  460         struct ifaddr *ifa;
  461         struct ifnet *ifp = rt->rt_ifp;
  462 
  463         if (!arpinit_done) {
  464                 arpinit_done = 1;
  465                 /*
  466                  * We generate expiration times from time_second
  467                  * so avoid accidentally creating permanent routes.
  468                  */
  469                 if (time_second == 0) {
  470                         struct timespec ts;
  471                         ts.tv_sec = 1;
  472                         ts.tv_nsec = 0;
  473                         tc_setclock(&ts);
  474                 }
  475                 callout_init(&arptimer_ch, CALLOUT_MPSAFE);
  476                 callout_reset(&arptimer_ch, hz, arptimer, NULL);
  477         }
  478 
  479         if ((rt->rt_flags & RTF_GATEWAY) != 0) {
  480                 if (req != RTM_ADD)
  481                         return;
  482 
  483                 /*
  484                  * linklayers with particular link MTU limitation.
  485                  */
  486                 switch(ifp->if_type) {
  487 #if NFDDI > 0
  488                 case IFT_FDDI:
  489                         if (ifp->if_mtu > FDDIIPMTU)
  490                                 rt->rt_rmx.rmx_mtu = FDDIIPMTU;
  491                         break;
  492 #endif
  493 #if NARC > 0
  494                 case IFT_ARCNET:
  495                     {
  496                         int arcipifmtu;
  497 
  498                         if (ifp->if_flags & IFF_LINK0)
  499                                 arcipifmtu = arc_ipmtu;
  500                         else
  501                                 arcipifmtu = ARCMTU;
  502                         if (ifp->if_mtu > arcipifmtu)
  503                                 rt->rt_rmx.rmx_mtu = arcipifmtu;
  504                         break;
  505                     }
  506 #endif
  507                 }
  508                 return;
  509         }
  510 
  511         ARP_LOCK(1);            /* we may already be locked here. */
  512 
  513         switch (req) {
  514         case RTM_SETGATE:
  515                 gate = arp_setgate(rt, gate, info->rti_info[RTAX_NETMASK]);
  516                 break;
  517         case RTM_ADD:
  518                 gate = arp_setgate(rt, gate, info->rti_info[RTAX_NETMASK]);
  519                 if (rt->rt_flags & RTF_CLONING) {
  520                         /*
  521                          * Give this route an expiration time, even though
  522                          * it's a "permanent" route, so that routes cloned
  523                          * from it do not need their expiration time set.
  524                          */
  525                         rt->rt_expire = time_second;
  526                         /*
  527                          * linklayers with particular link MTU limitation.
  528                          */
  529                         switch (ifp->if_type) {
  530 #if NFDDI > 0
  531                         case IFT_FDDI:
  532                                 if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
  533                                     (rt->rt_rmx.rmx_mtu > FDDIIPMTU ||
  534                                      (rt->rt_rmx.rmx_mtu == 0 &&
  535                                       ifp->if_mtu > FDDIIPMTU)))
  536                                         rt->rt_rmx.rmx_mtu = FDDIIPMTU;
  537                                 break;
  538 #endif
  539 #if NARC > 0
  540                         case IFT_ARCNET:
  541                             {
  542                                 int arcipifmtu;
  543                                 if (ifp->if_flags & IFF_LINK0)
  544                                         arcipifmtu = arc_ipmtu;
  545                                 else
  546                                         arcipifmtu = ARCMTU;
  547 
  548                                 if ((rt->rt_rmx.rmx_locks & RTV_MTU) == 0 &&
  549                                     (rt->rt_rmx.rmx_mtu > arcipifmtu ||
  550                                      (rt->rt_rmx.rmx_mtu == 0 &&
  551                                       ifp->if_mtu > arcipifmtu)))
  552                                         rt->rt_rmx.rmx_mtu = arcipifmtu;
  553                                 break;
  554                             }
  555 #endif
  556                         }
  557                         break;
  558                 }
  559                 /* Announce a new entry if requested. */
  560                 if (rt->rt_flags & RTF_ANNOUNCE)
  561                         arprequest(ifp,
  562                             &satocsin(rt_getkey(rt))->sin_addr,
  563                             &satocsin(rt_getkey(rt))->sin_addr,
  564                             CLLADDR(satocsdl(gate)));
  565                 /*FALLTHROUGH*/
  566         case RTM_RESOLVE:
  567                 if (gate->sa_family != AF_LINK ||
  568                     gate->sa_len < sockaddr_dl_measure(0, ifp->if_addrlen)) {
  569                         log(LOG_DEBUG, "arp_rtrequest: bad gateway value\n");
  570                         break;
  571                 }
  572                 satosdl(gate)->sdl_type = ifp->if_type;
  573                 satosdl(gate)->sdl_index = ifp->if_index;
  574                 if (la != NULL)
  575                         break; /* This happens on a route change */
  576                 /*
  577                  * Case 2:  This route may come from cloning, or a manual route
  578                  * add with a LL address.
  579                  */
  580                 switch (ifp->if_type) {
  581 #if NTOKEN > 0
  582                 case IFT_ISO88025:
  583                         allocsize = sizeof(*la) + sizeof(struct token_rif);
  584                         break;
  585 #endif /* NTOKEN > 0 */
  586                 default:
  587                         allocsize = sizeof(*la);
  588                 }
  589                 R_Malloc(la, struct llinfo_arp *, allocsize);
  590                 rt->rt_llinfo = (void *)la;
  591                 if (la == NULL) {
  592                         log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
  593                         break;
  594                 }
  595                 arp_inuse++, arp_allocated++;
  596                 memset(la, 0, allocsize);
  597                 la->la_rt = rt;
  598                 rt->rt_flags |= RTF_LLINFO;
  599                 LIST_INSERT_HEAD(&llinfo_arp, la, la_list);
  600 
  601                 INADDR_TO_IA(satocsin(rt_getkey(rt))->sin_addr, ia);
  602                 while (ia && ia->ia_ifp != ifp)
  603                         NEXT_IA_WITH_SAME_ADDR(ia);
  604                 if (ia) {
  605                         /*
  606                          * This test used to be
  607                          *      if (lo0ifp->if_flags & IFF_UP)
  608                          * It allowed local traffic to be forced through
  609                          * the hardware by configuring the loopback down.
  610                          * However, it causes problems during network
  611                          * configuration for boards that can't receive
  612                          * packets they send.  It is now necessary to clear
  613                          * "useloopback" and remove the route to force
  614                          * traffic out to the hardware.
  615                          *
  616                          * In 4.4BSD, the above "if" statement checked
  617                          * rt->rt_ifa against rt_getkey(rt).  It was changed
  618                          * to the current form so that we can provide a
  619                          * better support for multiple IPv4 addresses on a
  620                          * interface.
  621                          */
  622                         rt->rt_expire = 0;
  623                         if (sockaddr_dl_init(satosdl(gate), gate->sa_len,
  624                             ifp->if_index, ifp->if_type, NULL, 0,
  625                             CLLADDR(ifp->if_sadl), ifp->if_addrlen) == NULL) {
  626                                 panic("%s(%s): sockaddr_dl_init cannot fail",
  627                                     __func__, ifp->if_xname);
  628                         }
  629                         if (useloopback)
  630                                 ifp = rt->rt_ifp = lo0ifp;
  631                         /*
  632                          * make sure to set rt->rt_ifa to the interface
  633                          * address we are using, otherwise we will have trouble
  634                          * with source address selection.
  635                          */
  636                         ifa = &ia->ia_ifa;
  637                         if (ifa != rt->rt_ifa)
  638                                 rt_replace_ifa(rt, ifa);
  639                 }
  640                 break;
  641 
  642         case RTM_DELETE:
  643                 if (la == NULL)
  644                         break;
  645                 arp_inuse--;
  646                 LIST_REMOVE(la, la_list);
  647                 rt->rt_llinfo = NULL;
  648                 rt->rt_flags &= ~RTF_LLINFO;
  649 
  650                 s = splnet();
  651                 mold = la->la_hold;
  652                 la->la_hold = 0;
  653                 splx(s);
  654 
  655                 if (mold)
  656                         m_freem(mold);
  657 
  658                 Free((void *)la);
  659         }
  660         ARP_UNLOCK();
  661 }
  662 
  663 /*
  664  * Broadcast an ARP request. Caller specifies:
  665  *      - arp header source ip address
  666  *      - arp header target ip address
  667  *      - arp header source ethernet address
  668  */
  669 void
  670 arprequest(struct ifnet *ifp,
  671     const struct in_addr *sip, const struct in_addr *tip,
  672     const u_int8_t *enaddr)
  673 {
  674         struct mbuf *m;
  675         struct arphdr *ah;
  676         struct sockaddr sa;
  677         uint64_t *arps;
  678 
  679         if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
  680                 return;
  681         MCLAIM(m, &arpdomain.dom_mowner);
  682         switch (ifp->if_type) {
  683         case IFT_IEEE1394:
  684                 m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
  685                     ifp->if_addrlen;
  686                 break;
  687         default:
  688                 m->m_len = sizeof(*ah) + 2 * sizeof(struct in_addr) +
  689                     2 * ifp->if_addrlen;
  690                 break;
  691         }
  692         m->m_pkthdr.len = m->m_len;
  693         MH_ALIGN(m, m->m_len);
  694         ah = mtod(m, struct arphdr *);
  695         memset(ah, 0, m->m_len);
  696         switch (ifp->if_type) {
  697         case IFT_IEEE1394:      /* RFC2734 */
  698                 /* fill it now for ar_tpa computation */
  699                 ah->ar_hrd = htons(ARPHRD_IEEE1394);
  700                 break;
  701         default:
  702                 /* ifp->if_output will fill ar_hrd */
  703                 break;
  704         }
  705         ah->ar_pro = htons(ETHERTYPE_IP);
  706         ah->ar_hln = ifp->if_addrlen;           /* hardware address length */
  707         ah->ar_pln = sizeof(struct in_addr);    /* protocol address length */
  708         ah->ar_op = htons(ARPOP_REQUEST);
  709         memcpy(ar_sha(ah), enaddr, ah->ar_hln);
  710         memcpy(ar_spa(ah), sip, ah->ar_pln);
  711         memcpy(ar_tpa(ah), tip, ah->ar_pln);
  712         sa.sa_family = AF_ARP;
  713         sa.sa_len = 2;
  714         m->m_flags |= M_BCAST;
  715         arps = ARP_STAT_GETREF();
  716         arps[ARP_STAT_SNDTOTAL]++;
  717         arps[ARP_STAT_SENDREQUEST]++;
  718         ARP_STAT_PUTREF();
  719         (*ifp->if_output)(ifp, m, &sa, NULL);
  720 }
  721 
  722 /*
  723  * Resolve an IP address into an ethernet address.  If success,
  724  * desten is filled in.  If there is no entry in arptab,
  725  * set one up and broadcast a request for the IP address.
  726  * Hold onto this mbuf and resend it once the address
  727  * is finally resolved.  A return value of 1 indicates
  728  * that desten has been filled in and the packet should be sent
  729  * normally; a 0 return indicates that the packet has been
  730  * taken over here, either now or for later transmission.
  731  */
  732 int
  733 arpresolve(struct ifnet *ifp, struct rtentry *rt, struct mbuf *m,
  734     const struct sockaddr *dst, u_char *desten)
  735 {
  736         struct llinfo_arp *la;
  737         const struct sockaddr_dl *sdl;
  738         struct mbuf *mold;
  739         int s;
  740 
  741         if ((la = arplookup1(m, &satocsin(dst)->sin_addr, 1, 0, rt)) != NULL)
  742                 rt = la->la_rt;
  743 
  744         if (la == NULL || rt == NULL) {
  745                 ARP_STATINC(ARP_STAT_ALLOCFAIL);
  746                 log(LOG_DEBUG,
  747                     "arpresolve: can't allocate llinfo on %s for %s\n",
  748                     ifp->if_xname, in_fmtaddr(satocsin(dst)->sin_addr));
  749                 m_freem(m);
  750                 return 0;
  751         }
  752         sdl = satocsdl(rt->rt_gateway);
  753         /*
  754          * Check the address family and length is valid, the address
  755          * is resolved; otherwise, try to resolve.
  756          */
  757         if ((rt->rt_expire == 0 || rt->rt_expire > time_second) &&
  758             sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
  759                 memcpy(desten, CLLADDR(sdl),
  760                     min(sdl->sdl_alen, ifp->if_addrlen));
  761                 rt->rt_pksent = time_second; /* Time for last pkt sent */
  762                 return 1;
  763         }
  764         /*
  765          * There is an arptab entry, but no ethernet address
  766          * response yet.  Replace the held mbuf with this
  767          * latest one.
  768          */
  769 
  770         ARP_STATINC(ARP_STAT_DFRTOTAL);
  771         s = splnet();
  772         mold = la->la_hold;
  773         la->la_hold = m;
  774         splx(s);
  775 
  776         if (mold) {
  777                 ARP_STATINC(ARP_STAT_DFRDROPPED);
  778                 m_freem(mold);
  779         }
  780 
  781         /*
  782          * Re-send the ARP request when appropriate.
  783          */
  784 #ifdef  DIAGNOSTIC
  785         if (rt->rt_expire == 0) {
  786                 /* This should never happen. (Should it? -gwr) */
  787                 printf("arpresolve: unresolved and rt_expire == 0\n");
  788                 /* Set expiration time to now (expired). */
  789                 rt->rt_expire = time_second;
  790         }
  791 #endif
  792         if (rt->rt_expire) {
  793                 rt->rt_flags &= ~RTF_REJECT;
  794                 if (la->la_asked == 0 || rt->rt_expire != time_second) {
  795                         rt->rt_expire = time_second;
  796                         if (la->la_asked++ < arp_maxtries)
  797                                 arprequest(ifp,
  798                                     &satocsin(rt->rt_ifa->ifa_addr)->sin_addr,
  799                                     &satocsin(dst)->sin_addr,
  800 #if NCARP > 0
  801                                     (rt->rt_ifp->if_type == IFT_CARP) ?
  802                                     CLLADDR(rt->rt_ifp->if_sadl):
  803 #endif
  804                                     CLLADDR(ifp->if_sadl));
  805                         else {
  806                                 rt->rt_flags |= RTF_REJECT;
  807                                 rt->rt_expire += arpt_down;
  808                                 la->la_asked = 0;
  809                         }
  810                 }
  811         }
  812         return 0;
  813 }
  814 
  815 /*
  816  * Common length and type checks are done here,
  817  * then the protocol-specific routine is called.
  818  */
  819 void
  820 arpintr(void)
  821 {
  822         struct mbuf *m;
  823         struct arphdr *ar;
  824         int s;
  825         int arplen;
  826 
  827         mutex_enter(softnet_lock);
  828         KERNEL_LOCK(1, NULL);
  829         while (arpintrq.ifq_head) {
  830                 s = splnet();
  831                 IF_DEQUEUE(&arpintrq, m);
  832                 splx(s);
  833                 if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
  834                         panic("arpintr");
  835 
  836                 MCLAIM(m, &arpdomain.dom_mowner);
  837                 ARP_STATINC(ARP_STAT_RCVTOTAL);
  838 
  839                 /*
  840                  * First, make sure we have at least struct arphdr.
  841                  */
  842                 if (m->m_len < sizeof(struct arphdr) ||
  843                     (ar = mtod(m, struct arphdr *)) == NULL)
  844                         goto badlen;
  845 
  846                 switch (m->m_pkthdr.rcvif->if_type) {
  847                 case IFT_IEEE1394:
  848                         arplen = sizeof(struct arphdr) +
  849                             ar->ar_hln + 2 * ar->ar_pln;
  850                         break;
  851                 default:
  852                         arplen = sizeof(struct arphdr) +
  853                             2 * ar->ar_hln + 2 * ar->ar_pln;
  854                         break;
  855                 }
  856 
  857                 if (/* XXX ntohs(ar->ar_hrd) == ARPHRD_ETHER && */
  858                     m->m_len >= arplen)
  859                         switch (ntohs(ar->ar_pro)) {
  860                         case ETHERTYPE_IP:
  861                         case ETHERTYPE_IPTRAILERS:
  862                                 in_arpinput(m);
  863                                 continue;
  864                         default:
  865                                 ARP_STATINC(ARP_STAT_RCVBADPROTO);
  866                         }
  867                 else {
  868 badlen:
  869                         ARP_STATINC(ARP_STAT_RCVBADLEN);
  870                 }
  871                 m_freem(m);
  872         }
  873         KERNEL_UNLOCK_ONE(NULL);
  874         mutex_exit(softnet_lock);
  875 }
  876 
  877 /*
  878  * ARP for Internet protocols on 10 Mb/s Ethernet.
  879  * Algorithm is that given in RFC 826.
  880  * In addition, a sanity check is performed on the sender
  881  * protocol address, to catch impersonators.
  882  * We no longer handle negotiations for use of trailer protocol:
  883  * Formerly, ARP replied for protocol type ETHERTYPE_TRAIL sent
  884  * along with IP replies if we wanted trailers sent to us,
  885  * and also sent them in response to IP replies.
  886  * This allowed either end to announce the desire to receive
  887  * trailer packets.
  888  * We no longer reply to requests for ETHERTYPE_TRAIL protocol either,
  889  * but formerly didn't normally send requests.
  890  */
  891 static void
  892 in_arpinput(struct mbuf *m)
  893 {
  894         struct arphdr *ah;
  895         struct ifnet *ifp = m->m_pkthdr.rcvif;
  896         struct llinfo_arp *la = NULL;
  897         struct rtentry  *rt;
  898         struct in_ifaddr *ia;
  899 #if NBRIDGE > 0
  900         struct in_ifaddr *bridge_ia = NULL;
  901 #endif
  902 #if NCARP > 0
  903         u_int32_t count = 0, index = 0;
  904 #endif
  905         struct sockaddr_dl *sdl;
  906         struct sockaddr sa;
  907         struct in_addr isaddr, itaddr, myaddr;
  908         int op;
  909         struct mbuf *mold;
  910         void *tha;
  911         int s;
  912         uint64_t *arps;
  913 
  914         if (__predict_false(m_makewritable(&m, 0, m->m_pkthdr.len, M_DONTWAIT)))
  915                 goto out;
  916         ah = mtod(m, struct arphdr *);
  917         op = ntohs(ah->ar_op);
  918 
  919         /*
  920          * Fix up ah->ar_hrd if necessary, before using ar_tha() or
  921          * ar_tpa().
  922          */
  923         switch (ifp->if_type) {
  924         case IFT_IEEE1394:
  925                 if (ntohs(ah->ar_hrd) == ARPHRD_IEEE1394)
  926                         ;
  927                 else {
  928                         /* XXX this is to make sure we compute ar_tha right */
  929                         /* XXX check ar_hrd more strictly? */
  930                         ah->ar_hrd = htons(ARPHRD_IEEE1394);
  931                 }
  932                 break;
  933         default:
  934                 /* XXX check ar_hrd? */
  935                 break;
  936         }
  937 
  938         memcpy(&isaddr, ar_spa(ah), sizeof (isaddr));
  939         memcpy(&itaddr, ar_tpa(ah), sizeof (itaddr));
  940 
  941         if (m->m_flags & (M_BCAST|M_MCAST))
  942                 ARP_STATINC(ARP_STAT_RCVMCAST);
  943 
  944         /*
  945          * If the target IP address is zero, ignore the packet.
  946          * This prevents the code below from tring to answer
  947          * when we are using IP address zero (booting).
  948          */
  949         if (in_nullhost(itaddr)) {
  950                 ARP_STATINC(ARP_STAT_RCVZEROTPA);
  951                 goto out;
  952         }
  953 
  954         /*
  955          * If the source IP address is zero, this is most likely a
  956          * confused host trying to use IP address zero. (Windoze?)
  957          * XXX: Should we bother trying to reply to these?
  958          */
  959         if (in_nullhost(isaddr)) {
  960                 ARP_STATINC(ARP_STAT_RCVZEROSPA);
  961                 goto out;
  962         }
  963 
  964         /*
  965          * Search for a matching interface address
  966          * or any address on the interface to use
  967          * as a dummy address in the rest of this function
  968          */
  969         
  970         INADDR_TO_IA(itaddr, ia);
  971         while (ia != NULL) {
  972 #if NCARP > 0
  973                 if (ia->ia_ifp->if_type == IFT_CARP &&
  974                     ((ia->ia_ifp->if_flags & (IFF_UP|IFF_RUNNING)) ==
  975                     (IFF_UP|IFF_RUNNING))) {
  976                         index++;
  977                         if (ia->ia_ifp == m->m_pkthdr.rcvif &&
  978                             carp_iamatch(ia, ar_sha(ah),
  979                             &count, index)) {
  980                                 break;
  981                                 }
  982                 } else
  983 #endif
  984                             if (ia->ia_ifp == m->m_pkthdr.rcvif)
  985                                 break;
  986 #if NBRIDGE > 0
  987                 /*
  988                  * If the interface we received the packet on
  989                  * is part of a bridge, check to see if we need
  990                  * to "bridge" the packet to ourselves at this
  991                  * layer.  Note we still prefer a perfect match,
  992                  * but allow this weaker match if necessary.
  993                  */
  994                 if (m->m_pkthdr.rcvif->if_bridge != NULL &&
  995                     m->m_pkthdr.rcvif->if_bridge == ia->ia_ifp->if_bridge)
  996                         bridge_ia = ia;
  997 #endif /* NBRIDGE > 0 */
  998 
  999                 NEXT_IA_WITH_SAME_ADDR(ia);
 1000         }
 1001 
 1002 #if NBRIDGE > 0
 1003         if (ia == NULL && bridge_ia != NULL) {
 1004                 ia = bridge_ia;
 1005                 ifp = bridge_ia->ia_ifp;
 1006         }
 1007 #endif
 1008 
 1009         if (ia == NULL) {
 1010                 INADDR_TO_IA(isaddr, ia);
 1011                 while ((ia != NULL) && ia->ia_ifp != m->m_pkthdr.rcvif)
 1012                         NEXT_IA_WITH_SAME_ADDR(ia);
 1013 
 1014                 if (ia == NULL) {
 1015                         IFP_TO_IA(ifp, ia);
 1016                         if (ia == NULL) {
 1017                                 ARP_STATINC(ARP_STAT_RCVNOINT);
 1018                                 goto out;
 1019                         }
 1020                 }
 1021         }
 1022 
 1023         myaddr = ia->ia_addr.sin_addr;
 1024 
 1025         /* XXX checks for bridge case? */
 1026         if (!memcmp(ar_sha(ah), CLLADDR(ifp->if_sadl), ifp->if_addrlen)) {
 1027                 ARP_STATINC(ARP_STAT_RCVLOCALSHA);
 1028                 goto out;       /* it's from me, ignore it. */
 1029         }
 1030 
 1031         /* XXX checks for bridge case? */
 1032         if (!memcmp(ar_sha(ah), ifp->if_broadcastaddr, ifp->if_addrlen)) {
 1033                 ARP_STATINC(ARP_STAT_RCVBCASTSHA);
 1034                 log(LOG_ERR,
 1035                     "%s: arp: link address is broadcast for IP address %s!\n",
 1036                     ifp->if_xname, in_fmtaddr(isaddr));
 1037                 goto out;
 1038         }
 1039 
 1040         if (in_hosteq(isaddr, myaddr)) {
 1041                 ARP_STATINC(ARP_STAT_RCVLOCALSPA);
 1042                 log(LOG_ERR,
 1043                    "duplicate IP address %s sent from link address %s\n",
 1044                    in_fmtaddr(isaddr), lla_snprintf(ar_sha(ah), ah->ar_hln));
 1045                 itaddr = myaddr;
 1046                 goto reply;
 1047         }
 1048         la = arplookup(m, &isaddr, in_hosteq(itaddr, myaddr), 0);
 1049         if (la != NULL && (rt = la->la_rt) && (sdl = satosdl(rt->rt_gateway))) {
 1050                 if (sdl->sdl_alen &&
 1051                     memcmp(ar_sha(ah), CLLADDR(sdl), sdl->sdl_alen)) {
 1052                         if (rt->rt_flags & RTF_STATIC) {
 1053                                 ARP_STATINC(ARP_STAT_RCVOVERPERM);
 1054                                 log(LOG_INFO,
 1055                                     "%s tried to overwrite permanent arp info"
 1056                                     " for %s\n",
 1057                                     lla_snprintf(ar_sha(ah), ah->ar_hln),
 1058                                     in_fmtaddr(isaddr));
 1059                                 goto out;
 1060                         } else if (rt->rt_ifp != ifp) {
 1061                                 ARP_STATINC(ARP_STAT_RCVOVERINT);
 1062                                 log(LOG_INFO,
 1063                                     "%s on %s tried to overwrite "
 1064                                     "arp info for %s on %s\n",
 1065                                     lla_snprintf(ar_sha(ah), ah->ar_hln),
 1066                                     ifp->if_xname, in_fmtaddr(isaddr),
 1067                                     rt->rt_ifp->if_xname);
 1068                                     goto out;
 1069                         } else {
 1070                                 ARP_STATINC(ARP_STAT_RCVOVER);
 1071                                 log(LOG_INFO,
 1072                                     "arp info overwritten for %s by %s\n",
 1073                                     in_fmtaddr(isaddr),
 1074                                     lla_snprintf(ar_sha(ah), ah->ar_hln));
 1075                         }
 1076                 }
 1077                 /*
 1078                  * sanity check for the address length.
 1079                  * XXX this does not work for protocols with variable address
 1080                  * length. -is
 1081                  */
 1082                 if (sdl->sdl_alen &&
 1083                     sdl->sdl_alen != ah->ar_hln) {
 1084                         ARP_STATINC(ARP_STAT_RCVLENCHG);
 1085                         log(LOG_WARNING,
 1086                             "arp from %s: new addr len %d, was %d\n",
 1087                             in_fmtaddr(isaddr), ah->ar_hln, sdl->sdl_alen);
 1088                 }
 1089                 if (ifp->if_addrlen != ah->ar_hln) {
 1090                         ARP_STATINC(ARP_STAT_RCVBADLEN);
 1091                         log(LOG_WARNING,
 1092                             "arp from %s: addr len: new %d, i/f %d (ignored)\n",
 1093                             in_fmtaddr(isaddr), ah->ar_hln,
 1094                             ifp->if_addrlen);
 1095                         goto reply;
 1096                 }
 1097 #if NTOKEN > 0
 1098                 /*
 1099                  * XXX uses m_data and assumes the complete answer including
 1100                  * XXX token-ring headers is in the same buf
 1101                  */
 1102                 if (ifp->if_type == IFT_ISO88025) {
 1103                         struct token_header *trh;
 1104 
 1105                         trh = (struct token_header *)M_TRHSTART(m);
 1106                         if (trh->token_shost[0] & TOKEN_RI_PRESENT) {
 1107                                 struct token_rif        *rif;
 1108                                 size_t  riflen;
 1109 
 1110                                 rif = TOKEN_RIF(trh);
 1111                                 riflen = (ntohs(rif->tr_rcf) &
 1112                                     TOKEN_RCF_LEN_MASK) >> 8;
 1113 
 1114                                 if (riflen > 2 &&
 1115                                     riflen < sizeof(struct token_rif) &&
 1116                                     (riflen & 1) == 0) {
 1117                                         rif->tr_rcf ^= htons(TOKEN_RCF_DIRECTION);
 1118                                         rif->tr_rcf &= htons(~TOKEN_RCF_BROADCAST_MASK);
 1119                                         memcpy(TOKEN_RIF(la), rif, riflen);
 1120                                 }
 1121                         }
 1122                 }
 1123 #endif /* NTOKEN > 0 */
 1124                 (void)sockaddr_dl_setaddr(sdl, sdl->sdl_len, ar_sha(ah),
 1125                     ah->ar_hln);
 1126                 if (rt->rt_expire)
 1127                         rt->rt_expire = time_second + arpt_keep;
 1128                 rt->rt_flags &= ~RTF_REJECT;
 1129                 la->la_asked = 0;
 1130 
 1131                 s = splnet();
 1132                 mold = la->la_hold;
 1133                 la->la_hold = 0;
 1134                 splx(s);
 1135 
 1136                 if (mold) {
 1137                         ARP_STATINC(ARP_STAT_DFRSENT);
 1138                         (*ifp->if_output)(ifp, mold, rt_getkey(rt), rt);
 1139                 }
 1140         }
 1141 reply:
 1142         if (op != ARPOP_REQUEST) {
 1143                 if (op == ARPOP_REPLY)
 1144                         ARP_STATINC(ARP_STAT_RCVREPLY);
 1145         out:
 1146                 m_freem(m);
 1147                 return;
 1148         }
 1149         ARP_STATINC(ARP_STAT_RCVREQUEST);
 1150         if (in_hosteq(itaddr, myaddr)) {
 1151                 /* I am the target */
 1152                 tha = ar_tha(ah);
 1153                 if (tha)
 1154                         memcpy(tha, ar_sha(ah), ah->ar_hln);
 1155                 memcpy(ar_sha(ah), CLLADDR(ifp->if_sadl), ah->ar_hln);
 1156         } else {
 1157                 la = arplookup(m, &itaddr, 0, SIN_PROXY);
 1158                 if (la == NULL)
 1159                         goto out;
 1160                 rt = la->la_rt;
 1161                 if (rt->rt_ifp->if_type == IFT_CARP &&
 1162                     m->m_pkthdr.rcvif->if_type != IFT_CARP)
 1163                         goto out;
 1164                 tha = ar_tha(ah);
 1165                 if (tha)
 1166                         memcpy(tha, ar_sha(ah), ah->ar_hln);
 1167                 sdl = satosdl(rt->rt_gateway);
 1168                 memcpy(ar_sha(ah), CLLADDR(sdl), ah->ar_hln);
 1169         }
 1170 
 1171         memcpy(ar_tpa(ah), ar_spa(ah), ah->ar_pln);
 1172         memcpy(ar_spa(ah), &itaddr, ah->ar_pln);
 1173         ah->ar_op = htons(ARPOP_REPLY);
 1174         ah->ar_pro = htons(ETHERTYPE_IP); /* let's be sure! */
 1175         switch (ifp->if_type) {
 1176         case IFT_IEEE1394:
 1177                 /*
 1178                  * ieee1394 arp reply is broadcast
 1179                  */
 1180                 m->m_flags &= ~M_MCAST;
 1181                 m->m_flags |= M_BCAST;
 1182                 m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + ah->ar_hln;
 1183                 break;
 1184 
 1185         default:
 1186                 m->m_flags &= ~(M_BCAST|M_MCAST); /* never reply by broadcast */
 1187                 m->m_len = sizeof(*ah) + (2 * ah->ar_pln) + (2 * ah->ar_hln);
 1188                 break;
 1189         }
 1190         m->m_pkthdr.len = m->m_len;
 1191         sa.sa_family = AF_ARP;
 1192         sa.sa_len = 2;
 1193         arps = ARP_STAT_GETREF();
 1194         arps[ARP_STAT_SNDTOTAL]++;
 1195         arps[ARP_STAT_SNDREPLY]++;
 1196         ARP_STAT_PUTREF();
 1197         (*ifp->if_output)(ifp, m, &sa, (struct rtentry *)0);
 1198         return;
 1199 }
 1200 
 1201 /*
 1202  * Free an arp entry.
 1203  */
 1204 static void arptfree(struct llinfo_arp *la)
 1205 {
 1206         struct rtentry *rt = la->la_rt;
 1207         struct sockaddr_dl *sdl;
 1208 
 1209         ARP_LOCK_CHECK();
 1210 
 1211         if (rt == NULL)
 1212                 panic("arptfree");
 1213         if (rt->rt_refcnt > 0 && (sdl = satosdl(rt->rt_gateway)) &&
 1214             sdl->sdl_family == AF_LINK) {
 1215                 sdl->sdl_alen = 0;
 1216                 la->la_asked = 0;
 1217                 rt->rt_flags &= ~RTF_REJECT;
 1218                 return;
 1219         }
 1220         rtrequest(RTM_DELETE, rt_getkey(rt), NULL, rt_mask(rt), 0, NULL);
 1221 }
 1222 
 1223 static struct llinfo_arp *
 1224 arplookup(struct mbuf *m, const struct in_addr *addr, int create, int proxy)
 1225 {
 1226         return arplookup1(m, addr, create, proxy, NULL);
 1227 }
 1228 
 1229 /*
 1230  * Lookup or enter a new address in arptab.
 1231  */
 1232 static struct llinfo_arp *
 1233 arplookup1(struct mbuf *m, const struct in_addr *addr, int create, int proxy,
 1234     struct rtentry *rt0)
 1235 {
 1236         struct arphdr *ah;
 1237         struct ifnet *ifp = m->m_pkthdr.rcvif;
 1238         struct rtentry *rt;
 1239         struct sockaddr_inarp sin;
 1240         const char *why = NULL;
 1241 
 1242         ah = mtod(m, struct arphdr *);
 1243         if (rt0 == NULL) {
 1244                 memset(&sin, 0, sizeof(sin));
 1245                 sin.sin_len = sizeof(sin);
 1246                 sin.sin_family = AF_INET;
 1247                 sin.sin_addr = *addr;
 1248                 sin.sin_other = proxy ? SIN_PROXY : 0;
 1249                 rt = rtalloc1(sintosa(&sin), create);
 1250                 if (rt == NULL)
 1251                         return NULL;
 1252                 rt->rt_refcnt--;
 1253         } else
 1254                 rt = rt0;
 1255 
 1256 #define IS_LLINFO(__rt)                                                   \
 1257         (((__rt)->rt_flags & (RTF_GATEWAY | RTF_LLINFO)) == RTF_LLINFO && \
 1258          (__rt)->rt_gateway->sa_family == AF_LINK)
 1259 
 1260 
 1261         if (IS_LLINFO(rt))
 1262                 return (struct llinfo_arp *)rt->rt_llinfo;
 1263 
 1264         if (create) {
 1265                 if (rt->rt_flags & RTF_GATEWAY)
 1266                         why = "host is not on local network";
 1267                 else if ((rt->rt_flags & RTF_LLINFO) == 0) {
 1268                         ARP_STATINC(ARP_STAT_ALLOCFAIL);
 1269                         why = "could not allocate llinfo";
 1270                 } else
 1271                         why = "gateway route is not ours";
 1272                 log(LOG_DEBUG, "arplookup: unable to enter address"
 1273                     " for %s@%s on %s (%s)\n",
 1274                     in_fmtaddr(*addr), lla_snprintf(ar_sha(ah), ah->ar_hln),
 1275                     (ifp) ? ifp->if_xname : "null", why);
 1276                 if (rt->rt_refcnt <= 0 && (rt->rt_flags & RTF_CLONED) != 0) {
 1277                         rtrequest(RTM_DELETE, rt_getkey(rt),
 1278                             rt->rt_gateway, rt_mask(rt), rt->rt_flags, NULL);
 1279                 }
 1280         }
 1281         return NULL;
 1282 }
 1283 
 1284 int
 1285 arpioctl(u_long cmd, void *data)
 1286 {
 1287 
 1288         return EOPNOTSUPP;
 1289 }
 1290 
 1291 void
 1292 arp_ifinit(struct ifnet *ifp, struct ifaddr *ifa)
 1293 {
 1294         struct in_addr *ip;
 1295 
 1296         /*
 1297          * Warn the user if another station has this IP address,
 1298          * but only if the interface IP address is not zero.
 1299          */
 1300         ip = &IA_SIN(ifa)->sin_addr;
 1301         if (!in_nullhost(*ip))
 1302                 arprequest(ifp, ip, ip, CLLADDR(ifp->if_sadl));
 1303 
 1304         ifa->ifa_rtrequest = arp_rtrequest;
 1305         ifa->ifa_flags |= RTF_CLONING;
 1306 }
 1307 
 1308 /*
 1309  * Called from 10 Mb/s Ethernet interrupt handlers
 1310  * when ether packet type ETHERTYPE_REVARP
 1311  * is received.  Common length and type checks are done here,
 1312  * then the protocol-specific routine is called.
 1313  */
 1314 void
 1315 revarpinput(struct mbuf *m)
 1316 {
 1317         struct arphdr *ar;
 1318 
 1319         if (m->m_len < sizeof(struct arphdr))
 1320                 goto out;
 1321         ar = mtod(m, struct arphdr *);
 1322 #if 0 /* XXX I don't think we need this... and it will prevent other LL */
 1323         if (ntohs(ar->ar_hrd) != ARPHRD_ETHER)
 1324                 goto out;
 1325 #endif
 1326         if (m->m_len < sizeof(struct arphdr) + 2 * (ar->ar_hln + ar->ar_pln))
 1327                 goto out;
 1328         switch (ntohs(ar->ar_pro)) {
 1329         case ETHERTYPE_IP:
 1330         case ETHERTYPE_IPTRAILERS:
 1331                 in_revarpinput(m);
 1332                 return;
 1333 
 1334         default:
 1335                 break;
 1336         }
 1337 out:
 1338         m_freem(m);
 1339 }
 1340 
 1341 /*
 1342  * RARP for Internet protocols on 10 Mb/s Ethernet.
 1343  * Algorithm is that given in RFC 903.
 1344  * We are only using for bootstrap purposes to get an ip address for one of
 1345  * our interfaces.  Thus we support no user-interface.
 1346  *
 1347  * Since the contents of the RARP reply are specific to the interface that
 1348  * sent the request, this code must ensure that they are properly associated.
 1349  *
 1350  * Note: also supports ARP via RARP packets, per the RFC.
 1351  */
 1352 void
 1353 in_revarpinput(struct mbuf *m)
 1354 {
 1355         struct ifnet *ifp;
 1356         struct arphdr *ah;
 1357         void *tha;
 1358         int op;
 1359 
 1360         ah = mtod(m, struct arphdr *);
 1361         op = ntohs(ah->ar_op);
 1362 
 1363         switch (m->m_pkthdr.rcvif->if_type) {
 1364         case IFT_IEEE1394:
 1365                 /* ARP without target hardware address is not supported */
 1366                 goto out;
 1367         default:
 1368                 break;
 1369         }
 1370 
 1371         switch (op) {
 1372         case ARPOP_REQUEST:
 1373         case ARPOP_REPLY:       /* per RFC */
 1374                 in_arpinput(m);
 1375                 return;
 1376         case ARPOP_REVREPLY:
 1377                 break;
 1378         case ARPOP_REVREQUEST:  /* handled by rarpd(8) */
 1379         default:
 1380                 goto out;
 1381         }
 1382         if (!revarp_in_progress)
 1383                 goto out;
 1384         ifp = m->m_pkthdr.rcvif;
 1385         if (ifp != myip_ifp) /* !same interface */
 1386                 goto out;
 1387         if (myip_initialized)
 1388                 goto wake;
 1389         tha = ar_tha(ah);
 1390         if (tha == NULL)
 1391                 goto out;
 1392         if (memcmp(tha, CLLADDR(ifp->if_sadl), ifp->if_sadl->sdl_alen))
 1393                 goto out;
 1394         memcpy(&srv_ip, ar_spa(ah), sizeof(srv_ip));
 1395         memcpy(&myip, ar_tpa(ah), sizeof(myip));
 1396         myip_initialized = 1;
 1397 wake:   /* Do wakeup every time in case it was missed. */
 1398         wakeup((void *)&myip);
 1399 
 1400 out:
 1401         m_freem(m);
 1402 }
 1403 
 1404 /*
 1405  * Send a RARP request for the ip address of the specified interface.
 1406  * The request should be RFC 903-compliant.
 1407  */
 1408 void
 1409 revarprequest(struct ifnet *ifp)
 1410 {
 1411         struct sockaddr sa;
 1412         struct mbuf *m;
 1413         struct arphdr *ah;
 1414         void *tha;
 1415 
 1416         if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
 1417                 return;
 1418         MCLAIM(m, &arpdomain.dom_mowner);
 1419         m->m_len = sizeof(*ah) + 2*sizeof(struct in_addr) +
 1420             2*ifp->if_addrlen;
 1421         m->m_pkthdr.len = m->m_len;
 1422         MH_ALIGN(m, m->m_len);
 1423         ah = mtod(m, struct arphdr *);
 1424         memset(ah, 0, m->m_len);
 1425         ah->ar_pro = htons(ETHERTYPE_IP);
 1426         ah->ar_hln = ifp->if_addrlen;           /* hardware address length */
 1427         ah->ar_pln = sizeof(struct in_addr);    /* protocol address length */
 1428         ah->ar_op = htons(ARPOP_REVREQUEST);
 1429 
 1430         memcpy(ar_sha(ah), CLLADDR(ifp->if_sadl), ah->ar_hln);
 1431         tha = ar_tha(ah);
 1432         if (tha == NULL)
 1433                 return;
 1434         memcpy(tha, CLLADDR(ifp->if_sadl), ah->ar_hln);
 1435 
 1436         sa.sa_family = AF_ARP;
 1437         sa.sa_len = 2;
 1438         m->m_flags |= M_BCAST;
 1439         (*ifp->if_output)(ifp, m, &sa, NULL);
 1440 
 1441 }
 1442 
 1443 /*
 1444  * RARP for the ip address of the specified interface, but also
 1445  * save the ip address of the server that sent the answer.
 1446  * Timeout if no response is received.
 1447  */
 1448 int
 1449 revarpwhoarewe(struct ifnet *ifp, struct in_addr *serv_in,
 1450     struct in_addr *clnt_in)
 1451 {
 1452         int result, count = 20;
 1453 
 1454         myip_initialized = 0;
 1455         myip_ifp = ifp;
 1456 
 1457         revarp_in_progress = 1;
 1458         while (count--) {
 1459                 revarprequest(ifp);
 1460                 result = tsleep((void *)&myip, PSOCK, "revarp", hz/2);
 1461                 if (result != EWOULDBLOCK)
 1462                         break;
 1463         }
 1464         revarp_in_progress = 0;
 1465 
 1466         if (!myip_initialized)
 1467                 return ENETUNREACH;
 1468 
 1469         memcpy(serv_in, &srv_ip, sizeof(*serv_in));
 1470         memcpy(clnt_in, &myip, sizeof(*clnt_in));
 1471         return 0;
 1472 }
 1473 
 1474 
 1475 
 1476 #ifdef DDB
 1477 
 1478 #include <machine/db_machdep.h>
 1479 #include <ddb/db_interface.h>
 1480 #include <ddb/db_output.h>
 1481 
 1482 static void
 1483 db_print_sa(const struct sockaddr *sa)
 1484 {
 1485         int len;
 1486         const u_char *p;
 1487 
 1488         if (sa == NULL) {
 1489                 db_printf("[NULL]");
 1490                 return;
 1491         }
 1492 
 1493         p = (const u_char *)sa;
 1494         len = sa->sa_len;
 1495         db_printf("[");
 1496         while (len > 0) {
 1497                 db_printf("%d", *p);
 1498                 p++; len--;
 1499                 if (len) db_printf(",");
 1500         }
 1501         db_printf("]\n");
 1502 }
 1503 
 1504 static void
 1505 db_print_ifa(struct ifaddr *ifa)
 1506 {
 1507         if (ifa == NULL)
 1508                 return;
 1509         db_printf("  ifa_addr=");
 1510         db_print_sa(ifa->ifa_addr);
 1511         db_printf("  ifa_dsta=");
 1512         db_print_sa(ifa->ifa_dstaddr);
 1513         db_printf("  ifa_mask=");
 1514         db_print_sa(ifa->ifa_netmask);
 1515         db_printf("  flags=0x%x,refcnt=%d,metric=%d\n",
 1516                           ifa->ifa_flags,
 1517                           ifa->ifa_refcnt,
 1518                           ifa->ifa_metric);
 1519 }
 1520 
 1521 static void
 1522 db_print_llinfo(void *li)
 1523 {
 1524         struct llinfo_arp *la;
 1525 
 1526         if (li == NULL)
 1527                 return;
 1528         la = (struct llinfo_arp *)li;
 1529         db_printf("  la_rt=%p la_hold=%p, la_asked=0x%lx\n",
 1530                           la->la_rt, la->la_hold, la->la_asked);
 1531 }
 1532 
 1533 /*
 1534  * Function to pass to rt_walktree().
 1535  * Return non-zero error to abort walk.
 1536  */
 1537 static int
 1538 db_show_rtentry(struct rtentry *rt, void *w)
 1539 {
 1540         db_printf("rtentry=%p", rt);
 1541 
 1542         db_printf(" flags=0x%x refcnt=%d use=%ld expire=%ld\n",
 1543                           rt->rt_flags, rt->rt_refcnt,
 1544                           rt->rt_use, rt->rt_expire);
 1545 
 1546         db_printf(" key="); db_print_sa(rt_getkey(rt));
 1547         db_printf(" mask="); db_print_sa(rt_mask(rt));
 1548         db_printf(" gw="); db_print_sa(rt->rt_gateway);
 1549 
 1550         db_printf(" ifp=%p ", rt->rt_ifp);
 1551         if (rt->rt_ifp)
 1552                 db_printf("(%s)", rt->rt_ifp->if_xname);
 1553         else
 1554                 db_printf("(NULL)");
 1555 
 1556         db_printf(" ifa=%p\n", rt->rt_ifa);
 1557         db_print_ifa(rt->rt_ifa);
 1558 
 1559         db_printf(" gwroute=%p llinfo=%p\n",
 1560                           rt->rt_gwroute, rt->rt_llinfo);
 1561         db_print_llinfo(rt->rt_llinfo);
 1562 
 1563         return 0;
 1564 }
 1565 
 1566 /*
 1567  * Function to print all the route trees.
 1568  * Use this from ddb:  "show arptab"
 1569  */
 1570 void
 1571 db_show_arptab(db_expr_t addr, bool have_addr,
 1572     db_expr_t count, const char *modif)
 1573 {
 1574         rt_walktree(AF_INET, db_show_rtentry, NULL);
 1575 }
 1576 #endif
 1577 
 1578 static int
 1579 sysctl_net_inet_arp_stats(SYSCTLFN_ARGS)
 1580 {
 1581 
 1582         return NETSTAT_SYSCTL(arpstat_percpu, ARP_NSTATS);
 1583 }
 1584 
 1585 SYSCTL_SETUP(sysctl_net_inet_arp_setup, "sysctl net.inet.arp subtree setup")
 1586 {
 1587         const struct sysctlnode *node;
 1588 
 1589         sysctl_createv(clog, 0, NULL, NULL,
 1590                         CTLFLAG_PERMANENT,
 1591                         CTLTYPE_NODE, "net", NULL,
 1592                         NULL, 0, NULL, 0,
 1593                         CTL_NET, CTL_EOL);
 1594         sysctl_createv(clog, 0, NULL, NULL,
 1595                         CTLFLAG_PERMANENT,
 1596                         CTLTYPE_NODE, "inet", NULL,
 1597                         NULL, 0, NULL, 0,
 1598                         CTL_NET, PF_INET, CTL_EOL);
 1599         sysctl_createv(clog, 0, NULL, &node,
 1600                         CTLFLAG_PERMANENT,
 1601                         CTLTYPE_NODE, "arp",
 1602                         SYSCTL_DESCR("Address Resolution Protocol"),
 1603                         NULL, 0, NULL, 0,
 1604                         CTL_NET, PF_INET, CTL_CREATE, CTL_EOL);
 1605 
 1606         sysctl_createv(clog, 0, NULL, NULL,
 1607                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 1608                         CTLTYPE_INT, "prune",
 1609                         SYSCTL_DESCR("ARP cache pruning interval"),
 1610                         NULL, 0, &arpt_prune, 0,
 1611                         CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
 1612 
 1613         sysctl_createv(clog, 0, NULL, NULL,
 1614                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 1615                         CTLTYPE_INT, "keep",
 1616                         SYSCTL_DESCR("Valid ARP entry lifetime"),
 1617                         NULL, 0, &arpt_keep, 0,
 1618                         CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
 1619 
 1620         sysctl_createv(clog, 0, NULL, NULL,
 1621                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 1622                         CTLTYPE_INT, "down",
 1623                         SYSCTL_DESCR("Failed ARP entry lifetime"),
 1624                         NULL, 0, &arpt_down, 0,
 1625                         CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
 1626 
 1627         sysctl_createv(clog, 0, NULL, NULL,
 1628                         CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 1629                         CTLTYPE_INT, "refresh",
 1630                         SYSCTL_DESCR("ARP entry refresh interval"),
 1631                         NULL, 0, &arpt_refresh, 0,
 1632                         CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
 1633         
 1634         sysctl_createv(clog, 0, NULL, NULL,
 1635                         CTLFLAG_PERMANENT,
 1636                         CTLTYPE_STRUCT, "stats",
 1637                         SYSCTL_DESCR("ARP statistics"),
 1638                         sysctl_net_inet_arp_stats, 0, NULL, 0,
 1639                         CTL_NET,PF_INET, node->sysctl_num, CTL_CREATE, CTL_EOL);
 1640 }
 1641 
 1642 #endif /* INET */

Cache object: ee553b00f99170f022a8f2a58d2a7e09


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.