default ttl 30 => 60

[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 0c7b1ce..28dd53d 100644 (file)
--- a/usr/src/sys/netinet/if_ether.c
+++ b/usr/src/sys/netinet/if_ether.c
@@ -1,43 +1,67 @@
-/*     if_ether.c      6.3     83/12/15        */
+/*
+ * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ *     @(#)if_ether.c  7.10 (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 "in.h"
+#include "in_systm.h"
+#include "in_var.h"
+#include "ip.h"
+#include "if_ether.h"

 
 

-
-/*
- * Internet to ethernet address resolution table.
- */
-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 */
+#ifdef GATEWAY
+#define        ARPTAB_BSIZ     16              /* bucket size */
+#define        ARPTAB_NB       37              /* number of buckets */
+#else
+#define        ARPTAB_BSIZ     9               /* bucket size */

 #define        ARPTAB_NB       19              /* number of buckets */
 #define        ARPTAB_NB       19              /* number of buckets */

+#endif

 #define        ARPTAB_SIZE     (ARPTAB_BSIZ * ARPTAB_NB)
 struct arptab arptab[ARPTAB_SIZE];
 #define        ARPTAB_SIZE     (ARPTAB_BSIZ * ARPTAB_NB)
 struct arptab arptab[ARPTAB_SIZE];

+int    arptab_size = ARPTAB_SIZE;      /* for arp command */
+
+/*
+ * ARP trailer negotiation.  Trailer protocol is not IP specific,
+ * but ARP request/response use IP addresses.
+ */
+#define ETHERTYPE_IPTRAILERS ETHERTYPE_TRAIL

 
 #define        ARPTAB_HASH(a) \
 
 #define        ARPTAB_HASH(a) \

-       ((short)((((a) >> 16) ^ (a)) & 0x7fff) % ARPTAB_NB)
+       ((u_long)(a) % ARPTAB_NB)

 
 #define        ARPTAB_LOOK(at,addr) { \
        register n; \
 
 #define        ARPTAB_LOOK(at,addr) { \
        register n; \


@@ -46,53 +70,16 @@ struct      arptab arptab[ARPTAB_SIZE];
                if (at->at_iaddr.s_addr == addr) \
                        break; \
        if (n >= ARPTAB_BSIZ) \
                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 */
+               at = 0; \
+}

 
 /* 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 */
 
 
 /* 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 */
 

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

 extern struct ifnet loif;
 
 extern struct ifnet loif;
 

-/*
- * Local addresses in the range oldmap to infinity are
- * mapped according to the old mapping scheme.  That is,
- * mapping of Internet to Ethernet addresses is performed
- * by taking the high three bytes of the network interface's
- * address and the low three bytes of the local address part.
- * This only allows boards from the same manufacturer to
- * communicate unless the on-board address is overridden
- * (not possible in many manufacture's hardware).
- *
- * NB: setting oldmap to zero completely disables ARP
- *     (i.e. identical to setting IFF_NOARP with an ioctl).
- */
-int    oldmap = 1024;
-
-/*
- * Attach an ethernet interface to the list "arpcom" where
- * arptimer() can find it.  If first time 
- * initialization, start arptimer().
- */
-arpattach(ac)
-       register struct arpcom *ac;
-{
-       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();
-}
-

 /*
  * Timeout routine.  Age arp_tab entries once a minute.
  */
 /*
  * Timeout routine.  Age arp_tab entries once a minute.
  */


@@ -101,34 +88,16 @@ arptimer()
        register struct arptab *at;
        register i;
 
        register struct arptab *at;
        register i;
 

-       timeout(arptimer, (caddr_t)0, hz);
-#ifdef notdef
-       if (++arpt_sanity > ARPT_SANITY) {
-               register struct arpcom *ac;
-
-               /*
-                * Randomize sanity timer based on my host address.
-                * Ask who has my own address;  if someone else replies,
-                * then they are impersonating me.
-                */
-               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);
-               }
+       timeout(arptimer, (caddr_t)0, ARPT_AGE * hz);
+       at = &arptab[0];
+       for (i = 0; i < ARPTAB_SIZE; i++, at++) {
+               if (at->at_flags == 0 || (at->at_flags & ATF_PERM))
+                       continue;
+               if (++at->at_timer < ((at->at_flags&ATF_COM) ?
+                   ARPT_KILLC : ARPT_KILLI))
+                       continue;
+               /* timer has expired, clear entry */
+               arptfree(at);

        }
 }
 
        }
 }
 


@@ -144,85 +113,124 @@ arpwhohas(ac, addr)
        register struct ether_arp *ea;
        struct sockaddr sa;
 
        register struct ether_arp *ea;
        struct sockaddr sa;
 

-       if ((m = m_get(M_DONTWAIT, MT_DATA)) == NULL)
+       if ((m = m_gethdr(M_DONTWAIT, MT_DATA)) == NULL)

                return;
                return;

-       m->m_len = sizeof *ea;
-       m->m_off = MMAXOFF - m->m_len;
+       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;

-       (void) (*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);

 }
 
 }
 

+int    useloopback = 1;        /* use loopback interface for local traffic */
+
+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.
+ * 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.

  *
  * We do some (conservative) locking here at splimp, since
  * arptab is also altered from input interrupt service (ecintr/ilintr
  *
  * 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).
+ * calls arpinput when ETHERTYPE_ARP packets come in).

  */
  */

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

        register struct arpcom *ac;
        struct mbuf *m;
        register struct in_addr *destip;
        register u_char *desten;
        register struct arpcom *ac;
        struct mbuf *m;
        register struct in_addr *destip;
        register u_char *desten;

+       int *usetrailers;

 {
        register struct arptab *at;
 {
        register struct arptab *at;

-       register struct ifnet *ifp;

        struct sockaddr_in sin;
        struct sockaddr_in sin;

-       int s, lna;
+       register struct in_ifaddr *ia;
+       u_long lna;
+       int s;

 
 

-       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);
        }

-       ifp = &ac->ac_if;
-       /* if for us, then use software loopback driver */
-       if (destip->s_addr ==
-           ((struct sockaddr_in *)&ifp->if_addr)-> sin_addr.s_addr) {
-               sin.sin_family = AF_INET;
-               sin.sin_addr = *destip;
-               return (looutput(&loif, m, (struct sockaddr *)&sin));
-       }
-       if ((ifp->if_flags & IFF_NOARP) || lna >= oldmap) {
-               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);
+       lna = in_lnaof(*destip);
+       /* if for us, use software loopback driver if up */
+       for (ia = in_ifaddr; ia; ia = ia->ia_next)
+           if ((ia->ia_ifp == &ac->ac_if) &&
+               (destip->s_addr == ia->ia_addr.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"
+                * to force traffic out to the hardware.
+                */
+               if (useloopback) {
+                       sin.sin_family = AF_INET;
+                       sin.sin_addr = *destip;
+                       (void) looutput(&loif, m, (struct sockaddr *)&sin);
+                       /*
+                        * The packet has already been sent and freed.
+                        */
+                       return (0);
+               } else {
+                       bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten,
+                           sizeof(ac->ac_enaddr));
+                       return (1);
+               }

        }
        s = splimp();
        ARPTAB_LOOK(at, destip->s_addr);
        if (at == 0) {                  /* not found */
        }
        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);
-               return (0);
+               if (ac->ac_if.if_flags & IFF_NOARP) {
+                       bcopy((caddr_t)ac->ac_enaddr, (caddr_t)desten, 3);
+                       desten[3] = (lna >> 16) & 0x7f;
+                       desten[4] = (lna >> 8) & 0xff;
+                       desten[5] = lna & 0xff;
+                       splx(s);
+                       return (1);
+               } else {
+                       at = arptnew(destip);
+                       if (at == 0)
+                               panic("arpresolve: no free entry");
+                       at->at_hold = m;
+                       arpwhohas(ac, destip);
+                       splx(s);
+                       return (0);
+               }

        }
        at->at_timer = 0;               /* restart the timer */
        if (at->at_flags & ATF_COM) {   /* entry IS complete */
        }
        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);
+               bcopy((caddr_t)at->at_enaddr, (caddr_t)desten,
+                   sizeof(at->at_enaddr));
+               if (at->at_flags & ATF_USETRAILERS)
+                       *usetrailers = 1;

                splx(s);
                return (1);
        }
                splx(s);
                return (1);
        }


@@ -240,105 +248,202 @@ arpresolve(ac, m, destip, desten)
 }
 
 /*
 }
 
 /*

- * 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.
+ * Called from 10 Mb/s Ethernet interrupt handlers
+ * when ether packet type ETHERTYPE_ARP
+ * is received.  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;
+arpinput(ac, m)
+       struct arpcom *ac;
+       struct mbuf *m;

 {
 {

-       static struct in_addr addr;
+       register struct arphdr *ar;

 
 

-#ifdef lint
-       ac = ac;
-#endif
-       addr.s_addr = 0;
-       return (addr);
+       if (ac->ac_if.if_flags & IFF_NOARP)
+               goto out;
+       if (m->m_len < sizeof(struct arphdr))
+               goto out;
+       ar = mtod(m, struct arphdr *);
+       if (ntohs(ar->ar_hrd) != ARPHRD_ETHER)
+               goto out;
+       if (m->m_len < sizeof(struct arphdr) + 2 * ar->ar_hln + 2 * ar->ar_pln)
+               goto out;
+
+       switch (ntohs(ar->ar_pro)) {
+
+       case ETHERTYPE_IP:
+       case ETHERTYPE_IPTRAILERS:
+               in_arpinput(ac, m);
+               return;
+
+       default:
+               break;
+       }
+out:
+       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)
+in_arpinput(ac, m)

        register struct arpcom *ac;
        struct mbuf *m;
 {
        register struct ether_arp *ea;
        struct ether_header *eh;
        register struct arpcom *ac;
        struct mbuf *m;
 {
        register struct ether_arp *ea;
        struct ether_header *eh;

-       register struct arptab *at = 0;  /* same as "merge" flag */
+       register struct arptab *at;  /* same as "merge" flag */
+       register struct in_ifaddr *ia;
+       struct in_ifaddr *maybe_ia = 0;
+       struct mbuf *mcopy = 0;

        struct sockaddr_in sin;
        struct sockaddr sa;
        struct sockaddr_in sin;
        struct sockaddr sa;

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

 
 

-       if (m->m_len < sizeof *ea)
-               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;
        }

+       s = splimp();
+       s = splimp();

        ARPTAB_LOOK(at, isaddr.s_addr);
        if (at) {
                bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
        ARPTAB_LOOK(at, isaddr.s_addr);
        if (at) {
                bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,

-                  sizeof (ea->arp_sha));
+                   sizeof(ea->arp_sha));
+               if ((at->at_flags & ATF_COM) == 0)
+                       completed = 1;

                at->at_flags |= ATF_COM;
                if (at->at_hold) {
                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, 
                        sin.sin_family = AF_INET;
                        sin.sin_addr = isaddr;
                        (*ac->ac_if.if_output)(&ac->ac_if, 

-                           mhold, (struct sockaddr *)&sin);
+                           at->at_hold, (struct sockaddr *)&sin);
+                       at->at_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 (at == 0 && itaddr.s_addr == myaddr.s_addr) {
+               /* ensure we have a table entry */
+               if (at = arptnew(&isaddr)) {
+                       bcopy((caddr_t)ea->arp_sha, (caddr_t)at->at_enaddr,
+                           sizeof(ea->arp_sha));
+                       completed = 1;
+                       at->at_flags |= ATF_COM;
+               }

        }
        }

-       if (ntohs(ea->arp_op) != ARPOP_REQUEST)
-               goto out;
+       splx(s);
+       splx(s);

 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 (at)
+                       at->at_flags |= ATF_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));
+       } else {
+               ARPTAB_LOOK(at, itaddr.s_addr);
+               if (at == NULL || (at->at_flags & ATF_PUBL) == 0)
+                       goto out;
+               bcopy((caddr_t)ea->arp_sha, (caddr_t)ea->arp_tha,
+                   sizeof(ea->arp_sha));
+               bcopy((caddr_t)at->at_enaddr, (caddr_t)ea->arp_sha,
+                   sizeof(ea->arp_sha));
+       }
+

        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 &&
+           (ac->ac_if.if_flags & IFF_NOTRAILERS) == 0)
+               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;

+       sa.sa_len = sizeof(sa);

        (*ac->ac_if.if_output)(&ac->ac_if, m, &sa);
        (*ac->ac_if.if_output)(&ac->ac_if, m, &sa);

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

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


@@ -364,24 +469,37 @@ arptfree(at)
 /*
  * Enter a new address in arptab, pushing out the oldest entry 
  * from the bucket if there is no room.
 /*
  * Enter a new address in arptab, pushing out the oldest entry 
  * from the bucket if there is no room.

+ * This always succeeds since no bucket can be completely filled
+ * with permanent entries (except from arpioctl when testing whether
+ * another permanent entry will fit).
+ * MUST BE CALLED AT SPLIMP.

  */
 struct arptab *
 arptnew(addr)
        struct in_addr *addr;
 {
        register n;
  */
 struct arptab *
 arptnew(addr)
        struct in_addr *addr;
 {
        register n;

-       int oldest = 0;
-       register struct arptab *at, *ato;
+       int oldest = -1;
+       register struct arptab *at, *ato = NULL;
+       static int first = 1;

 
 

-       ato = at = &arptab[ARPTAB_HASH(addr->s_addr) * ARPTAB_BSIZ];
-       for (n = 0 ; n < ARPTAB_BSIZ ; n++,at++) {
+       if (first) {
+               first = 0;
+               timeout(arptimer, (caddr_t)0, hz);
+       }
+       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_flags == 0)
                        goto out;        /* found an empty entry */

-               if (at->at_timer > oldest) {
+               if (at->at_flags & ATF_PERM)
+                       continue;
+               if ((int) at->at_timer > oldest) {

                        oldest = at->at_timer;
                        ato = at;
                }
        }
                        oldest = at->at_timer;
                        ato = at;
                }
        }

+       if (ato == NULL)
+               return (NULL);

        at = ato;
        arptfree(at);
 out:
        at = ato;
        arptfree(at);
 out:


@@ -389,3 +507,88 @@ out:
        at->at_flags = ATF_INUSE;
        return (at);
 }
        at->at_flags = ATF_INUSE;
        return (at);
 }

+
+arpioctl(cmd, data)
+       int cmd;
+       caddr_t data;
+{
+       register struct arpreq *ar = (struct arpreq *)data;
+       register struct arptab *at;
+       register struct sockaddr_in *sin;
+       int s;
+
+       sin = (struct sockaddr_in *)&ar->arp_ha;
+#if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN
+       if (sin->sin_family == 0 && sin->sin_len < 16)
+               sin->sin_family = sin->sin_len;
+#endif
+       sin->sin_len = sizeof(ar->arp_ha);
+       sin = (struct sockaddr_in *)&ar->arp_pa;
+#if defined(COMPAT_43) && BYTE_ORDER != BIG_ENDIAN
+       if (sin->sin_family == 0 && sin->sin_len < 16)
+               sin->sin_family = sin->sin_len;
+#endif
+       sin->sin_len = sizeof(ar->arp_pa);
+       if (ar->arp_pa.sa_family != AF_INET ||
+           ar->arp_ha.sa_family != AF_UNSPEC)
+               return (EAFNOSUPPORT);
+       s = splimp();
+       ARPTAB_LOOK(at, sin->sin_addr.s_addr);
+       if (at == NULL) {               /* not found */
+               if (cmd != SIOCSARP) {
+                       splx(s);
+                       return (ENXIO);
+               }
+               if (ifa_ifwithnet(&ar->arp_pa) == NULL) {
+                       splx(s);
+                       return (ENETUNREACH);
+               }
+       }
+       switch (cmd) {
+
+       case SIOCSARP:          /* set entry */
+               if (at == NULL) {
+                       at = arptnew(&sin->sin_addr);
+                       if (at == NULL) {
+                               splx(s);
+                               return (EADDRNOTAVAIL);
+                       }
+                       if (ar->arp_flags & ATF_PERM) {
+                       /* never make all entries in a bucket permanent */
+                               register struct arptab *tat;
+                               
+                               /* try to re-allocate */
+                               tat = arptnew(&sin->sin_addr);
+                               if (tat == NULL) {
+                                       arptfree(at);
+                                       splx(s);
+                                       return (EADDRNOTAVAIL);
+                               }
+                               arptfree(tat);
+                       }
+               }
+               bcopy((caddr_t)ar->arp_ha.sa_data, (caddr_t)at->at_enaddr,
+                   sizeof(at->at_enaddr));
+               at->at_flags = ATF_COM | ATF_INUSE |
+                       (ar->arp_flags & (ATF_PERM|ATF_PUBL|ATF_USETRAILERS));
+               at->at_timer = 0;
+               break;
+
+       case SIOCDARP:          /* delete entry */
+               arptfree(at);
+               break;
+
+       case SIOCGARP:          /* get entry */
+       case OSIOCGARP:
+               bcopy((caddr_t)at->at_enaddr, (caddr_t)ar->arp_ha.sa_data,
+                   sizeof(at->at_enaddr));
+#ifdef COMPAT_43
+               if (cmd == OSIOCGARP)
+                       *(u_short *)&ar->arp_ha = ar->arp_ha.sa_family;
+#endif
+               ar->arp_flags = at->at_flags;
+               break;
+       }
+       splx(s);
+       return (0);
+}