ARP(ADMP)                                  UNIX System V



     Name
          arp - Address Resolution Protocol


     Description
          ARP is a protocol used  to  map  dynamically  between  DARPA
          Internet  and  10Mb/s Ethernet addresses.  It is used by all
          the 10Mb/s Ethernet interface drivers running  the  Internet
          protocols.

          ARP caches  Internet-Ethernet  address  mappings.   When  an
          interface  requests  a  mapping  for  an  address not in the
          cache, ARP queues the message which requires the mapping and
          broadcasts  a  message  on the associated network requesting
          the address mapping.  If a response  is  provided,  the  new
          mapping  is  cached  and any pending message is transmitted.
          ARP will queue at  most  one  packet  while  waiting  for  a
          mapping  request  to  be  answered;  only  the most recently
          ``transmitted''  packet  is  kept.   The  ARP  protocol   is
          implemented   by   a  STREAMS  driver  to  do  the  protocol
          negotiation, and by a separate  STREAMS  module  to  do  the
          address translation.

          To facilitate communications with systems that  do  not  use
          ARP,  ioctls are provided to enter and delete entries in the
          Internet-to-Ethernet tables.  Usage:

               #include <sys/ioctl.h>
               #include <sys/socket.h>
               #include <net/if.h>
               struct arpreq arpreq;

               ioctl(s, SIOCSARP, (caddr_t)&arpreq);
               ioctl(s, SIOCGARP, (caddr_t)&arpreq);
               ioctl(s, SIOCDARP, (caddr_t)&arpreq);

          Each  ioctl  takes  the  same  structure  as  an   argument.
          SIOCSARP  sets an ARP entry, SIOCGARP gets an ARP entry, and
          SIOCDARP deletes an ARP entry.  These ioctls may be  applied
          to  any socket descriptor s, but only by the superuser.  The
          arpreq structure is as follows:

            /* ARP ioctl request */
          struct arpreq {
            struct sockaddr  arp_pa;/* protocol address */
            struct sockaddr  arp_ha;/* hardware address */
            int              arp_flags;/* flags */
          };
            /*  arp_flags field values */
          #define         ATF_COM0x02/* completed entry
                                (arp_ha valid) */
          #define         ATF_PERM0x04/* permanent entry */
          #define         ATF_PUBL0x08/* publish
                                (respond for other host) */
          #define         ATF_USETRAILERS0x10/* send trailer packets
                                to host */

          The address  family  for  the  arp_pa  sockaddr  ,  must  be
          AF_INET;  for the arp_ha sockaddr it must be AF_UNSPEC.  The
          only flag bits which may be written are  ATF_PERM,  ATF_PUBL
          and   ATF_USETRAILERS.  ATF_PERM  causes  the  entry  to  be
          permanent if the ioctl call succeeds.  The  peculiar  nature
          of the ARP tables may cause the ioctl to fail if more than 8
          (permanent) Internet host addresses hash to the  same  slot.
          ATF_PUBL  specifies  that the ARP code should respond to ARP
          requests for the indicated host coming from other  machines.
          This allows a host to act as an ``ARP server,'' which may be
          useful in convincing an ARP-only machine to talk to  a  non-
          ARP machine.

          ARP can also negotiate the use of trailer IP encapsulations;
          trailers  are  an  alternate  encapsulation  used  to  allow
          efficient  packet  alignment  for  large   packets   despite
          variable-sized  headers.  Hosts that wish to receive trailer
          encapsulations  indicate  so  by  sending   gratuitous   ARP
          translation  replies along with replies to IP requests; they
          are also sent in  reply  to  IP  translation  replies.   The
          negotiation  is  thus  fully  symmetrical, in that either or
          both hosts may request trailers.  The  ATF_USETRAILERS  flag
          is  used  to record the receipt of such a reply, and enables
          the transmission of trailer packets to that host.

          ARP watches passively for hosts impersonating the local host
          (that is, a host that responds to an ARP mapping request for
          the local host's address).


     Diagnostics
            duplicate  IP  address!!
            sent   from   ethernet   address:
            %x:%x:%x:%x:%x:%x.
          ARP has discovered another host on the  local  network  that
          responds to mapping requests for its own Internet address.


     Files
          /dev/inet/arp


     See Also
          arp(ADMP), ifconfig(ADMN), inet(ADMP).


     (printed 8/17/89)                                  ARP(ADMP)