sys/net/if_ether.h

   1 /*      $NetBSD: if_ether.h,v 1.64 2014/07/28 14:24:48 ozaki-r Exp $    */
   2
   3 /*
   4  * Copyright (c) 1982, 1986, 1993
   5  *      The Regents of the University of California.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. Neither the name of the University nor the names of its contributors
  16  *    may be used to endorse or promote products derived from this software
  17  *    without specific prior written permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  29  * SUCH DAMAGE.
  30  *
  31  *      @(#)if_ether.h  8.1 (Berkeley) 6/10/93
  32  */
  33
  34 #ifndef _NET_IF_ETHER_H_
  35 #define _NET_IF_ETHER_H_
  36
  37 #ifdef _KERNEL
  38 #ifdef _KERNEL_OPT
  39 #include "opt_mbuftrace.h"
  40 #endif
  41 #include <sys/mbuf.h>
  42 #endif
  43
  44 #ifndef _STANDALONE
  45 #include <net/if.h>
  46 #endif
  47
  48 /*
  49  * Some basic Ethernet constants.
  50  */
  51 #define ETHER_ADDR_LEN  6       /* length of an Ethernet address */
  52 #define ETHER_TYPE_LEN  2       /* length of the Ethernet type field */
  53 #define ETHER_CRC_LEN   4       /* length of the Ethernet CRC */
  54 #define ETHER_HDR_LEN   ((ETHER_ADDR_LEN * 2) + ETHER_TYPE_LEN)
  55 #define ETHER_MIN_LEN   64      /* minimum frame length, including CRC */
  56 #define ETHER_MAX_LEN   1518    /* maximum frame length, including CRC */
  57 #define ETHER_MAX_LEN_JUMBO 9018 /* maximum jumbo frame len, including CRC */
  58
  59 /*
  60  * Some Ethernet extensions.
  61  */
  62 #define ETHER_VLAN_ENCAP_LEN 4  /* length of 802.1Q VLAN encapsulation */
  63 #define ETHER_PPPOE_ENCAP_LEN 8 /* length of PPPoE encapsulation */
  64
  65 /*
  66  * Ethernet address - 6 octets
  67  * this is only used by the ethers(3) functions.
  68  */
  69 struct ether_addr {
  70         uint8_t ether_addr_octet[ETHER_ADDR_LEN];
  71 } __packed;
  72
  73 #if defined(__minix)
  74 #define ea_addr ether_addr_octet
  75 typedef struct ether_addr ether_addr_t;
  76 #endif /* defined(__minix) */
  77
  78 /*
  79  * Structure of a 10Mb/s Ethernet header.
  80  */
  81 struct ether_header {
  82         uint8_t  ether_dhost[ETHER_ADDR_LEN];
  83         uint8_t  ether_shost[ETHER_ADDR_LEN];
  84         uint16_t ether_type;
  85 } __packed;
  86
  87 #include <net/ethertypes.h>
  88
  89 #define ETHER_IS_MULTICAST(addr) (*(addr) & 0x01) /* is address mcast/bcast? */
  90 #define ETHER_IS_LOCAL(addr) (*(addr) & 0x02) /* is address local? */
  91
  92 #define ETHERMTU_JUMBO  (ETHER_MAX_LEN_JUMBO - ETHER_HDR_LEN - ETHER_CRC_LEN)
  93 #define ETHERMTU        (ETHER_MAX_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN)
  94 #define ETHERMIN        (ETHER_MIN_LEN - ETHER_HDR_LEN - ETHER_CRC_LEN)
  95
  96 /*
  97  * Compute the maximum frame size based on ethertype (i.e. possible
  98  * encapsulation) and whether or not an FCS is present.
  99  */
 100 #define ETHER_MAX_FRAME(ifp, etype, hasfcs)                             \
 101         ((ifp)->if_mtu + ETHER_HDR_LEN +                                \
 102          ((hasfcs) ? ETHER_CRC_LEN : 0) +                               \
 103          (((etype) == ETHERTYPE_VLAN) ? ETHER_VLAN_ENCAP_LEN : 0) +     \
 104          (((etype) == ETHERTYPE_PPPOE) ? ETHER_PPPOE_ENCAP_LEN : 0))
 105
 106 /*
 107  * Ethernet CRC32 polynomials (big- and little-endian verions).
 108  */
 109 #define ETHER_CRC_POLY_LE       0xedb88320
 110 #define ETHER_CRC_POLY_BE       0x04c11db6
 111
 112 #ifndef _STANDALONE
 113
 114 /*
 115  * Ethernet-specific mbuf flags.
 116  */
 117 #define M_HASFCS        M_LINK0 /* FCS included at end of frame */
 118 #define M_PROMISC       M_LINK1 /* this packet is not for us */
 119
 120 #ifdef _KERNEL
 121 /*
 122  * Macro to map an IP multicast address to an Ethernet multicast address.
 123  * The high-order 25 bits of the Ethernet address are statically assigned,
 124  * and the low-order 23 bits are taken from the low end of the IP address.
 125  */
 126 #define ETHER_MAP_IP_MULTICAST(ipaddr, enaddr)                          \
 127         /* const struct in_addr *ipaddr; */                             \
 128         /* uint8_t enaddr[ETHER_ADDR_LEN]; */                           \
 129 do {                                                                    \
 130         (enaddr)[0] = 0x01;                                             \
 131         (enaddr)[1] = 0x00;                                             \
 132         (enaddr)[2] = 0x5e;                                             \
 133         (enaddr)[3] = ((const uint8_t *)ipaddr)[1] & 0x7f;              \
 134         (enaddr)[4] = ((const uint8_t *)ipaddr)[2];                     \
 135         (enaddr)[5] = ((const uint8_t *)ipaddr)[3];                     \
 136 } while (/*CONSTCOND*/0)
 137 /*
 138  * Macro to map an IP6 multicast address to an Ethernet multicast address.
 139  * The high-order 16 bits of the Ethernet address are statically assigned,
 140  * and the low-order 32 bits are taken from the low end of the IP6 address.
 141  */
 142 #define ETHER_MAP_IPV6_MULTICAST(ip6addr, enaddr)                       \
 143         /* struct in6_addr *ip6addr; */                                 \
 144         /* uint8_t enaddr[ETHER_ADDR_LEN]; */                           \
 145 {                                                                       \
 146         (enaddr)[0] = 0x33;                                             \
 147         (enaddr)[1] = 0x33;                                             \
 148         (enaddr)[2] = ((const uint8_t *)ip6addr)[12];                   \
 149         (enaddr)[3] = ((const uint8_t *)ip6addr)[13];                   \
 150         (enaddr)[4] = ((const uint8_t *)ip6addr)[14];                   \
 151         (enaddr)[5] = ((const uint8_t *)ip6addr)[15];                   \
 152 }
 153 #endif
 154
 155 struct mii_data;
 156
 157 struct ethercom;
 158
 159 typedef int (*ether_cb_t)(struct ethercom *);
 160
 161 #if !defined(__minix)
 162 /*
 163  * Structure shared between the ethernet driver modules and
 164  * the multicast list code.  For example, each ec_softc or il_softc
 165  * begins with this structure.
 166  */
 167 struct ethercom {
 168         struct  ifnet ec_if;                    /* network-visible interface */
 169         LIST_HEAD(, ether_multi) ec_multiaddrs; /* list of ether multicast
 170                                                    addrs */
 171         int     ec_multicnt;                    /* length of ec_multiaddrs
 172                                                    list */
 173         int     ec_capabilities;                /* capabilities, provided by
 174                                                    driver */
 175         int     ec_capenable;                   /* tells hardware which
 176                                                    capabilities to enable */
 177
 178         int     ec_nvlans;                      /* # VLANs on this interface */
 179         /* The device handle for the MII bus child device. */
 180         struct mii_data                         *ec_mii;
 181         /* Called after a change to ec_if.if_flags.  Returns
 182          * ENETRESET if the device should be reinitialized with
 183          * ec_if.if_init, 0 on success, not 0 on failure.
 184          */
 185         ether_cb_t                              ec_ifflags_cb;
 186 #ifdef MBUFTRACE
 187         struct  mowner ec_rx_mowner;            /* mbufs received */
 188         struct  mowner ec_tx_mowner;            /* mbufs transmitted */
 189 #endif
 190 };
 191 #endif /* !defined(__minix) */
 192
 193 #define ETHERCAP_VLAN_MTU       0x00000001      /* VLAN-compatible MTU */
 194 #define ETHERCAP_VLAN_HWTAGGING 0x00000002      /* hardware VLAN tag support */
 195 #define ETHERCAP_JUMBO_MTU      0x00000004      /* 9000 byte MTU supported */
 196 #define ETHERCAP_MASK           0x00000007
 197
 198 #if !defined(__minix)
 199 #define ECCAPBITS               \
 200         "\020"                  \
 201         "\1VLAN_MTU"            \
 202         "\2VLAN_HWTAGGING"      \
 203         "\3JUMBO_MTU"
 204
 205 /* ioctl() for Ethernet capabilities */
 206 struct eccapreq {
 207         char            eccr_name[IFNAMSIZ];    /* if name, e.g. "en0" */
 208         int             eccr_capabilities;      /* supported capabiliites */
 209         int             eccr_capenable;         /* capabilities enabled */
 210 };
 211 #endif /* !defined(__minix) */
 212
 213 #ifdef  _KERNEL
 214 extern const uint8_t etherbroadcastaddr[ETHER_ADDR_LEN];
 215 extern const uint8_t ethermulticastaddr_slowprotocols[ETHER_ADDR_LEN];
 216 extern const uint8_t ether_ipmulticast_min[ETHER_ADDR_LEN];
 217 extern const uint8_t ether_ipmulticast_max[ETHER_ADDR_LEN];
 218
 219 void    ether_set_ifflags_cb(struct ethercom *, ether_cb_t);
 220 int     ether_ioctl(struct ifnet *, u_long, void *);
 221 int     ether_addmulti(const struct sockaddr *, struct ethercom *);
 222 int     ether_delmulti(const struct sockaddr *, struct ethercom *);
 223 int     ether_multiaddr(const struct sockaddr *, uint8_t[], uint8_t[]);
 224 void    ether_input(struct ifnet *, struct mbuf *);
 225 #endif /* _KERNEL */
 226
 227 #if !defined(__minix)
 228 /*
 229  * Ethernet multicast address structure.  There is one of these for each
 230  * multicast address or range of multicast addresses that we are supposed
 231  * to listen to on a particular interface.  They are kept in a linked list,
 232  * rooted in the interface's ethercom structure.
 233  */
 234 struct ether_multi {
 235         uint8_t enm_addrlo[ETHER_ADDR_LEN]; /* low  or only address of range */
 236         uint8_t enm_addrhi[ETHER_ADDR_LEN]; /* high or only address of range */
 237         u_int    enm_refcount;          /* no. claims to this addr/range */
 238         LIST_ENTRY(ether_multi) enm_list;
 239 };
 240
 241 struct ether_multi_sysctl {
 242         u_int   enm_refcount;
 243         uint8_t enm_addrlo[ETHER_ADDR_LEN];
 244         uint8_t enm_addrhi[ETHER_ADDR_LEN];
 245 };
 246 #endif /* !defined(__minix) */
 247
 248 /*
 249  * Structure used by macros below to remember position when stepping through
 250  * all of the ether_multi records.
 251  */
 252 struct ether_multistep {
 253         struct ether_multi  *e_enm;
 254 };
 255
 256 /*
 257  * Macro for looking up the ether_multi record for a given range of Ethernet
 258  * multicast addresses connected to a given ethercom structure.  If no matching
 259  * record is found, "enm" returns NULL.
 260  */
 261 #define ETHER_LOOKUP_MULTI(addrlo, addrhi, ec, enm)                     \
 262         /* uint8_t addrlo[ETHER_ADDR_LEN]; */                           \
 263         /* uint8_t addrhi[ETHER_ADDR_LEN]; */                           \
 264         /* struct ethercom *ec; */                                      \
 265         /* struct ether_multi *enm; */                                  \
 266 {                                                                       \
 267         for ((enm) = LIST_FIRST(&(ec)->ec_multiaddrs);                  \
 268             (enm) != NULL &&                                            \
 269             (memcmp((enm)->enm_addrlo, (addrlo), ETHER_ADDR_LEN) != 0 ||        \
 270              memcmp((enm)->enm_addrhi, (addrhi), ETHER_ADDR_LEN) != 0); \
 271                 (enm) = LIST_NEXT((enm), enm_list));                    \
 272 }
 273
 274 /*
 275  * Macro to step through all of the ether_multi records, one at a time.
 276  * The current position is remembered in "step", which the caller must
 277  * provide.  ETHER_FIRST_MULTI(), below, must be called to initialize "step"
 278  * and get the first record.  Both macros return a NULL "enm" when there
 279  * are no remaining records.
 280  */
 281 #define ETHER_NEXT_MULTI(step, enm) \
 282         /* struct ether_multistep step; */  \
 283         /* struct ether_multi *enm; */  \
 284 { \
 285         if (((enm) = (step).e_enm) != NULL) \
 286                 (step).e_enm = LIST_NEXT((enm), enm_list); \
 287 }
 288
 289 #define ETHER_FIRST_MULTI(step, ec, enm) \
 290         /* struct ether_multistep step; */ \
 291         /* struct ethercom *ec; */ \
 292         /* struct ether_multi *enm; */ \
 293 { \
 294         (step).e_enm = LIST_FIRST(&(ec)->ec_multiaddrs); \
 295         ETHER_NEXT_MULTI((step), (enm)); \
 296 }
 297
 298 #ifdef _KERNEL
 299
 300 /*
 301  * Ethernet 802.1Q VLAN structures.
 302  */
 303
 304 /* add VLAN tag to input/received packet */
 305 static inline int vlan_input_tag(struct ifnet *, struct mbuf *, u_int);
 306 static inline int
 307 vlan_input_tag(struct ifnet *ifp, struct mbuf *m, u_int vlanid)
 308 {
 309         struct m_tag *mtag;
 310         mtag = m_tag_get(PACKET_TAG_VLAN, sizeof(u_int), M_NOWAIT);
 311         if (mtag == NULL) {
 312                 ifp->if_ierrors++;
 313                 printf("%s: unable to allocate VLAN tag\n", ifp->if_xname);
 314                 m_freem(m);
 315                 return 1;
 316         }
 317         *(u_int *)(mtag + 1) = vlanid;
 318         m_tag_prepend(m, mtag);
 319         return 0;
 320 }
 321
 322 #define VLAN_INPUT_TAG(ifp, m, vlanid, _errcase)                \
 323     if (vlan_input_tag(ifp, m, vlanid) != 0) {                  \
 324         _errcase;                                               \
 325     }
 326
 327 /* extract VLAN tag from output/trasmit packet */
 328 #define VLAN_OUTPUT_TAG(ec, m0)                 \
 329         (VLAN_ATTACHED(ec) ? m_tag_find((m0), PACKET_TAG_VLAN, NULL) : NULL)
 330
 331 /* extract VLAN ID value from a VLAN tag */
 332 #define VLAN_TAG_VALUE(mtag)    \
 333         ((*(u_int *)(mtag + 1)) & 4095)
 334
 335 /* test if any VLAN is configured for this interface */
 336 #define VLAN_ATTACHED(ec)       ((ec)->ec_nvlans > 0)
 337
 338 void    etherinit(void);
 339 void    ether_ifattach(struct ifnet *, const uint8_t *);
 340 void    ether_ifdetach(struct ifnet *);
 341 int     ether_mediachange(struct ifnet *);
 342 void    ether_mediastatus(struct ifnet *, struct ifmediareq *);
 343
 344 char    *ether_sprintf(const uint8_t *);
 345 char    *ether_snprintf(char *, size_t, const uint8_t *);
 346
 347 uint32_t ether_crc32_le(const uint8_t *, size_t);
 348 uint32_t ether_crc32_be(const uint8_t *, size_t);
 349
 350 int     ether_aton_r(u_char *, size_t, const char *);
 351 #else
 352 /*
 353  * Prototype ethers(3) functions.
 354  */
 355 #include <sys/cdefs.h>
 356 __BEGIN_DECLS
 357 char *  ether_ntoa(const struct ether_addr *);
 358 struct ether_addr *
 359         ether_aton(const char *);
 360 int     ether_ntohost(char *, const struct ether_addr *);
 361 int     ether_hostton(const char *, struct ether_addr *);
 362 int     ether_line(const char *, struct ether_addr *, char *);
 363 __END_DECLS
 364 #endif
 365
 366 #endif /* _STANDALONE */
 367
 368 #endif /* !_NET_IF_ETHER_H_ */