1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 1982, 1989, 1993
|
|
|
|
* The Regents of the University of California. All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer.
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. All advertising materials mentioning features or use of this software
|
|
|
|
* must display the following acknowledgement:
|
|
|
|
* This product includes software developed by the University of
|
|
|
|
* California, Berkeley and its contributors.
|
|
|
|
* 4. Neither the name of the University nor the names of its contributors
|
|
|
|
* may be used to endorse or promote products derived from this software
|
|
|
|
* without specific prior written permission.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
|
|
|
* @(#)if_ethersubr.c 8.1 (Berkeley) 6/10/93
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
|
|
|
|
1998-01-09 00:51:57 +00:00
|
|
|
#include "opt_atalk.h"
|
1998-01-08 23:42:31 +00:00
|
|
|
#include "opt_inet.h"
|
1999-12-07 17:39:16 +00:00
|
|
|
#include "opt_inet6.h"
|
1997-12-15 20:31:25 +00:00
|
|
|
#include "opt_ipx.h"
|
1998-12-14 17:58:05 +00:00
|
|
|
#include "opt_bdg.h"
|
2002-07-31 16:22:02 +00:00
|
|
|
#include "opt_mac.h"
|
1999-10-21 09:06:11 +00:00
|
|
|
#include "opt_netgraph.h"
|
1997-12-15 20:31:25 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/kernel.h>
|
2002-07-31 16:22:02 +00:00
|
|
|
#include <sys/mac.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/malloc.h>
|
|
|
|
#include <sys/mbuf.h>
|
2001-02-18 17:54:52 +00:00
|
|
|
#include <sys/random.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <sys/socket.h>
|
1997-03-24 11:33:46 +00:00
|
|
|
#include <sys/sockio.h>
|
1995-12-20 21:53:53 +00:00
|
|
|
#include <sys/sysctl.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
|
|
|
#include <net/if.h>
|
|
|
|
#include <net/netisr.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
#include <net/if_llc.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_types.h>
|
2000-05-14 02:18:43 +00:00
|
|
|
#include <net/bpf.h>
|
2000-06-26 23:34:54 +00:00
|
|
|
#include <net/ethernet.h>
|
2001-10-05 05:45:27 +00:00
|
|
|
#include <net/bridge.h>
|
2002-11-14 23:35:06 +00:00
|
|
|
#include <net/if_vlan_var.h>
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-11-22 02:45:11 +00:00
|
|
|
#if defined(INET) || defined(INET6)
|
1994-05-24 10:09:53 +00:00
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/in_var.h>
|
|
|
|
#include <netinet/if_ether.h>
|
2002-05-13 10:37:19 +00:00
|
|
|
#include <netinet/ip_fw.h>
|
|
|
|
#include <netinet/ip_dummynet.h>
|
1998-01-08 23:42:31 +00:00
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
#ifdef INET6
|
|
|
|
#include <netinet6/nd6.h>
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1995-10-26 20:31:59 +00:00
|
|
|
#ifdef IPX
|
|
|
|
#include <netipx/ipx.h>
|
|
|
|
#include <netipx/ipx_if.h>
|
1999-12-13 16:24:22 +00:00
|
|
|
int (*ef_inputp)(struct ifnet*, struct ether_header *eh, struct mbuf *m);
|
2000-04-27 10:13:52 +00:00
|
|
|
int (*ef_outputp)(struct ifnet *ifp, struct mbuf **mp,
|
2000-09-30 14:33:53 +00:00
|
|
|
struct sockaddr *dst, short *tp, int *hlen);
|
1995-10-26 20:31:59 +00:00
|
|
|
#endif
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef NS
|
|
|
|
#include <netns/ns.h>
|
|
|
|
#include <netns/ns_if.h>
|
1996-10-18 15:59:25 +00:00
|
|
|
ushort ns_nettype;
|
1996-10-17 17:16:58 +00:00
|
|
|
int ether_outputdebug = 0;
|
|
|
|
int ether_inputdebug = 0;
|
1994-05-24 10:09:53 +00:00
|
|
|
#endif
|
|
|
|
|
1996-05-24 01:35:45 +00:00
|
|
|
#ifdef NETATALK
|
|
|
|
#include <netatalk/at.h>
|
|
|
|
#include <netatalk/at_var.h>
|
|
|
|
#include <netatalk/at_extern.h>
|
|
|
|
|
|
|
|
#define llc_snap_org_code llc_un.type_snap.org_code
|
|
|
|
#define llc_snap_ether_type llc_un.type_snap.ether_type
|
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
extern u_char at_org_code[3];
|
|
|
|
extern u_char aarp_org_code[3];
|
|
|
|
#endif /* NETATALK */
|
|
|
|
|
2000-06-26 23:34:54 +00:00
|
|
|
/* netgraph node hooks for ng_ether(4) */
|
2002-11-14 23:35:06 +00:00
|
|
|
void (*ng_ether_input_p)(struct ifnet *ifp, struct mbuf **mp);
|
|
|
|
void (*ng_ether_input_orphan_p)(struct ifnet *ifp, struct mbuf *m);
|
2000-06-26 23:34:54 +00:00
|
|
|
int (*ng_ether_output_p)(struct ifnet *ifp, struct mbuf **mp);
|
|
|
|
void (*ng_ether_attach_p)(struct ifnet *ifp);
|
|
|
|
void (*ng_ether_detach_p)(struct ifnet *ifp);
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
void (*vlan_input_p)(struct ifnet *, struct mbuf *);
|
2001-09-05 21:10:28 +00:00
|
|
|
|
2001-10-05 05:45:27 +00:00
|
|
|
/* bridge support */
|
2002-02-15 04:57:18 +00:00
|
|
|
int do_bridge;
|
2001-10-05 05:45:27 +00:00
|
|
|
bridge_in_t *bridge_in_ptr;
|
|
|
|
bdg_forward_t *bdg_forward_ptr;
|
|
|
|
bdgtakeifaces_t *bdgtakeifaces_ptr;
|
2002-02-15 04:57:18 +00:00
|
|
|
struct bdg_softc *ifp2sc;
|
2001-10-05 05:45:27 +00:00
|
|
|
|
2002-03-19 21:54:18 +00:00
|
|
|
static int ether_resolvemulti(struct ifnet *, struct sockaddr **,
|
2002-06-23 11:19:53 +00:00
|
|
|
struct sockaddr *);
|
1994-05-24 10:09:53 +00:00
|
|
|
u_char etherbroadcastaddr[6] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
|
1999-01-31 08:17:16 +00:00
|
|
|
#define senderr(e) do { error = (e); goto bad;} while (0)
|
|
|
|
#define IFP2AC(IFP) ((struct arpcom *)IFP)
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-05-13 10:37:19 +00:00
|
|
|
int
|
|
|
|
ether_ipfw_chk(struct mbuf **m0, struct ifnet *dst,
|
2002-11-14 23:35:06 +00:00
|
|
|
struct ip_fw **rule, int shared);
|
2002-05-13 10:37:19 +00:00
|
|
|
static int ether_ipfw;
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
|
|
|
* Ethernet output routine.
|
|
|
|
* Encapsulate a packet of type family for the local net.
|
|
|
|
* Use trailer local net encapsulation if enough data in first
|
|
|
|
* packet leaves a multiple of 512 bytes of data in remainder.
|
|
|
|
* Assumes that ifp is actually pointer to arpcom structure.
|
|
|
|
*/
|
|
|
|
int
|
1999-12-19 01:55:37 +00:00
|
|
|
ether_output(ifp, m, dst, rt0)
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct ifnet *ifp;
|
1999-12-19 01:55:37 +00:00
|
|
|
struct mbuf *m;
|
1994-05-24 10:09:53 +00:00
|
|
|
struct sockaddr *dst;
|
|
|
|
struct rtentry *rt0;
|
|
|
|
{
|
|
|
|
short type;
|
2000-06-26 23:34:54 +00:00
|
|
|
int error = 0, hdrcmplt = 0;
|
1999-10-15 05:07:00 +00:00
|
|
|
u_char esrc[6], edst[6];
|
1994-05-24 10:09:53 +00:00
|
|
|
register struct rtentry *rt;
|
|
|
|
register struct ether_header *eh;
|
2002-06-30 08:02:38 +00:00
|
|
|
int loop_copy = 0;
|
1998-08-04 23:17:05 +00:00
|
|
|
int hlen; /* link layer header lenght */
|
1999-01-31 08:17:16 +00:00
|
|
|
struct arpcom *ac = IFP2AC(ifp);
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-07-31 16:22:02 +00:00
|
|
|
#ifdef MAC
|
|
|
|
error = mac_check_ifnet_transmit(ifp, m);
|
|
|
|
if (error)
|
|
|
|
senderr(error);
|
|
|
|
#endif
|
|
|
|
|
2002-09-27 18:57:47 +00:00
|
|
|
if (ifp->if_flags & IFF_MONITOR)
|
|
|
|
senderr(ENETDOWN);
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((ifp->if_flags & (IFF_UP|IFF_RUNNING)) != (IFF_UP|IFF_RUNNING))
|
|
|
|
senderr(ENETDOWN);
|
1995-12-09 20:47:15 +00:00
|
|
|
rt = rt0;
|
|
|
|
if (rt) {
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((rt->rt_flags & RTF_UP) == 0) {
|
1995-12-09 20:47:15 +00:00
|
|
|
rt0 = rt = rtalloc1(dst, 1, 0UL);
|
|
|
|
if (rt0)
|
1994-05-24 10:09:53 +00:00
|
|
|
rt->rt_refcnt--;
|
1995-05-30 08:16:23 +00:00
|
|
|
else
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(EHOSTUNREACH);
|
|
|
|
}
|
|
|
|
if (rt->rt_flags & RTF_GATEWAY) {
|
|
|
|
if (rt->rt_gwroute == 0)
|
|
|
|
goto lookup;
|
|
|
|
if (((rt = rt->rt_gwroute)->rt_flags & RTF_UP) == 0) {
|
|
|
|
rtfree(rt); rt = rt0;
|
1995-05-30 08:16:23 +00:00
|
|
|
lookup: rt->rt_gwroute = rtalloc1(rt->rt_gateway, 1,
|
1994-12-13 22:31:49 +00:00
|
|
|
0UL);
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((rt = rt->rt_gwroute) == 0)
|
|
|
|
senderr(EHOSTUNREACH);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (rt->rt_flags & RTF_REJECT)
|
|
|
|
if (rt->rt_rmx.rmx_expire == 0 ||
|
1998-03-30 09:56:58 +00:00
|
|
|
time_second < rt->rt_rmx.rmx_expire)
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(rt == rt0 ? EHOSTDOWN : EHOSTUNREACH);
|
|
|
|
}
|
1998-08-04 23:17:05 +00:00
|
|
|
hlen = ETHER_HDR_LEN;
|
1994-05-24 10:09:53 +00:00
|
|
|
switch (dst->sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2001-10-14 20:17:53 +00:00
|
|
|
if (!arpresolve(ifp, rt, m, dst, edst, rt0))
|
1994-05-24 10:09:53 +00:00
|
|
|
return (0); /* if not yet resolved */
|
1996-06-13 02:54:19 +00:00
|
|
|
type = htons(ETHERTYPE_IP);
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
if (!nd6_storelladdr(&ac->ac_if, rt, m, dst, (u_char *)edst)) {
|
2001-03-11 05:31:45 +00:00
|
|
|
/* Something bad happened */
|
1999-11-22 02:45:11 +00:00
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
type = htons(ETHERTYPE_IPV6);
|
|
|
|
break;
|
|
|
|
#endif
|
1995-10-26 20:31:59 +00:00
|
|
|
#ifdef IPX
|
|
|
|
case AF_IPX:
|
1999-12-13 16:24:22 +00:00
|
|
|
if (ef_outputp) {
|
2000-09-30 14:33:53 +00:00
|
|
|
error = ef_outputp(ifp, &m, dst, &type, &hlen);
|
2000-04-27 10:13:52 +00:00
|
|
|
if (error)
|
|
|
|
goto bad;
|
1999-12-13 16:24:22 +00:00
|
|
|
} else
|
|
|
|
type = htons(ETHERTYPE_IPX);
|
1995-10-26 20:31:59 +00:00
|
|
|
bcopy((caddr_t)&(((struct sockaddr_ipx *)dst)->sipx_addr.x_host),
|
|
|
|
(caddr_t)edst, sizeof (edst));
|
|
|
|
break;
|
|
|
|
#endif
|
1996-05-24 01:35:45 +00:00
|
|
|
#ifdef NETATALK
|
|
|
|
case AF_APPLETALK:
|
1998-06-12 03:48:19 +00:00
|
|
|
{
|
|
|
|
struct at_ifaddr *aa;
|
1997-10-29 00:30:52 +00:00
|
|
|
|
1998-06-12 03:48:19 +00:00
|
|
|
if ((aa = at_ifawithnet((struct sockaddr_at *)dst)) == NULL) {
|
|
|
|
goto bad;
|
1997-10-29 00:30:52 +00:00
|
|
|
}
|
1998-06-12 03:48:19 +00:00
|
|
|
if (!aarpresolve(ac, m, (struct sockaddr_at *)dst, edst))
|
|
|
|
return (0);
|
1996-05-24 01:35:45 +00:00
|
|
|
/*
|
1998-06-12 03:48:19 +00:00
|
|
|
* In the phase 2 case, need to prepend an mbuf for the llc header.
|
1996-05-24 01:35:45 +00:00
|
|
|
* Since we must preserve the value of m, which is passed to us by
|
|
|
|
* value, we m_copy() the first mbuf, and use it for our llc header.
|
|
|
|
*/
|
|
|
|
if ( aa->aa_flags & AFA_PHASE2 ) {
|
|
|
|
struct llc llc;
|
|
|
|
|
2000-12-21 21:44:31 +00:00
|
|
|
M_PREPEND(m, sizeof(struct llc), M_TRYWAIT);
|
1996-05-24 01:35:45 +00:00
|
|
|
llc.llc_dsap = llc.llc_ssap = LLC_SNAP_LSAP;
|
|
|
|
llc.llc_control = LLC_UI;
|
|
|
|
bcopy(at_org_code, llc.llc_snap_org_code, sizeof(at_org_code));
|
|
|
|
llc.llc_snap_ether_type = htons( ETHERTYPE_AT );
|
|
|
|
bcopy(&llc, mtod(m, caddr_t), sizeof(struct llc));
|
1996-06-13 02:54:19 +00:00
|
|
|
type = htons(m->m_pkthdr.len);
|
1998-08-04 23:17:05 +00:00
|
|
|
hlen = sizeof(struct llc) + ETHER_HDR_LEN;
|
1996-05-24 01:35:45 +00:00
|
|
|
} else {
|
1996-06-13 02:54:19 +00:00
|
|
|
type = htons(ETHERTYPE_AT);
|
1996-05-24 01:35:45 +00:00
|
|
|
}
|
|
|
|
break;
|
1998-06-12 03:48:19 +00:00
|
|
|
}
|
2001-09-10 01:33:03 +00:00
|
|
|
#endif /* NETATALK */
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef NS
|
|
|
|
case AF_NS:
|
1996-10-17 17:16:58 +00:00
|
|
|
switch(ns_nettype){
|
|
|
|
default:
|
|
|
|
case 0x8137: /* Novell Ethernet_II Ethernet TYPE II */
|
|
|
|
type = 0x8137;
|
|
|
|
break;
|
|
|
|
case 0x0: /* Novell 802.3 */
|
|
|
|
type = htons( m->m_pkthdr.len);
|
|
|
|
break;
|
|
|
|
case 0xe0e0: /* Novell 802.2 and Token-Ring */
|
2000-12-21 21:44:31 +00:00
|
|
|
M_PREPEND(m, 3, M_TRYWAIT);
|
1996-10-17 17:16:58 +00:00
|
|
|
type = htons( m->m_pkthdr.len);
|
|
|
|
cp = mtod(m, u_char *);
|
|
|
|
*cp++ = 0xE0;
|
|
|
|
*cp++ = 0xE0;
|
|
|
|
*cp++ = 0x03;
|
|
|
|
break;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
bcopy((caddr_t)&(((struct sockaddr_ns *)dst)->sns_addr.x_host),
|
|
|
|
(caddr_t)edst, sizeof (edst));
|
1999-01-31 08:17:16 +00:00
|
|
|
/*
|
|
|
|
* XXX if ns_thishost is the same as the node's ethernet
|
|
|
|
* address then just the default code will catch this anyhow.
|
|
|
|
* So I'm not sure if this next clause should be here at all?
|
|
|
|
* [JRE]
|
|
|
|
*/
|
1996-10-17 17:16:58 +00:00
|
|
|
if (!bcmp((caddr_t)edst, (caddr_t)&ns_thishost, sizeof(edst))){
|
|
|
|
m->m_pkthdr.rcvif = ifp;
|
|
|
|
inq = &nsintrq;
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
if (IF_HANDOFF(inq, m, NULL))
|
|
|
|
schednetisr(NETISR_NS);
|
1996-10-17 17:16:58 +00:00
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (!bcmp((caddr_t)edst, (caddr_t)&ns_broadhost, sizeof(edst))){
|
1999-01-31 08:17:16 +00:00
|
|
|
m->m_flags |= M_BCAST;
|
1996-10-17 17:16:58 +00:00
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
break;
|
1996-10-17 17:16:58 +00:00
|
|
|
#endif /* NS */
|
1994-05-24 10:09:53 +00:00
|
|
|
|
1999-10-15 05:07:00 +00:00
|
|
|
case pseudo_AF_HDRCMPLT:
|
|
|
|
hdrcmplt = 1;
|
|
|
|
eh = (struct ether_header *)dst->sa_data;
|
|
|
|
(void)memcpy(esrc, eh->ether_shost, sizeof (esrc));
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
case AF_UNSPEC:
|
1998-06-13 02:27:10 +00:00
|
|
|
loop_copy = -1; /* if this is for us, don't do it */
|
1994-05-24 10:09:53 +00:00
|
|
|
eh = (struct ether_header *)dst->sa_data;
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(edst, eh->ether_dhost, sizeof (edst));
|
1994-05-24 10:09:53 +00:00
|
|
|
type = eh->ether_type;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2002-10-21 02:51:56 +00:00
|
|
|
if_printf(ifp, "can't handle af%d\n", dst->sa_family);
|
1994-05-24 10:09:53 +00:00
|
|
|
senderr(EAFNOSUPPORT);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add local net header. If no space in first mbuf,
|
|
|
|
* allocate another.
|
|
|
|
*/
|
|
|
|
M_PREPEND(m, sizeof (struct ether_header), M_DONTWAIT);
|
|
|
|
if (m == 0)
|
|
|
|
senderr(ENOBUFS);
|
|
|
|
eh = mtod(m, struct ether_header *);
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(&eh->ether_type, &type,
|
1994-05-24 10:09:53 +00:00
|
|
|
sizeof(eh->ether_type));
|
1995-05-09 13:35:48 +00:00
|
|
|
(void)memcpy(eh->ether_dhost, edst, sizeof (edst));
|
1999-10-15 05:07:00 +00:00
|
|
|
if (hdrcmplt)
|
|
|
|
(void)memcpy(eh->ether_shost, esrc,
|
|
|
|
sizeof(eh->ether_shost));
|
|
|
|
else
|
|
|
|
(void)memcpy(eh->ether_shost, ac->ac_enaddr,
|
|
|
|
sizeof(eh->ether_shost));
|
1998-06-12 03:48:19 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If a simplex interface, and the packet is being sent to our
|
|
|
|
* Ethernet address or a broadcast address, loopback a copy.
|
|
|
|
* XXX To make a simplex device behave exactly like a duplex
|
|
|
|
* device, we should copy in the case of sending to our own
|
|
|
|
* ethernet address (thus letting the original actually appear
|
|
|
|
* on the wire). However, we don't do that here for security
|
|
|
|
* reasons and compatibility with the original behavior.
|
|
|
|
*/
|
1999-01-31 08:17:16 +00:00
|
|
|
if ((ifp->if_flags & IFF_SIMPLEX) && (loop_copy != -1)) {
|
2002-01-11 16:04:47 +00:00
|
|
|
int csum_flags = 0;
|
|
|
|
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_IP)
|
|
|
|
csum_flags |= (CSUM_IP_CHECKED|CSUM_IP_VALID);
|
|
|
|
if (m->m_pkthdr.csum_flags & CSUM_DELAY_DATA)
|
|
|
|
csum_flags |= (CSUM_DATA_VALID|CSUM_PSEUDO_HDR);
|
1998-06-13 02:27:10 +00:00
|
|
|
if ((m->m_flags & M_BCAST) || (loop_copy > 0)) {
|
1998-06-12 03:48:19 +00:00
|
|
|
struct mbuf *n = m_copy(m, 0, (int)M_COPYALL);
|
|
|
|
|
2002-01-11 16:04:47 +00:00
|
|
|
n->m_pkthdr.csum_flags |= csum_flags;
|
|
|
|
if (csum_flags & CSUM_DATA_VALID)
|
|
|
|
n->m_pkthdr.csum_data = 0xffff;
|
|
|
|
|
2000-05-24 21:16:56 +00:00
|
|
|
(void) if_simloop(ifp, n, dst->sa_family, hlen);
|
1998-06-12 03:48:19 +00:00
|
|
|
} else if (bcmp(eh->ether_dhost,
|
|
|
|
eh->ether_shost, ETHER_ADDR_LEN) == 0) {
|
2002-01-11 16:04:47 +00:00
|
|
|
m->m_pkthdr.csum_flags |= csum_flags;
|
|
|
|
if (csum_flags & CSUM_DATA_VALID)
|
|
|
|
m->m_pkthdr.csum_data = 0xffff;
|
2000-05-24 21:16:56 +00:00
|
|
|
(void) if_simloop(ifp, m, dst->sa_family, hlen);
|
1999-01-12 12:07:00 +00:00
|
|
|
return (0); /* XXX */
|
1998-06-12 03:48:19 +00:00
|
|
|
}
|
|
|
|
}
|
2000-05-14 02:18:43 +00:00
|
|
|
|
2000-06-26 23:34:54 +00:00
|
|
|
/* Handle ng_ether(4) processing, if any */
|
|
|
|
if (ng_ether_output_p != NULL) {
|
|
|
|
if ((error = (*ng_ether_output_p)(ifp, &m)) != 0) {
|
|
|
|
bad: if (m != NULL)
|
|
|
|
m_freem(m);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
if (m == NULL)
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Continue with link-layer output */
|
|
|
|
return ether_output_frame(ifp, m);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ethernet link layer output routine to send a raw frame to the device.
|
|
|
|
*
|
|
|
|
* This assumes that the 14 byte Ethernet header is present and contiguous
|
|
|
|
* in the first mbuf (if BRIDGE'ing).
|
|
|
|
*/
|
|
|
|
int
|
2002-11-14 23:35:06 +00:00
|
|
|
ether_output_frame(struct ifnet *ifp, struct mbuf *m)
|
2000-06-26 23:34:54 +00:00
|
|
|
{
|
2002-05-13 10:37:19 +00:00
|
|
|
struct ip_fw *rule = NULL;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
|
|
|
|
/* Extract info from dummynet tag, ignore others */
|
|
|
|
for (; m->m_type == MT_TAG; m = m->m_next)
|
|
|
|
if (m->m_flags == PACKET_TAG_DUMMYNET)
|
|
|
|
rule = ((struct dn_pkt *)m)->rule;
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
if (rule == NULL && BDG_ACTIVE(ifp)) {
|
|
|
|
/*
|
|
|
|
* Beware, the bridge code notices the null rcvif and
|
|
|
|
* uses that identify that it's being called from
|
|
|
|
* ether_output as opposd to ether_input. Yech.
|
|
|
|
*/
|
2000-05-14 02:18:43 +00:00
|
|
|
m->m_pkthdr.rcvif = NULL;
|
2002-11-14 23:35:06 +00:00
|
|
|
m = bdg_forward_ptr(m, ifp);
|
2000-05-14 02:18:43 +00:00
|
|
|
if (m != NULL)
|
|
|
|
m_freem(m);
|
1999-01-12 12:07:00 +00:00
|
|
|
return (0);
|
1998-12-14 17:58:05 +00:00
|
|
|
}
|
2002-05-13 10:37:19 +00:00
|
|
|
if (IPFW_LOADED && ether_ipfw != 0) {
|
2002-11-14 23:35:06 +00:00
|
|
|
if (ether_ipfw_chk(&m, ifp, &rule, 0) == 0) {
|
2002-05-13 10:37:19 +00:00
|
|
|
if (m) {
|
|
|
|
m_freem(m);
|
|
|
|
return ENOBUFS; /* pkt dropped */
|
|
|
|
} else
|
|
|
|
return 0; /* consumed e.g. in a pipe */
|
|
|
|
}
|
|
|
|
}
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
* Queue message on interface, update output statistics if
|
|
|
|
* successful, and start output if interface not yet active.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-11-14 23:35:06 +00:00
|
|
|
return (IF_HANDOFF(&ifp->if_snd, m, ifp) ? 0 : ENOBUFS);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
2002-05-13 10:37:19 +00:00
|
|
|
/*
|
|
|
|
* ipfw processing for ethernet packets (in and out).
|
|
|
|
* The second parameter is NULL from ether_demux, and ifp from
|
|
|
|
* ether_output_frame. This section of code could be used from
|
2002-06-23 11:19:53 +00:00
|
|
|
* bridge.c as well as long as we use some extra info
|
2002-05-13 10:37:19 +00:00
|
|
|
* to distinguish that case from ether_output_frame();
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
ether_ipfw_chk(struct mbuf **m0, struct ifnet *dst,
|
2002-11-14 23:35:06 +00:00
|
|
|
struct ip_fw **rule, int shared)
|
2002-05-13 10:37:19 +00:00
|
|
|
{
|
2002-11-14 23:35:06 +00:00
|
|
|
struct ether_header *eh;
|
|
|
|
struct ether_header save_eh;
|
|
|
|
struct mbuf *m;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
int i;
|
|
|
|
struct ip_fw_args args;
|
2002-05-13 10:37:19 +00:00
|
|
|
|
2002-09-12 15:36:13 +00:00
|
|
|
if (*rule != NULL /*&& fw_one_pass*/) /* HACK! need to obey fw_one_pass */
|
2002-09-12 01:05:46 +00:00
|
|
|
return 1; /* dummynet packet, already partially processed */
|
2002-06-23 11:19:53 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* I need some amt of data to be contiguous, and in case others need
|
|
|
|
* the packet (shared==1) also better be in the first mbuf.
|
|
|
|
*/
|
2002-11-14 23:35:06 +00:00
|
|
|
m = *m0;
|
|
|
|
i = min( m->m_pkthdr.len, max_protohdr);
|
|
|
|
if ( shared || m->m_len < i) {
|
|
|
|
m = m_pullup(m, i);
|
|
|
|
if (m == NULL) {
|
|
|
|
*m0 = m;
|
2002-05-13 10:37:19 +00:00
|
|
|
return 0;
|
2002-11-14 23:35:06 +00:00
|
|
|
}
|
2002-06-23 11:19:53 +00:00
|
|
|
}
|
2002-11-14 23:35:06 +00:00
|
|
|
eh = mtod(m, struct ether_header *);
|
|
|
|
save_eh = *eh; /* save copy for restore below */
|
|
|
|
m_adj(m, ETHER_HDR_LEN); /* strip ethernet header */
|
2002-05-13 10:37:19 +00:00
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
args.m = m; /* the packet we are looking at */
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
args.oif = dst; /* destination, if any */
|
|
|
|
args.divert_rule = 0; /* we do not support divert yet */
|
|
|
|
args.rule = *rule; /* matching rule to restart */
|
2002-06-23 11:19:53 +00:00
|
|
|
args.next_hop = NULL; /* we do not support forward yet */
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
args.eh = &save_eh; /* MAC header for bridged/MAC packets */
|
2002-06-23 11:19:53 +00:00
|
|
|
i = ip_fw_chk_ptr(&args);
|
2002-11-14 23:35:06 +00:00
|
|
|
m = args.m;
|
|
|
|
if (m != NULL) {
|
|
|
|
/*
|
|
|
|
* Restore Ethernet header, as needed, in case the
|
|
|
|
* mbuf chain was replaced by ipfw.
|
|
|
|
*/
|
|
|
|
M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT);
|
|
|
|
if (m == NULL) {
|
|
|
|
*m0 = m;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (eh != mtod(m, struct ether_header *))
|
|
|
|
bcopy(&save_eh, mtod(m, struct ether_header *),
|
|
|
|
ETHER_HDR_LEN);
|
|
|
|
}
|
|
|
|
*m0 = m;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
*rule = args.rule;
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
if ( (i & IP_FW_PORT_DENY_FLAG) || m == NULL) /* drop */
|
2002-05-13 10:37:19 +00:00
|
|
|
return 0;
|
|
|
|
|
2002-06-23 11:19:53 +00:00
|
|
|
if (i == 0) /* a PASS rule. */
|
2002-05-13 10:37:19 +00:00
|
|
|
return 1;
|
|
|
|
|
2002-06-23 11:19:53 +00:00
|
|
|
if (DUMMYNET_LOADED && (i & IP_FW_PORT_DYNT_FLAG)) {
|
2002-05-13 10:37:19 +00:00
|
|
|
/*
|
|
|
|
* Pass the pkt to dummynet, which consumes it.
|
|
|
|
* If shared, make a copy and keep the original.
|
|
|
|
*/
|
|
|
|
if (shared) {
|
2002-11-14 23:35:06 +00:00
|
|
|
m = m_copypacket(m, M_DONTWAIT);
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (m == NULL)
|
2002-05-13 10:37:19 +00:00
|
|
|
return 0;
|
|
|
|
} else {
|
2002-11-14 23:35:06 +00:00
|
|
|
/*
|
|
|
|
* Pass the original to dummynet and
|
|
|
|
* nothing back to the caller
|
|
|
|
*/
|
|
|
|
*m0 = NULL ;
|
2002-05-13 10:37:19 +00:00
|
|
|
}
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
ip_dn_io_ptr(m, (i & 0xffff),
|
|
|
|
dst ? DN_TO_ETH_OUT: DN_TO_ETH_DEMUX, &args);
|
2002-05-13 10:37:19 +00:00
|
|
|
return 0;
|
2002-06-23 11:19:53 +00:00
|
|
|
}
|
|
|
|
/*
|
|
|
|
* XXX at some point add support for divert/forward actions.
|
|
|
|
* If none of the above matches, we have to drop the pkt.
|
|
|
|
*/
|
|
|
|
return 0;
|
2002-05-13 10:37:19 +00:00
|
|
|
}
|
|
|
|
|
1994-05-24 10:09:53 +00:00
|
|
|
/*
|
2002-11-14 23:35:06 +00:00
|
|
|
* Process a received Ethernet packet; the packet is in the
|
|
|
|
* mbuf chain m with the ethernet header at the front.
|
1994-05-24 10:09:53 +00:00
|
|
|
*/
|
2002-11-14 23:35:06 +00:00
|
|
|
static void
|
|
|
|
ether_input(struct ifnet *ifp, struct mbuf *m)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
2002-11-14 23:35:06 +00:00
|
|
|
struct ether_header *eh;
|
|
|
|
u_short etype;
|
1994-05-24 10:09:53 +00:00
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
/*
|
|
|
|
* Do consistency checks to verify assumptions
|
|
|
|
* made by code past this point.
|
|
|
|
*/
|
|
|
|
if ((m->m_flags & M_PKTHDR) == 0) {
|
|
|
|
if_printf(ifp, "discard frame w/o packet header\n");
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (m->m_len < sizeof (struct ether_header)) {
|
|
|
|
/* XXX maybe should pullup? */
|
|
|
|
if_printf(ifp, "discard frame w/o leading ethernet "
|
|
|
|
"header (len %u pkt len %u)\n",
|
|
|
|
m->m_len, m->m_pkthdr.len);
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
2000-05-14 02:18:43 +00:00
|
|
|
}
|
2002-11-14 23:35:06 +00:00
|
|
|
eh = mtod(m, struct ether_header *);
|
|
|
|
etype = ntohs(eh->ether_type);
|
|
|
|
if (m->m_pkthdr.len >
|
|
|
|
ETHER_MAX_FRAME(ifp, etype, m->m_flags & M_HASFCS)) {
|
|
|
|
if_printf(ifp, "discard oversize frame "
|
|
|
|
"(ether type %x flags %x len %u > max %lu)\n",
|
|
|
|
etype, m->m_flags, m->m_pkthdr.len,
|
|
|
|
ETHER_MAX_FRAME(ifp, etype,
|
|
|
|
m->m_flags & M_HASFCS));
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (m->m_pkthdr.rcvif == NULL) {
|
|
|
|
if_printf(ifp, "discard frame w/o interface pointer\n");
|
|
|
|
ifp->if_ierrors++;
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
|
|
if (m->m_pkthdr.rcvif != ifp) {
|
|
|
|
if_printf(ifp, "Warning, frame marked as received on %s%u\n",
|
|
|
|
m->m_pkthdr.rcvif->if_name,
|
|
|
|
m->m_pkthdr.rcvif->if_unit);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Give bpf a chance at the packet.
|
|
|
|
*/
|
|
|
|
BPF_MTAP(ifp, m);
|
2000-05-14 02:18:43 +00:00
|
|
|
|
2002-09-27 18:57:47 +00:00
|
|
|
if (ifp->if_flags & IFF_MONITOR) {
|
2002-11-14 23:35:06 +00:00
|
|
|
/*
|
|
|
|
* Interface marked for monitoring; discard packet.
|
|
|
|
*/
|
2002-09-27 18:57:47 +00:00
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
/* If the CRC is still on the packet, trim it off. */
|
|
|
|
if (m->m_flags & M_HASFCS) {
|
|
|
|
m_adj(m, -ETHER_CRC_LEN);
|
|
|
|
m->m_flags &= ~M_HASFCS;
|
|
|
|
}
|
|
|
|
|
2002-09-18 19:50:48 +00:00
|
|
|
#ifdef MAC
|
|
|
|
mac_create_mbuf_from_ifnet(ifp, m);
|
|
|
|
#endif
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
ifp->if_ibytes += m->m_pkthdr.len;
|
2001-12-14 04:41:07 +00:00
|
|
|
|
2000-06-26 23:34:54 +00:00
|
|
|
/* Handle ng_ether(4) processing, if any */
|
|
|
|
if (ng_ether_input_p != NULL) {
|
2002-11-14 23:35:06 +00:00
|
|
|
(*ng_ether_input_p)(ifp, &m);
|
2000-06-26 23:34:54 +00:00
|
|
|
if (m == NULL)
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2000-05-14 02:18:43 +00:00
|
|
|
/* Check for bridging mode */
|
2001-11-04 22:56:25 +00:00
|
|
|
if (BDG_ACTIVE(ifp) ) {
|
2000-05-14 02:18:43 +00:00
|
|
|
struct ifnet *bif;
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
/*
|
|
|
|
* Check with bridging code to see how the packet
|
|
|
|
* should be handled. Possibilities are:
|
|
|
|
*
|
|
|
|
* BDG_BCAST broadcast
|
|
|
|
* BDG_MCAST multicast
|
|
|
|
* BDG_LOCAL for local address, don't forward
|
|
|
|
* BDG_DROP discard
|
|
|
|
* ifp forward only to specified interface(s)
|
|
|
|
*
|
|
|
|
* Non-local destinations are handled by passing the
|
|
|
|
* packet back to the bridge code.
|
|
|
|
*/
|
|
|
|
bif = bridge_in_ptr(ifp, eh);
|
|
|
|
if (bif == BDG_DROP) { /* discard packet */
|
2000-05-14 02:18:43 +00:00
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
2002-11-14 23:35:06 +00:00
|
|
|
if (bif != BDG_LOCAL) { /* non-local, forward */
|
|
|
|
m = bdg_forward_ptr(m, bif);
|
2000-09-24 04:08:38 +00:00
|
|
|
/*
|
2002-11-14 23:35:06 +00:00
|
|
|
* The bridge may consume the packet if it's not
|
|
|
|
* supposed to be passed up or if a problem occurred
|
|
|
|
* while doing its job. This is reflected by it
|
|
|
|
* returning a NULL mbuf pointer.
|
2000-09-24 04:08:38 +00:00
|
|
|
*/
|
2001-02-02 00:18:00 +00:00
|
|
|
if (m == NULL) {
|
2002-11-14 23:35:06 +00:00
|
|
|
if (bif == BDG_BCAST || bif == BDG_MCAST)
|
|
|
|
if_printf(ifp,
|
|
|
|
"bridge dropped %s packet\n",
|
|
|
|
bif == BDG_BCAST ? "broadcast" :
|
|
|
|
"multicast");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* But in some cases the bridge may return the
|
|
|
|
* packet for us to free; sigh.
|
|
|
|
*/
|
|
|
|
if (bif != BDG_BCAST && bif != BDG_MCAST) {
|
|
|
|
printf("ether_input: drop bdg packet, bif %p\n", bif);/*XXX*/
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
2001-02-02 00:18:00 +00:00
|
|
|
}
|
2000-09-24 04:08:38 +00:00
|
|
|
}
|
2002-10-01 15:48:31 +00:00
|
|
|
}
|
2000-05-14 02:18:43 +00:00
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
ether_demux(ifp, m);
|
2002-09-26 14:01:50 +00:00
|
|
|
/* First chunk of an mbuf contains good entropy */
|
2001-02-18 17:54:52 +00:00
|
|
|
if (harvest.ethernet)
|
|
|
|
random_harvest(m, 16, 3, 0, RANDOM_NET);
|
2000-06-26 23:34:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Upper layer processing for a received Ethernet packet.
|
|
|
|
*/
|
|
|
|
void
|
2002-11-14 23:35:06 +00:00
|
|
|
ether_demux(struct ifnet *ifp, struct mbuf *m)
|
2000-06-26 23:34:54 +00:00
|
|
|
{
|
2002-11-14 23:35:06 +00:00
|
|
|
struct ether_header *eh;
|
2000-06-26 23:34:54 +00:00
|
|
|
struct ifqueue *inq;
|
|
|
|
u_short ether_type;
|
|
|
|
#if defined(NETATALK)
|
|
|
|
register struct llc *l;
|
|
|
|
#endif
|
2002-05-13 10:37:19 +00:00
|
|
|
struct ip_fw *rule = NULL;
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
|
|
|
|
/* Extract info from dummynet tag, ignore others */
|
|
|
|
for (;m->m_type == MT_TAG; m = m->m_next)
|
|
|
|
if (m->m_flags == PACKET_TAG_DUMMYNET) {
|
|
|
|
rule = ((struct dn_pkt *)m)->rule;
|
|
|
|
ifp = m->m_next->m_pkthdr.rcvif;
|
|
|
|
}
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
KASSERT(ifp != NULL, ("ether_demux: NULL interface pointer"));
|
|
|
|
|
|
|
|
eh = mtod(m, struct ether_header *);
|
|
|
|
|
Remove (almost all) global variables that were used to hold
packet forwarding state ("annotations") during ip processing.
The code is considerably cleaner now.
The variables removed by this change are:
ip_divert_cookie used by divert sockets
ip_fw_fwd_addr used for transparent ip redirection
last_pkt used by dynamic pipes in dummynet
Removal of the first two has been done by carrying the annotations
into volatile structs prepended to the mbuf chains, and adding
appropriate code to add/remove annotations in the routines which
make use of them, i.e. ip_input(), ip_output(), tcp_input(),
bdg_forward(), ether_demux(), ether_output_frame(), div_output().
On passing, remove a bug in divert handling of fragmented packet.
Now it is the fragment at offset 0 which sets the divert status of
the whole packet, whereas formerly it was the last incoming fragment
to decide.
Removal of last_pkt required a change in the interface of ip_fw_chk()
and dummynet_io(). On passing, use the same mechanism for dummynet
annotations and for divert/forward annotations.
option IPFIREWALL_FORWARD is effectively useless, the code to
implement it is very small and is now in by default to avoid the
obfuscation of conditionally compiled code.
NOTES:
* there is at least one global variable left, sro_fwd, in ip_output().
I am not sure if/how this can be removed.
* I have deliberately avoided gratuitous style changes in this commit
to avoid cluttering the diffs. Minor stule cleanup will likely be
necessary
* this commit only focused on the IP layer. I am sure there is a
number of global variables used in the TCP and maybe UDP stack.
* despite the number of files touched, there are absolutely no API's
or data structures changed by this commit (except the interfaces of
ip_fw_chk() and dummynet_io(), which are internal anyways), so
an MFC is quite safe and unintrusive (and desirable, given the
improved readability of the code).
MFC after: 10 days
2002-06-22 11:51:02 +00:00
|
|
|
if (rule) /* packet was already bridged */
|
2002-05-13 10:37:19 +00:00
|
|
|
goto post_stats;
|
|
|
|
|
2002-10-16 09:00:53 +00:00
|
|
|
if (!(BDG_ACTIVE(ifp))) {
|
|
|
|
/*
|
|
|
|
* Discard packet if upper layers shouldn't see it because it
|
|
|
|
* was unicast to a different Ethernet address. If the driver
|
|
|
|
* is working properly, then this situation can only happen
|
|
|
|
* when the interface is in promiscuous mode.
|
|
|
|
*/
|
|
|
|
if ((ifp->if_flags & IFF_PROMISC) != 0
|
|
|
|
&& (eh->ether_dhost[0] & 1) == 0
|
|
|
|
&& bcmp(eh->ether_dhost,
|
|
|
|
IFP2AC(ifp)->ac_enaddr, ETHER_ADDR_LEN) != 0
|
|
|
|
&& (ifp->if_flags & IFF_PPROMISC) == 0) {
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
2001-02-08 17:56:49 +00:00
|
|
|
}
|
|
|
|
|
2000-05-14 02:18:43 +00:00
|
|
|
/* Discard packet if interface is not up */
|
1994-05-24 10:09:53 +00:00
|
|
|
if ((ifp->if_flags & IFF_UP) == 0) {
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
1998-03-18 01:40:12 +00:00
|
|
|
if (eh->ether_dhost[0] & 1) {
|
|
|
|
if (bcmp((caddr_t)etherbroadcastaddr, (caddr_t)eh->ether_dhost,
|
|
|
|
sizeof(etherbroadcastaddr)) == 0)
|
|
|
|
m->m_flags |= M_BCAST;
|
|
|
|
else
|
|
|
|
m->m_flags |= M_MCAST;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
if (m->m_flags & (M_BCAST|M_MCAST))
|
|
|
|
ifp->if_imcasts++;
|
|
|
|
|
2002-05-13 10:37:19 +00:00
|
|
|
post_stats:
|
2002-06-23 11:19:53 +00:00
|
|
|
if (IPFW_LOADED && ether_ipfw != 0) {
|
2002-11-14 23:35:06 +00:00
|
|
|
if (ether_ipfw_chk(&m, NULL, &rule, 0) == 0) {
|
2002-05-13 10:37:19 +00:00
|
|
|
if (m)
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
/*
|
|
|
|
* If VLANs are configured on the interface, check to
|
|
|
|
* see if the device performed the decapsulation and
|
|
|
|
* provided us with the tag.
|
|
|
|
*/
|
|
|
|
if (ifp->if_nvlans &&
|
|
|
|
m_tag_locate(m, MTAG_VLAN, MTAG_VLAN_TAG, NULL) != NULL) {
|
|
|
|
/*
|
|
|
|
* vlan_input() will either recursively call ether_input()
|
|
|
|
* or drop the packet.
|
|
|
|
*/
|
|
|
|
KASSERT(vlan_input_p != NULL,("ether_input: VLAN not loaded!"));
|
|
|
|
(*vlan_input_p)(ifp, m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
1994-11-24 14:29:38 +00:00
|
|
|
ether_type = ntohs(eh->ether_type);
|
|
|
|
|
2002-11-14 23:35:06 +00:00
|
|
|
/*
|
|
|
|
* Handle protocols that expect to have the Ethernet header
|
|
|
|
* (and possibly FCS) intact.
|
|
|
|
*/
|
|
|
|
switch (ether_type) {
|
|
|
|
case ETHERTYPE_VLAN:
|
|
|
|
if (ifp->if_nvlans != 0) {
|
|
|
|
KASSERT(vlan_input_p,("ether_input: VLAN not loaded!"));
|
|
|
|
(*vlan_input_p)(ifp, m);
|
|
|
|
} else {
|
|
|
|
ifp->if_noproto++;
|
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Strip off Ethernet header. */
|
|
|
|
m_adj(m, sizeof (struct ether_header));
|
|
|
|
|
|
|
|
/* If the CRC is still on the packet, trim it off. */
|
|
|
|
if (m->m_flags & M_HASFCS) {
|
|
|
|
m_adj(m, -ETHER_CRC_LEN);
|
|
|
|
m->m_flags &= ~M_HASFCS;
|
|
|
|
}
|
|
|
|
|
1994-11-24 14:29:38 +00:00
|
|
|
switch (ether_type) {
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef INET
|
|
|
|
case ETHERTYPE_IP:
|
1998-05-19 14:04:36 +00:00
|
|
|
if (ipflow_fastforward(m))
|
|
|
|
return;
|
1994-05-24 10:09:53 +00:00
|
|
|
schednetisr(NETISR_IP);
|
|
|
|
inq = &ipintrq;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ETHERTYPE_ARP:
|
2001-06-15 21:00:32 +00:00
|
|
|
if (ifp->if_flags & IFF_NOARP) {
|
|
|
|
/* Discard packet if ARP is disabled on interface */
|
|
|
|
m_freem(m);
|
|
|
|
return;
|
|
|
|
}
|
1994-05-24 10:09:53 +00:00
|
|
|
schednetisr(NETISR_ARP);
|
|
|
|
inq = &arpintrq;
|
|
|
|
break;
|
|
|
|
#endif
|
1995-10-26 20:31:59 +00:00
|
|
|
#ifdef IPX
|
|
|
|
case ETHERTYPE_IPX:
|
1999-12-13 16:24:22 +00:00
|
|
|
if (ef_inputp && ef_inputp(ifp, eh, m) == 0)
|
|
|
|
return;
|
1995-10-26 20:31:59 +00:00
|
|
|
schednetisr(NETISR_IPX);
|
|
|
|
inq = &ipxintrq;
|
|
|
|
break;
|
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
#ifdef INET6
|
|
|
|
case ETHERTYPE_IPV6:
|
|
|
|
schednetisr(NETISR_IPV6);
|
|
|
|
inq = &ip6intrq;
|
|
|
|
break;
|
|
|
|
#endif
|
1994-05-24 10:09:53 +00:00
|
|
|
#ifdef NS
|
1996-10-17 17:16:58 +00:00
|
|
|
case 0x8137: /* Novell Ethernet_II Ethernet TYPE II */
|
1994-05-24 10:09:53 +00:00
|
|
|
schednetisr(NETISR_NS);
|
|
|
|
inq = &nsintrq;
|
|
|
|
break;
|
1996-10-17 17:16:58 +00:00
|
|
|
|
|
|
|
#endif /* NS */
|
1996-05-24 01:35:45 +00:00
|
|
|
#ifdef NETATALK
|
|
|
|
case ETHERTYPE_AT:
|
|
|
|
schednetisr(NETISR_ATALK);
|
|
|
|
inq = &atintrq1;
|
|
|
|
break;
|
|
|
|
case ETHERTYPE_AARP:
|
|
|
|
/* probably this should be done with a NETISR as well */
|
1999-01-31 08:17:16 +00:00
|
|
|
aarpinput(IFP2AC(ifp), m); /* XXX */
|
1996-05-24 01:35:45 +00:00
|
|
|
return;
|
2001-09-10 01:33:03 +00:00
|
|
|
#endif /* NETATALK */
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
1999-12-13 16:24:22 +00:00
|
|
|
#ifdef IPX
|
|
|
|
if (ef_inputp && ef_inputp(ifp, eh, m) == 0)
|
|
|
|
return;
|
|
|
|
#endif /* IPX */
|
1996-10-17 17:16:58 +00:00
|
|
|
#ifdef NS
|
|
|
|
checksum = mtod(m, ushort *);
|
|
|
|
/* Novell 802.3 */
|
|
|
|
if ((ether_type <= ETHERMTU) &&
|
|
|
|
((*checksum == 0xffff) || (*checksum == 0xE0E0))){
|
|
|
|
if(*checksum == 0xE0E0) {
|
|
|
|
m->m_pkthdr.len -= 3;
|
|
|
|
m->m_len -= 3;
|
|
|
|
m->m_data += 3;
|
|
|
|
}
|
|
|
|
schednetisr(NETISR_NS);
|
|
|
|
inq = &nsintrq;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* NS */
|
2000-02-13 03:32:07 +00:00
|
|
|
#if defined(NETATALK)
|
1994-11-24 14:29:38 +00:00
|
|
|
if (ether_type > ETHERMTU)
|
2002-11-14 23:35:06 +00:00
|
|
|
goto discard;
|
1994-05-24 10:09:53 +00:00
|
|
|
l = mtod(m, struct llc *);
|
|
|
|
switch (l->llc_dsap) {
|
1996-05-24 01:35:45 +00:00
|
|
|
case LLC_SNAP_LSAP:
|
|
|
|
switch (l->llc_control) {
|
|
|
|
case LLC_UI:
|
|
|
|
if (l->llc_ssap != LLC_SNAP_LSAP)
|
2002-11-14 23:35:06 +00:00
|
|
|
goto discard;
|
1996-05-24 01:35:45 +00:00
|
|
|
|
|
|
|
if (Bcmp(&(l->llc_snap_org_code)[0], at_org_code,
|
|
|
|
sizeof(at_org_code)) == 0 &&
|
|
|
|
ntohs(l->llc_snap_ether_type) == ETHERTYPE_AT) {
|
|
|
|
inq = &atintrq2;
|
|
|
|
m_adj( m, sizeof( struct llc ));
|
|
|
|
schednetisr(NETISR_ATALK);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Bcmp(&(l->llc_snap_org_code)[0], aarp_org_code,
|
|
|
|
sizeof(aarp_org_code)) == 0 &&
|
|
|
|
ntohs(l->llc_snap_ether_type) == ETHERTYPE_AARP) {
|
|
|
|
m_adj( m, sizeof( struct llc ));
|
1999-01-31 08:17:16 +00:00
|
|
|
aarpinput(IFP2AC(ifp), m); /* XXX */
|
1996-05-24 01:35:45 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:
|
2002-11-14 23:35:06 +00:00
|
|
|
goto discard;
|
1996-05-24 01:35:45 +00:00
|
|
|
}
|
|
|
|
break;
|
1994-05-24 10:09:53 +00:00
|
|
|
default:
|
2002-11-14 23:35:06 +00:00
|
|
|
goto discard;
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
2000-02-13 03:32:07 +00:00
|
|
|
#else /* NETATALK */
|
2002-11-14 23:35:06 +00:00
|
|
|
goto discard;
|
2000-02-13 03:32:07 +00:00
|
|
|
#endif /* NETATALK */
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
(void) IF_HANDOFF(inq, m, NULL);
|
2002-11-14 23:35:06 +00:00
|
|
|
return;
|
|
|
|
discard:
|
|
|
|
/*
|
|
|
|
* Packet is to be discarded. If netgraph is present,
|
|
|
|
* hand the packet to it for last chance processing;
|
|
|
|
* otherwise dispose of it.
|
|
|
|
*/
|
|
|
|
if (ng_ether_input_orphan_p != NULL) {
|
|
|
|
/*
|
|
|
|
* Put back the ethernet header so netgraph has a
|
|
|
|
* consistent view of inbound packets.
|
|
|
|
*/
|
|
|
|
M_PREPEND(m, sizeof (struct ether_header), M_NOWAIT);
|
|
|
|
(*ng_ether_input_orphan_p)(ifp, m);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_freem(m);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Convert Ethernet address to printable (loggable) representation.
|
|
|
|
* This routine is for compatibility; it's better to just use
|
|
|
|
*
|
|
|
|
* printf("%6D", <pointer to address>, ":");
|
|
|
|
*
|
|
|
|
* since there's no static buffer involved.
|
|
|
|
*/
|
|
|
|
char *
|
|
|
|
ether_sprintf(const u_char *ap)
|
|
|
|
{
|
|
|
|
static char etherbuf[18];
|
|
|
|
snprintf(etherbuf, sizeof (etherbuf), "%6D", ap, ":");
|
|
|
|
return (etherbuf);
|
1994-05-24 10:09:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Perform common duties while attaching to interface list
|
|
|
|
*/
|
|
|
|
void
|
2002-11-14 23:35:06 +00:00
|
|
|
ether_ifattach(struct ifnet *ifp, const u_int8_t *llc)
|
1994-05-24 10:09:53 +00:00
|
|
|
{
|
|
|
|
register struct ifaddr *ifa;
|
|
|
|
register struct sockaddr_dl *sdl;
|
|
|
|
|
|
|
|
ifp->if_type = IFT_ETHER;
|
2002-11-14 23:35:06 +00:00
|
|
|
ifp->if_addrlen = ETHER_ADDR_LEN;
|
|
|
|
ifp->if_hdrlen = ETHER_HDR_LEN;
|
2001-10-11 05:37:59 +00:00
|
|
|
if_attach(ifp);
|
1994-05-24 10:09:53 +00:00
|
|
|
ifp->if_mtu = ETHERMTU;
|
2002-11-14 23:35:06 +00:00
|
|
|
ifp->if_output = ether_output;
|
|
|
|
ifp->if_input = ether_input;
|
1997-01-07 19:15:32 +00:00
|
|
|
ifp->if_resolvemulti = ether_resolvemulti;
|
1996-06-01 23:25:10 +00:00
|
|
|
if (ifp->if_baudrate == 0)
|
2002-11-14 23:35:06 +00:00
|
|
|
ifp->if_baudrate = IF_Mbps(10); /* just a default */
|
2001-10-14 20:17:53 +00:00
|
|
|
ifp->if_broadcastaddr = etherbroadcastaddr;
|
2002-11-14 23:35:06 +00:00
|
|
|
|
2001-09-06 02:40:43 +00:00
|
|
|
ifa = ifaddr_byindex(ifp->if_index);
|
2001-12-10 08:09:49 +00:00
|
|
|
KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__));
|
1996-12-13 21:29:07 +00:00
|
|
|
sdl = (struct sockaddr_dl *)ifa->ifa_addr;
|
|
|
|
sdl->sdl_type = IFT_ETHER;
|
|
|
|
sdl->sdl_alen = ifp->if_addrlen;
|
2002-11-14 23:35:06 +00:00
|
|
|
bcopy(llc, LLADDR(sdl), ifp->if_addrlen);
|
|
|
|
/*
|
|
|
|
* XXX: This doesn't belong here; we do it until
|
|
|
|
* XXX: all drivers are cleaned up
|
|
|
|
*/
|
|
|
|
if (llc != IFP2AC(ifp)->ac_enaddr)
|
|
|
|
bcopy(llc, IFP2AC(ifp)->ac_enaddr, ifp->if_addrlen);
|
|
|
|
|
|
|
|
bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
|
2000-06-26 23:34:54 +00:00
|
|
|
if (ng_ether_attach_p != NULL)
|
|
|
|
(*ng_ether_attach_p)(ifp);
|
2001-11-04 22:56:25 +00:00
|
|
|
if (BDG_LOADED)
|
2001-10-05 05:45:27 +00:00
|
|
|
bdgtakeifaces_ptr();
|
2000-06-26 23:34:54 +00:00
|
|
|
}
|
|
|
|
|
2000-07-13 22:54:34 +00:00
|
|
|
/*
|
|
|
|
* Perform common duties while detaching an Ethernet interface
|
|
|
|
*/
|
|
|
|
void
|
2002-11-14 23:35:06 +00:00
|
|
|
ether_ifdetach(struct ifnet *ifp)
|
2000-07-13 22:54:34 +00:00
|
|
|
{
|
|
|
|
if (ng_ether_detach_p != NULL)
|
|
|
|
(*ng_ether_detach_p)(ifp);
|
2002-11-14 23:35:06 +00:00
|
|
|
bpfdetach(ifp);
|
2000-07-13 22:54:34 +00:00
|
|
|
if_detach(ifp);
|
2001-11-04 22:56:25 +00:00
|
|
|
if (BDG_LOADED)
|
2001-10-05 05:45:27 +00:00
|
|
|
bdgtakeifaces_ptr();
|
2000-07-13 22:54:34 +00:00
|
|
|
}
|
|
|
|
|
1999-02-16 10:49:55 +00:00
|
|
|
SYSCTL_DECL(_net_link);
|
1995-12-20 21:53:53 +00:00
|
|
|
SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW, 0, "Ethernet");
|
2002-05-13 10:37:19 +00:00
|
|
|
SYSCTL_INT(_net_link_ether, OID_AUTO, ipfw, CTLFLAG_RW,
|
2002-06-23 11:19:53 +00:00
|
|
|
ðer_ipfw,0,"Pass ether pkts through firewall");
|
1996-08-04 10:54:13 +00:00
|
|
|
|
1996-12-10 07:29:50 +00:00
|
|
|
int
|
1997-12-20 00:07:11 +00:00
|
|
|
ether_ioctl(ifp, command, data)
|
|
|
|
struct ifnet *ifp;
|
|
|
|
int command;
|
|
|
|
caddr_t data;
|
1996-08-04 10:54:13 +00:00
|
|
|
{
|
|
|
|
struct ifaddr *ifa = (struct ifaddr *) data;
|
|
|
|
struct ifreq *ifr = (struct ifreq *) data;
|
1996-12-10 07:29:50 +00:00
|
|
|
int error = 0;
|
1996-08-04 10:54:13 +00:00
|
|
|
|
|
|
|
switch (command) {
|
|
|
|
case SIOCSIFADDR:
|
|
|
|
ifp->if_flags |= IFF_UP;
|
|
|
|
|
|
|
|
switch (ifa->ifa_addr->sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
ifp->if_init(ifp->if_softc); /* before arpwhohas */
|
2001-10-14 20:17:53 +00:00
|
|
|
arp_ifinit(ifp, ifa);
|
1996-08-04 10:54:13 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
#ifdef IPX
|
|
|
|
/*
|
|
|
|
* XXX - This code is probably wrong
|
|
|
|
*/
|
|
|
|
case AF_IPX:
|
|
|
|
{
|
|
|
|
register struct ipx_addr *ina = &(IA_SIPX(ifa)->sipx_addr);
|
1999-01-31 08:17:16 +00:00
|
|
|
struct arpcom *ac = IFP2AC(ifp);
|
1996-08-04 10:54:13 +00:00
|
|
|
|
|
|
|
if (ipx_nullhost(*ina))
|
|
|
|
ina->x_host =
|
1999-11-22 02:45:11 +00:00
|
|
|
*(union ipx_host *)
|
1996-08-04 11:45:37 +00:00
|
|
|
ac->ac_enaddr;
|
1996-08-04 10:54:13 +00:00
|
|
|
else {
|
|
|
|
bcopy((caddr_t) ina->x_host.c_host,
|
1996-08-04 11:45:37 +00:00
|
|
|
(caddr_t) ac->ac_enaddr,
|
|
|
|
sizeof(ac->ac_enaddr));
|
1996-08-04 10:54:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set new address
|
|
|
|
*/
|
|
|
|
ifp->if_init(ifp->if_softc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef NS
|
|
|
|
/*
|
|
|
|
* XXX - This code is probably wrong
|
|
|
|
*/
|
|
|
|
case AF_NS:
|
|
|
|
{
|
|
|
|
register struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
|
1999-01-31 08:17:16 +00:00
|
|
|
struct arpcom *ac = IFP2AC(ifp);
|
1996-08-04 10:54:13 +00:00
|
|
|
|
|
|
|
if (ns_nullhost(*ina))
|
|
|
|
ina->x_host =
|
1996-08-04 11:45:37 +00:00
|
|
|
*(union ns_host *) (ac->ac_enaddr);
|
1996-08-04 10:54:13 +00:00
|
|
|
else {
|
|
|
|
bcopy((caddr_t) ina->x_host.c_host,
|
1996-08-04 11:45:37 +00:00
|
|
|
(caddr_t) ac->ac_enaddr,
|
|
|
|
sizeof(ac->ac_enaddr));
|
1996-08-04 10:54:13 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set new address
|
|
|
|
*/
|
|
|
|
ifp->if_init(ifp->if_softc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
ifp->if_init(ifp->if_softc);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCGIFADDR:
|
|
|
|
{
|
|
|
|
struct sockaddr *sa;
|
|
|
|
|
|
|
|
sa = (struct sockaddr *) & ifr->ifr_data;
|
1999-01-31 08:17:16 +00:00
|
|
|
bcopy(IFP2AC(ifp)->ac_enaddr,
|
1996-08-04 10:54:13 +00:00
|
|
|
(caddr_t) sa->sa_data, ETHER_ADDR_LEN);
|
|
|
|
}
|
|
|
|
break;
|
1996-12-10 07:29:50 +00:00
|
|
|
|
|
|
|
case SIOCSIFMTU:
|
|
|
|
/*
|
|
|
|
* Set the interface MTU.
|
|
|
|
*/
|
|
|
|
if (ifr->ifr_mtu > ETHERMTU) {
|
|
|
|
error = EINVAL;
|
|
|
|
} else {
|
|
|
|
ifp->if_mtu = ifr->ifr_mtu;
|
|
|
|
}
|
|
|
|
break;
|
2002-11-14 23:35:06 +00:00
|
|
|
default:
|
|
|
|
error = EINVAL; /* XXX netbsd has ENOTTY??? */
|
|
|
|
break;
|
1996-08-04 10:54:13 +00:00
|
|
|
}
|
1996-12-10 07:29:50 +00:00
|
|
|
return (error);
|
1996-08-04 10:54:13 +00:00
|
|
|
}
|
1997-01-07 19:15:32 +00:00
|
|
|
|
2002-09-28 17:15:38 +00:00
|
|
|
static int
|
1997-01-07 19:15:32 +00:00
|
|
|
ether_resolvemulti(ifp, llsa, sa)
|
|
|
|
struct ifnet *ifp;
|
|
|
|
struct sockaddr **llsa;
|
|
|
|
struct sockaddr *sa;
|
|
|
|
{
|
|
|
|
struct sockaddr_dl *sdl;
|
|
|
|
struct sockaddr_in *sin;
|
1999-11-22 02:45:11 +00:00
|
|
|
#ifdef INET6
|
|
|
|
struct sockaddr_in6 *sin6;
|
|
|
|
#endif
|
1997-01-07 19:15:32 +00:00
|
|
|
u_char *e_addr;
|
|
|
|
|
|
|
|
switch(sa->sa_family) {
|
|
|
|
case AF_LINK:
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1997-07-15 23:25:32 +00:00
|
|
|
* No mapping needed. Just check that it's a valid MC address.
|
|
|
|
*/
|
1997-01-07 19:15:32 +00:00
|
|
|
sdl = (struct sockaddr_dl *)sa;
|
|
|
|
e_addr = LLADDR(sdl);
|
|
|
|
if ((e_addr[0] & 1) != 1)
|
|
|
|
return EADDRNOTAVAIL;
|
|
|
|
*llsa = 0;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
|
|
|
sin = (struct sockaddr_in *)sa;
|
|
|
|
if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr)))
|
|
|
|
return EADDRNOTAVAIL;
|
|
|
|
MALLOC(sdl, struct sockaddr_dl *, sizeof *sdl, M_IFMADDR,
|
2001-05-02 16:12:58 +00:00
|
|
|
M_WAITOK|M_ZERO);
|
1997-01-07 19:15:32 +00:00
|
|
|
sdl->sdl_len = sizeof *sdl;
|
|
|
|
sdl->sdl_family = AF_LINK;
|
|
|
|
sdl->sdl_index = ifp->if_index;
|
|
|
|
sdl->sdl_type = IFT_ETHER;
|
|
|
|
sdl->sdl_alen = ETHER_ADDR_LEN;
|
|
|
|
e_addr = LLADDR(sdl);
|
|
|
|
ETHER_MAP_IP_MULTICAST(&sin->sin_addr, e_addr);
|
|
|
|
*llsa = (struct sockaddr *)sdl;
|
|
|
|
return 0;
|
|
|
|
#endif
|
1999-11-22 02:45:11 +00:00
|
|
|
#ifdef INET6
|
|
|
|
case AF_INET6:
|
|
|
|
sin6 = (struct sockaddr_in6 *)sa;
|
2000-07-09 11:17:17 +00:00
|
|
|
if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) {
|
|
|
|
/*
|
|
|
|
* An IP6 address of 0 means listen to all
|
|
|
|
* of the Ethernet multicast address used for IP6.
|
|
|
|
* (This is used for multicast routers.)
|
|
|
|
*/
|
|
|
|
ifp->if_flags |= IFF_ALLMULTI;
|
|
|
|
*llsa = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
1999-11-22 02:45:11 +00:00
|
|
|
if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
|
|
|
|
return EADDRNOTAVAIL;
|
|
|
|
MALLOC(sdl, struct sockaddr_dl *, sizeof *sdl, M_IFMADDR,
|
2001-05-02 16:12:58 +00:00
|
|
|
M_WAITOK|M_ZERO);
|
1999-11-22 02:45:11 +00:00
|
|
|
sdl->sdl_len = sizeof *sdl;
|
|
|
|
sdl->sdl_family = AF_LINK;
|
|
|
|
sdl->sdl_index = ifp->if_index;
|
|
|
|
sdl->sdl_type = IFT_ETHER;
|
|
|
|
sdl->sdl_alen = ETHER_ADDR_LEN;
|
|
|
|
e_addr = LLADDR(sdl);
|
|
|
|
ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, e_addr);
|
|
|
|
*llsa = (struct sockaddr *)sdl;
|
|
|
|
return 0;
|
|
|
|
#endif
|
1997-01-07 19:15:32 +00:00
|
|
|
|
|
|
|
default:
|
1999-11-22 02:45:11 +00:00
|
|
|
/*
|
1997-01-07 19:15:32 +00:00
|
|
|
* Well, the text isn't quite right, but it's the name
|
|
|
|
* that counts...
|
|
|
|
*/
|
|
|
|
return EAFNOSUPPORT;
|
|
|
|
}
|
|
|
|
}
|