reorganization to move ufsmount ops to be vnode ops;

[unix-history] / usr / src / sys / netinet / if_ether.c

diff --git a/usr/src/sys/netinet/if_ether.c b/usr/src/sys/netinet/if_ether.c
index 653f9ab..f2e2838 100644 (file)
--- a/usr/src/sys/netinet/if_ether.c
+++ b/usr/src/sys/netinet/if_ether.c
@@ -1,121 +1,173 @@
-/*     if_ether.c      4.2     83/05/27        */
+/*
+ * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * %sccs.include.redist.c%
+ *
+ *     @(#)if_ether.c  7.15 (Berkeley) %G%
+ */

 
 /*
  * Ethernet address resolution protocol.
 
 /*
  * Ethernet address resolution protocol.

+ * TODO:
+ *     run at splnet (add ARP protocol intr.)
+ *     link entries onto hash chains, keep free list
+ *     add "inuse/lock" bit (or ref. count) along with valid bit

  */
 
  */
 

-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/mbuf.h"
-#include "../h/socket.h"
-#include "../h/time.h"
-#include "../h/kernel.h"
-#include "../h/errno.h"
+#include "param.h"
+#include "systm.h"
+#include "malloc.h"
+#include "mbuf.h"
+#include "socket.h"
+#include "time.h"
+#include "kernel.h"
+#include "errno.h"
+#include "ioctl.h"
+#include "syslog.h"

 
 #include "../net/if.h"
 
 #include "../net/if.h"

-#include "../netinet/in.h"
-#include "../netinet/if_ether.h"
+#include "../net/if_dl.h"
+#include "../net/route.h"
+
+#include "in.h"
+#include "in_systm.h"
+#include "in_var.h"
+#include "ip.h"
+#include "if_ether.h"

 
 

+#define SIN(s) ((struct sockaddr_in *)s)
+#define SDL(s) ((struct sockaddr_dl *)s)
+#define SRP(s) ((struct sockaddr_inarp *)s)

 
 /*
 
 /*

- * Internet to ethernet address resolution table.
+ * ARP trailer negotiation.  Trailer protocol is not IP specific,
+ * but ARP request/response use IP addresses.

  */
  */

-struct arptab {
-       struct  in_addr at_iaddr;       /* internet address */
-       u_char  at_enaddr[6];           /* ethernet address */
-       struct  mbuf *at_hold;          /* last packet until resolved/timeout */
-       u_char  at_timer;               /* minutes since last reference */
-       u_char  at_flags;               /* flags */
-};
-/* at_flags field values */
-#define        ATF_INUSE       1               /* entry in use */
-#define ATF_COM                2               /* completed entry (enaddr valid) */
-
-#define        ARPTAB_BSIZ     5               /* bucket size */
-#define        ARPTAB_NB       19              /* number of buckets */
-#define        ARPTAB_SIZE     (ARPTAB_BSIZ * ARPTAB_NB)
-struct arptab arptab[ARPTAB_SIZE];
-
-#define        ARPTAB_HASH(a) \
-       ((short)((((a) >> 16) ^ (a)) & 0x7fff) % ARPTAB_NB)
-
-#define        ARPTAB_LOOK(at,addr) { \
-       register n; \
-       at = &arptab[ARPTAB_HASH(addr) * ARPTAB_BSIZ]; \
-       for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) \
-               if (at->at_iaddr.s_addr == addr) \
-                       break; \
-       if (n >= ARPTAB_BSIZ) \
-               at = 0; }
-
-struct arpcom *arpcom;         /* chain of active ether interfaces */
-int    arpt_age;               /* aging timer */
+#define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL
+

 
 /* timer values */
 
 /* timer values */

-#define        ARPT_AGE        (60*1)  /* aging timer, 1 min. */
-#define        ARPT_KILLC      20      /* kill completed entry in 20 mins. */
-#define        ARPT_KILLI      3       /* kill incomplete entry in 3 minutes */
+int    arpt_prune = (5*60*1);  /* walk list every 5 minutes */
+int    arpt_keep = (20*60);    /* once resolved, good for 20 more minutes */
+int    arpt_down = 20;         /* once declared down, don't send for 20 secs */
+#define RTF_USETRAILERS        RTF_PROTO1
+#define rt_expire rt_rmx.rmx_expire

 
 

-u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

 extern struct ifnet loif;
 extern struct ifnet loif;

-
-#define        OLDMAP  1               /* if LNA > 1023 use old 3COM mapping */
+extern struct timeval time;
+struct llinfo_arp *arplookup(), llinfo_arp = {&llinfo_arp, &llinfo_arp};
+struct ifqueue arpintrq = {0, 0, 0, 50};
+int    arp_inuse, arp_allocated, arp_intimer;
+int    arp_maxtries = 5;
+int    useloopback = 1;        /* use loopback interface for local traffic */
+int    arpinit_done = 0;

 
 /*
 
 /*

- * Attach an ethernet interface to the list "arpcom" where
- * arptimer() can find it.  If first time 
- * initialization, start arptimer().
+ * Timeout routine.  Age arp_tab entries periodically.

  */
  */

-arpattach(ac)
-       register struct arpcom *ac;
+arptimer()

 {
 {

-       register struct arpcom *acp;
-
-       for (acp = arpcom; acp != (struct arpcom *)0; acp = acp->ac_ac)
-               if (acp == ac)          /* if already on list */
-                       return;
-       ac->ac_ac = arpcom;
-       arpcom = ac;
-       if (arpcom->ac_ac == 0)         /* very first time */
-               arptimer();
+       int s = splnet();
+       register struct llinfo_arp *la = llinfo_arp.la_next;
+
+       timeout(arptimer, (caddr_t)0, arpt_prune * hz);
+       while (la != &llinfo_arp) {
+               register struct rtentry *rt = la->la_rt;
+               la = la->la_next;
+               if (rt->rt_expire && rt->rt_expire <= time.tv_sec)
+                       arptfree(la->la_prev); /* timer has expired, clear */
+       }
+       splx(s);

 }
 
 /*
 }
 
 /*

- * Timeout routine.  Age arp_tab entries once a minute.
+ * Parallel to llc_rtrequest. 

  */
  */

-arptimer()
+arp_rtrequest(req, rt, sa)
+       int req;
+       register struct rtentry *rt;
+       struct sockaddr *sa;

 {
 {

-       register struct arptab *at;
-       register i;
-
-       timeout(arptimer, (caddr_t)0, hz);
-#ifdef notdef
-       if (++arpt_sanity > ARPT_SANITY) {
-               register struct arpcom *ac;
+       register struct sockaddr *gate = rt->rt_gateway;
+       register struct llinfo_arp *la = (struct llinfo_arp *)rt->rt_llinfo;
+       static struct sockaddr_dl null_sdl = {sizeof(null_sdl), AF_LINK};

 
 

+       if (!arpinit_done) {
+               arpinit_done = 1;
+               timeout(arptimer, (caddr_t)0, hz);
+       }
+       if (rt->rt_flags & RTF_GATEWAY)
+               return;
+       switch (req) {
+       case RTM_ADD:
+       case RTM_RESOLVE:
+               if (rt->rt_flags & RTF_CLONING) {
+                       /*
+                        * Case 1: This route should come from a route to iface.
+                        */
+                       rt_setgate(rt, rt_key(rt), &null_sdl);
+                       gate = rt->rt_gateway;
+                       SDL(gate)->sdl_type = rt->rt_ifp->if_type;
+                       SDL(gate)->sdl_index = rt->rt_ifp->if_index;
+                       rt->rt_expire = time.tv_sec;
+                       break;
+               }
+               if (gate->sa_family != AF_LINK ||
+                   gate->sa_len < sizeof(null_sdl)) {
+                       log(LOG_DEBUG, "arp_rtrequest: bad gateway value");
+                       break;
+               }
+               SDL(gate)->sdl_type = rt->rt_ifp->if_type;
+               SDL(gate)->sdl_index = rt->rt_ifp->if_index;
+               if (la != 0)
+                       break; /* This happens on a route change */

                /*
                /*

-                * Randomize sanity timer based on my host address.
-                * Ask who has my own address;  if someone else replies,
-                * then they are impersonating me.
+                * Case 2:  This route may come from cloning, or a manual route
+                * add with a LL address.

                 */
                 */

-               arpt_sanity = arpcom->ac_enaddr[5] & 0x3f;
-               for (ac = arpcom; ac != (struct arpcom *)-1; ac = ac->ac_ac)
-                       arpwhohas(ac, &((struct sockaddr_in *)
-                           &ac->ac_if.if_addr)->sin_addr);
-       }
-#endif
-       if (++arpt_age > ARPT_AGE) {
-               arpt_age = 0;
-               at = &arptab[0];
-               for (i = 0; i < ARPTAB_SIZE; i++, at++) {
-                       if (at->at_flags == 0)
-                               continue;
-                       if (++at->at_timer < ((at->at_flags&ATF_COM) ?
-                           ARPT_KILLC : ARPT_KILLI))
-                               continue;
-                       /* timer has expired, clear entry */
-                       arptfree(at);
+               R_Malloc(la, struct llinfo_arp *, sizeof(*la));
+               rt->rt_llinfo = (caddr_t)la;
+               if (la == 0) {
+                       log(LOG_DEBUG, "arp_rtrequest: malloc failed\n");
+                       break;
+               }
+               arp_inuse++, arp_allocated++;
+               Bzero(la, sizeof(*la));
+               la->la_rt = rt;
+               rt->rt_flags |= RTF_LLINFO;
+               insque(la, &llinfo_arp);
+               if (SIN(rt_key(rt))->sin_addr.s_addr ==
+                   (IA_SIN(rt->rt_ifa))->sin_addr.s_addr) {
+                   /*
+                    * This test used to be
+                    *  if (loif.if_flags & IFF_UP)
+                    * It allowed local traffic to be forced
+                    * through the hardware by configuring the loopback down.
+                    * However, it causes problems during network configuration
+                    * for boards that can't receive packets they send.
+                    * It is now necessary to clear "useloopback" and remove
+                    * the route to force traffic out to the hardware.
+                    */
+                       rt->rt_expire = 0;
+                       Bcopy(((struct arpcom *)rt->rt_ifp)->ac_enaddr,
+                               LLADDR(SDL(gate)), SDL(gate)->sdl_alen = 6);
+                       if (useloopback)
+                               rt->rt_ifp = &loif;
+                               

                }
                }

+               break;
+
+       case RTM_DELETE:
+               if (la == 0)
+                       break;
+               arp_inuse--;
+               remque(la);
+               rt->rt_llinfo = 0;
+               rt->rt_flags &= ~RTF_LLINFO;
+               if (la->la_hold)
+                       m_freem(la->la_hold);
+               Free((caddr_t)la);

        }
 }
 
        }
 }
 


@@ -124,204 +176,306 @@ arptimer()
  */
 arpwhohas(ac, addr)
        register struct arpcom *ac;
  */
 arpwhohas(ac, addr)
        register struct arpcom *ac;

-       struct in_addr *addr;
+       struct inaddr *addr;

 {
        register struct mbuf *m;
        register struct ether_header *eh;
        register struct ether_arp *ea;
        struct sockaddr sa;
 
 {
        register struct mbuf *m;
        register struct ether_header *eh;
        register struct ether_arp *ea;
        struct sockaddr sa;
 

-       if ((m = m_get(M_DONTWAIT, MT_DATA)) == NULL)
-               return (ENOBUFS);
-       m->m_len = sizeof *ea + sizeof *eh;
-       m->m_off = MMAXOFF - m->m_len;
+       if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)
+               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,
        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,

-          sizeof (etherbroadcastaddr));
-       eh->ether_type = ETHERPUP_ARPTYPE;      /* if_output will swap */
+           sizeof(eh->ether_dhost));
+       eh->ether_type = ETHERTYPE_ARP;         /* if_output will swap */

        ea->arp_hrd = htons(ARPHRD_ETHER);
        ea->arp_hrd = htons(ARPHRD_ETHER);

-       ea->arp_pro = htons(ETHERPUP_IPTYPE);
-       ea->arp_hln = sizeof ea->arp_sha;       /* hardware address length */
-       ea->arp_pln = sizeof ea->arp_spa;       /* protocol address length */
+       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)ac->ac_enaddr, (caddr_t)ea->arp_sha,
        ea->arp_op = htons(ARPOP_REQUEST);
        bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,

-          sizeof (ea->arp_sha));
-       bcopy((caddr_t)&((struct sockaddr_in *)&ac->ac_if.if_addr)->sin_addr,
-          (caddr_t)ea->arp_spa, sizeof (ea->arp_spa));
-       bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof (ea->arp_tpa));
+          sizeof(ea->arp_sha));
+       bcopy((caddr_t)&ac->ac_ipaddr, (caddr_t)ea->arp_spa,
+          sizeof(ea->arp_spa));
+       bcopy((caddr_t)addr, (caddr_t)ea->arp_tpa, sizeof(ea->arp_tpa));

        sa.sa_family = AF_UNSPEC;
        sa.sa_family = AF_UNSPEC;

-       return ((*ac->ac_if.if_output)(&ac->ac_if, m, &sa));
+       sa.sa_len = sizeof(sa);
+       (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);

 }
 
 }
 

+int    useloopback = 1;        /* use loopback interface for local traffic */
+

 /*
  * Resolve an IP address into an ethernet address.  If success, 
 /*
  * Resolve an IP address into an ethernet address.  If success, 

- * desten is filled in and 1 is returned.  If there is no entry
- * in arptab, set one up and broadcast a request 
- * for the IP address;  return 0.  Hold onto this mbuf and 
- * resend it once the address is finally resolved.
- *
- * We do some (conservative) locking here at splimp, since
- * arptab is also altered from input interrupt service (ecintr/ilintr
- * calls arpinput when ETHERPUP_ARPTYPE packets come in).
+ * desten is filled in.  If there is no entry in arptab,
+ * set one up and broadcast a request for the IP address.
+ * Hold onto this mbuf and resend it once the address
+ * is finally resolved.  A return value of 1 indicates
+ * that desten has been filled in and the packet should be sent
+ * normally; a 0 return indicates that the packet has been
+ * taken over here, either now or for later transmission.

  */
  */

-arpresolve(ac, m, destip, desten)
+arpresolve(ac, rt, m, dst, desten, usetrailers)

        register struct arpcom *ac;
        register struct arpcom *ac;

+       register struct rtentry *rt;

        struct mbuf *m;
        struct mbuf *m;

-       register struct in_addr *destip;
+       register struct sockaddr *dst;

        register u_char *desten;
        register u_char *desten;

+       int *usetrailers;

 {
 {

-       register struct arptab *at;
-       struct sockaddr_in sin;
-       int s, lna;
+       register struct llinfo_arp *la;
+       register struct in_ifaddr *ia;
+       struct sockaddr_dl *sdl;

 
 

-       lna = in_lnaof(*destip);
-       if (lna == INADDR_ANY) {        /* broadcast address */
+       *usetrailers = 0;
+       if (m->m_flags & M_BCAST) {     /* broadcast */

                bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten,
                bcopy((caddr_t)etherbroadcastaddr, (caddr_t)desten,

-                  sizeof (etherbroadcastaddr));
+                   sizeof(etherbroadcastaddr));

                return (1);
        }
                return (1);
        }

-       if (destip->s_addr == ((struct sockaddr_in *)&ac->ac_if.if_addr)->
-           sin_addr.s_addr) {                  /* if for us, use lo driver */
-               sin.sin_family = AF_INET;
-               sin.sin_addr = *destip;
-               return (looutput(&loif, m, (struct sockaddr *)&sin));
-       }
-#ifdef OLDMAP
-       if (lna >= 1024) {
-               bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3);
-               desten[3] = (lna >> 16) & 0x7f;
-               desten[4] = (lna >> 8) & 0xff;
-               desten[5] = lna & 0xff;
-               return (1);
+       if (rt)
+               la = (struct llinfo_arp *)rt->rt_llinfo;
+       else {
+               if (la = arplookup(SIN(dst)->sin_addr.s_addr, 1, 0)) 
+                       rt = la->la_rt;

        }
        }

-#endif OLDMAP
-       s = splimp();
-       ARPTAB_LOOK(at, destip->s_addr);
-       if (at == 0) {                  /* not found */
-               at = arptnew(destip);
-               at->at_hold = m;
-               arpwhohas(ac, destip);
-               splx(s);
+       if (la == 0 || rt == 0) {
+               log(LOG_DEBUG, "arpresolve: can't allocate llinfo");
+               m_freem(m);

                return (0);
        }
                return (0);
        }

-       at->at_timer = 0;               /* restart the timer */
-       if (at->at_flags & ATF_COM) {   /* entry IS complete */
-               bcopy((caddr_t)at->at_enaddr, (caddr_t)desten, 6);
-               splx(s);
-               return (1);
+       sdl = SDL(rt->rt_gateway);
+       /*
+        * Check the address family and length is valid, the address
+        * is resolved; otherwise, try to resolve.
+        */
+       if ((rt->rt_expire == 0 || rt->rt_expire > time.tv_sec) &&
+           sdl->sdl_family == AF_LINK && sdl->sdl_alen != 0) {
+               bcopy(LLADDR(sdl), desten, sdl->sdl_alen);
+               *usetrailers = rt->rt_flags & RTF_USETRAILERS;
+               return 1;

        }
        /*
         * There is an arptab entry, but no ethernet address
         * response yet.  Replace the held mbuf with this
         * latest one.
         */
        }
        /*
         * There is an arptab entry, but no ethernet address
         * response yet.  Replace the held mbuf with this
         * latest one.
         */

-       if (at->at_hold)
-               m_freem(at->at_hold);
-       at->at_hold = m;
-       arpwhohas(ac, destip);          /* ask again */
-       splx(s);
+       if (la->la_hold)
+               m_freem(la->la_hold);
+       la->la_hold = m;
+       if (rt->rt_expire) {
+               rt->rt_flags &= ~RTF_REJECT;
+               if (la->la_asked == 0 || rt->rt_expire != time.tv_sec) {
+                       rt->rt_expire = time.tv_sec;
+                       if (la->la_asked++ < arp_maxtries)
+                               arpwhohas(ac, &(SIN(dst)->sin_addr));
+                       else {
+                               rt->rt_flags |= RTF_REJECT;
+                               rt->rt_expire += arpt_down;
+                               la->la_asked = 0;
+                       }
+
+               }
+       }

        return (0);
 }
 
 /*
        return (0);
 }
 
 /*

- * Find my own IP address.  It will either be waiting for us in
- * monitor RAM, or can be obtained via broadcast to the file/boot
- * server (not necessarily using the ARP packet format).
- *
- * Unimplemented at present, return 0 and assume that the host
- * will set his own IP address via the SIOCSIFADDR ioctl.
+ * Common length and type checks are done here,
+ * then the protocol-specific routine is called.

  */
  */

-/*ARGSUSED*/
-struct in_addr
-arpmyaddr(ac)
-       register struct arpcom *ac;
+arpintr()

 {
 {

-       static struct in_addr addr;
+       register struct mbuf *m;
+       register struct arphdr *ar;
+       int s;

 
 

-       addr.s_addr = 0;
-       return (addr);
+       while (arpintrq.ifq_head) {
+               s = splimp();
+               IF_DEQUEUE(&arpintrq, m);
+               splx(s);
+               if (m == 0 || (m->m_flags & M_PKTHDR) == 0)
+                       panic("arpintr");
+               if (m->m_len >= sizeof(struct arphdr) &&
+                   (ar = mtod(m, struct arphdr *)) &&
+                   ntohs(ar->ar_hrd) == ARPHRD_ETHER &&
+                   m->m_len >=
+                     sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln)
+
+                           switch (ntohs(ar->ar_pro)) {
+
+                           case ETHERTYPE_IP:
+                           case ETHERTYPE_IPTRAILERS:
+                                   in_arpinput(m);
+                                   continue;
+                           }
+               m_freem(m);
+       }

 }
 
 /*
 }
 
 /*

- * Called from ecintr/ilintr when ether packet type ETHERPUP_ARP
- * is received.  Algorithm is exactly that given in RFC 826.
+ * ARP for Internet protocols on 10 Mb/s Ethernet.
+ * Algorithm is that given in RFC 826.

  * In addition, a sanity check is performed on the sender
  * protocol address, to catch impersonators.
  * In addition, a sanity check is performed on the sender
  * protocol address, to catch impersonators.

+ * We also handle negotiations for use of trailer protocol:
+ * ARP replies for protocol type ETHERTYPE_TRAIL are sent
+ * along with IP replies if we want trailers sent to us,
+ * and also send them in response to IP replies.
+ * This allows either end to announce the desire to receive
+ * trailer packets.
+ * We reply to requests for ETHERTYPE_TRAIL protocol as well,
+ * but don't normally send requests.

  */
  */

-arpinput(ac, m)
-       register struct arpcom *ac;
+in_arpinput(m)

        struct mbuf *m;
 {
        register struct ether_arp *ea;
        struct mbuf *m;
 {
        register struct ether_arp *ea;

+       register struct arpcom *ac = (struct arpcom *)m->m_pkthdr.rcvif;

        struct ether_header *eh;
        struct ether_header *eh;

-       register struct arptab *at = 0;  /* same as "merge" flag */
-       struct sockaddr_in sin;
+       register struct llinfo_arp *la = 0;
+       register struct rtentry *rt;
+       struct in_ifaddr *ia, *maybe_ia = 0;
+       struct mbuf *mcopy = 0;
+       struct sockaddr_dl *sdl;

        struct sockaddr sa;
        struct sockaddr sa;

-       struct mbuf *mhold;
-       struct in_addr isaddr,itaddr,myaddr;
+       struct in_addr isaddr, itaddr, myaddr;
+       int proto, op, completed = 0, sendtrailers;

 
 

-       if (m->m_len < sizeof *ea)
+       if (ac->ac_if.if_flags & IFF_NOARP)

                goto out;
                goto out;

-       myaddr = ((struct sockaddr_in *)&ac->ac_if.if_addr)->sin_addr;

        ea = mtod(m, struct ether_arp *);
        ea = mtod(m, struct ether_arp *);

-       if (ntohs(ea->arp_pro) != ETHERPUP_IPTYPE)
+       proto = ntohs(ea->arp_pro);
+       op = ntohs(ea->arp_op);
+       bcopy((caddr_t)ea->arp_spa, (caddr_t)&isaddr, sizeof (isaddr));
+       bcopy((caddr_t)ea->arp_tpa, (caddr_t)&itaddr, sizeof (itaddr));
+       for (ia = in_ifaddr; ia; ia = ia->ia_next)
+               if (ia->ia_ifp == &ac->ac_if) {
+                       maybe_ia = ia;
+                       if ((itaddr.s_addr == ia->ia_addr.sin_addr.s_addr) ||
+                            (isaddr.s_addr == ia->ia_addr.sin_addr.s_addr))
+                               break;
+               }
+       if (maybe_ia == 0)

                goto out;
                goto out;

-       isaddr.s_addr = ((struct in_addr *)ea->arp_spa)->s_addr;
-       itaddr.s_addr = ((struct in_addr *)ea->arp_tpa)->s_addr;
+       myaddr = ia ? ia->ia_addr.sin_addr : maybe_ia->ia_addr.sin_addr;

        if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr,
        if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)ac->ac_enaddr,

-         sizeof (ac->ac_enaddr)))
+           sizeof (ea->arp_sha)))

                goto out;       /* it's from me, ignore it. */
                goto out;       /* it's from me, ignore it. */

+       if (!bcmp((caddr_t)ea->arp_sha, (caddr_t)etherbroadcastaddr,
+           sizeof (ea->arp_sha))) {
+               log(LOG_ERR,
+                   "arp: ether address is broadcast for IP address %x!\n",
+                   ntohl(isaddr.s_addr));
+               goto out;
+       }

        if (isaddr.s_addr == myaddr.s_addr) {
        if (isaddr.s_addr == myaddr.s_addr) {

-               printf("duplicate IP address!! sent from ethernet address: ");
-               printf("%x %x %x %x %x %x\n", ea->arp_sha[0], ea->arp_sha[1],
-                   ea->arp_sha[2], ea->arp_sha[3],
-                   ea->arp_sha[4], ea->arp_sha[5]);
-               if (ntohs(ea->arp_op) == ARPOP_REQUEST)
+               log(LOG_ERR,
+                  "duplicate IP address %x!! sent from ethernet address: %s\n",
+                  ntohl(isaddr.s_addr), ether_sprintf(ea->arp_sha));
+               itaddr = myaddr;
+               if (op == ARPOP_REQUEST)

                        goto reply;
                goto out;
        }
                        goto reply;
                goto out;
        }

-       ARPTAB_LOOK(at, isaddr.s_addr);
-       if (at) {
-               bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
-                  sizeof (ea->arp_sha));
-               at->at_flags |= ATF_COM;
-               if (at->at_hold) {
-                       mhold = at->at_hold;
-                       at->at_hold = 0;
-                       sin.sin_family = AF_INET;
-                       sin.sin_addr = isaddr;
-                       (*ac->ac_if.if_output)(&ac->ac_if, 
-                           mhold, (struct sockaddr *)&sin);
+       s = splimp();
+       la = arplookup(isaddr.s_addr, itaddr.s_addr == myaddr.s_addr, 0);
+       if (la && (rt = la->la_rt) && (sdl = SDL(rt->rt_gateway))) {
+               if (sdl->sdl_alen &&
+                   bcmp((caddr_t)ea->arp_sha, LLADDR(sdl), sdl->sdl_alen))
+                       log(LOG_INFO, "arp info overwritten for %x by %s\n",
+                           isaddr.s_addr, ether_sprintf(ea->arp_sha));
+               completed = 1; 
+               bcopy((caddr_t)ea->arp_sha, LLADDR(sdl),
+                           sdl->sdl_alen = sizeof(ea->arp_sha));
+               if (rt->rt_expire)
+                       rt->rt_expire = time.tv_sec + arpt_keep;
+               rt->rt_flags &= ~RTF_REJECT;
+               la->la_asked = 0;
+               if (la->la_hold) {
+                       (*ac->ac_if.if_output)(&ac->ac_if, la->la_hold,
+                               rt_key(rt), rt);
+                       la->la_hold = 0;

                }
        }
                }
        }

-       if (itaddr.s_addr != myaddr.s_addr)
-               goto out;       /* if I am not the target */
-       if (at == 0) {          /* ensure we have a table entry */
-               at = arptnew(&isaddr);
-               bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
-                  sizeof (ea->arp_sha));
-               at->at_flags |= ATF_COM;
-       }
-       if (ntohs(ea->arp_op) != ARPOP_REQUEST)
-               goto out;

 reply:
 reply:

-       bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
-          sizeof (ea->arp_sha));
+       switch (proto) {
+
+       case ETHERTYPE_IPTRAILERS:
+               /* partner says trailers are OK */
+               if (la)
+                       la->la_rt->rt_flags |= RTF_USETRAILERS;
+               /*
+                * Reply to request iff we want trailers.
+                */
+               if (op != ARPOP_REQUEST || ac->ac_if.if_flags & IFF_NOTRAILERS)
+                       goto out;
+               break;
+
+       case ETHERTYPE_IP:
+               /*
+                * Reply if this is an IP request,
+                * or if we want to send a trailer response.
+                * Send the latter only to the IP response
+                * that completes the current ARP entry.
+                */
+               if (op != ARPOP_REQUEST &&
+                   (completed == 0 || ac->ac_if.if_flags & IFF_NOTRAILERS))
+                       goto out;
+       }
+       if (itaddr.s_addr == myaddr.s_addr) {
+               /* I am the target */
+               bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
+                   sizeof(ea->arp_sha));
+               bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
+                   sizeof(ea->arp_sha));
+               sendtrailers = !(ac->ac_if.if_flags & IFF_NOTRAILERS);
+       } else {
+               la = arplookup(itaddr.s_addr, 0, SIN_PROXY);
+               if (la == NULL)
+                       goto out;
+               bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
+                   sizeof(ea->arp_sha));
+               sdl = SDL(la->la_rt->rt_gateway);
+               bcopy(LLADDR(sdl), (caddr_t)ea->arp_sha, sizeof(ea->arp_sha));
+               sendtrailers = rt->rt_flags & RTF_USETRAILERS;
+       }
+

        bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa,
        bcopy((caddr_t)ea->arp_spa, (caddr_t)ea->arp_tpa,

-          sizeof (ea->arp_spa));
-       bcopy((caddr_t)ac->ac_enaddr, (caddr_t)ea->arp_sha,
-          sizeof (ea->arp_sha));
-       bcopy((caddr_t)&myaddr, (caddr_t)ea->arp_spa,
-          sizeof (ea->arp_spa));
-       ea->arp_op = htons(ARPOP_REPLY);
+           sizeof(ea->arp_spa));
+       bcopy((caddr_t)&itaddr, (caddr_t)ea->arp_spa,
+           sizeof(ea->arp_spa));
+       ea->arp_op = htons(ARPOP_REPLY); 
+       /*
+        * If incoming packet was an IP reply,
+        * we are sending a reply for type IPTRAILERS.
+        * If we are sending a reply for type IP
+        * and we want to receive trailers,
+        * send a trailer reply as well.
+        */
+       if (op == ARPOP_REPLY)
+               ea->arp_pro = htons(ETHERTYPE_IPTRAILERS);
+       else if (proto == ETHERTYPE_IP && sendtrailers)
+               mcopy = m_copy(m, 0, (int)M_COPYALL);

        eh = (struct ether_header *)sa.sa_data;
        bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost,
        eh = (struct ether_header *)sa.sa_data;
        bcopy((caddr_t)ea->arp_tha, (caddr_t)eh->ether_dhost,

-          sizeof (eh->ether_dhost));
-       eh->ether_type = ETHERPUP_ARPTYPE;
+           sizeof(eh->ether_dhost));
+       eh->ether_type = ETHERTYPE_ARP;

        sa.sa_family = AF_UNSPEC;
        sa.sa_family = AF_UNSPEC;

-       (*ac->ac_if.if_output)(&ac->ac_if, m, &sa);
+       sa.sa_len = sizeof(sa);
+       (*ac->ac_if.if_output)(&ac->ac_if, m, &sa, (struct rtentry *)0);
+       if (mcopy) {
+               ea = mtod(mcopy, struct ether_arp *);
+               ea->arp_pro = htons(ETHERTYPE_IPTRAILERS);
+               (*ac->ac_if.if_output)(&ac->ac_if,
+                                       mcopy, &sa, (struct rtentry *)0);
+       }

        return;
 out:
        m_freem(m);
        return;
 out:
        m_freem(m);


@@ -329,46 +483,57 @@ out:
 }
 
 /*
 }
 
 /*

- * Free an arptab entry.
+ * Free an arp entry.

  */
  */

-arptfree(at)
-       register struct arptab *at;
+arptfree(la)
+       register struct llinfo_arp *la;

 {
 {

-       int s = splimp();
-
-       if (at->at_hold)
-               m_freem(at->at_hold);
-       at->at_hold = 0;
-       at->at_timer = at->at_flags = 0;
-       at->at_iaddr.s_addr = 0;
-       splx(s);
+       register struct rtentry *rt = la->la_rt;
+       register struct sockaddr_dl *sdl;
+       if (rt == 0)
+               panic("arptfree");
+       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;
+               return;
+       }
+       rtrequest(RTM_DELETE, rt_key(rt), (struct sockaddr *)0, rt_mask(rt),
+                       0, (struct rtentry **)0);

 }
 }

-
+int arpdebug = 0;

 /*
 /*

- * Enter a new address in arptab, pushing out the oldest entry 
- * from the bucket if there is no room.
+ * Lookup or enter a new address in arptab.

  */
  */

-struct arptab *
-arptnew(addr)
-       struct in_addr *addr;
+struct llinfo_arp *
+arplookup(addr, create, proxy)
+       u_long addr;

 {
 {

-       register n;
-       int oldest = 0;
-       register struct arptab *at, *ato;
-
-       ato = at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ];
-       for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) {
-               if (at->at_flags == 0)
-                       goto out;        /* found an empty entry */
-               if (at->at_timer > oldest) {
-                       oldest = at->at_timer;
-                       ato = at;
-               }
+       register struct rtentry *rt;
+       static struct sockaddr_inarp sin = {sizeof(sin), AF_INET };
+
+       sin.sin_addr.s_addr = addr;
+       sin.sin_other = proxy ? SIN_PROXY : 0;
+       rt = rtalloc1((struct sockaddr *)&sin, create);
+       if (rt == 0)
+               return (0);
+       rt->rt_refcnt--;
+       if ((rt->rt_flags & RTF_GATEWAY) || !(rt->rt_flags & RTF_LLINFO) ||
+               rt->rt_gateway->sa_family != AF_LINK) {
+               arpcatchme();
+               if (arpdebug)
+                       log(LOG_DEBUG, "arptnew failed on %x\n", ntohl(addr));
+               return (0);

        }
        }

-       at = ato;
-       arptfree(at);
-out:
-       at->at_iaddr = *addr;
-       at->at_flags = ATF_INUSE;
-       return (at);
+       return ((struct llinfo_arp *)rt->rt_llinfo);
+}
+
+arpcatchme(){}
+
+arpioctl(cmd, data)
+       int cmd;
+       caddr_t data;
+{
+       return (EOPNOTSUPP);

 }
 }