ebtables-devel Mailing List for Ethernet bridge tables (Page 11)

Brought to you by: bdschuym

ebtables-devel — Development questions, bugs, patches

You can subscribe to this list here.

2002	Jan	Feb	Mar	Apr (6)	May (9)	Jun (6)	Jul (5)	Aug (7)	Sep (13)	Oct (9)	Nov (11)	Dec (8)
2003	Jan (13)	Feb (8)	Mar (32)	Apr (21)	May (15)	Jun (7)	Jul (35)	Aug (26)	Sep (29)	Oct (13)	Nov (4)	Dec (32)
2004	Jan (2)	Feb (20)	Mar (9)	Apr	May (7)	Jun (22)	Jul (7)	Aug (6)	Sep (15)	Oct (17)	Nov (12)	Dec (16)
2005	Jan (6)	Feb (15)	Mar (17)	Apr (27)	May (13)	Jun (43)	Jul (3)	Aug (12)	Sep (16)	Oct (12)	Nov (9)	Dec (10)
2006	Jan (3)	Feb (1)	Mar (1)	Apr (4)	May	Jun (2)	Jul (15)	Aug (2)	Sep (1)	Oct (5)	Nov (5)	Dec (10)
2007	Jan (2)	Feb (14)	Mar (19)	Apr	May (1)	Jun (3)	Jul	Aug (9)	Sep (6)	Oct (7)	Nov (4)	Dec
2008	Jan (11)	Feb (43)	Mar (3)	Apr (5)	May	Jun (1)	Jul	Aug	Sep (2)	Oct (2)	Nov	Dec
2009	Jan	Feb (1)	Mar	Apr	May	Jun	Jul (1)	Aug	Sep	Oct	Nov	Dec
2010	Jan	Feb	Mar (2)	Apr (1)	May	Jun (4)	Jul (3)	Aug	Sep (2)	Oct (4)	Nov	Dec
2013	Jan	Feb	Mar	Apr	May	Jun	Jul (3)	Aug	Sep	Oct	Nov	Dec

Flat | Threaded

<< < 1 .. 9 10 11 12 13 .. 33 > >> (Page 11 of 33)

Re: [Ebtables-devel] Re: [Ebtables-user] bridge/ebtables interaction...

From: Bart De S. <bds...@pa...> - 2005-08-31 16:00:44

Op ma, 29-08-2005 te 12:04 -0700, schreef Stephen Hemminger:
> On Mon, 29 Aug 2005 19:11:39 +0000
> Bart De Schuymer <bds...@pa...> wrote:
> 
> > Op ma, 29-08-2005 te 08:55 -0700, schreef Stephen Hemminger:
> > > On Tue, 23 Aug 2005 22:08:05 +0000
> > > Bart De Schuymer <bds...@pa...> wrote:
> > > > I was wondering what happened to the plan to postpone fdb updates until
> > > > after the PF_BRIDGE/PRE_ROUTING hook. Looking in the current
> > > > net/bridge/br_input.c I don't see any changes.
> > > > Did you decide not to do this after all?
> > > > 
> > > 
> > > 2.6.12 (and 2.6.13) both don't do fdb_update until handle_frame_finish.
> > 
> > Here's a code snippet from 2.6.12.5 (same code for 2.6.13):
> > int br_handle_frame(struct net_bridge_port *p, struct sk_buff **pskb)
> > {
> > 	struct sk_buff *skb = *pskb;
> > 	const unsigned char *dest = eth_hdr(skb)->h_dest;
> > 
> > 	if (p->state == BR_STATE_DISABLED)
> > 		goto err;
> > 
> > 	if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
> > 		goto err;
> > 
> > 	if (p->state == BR_STATE_LEARNING)
> > 		br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
> > ...
> > 
> > Unless I'm not reading this correctly, the fdb update is still done at
> > the same place.
> >
> Only in the learning state which happens only during the initial
> state before frames are forwarded.  There is actually a different
> problem here, it is that the bridge filtering code doesn't really
> process frames in this early state.  It should probably do
> something like feed the packets into the ebtables code then
> drop them.  This would allow the filters to pickup these early
> packets even if they aren't going to be forwarded.

The only way to fix that is by introducing a new ebtables table, like
Jon Anderson did. The problem I had with his code is that it's not
backwards compatible and there was another fix for his problem. It's
actually possible to create a new table without breaking backwards
compatibility. The question now is where to add it. I was thinking of an
ebtables table "fdb" that is traversed inside br_fdb_update, right
before the update. It just seems a waste to make a new table just for
the learning state. Something like this would be added:

--- net/bridge/br_fdb.c.old	2005-08-31 16:05:31.213809448 +0000
+++ net/bridge/br_fdb.c	2005-08-31 16:07:50.850581432 +0000
@@ -341,6 +341,10 @@ void br_fdb_update(struct net_bridge *br
 	if (hold_time(br) == 0)
 		return;
 
+	if (br_fdb_update_hook)
+		if (!br_fdb_update_hook(pskb))
+			return;
+
 	rcu_read_lock();
 	fdb = fdb_find(head, addr);
 	if (likely(fdb)) {

What do you think?

cheers,
Bart

Re: [Ebtables-devel] Re: [Ebtables-user] bridge/ebtables interaction...

From: Stephen H. <she...@os...> - 2005-08-29 19:04:19

On Mon, 29 Aug 2005 19:11:39 +0000
Bart De Schuymer <bds...@pa...> wrote:

> Op ma, 29-08-2005 te 08:55 -0700, schreef Stephen Hemminger:
> > On Tue, 23 Aug 2005 22:08:05 +0000
> > Bart De Schuymer <bds...@pa...> wrote:
> > > I was wondering what happened to the plan to postpone fdb updates until
> > > after the PF_BRIDGE/PRE_ROUTING hook. Looking in the current
> > > net/bridge/br_input.c I don't see any changes.
> > > Did you decide not to do this after all?
> > > 
> > 
> > 2.6.12 (and 2.6.13) both don't do fdb_update until handle_frame_finish.
> 
> Here's a code snippet from 2.6.12.5 (same code for 2.6.13):
> int br_handle_frame(struct net_bridge_port *p, struct sk_buff **pskb)
> {
> 	struct sk_buff *skb = *pskb;
> 	const unsigned char *dest = eth_hdr(skb)->h_dest;
> 
> 	if (p->state == BR_STATE_DISABLED)
> 		goto err;
> 
> 	if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
> 		goto err;
> 
> 	if (p->state == BR_STATE_LEARNING)
> 		br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
> ...
> 
> Unless I'm not reading this correctly, the fdb update is still done at
> the same place.
>
Only in the learning state which happens only during the initial
state before frames are forwarded.  There is actually a different
problem here, it is that the bridge filtering code doesn't really
process frames in this early state.  It should probably do
something like feed the packets into the ebtables code then
drop them.  This would allow the filters to pickup these early
packets even if they aren't going to be forwarded.

Re: [Ebtables-devel] Re: [Ebtables-user] bridge/ebtables interaction...

From: Bart De S. <bds...@pa...> - 2005-08-29 18:56:01

Op ma, 29-08-2005 te 08:55 -0700, schreef Stephen Hemminger:
> On Tue, 23 Aug 2005 22:08:05 +0000
> Bart De Schuymer <bds...@pa...> wrote:
> > I was wondering what happened to the plan to postpone fdb updates until
> > after the PF_BRIDGE/PRE_ROUTING hook. Looking in the current
> > net/bridge/br_input.c I don't see any changes.
> > Did you decide not to do this after all?
> > 
> 
> 2.6.12 (and 2.6.13) both don't do fdb_update until handle_frame_finish.

Here's a code snippet from 2.6.12.5 (same code for 2.6.13):
int br_handle_frame(struct net_bridge_port *p, struct sk_buff **pskb)
{
	struct sk_buff *skb = *pskb;
	const unsigned char *dest = eth_hdr(skb)->h_dest;

	if (p->state == BR_STATE_DISABLED)
		goto err;

	if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
		goto err;

	if (p->state == BR_STATE_LEARNING)
		br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
...

Unless I'm not reading this correctly, the fdb update is still done at
the same place.

cheers,
Bart

Re: [Ebtables-devel] Re: [Ebtables-user] bridge/ebtables interaction...

From: Stephen H. <she...@os...> - 2005-08-29 15:55:25

On Tue, 23 Aug 2005 22:08:05 +0000
Bart De Schuymer <bds...@pa...> wrote:

> Op wo, 25-05-2005 te 14:43 -0700, schreef Stephen Hemminger:
> > This is the patch I am testing now, does it do what you want?
> > 
> > Index: bridge/net/bridge/br_input.c
> > ===================================================================
> > --- bridge.orig/net/bridge/br_input.c
> > +++ bridge/net/bridge/br_input.c
> > @@ -54,6 +54,9 @@ int br_handle_frame_finish(struct sk_buf
> >  	struct net_bridge_fdb_entry *dst;
> >  	int passedup = 0;
> >  
> > +	/* insert into forwarding database after filtering to avoid spoofing */
> > +	br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
> > +
> >  	if (br->dev->flags & IFF_PROMISC) {
> >  		struct sk_buff *skb2;
> >  
> > @@ -108,8 +111,7 @@ int br_handle_frame(struct net_bridge_po
> >  	if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
> >  		goto err;
> >  
> > -	if (p->state == BR_STATE_LEARNING ||
> > -	    p->state == BR_STATE_FORWARDING)
> > +	if (p->state == BR_STATE_LEARNING)
> >  		br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
> >  
> >  	if (p->br->stp_enabled &&
> 
> Hi Stephen,
> 
> I was wondering what happened to the plan to postpone fdb updates until
> after the PF_BRIDGE/PRE_ROUTING hook. Looking in the current
> net/bridge/br_input.c I don't see any changes.
> Did you decide not to do this after all?
> 

2.6.12 (and 2.6.13) both don't do fdb_update until handle_frame_finish.

Re: [Ebtables-devel] broute problems

From: Bart De S. <bds...@pa...> - 2005-08-23 21:59:43

Op ma, 22-08-2005 te 16:23 +0200, schreef Clifford Wolf:
> Hi,
> 
> (please let me know if this is not the right mailing list)
> 
> I'm using the broute table and have the following problem with it: It looks
> like the linux kernel bridge fdb learning mechanism is triggered before the
> broute table. So packages which are not ment for the brigde (DROPed in
> broute) are not bridged but do update the fdb entries.
> 
> In my (somehow bizare but still valid) setup this is an absolute
> showstopper bug since the linux bridge code has no support for static fdb
> entries (that would be a nice-to-have, btw ;-).
> 
> can anyone help? is this a known problem?

Yes, it's a known problem, there was a discussion on the lists some time
ago. See

http://search.gmane.org/search.php?query=bridge+ebtables+interaction&email=&group=gmane.linux.network.bridge.ebtables.user&sort=date

cheers,
Bart

Re: [Ebtables-devel] Re: [Ebtables-user] bridge/ebtables interaction...

From: Bart De S. <bds...@pa...> - 2005-08-23 21:52:42

Op wo, 25-05-2005 te 14:43 -0700, schreef Stephen Hemminger:
> This is the patch I am testing now, does it do what you want?
> 
> Index: bridge/net/bridge/br_input.c
> ===================================================================
> --- bridge.orig/net/bridge/br_input.c
> +++ bridge/net/bridge/br_input.c
> @@ -54,6 +54,9 @@ int br_handle_frame_finish(struct sk_buf
>  	struct net_bridge_fdb_entry *dst;
>  	int passedup = 0;
>  
> +	/* insert into forwarding database after filtering to avoid spoofing */
> +	br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
> +
>  	if (br->dev->flags & IFF_PROMISC) {
>  		struct sk_buff *skb2;
>  
> @@ -108,8 +111,7 @@ int br_handle_frame(struct net_bridge_po
>  	if (!is_valid_ether_addr(eth_hdr(skb)->h_source))
>  		goto err;
>  
> -	if (p->state == BR_STATE_LEARNING ||
> -	    p->state == BR_STATE_FORWARDING)
> +	if (p->state == BR_STATE_LEARNING)
>  		br_fdb_update(p->br, p, eth_hdr(skb)->h_source);
>  
>  	if (p->br->stp_enabled &&

Hi Stephen,

I was wondering what happened to the plan to postpone fdb updates until
after the PF_BRIDGE/PRE_ROUTING hook. Looking in the current
net/bridge/br_input.c I don't see any changes.
Did you decide not to do this after all?

cheers,
Bart

[Ebtables-devel] broute problems

From: Clifford W. <cli...@cl...> - 2005-08-22 14:24:10

Hi,

(please let me know if this is not the right mailing list)

I'm using the broute table and have the following problem with it: It looks
like the linux kernel bridge fdb learning mechanism is triggered before the
broute table. So packages which are not ment for the brigde (DROPed in
broute) are not bridged but do update the fdb entries.

In my (somehow bizare but still valid) setup this is an absolute
showstopper bug since the linux bridge code has no support for static fdb
entries (that would be a nice-to-have, btw ;-).

can anyone help? is this a known problem?

afaics this should be easy to solve by just moving the call to an ebtables
hook to another location, but I did not really look into the ebtables APIs
so far..

yours,
 - clifford

--
#!/usr/bin/perl
$p="1"x1002;for$c(2..1000){if($p=~/^.{$c}0/){next;};printf"%3d\%s",
$c,++$x%14?" ":"\n";while($p=~s/^((.{$c})+)1/${1}0/){}}$_="lPSFZQ".
"SJNFTZBUZ<IUUQ:;;XXX.DMJGGPSE.BU;QSJNF;>\n";y:B-Zl;:a-x M/:;print;

[Ebtables-devel] =?gb2312?B?UmU6IFJlOiBSZTogW0VidGFibGVzLXVzZXJdIEtlcm5lbCgyLjQuMjE=?= =?gb2312?B?KSBjcmFzaCBhdCBhcmNoIA==?=

From: <jg...@16...> - 2005-08-19 03:42:15
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...
 
[truncated message content]

Re: [Ebtables-devel] Vlan patch for large UDP packets

From: Bart De S. <bds...@pa...> - 2005-08-16 20:24:58

Op di, 16-08-2005 te 12:53 +0000, schreef jl...@co...:
> If you send a large UDP packet through a bridge that is running over a VLAN, the kernel will panic.  The attached patch will fix the problem.  This fix was back ported from a working 2.6 kernel.  Basically the fragments that are created in ip_fragment() need to leave room in the refragmented packets for the VLAN data.    This patch applies to the 2.4.31 kernel.

Looks ok, I'll make a new release. Didn't know I forgot to backport
it...

Thanks,
Bart

[Ebtables-devel] Vlan patch for large UDP packets

From: <jl...@co...> - 2005-08-16 12:54:14

If you send a large UDP packet through a bridge that is running over a VLAN, the kernel will panic.  The attached patch will fix the problem.  This fix was back ported from a working 2.6 kernel.  Basically the fragments that are created in ip_fragment() need to leave room in the refragmented packets for the VLAN data.    This patch applies to the 2.4.31 kernel.

- Joy Leima -

Re: [Ebtables-devel] ebtables bug ???

From: Bart De S. <bds...@pa...> - 2005-07-22 12:53:20

Op di, 19-07-2005 te 14:39 +0200, schreef julien WICQUART:
> Hello,
> 
> i'm using ebtables 2.0.6-3 (from stable debian distribution) to make a brouter.
> 
> Here are the rules used:
> $EBTABLES -t broute -A BROUTING -p ipv4 -i $INT_INTERNE --ip-dst $IP_INTERNE -j redirect \
> --redirect-target DROP
> $EBTABLES -t broute -A BROUTING -p ipv4 -i $INT_EXTERNE --ip-dst $IP_EXTERNE -j redirect \
> --redirect-target DROP
> $EBTABLES -t broute -A BROUTING -p arp -i $INT_INTERNE -d $MAC_INTERNE -j redirect \
> --redirect-target  DROP
> $EBTABLES -t broute -A BROUTING -p arp -i $INT_EXTERNE -d $MAC_EXTERNE -j redirect \
> --redirect-target DROP
> $EBTABLES -t broute -A BROUTING -p arp -i $INT_INTERNE -d broadcast --arp-ip-dst $IP_INTERNE -j \
> redirect --redirect-target DROP
> $EBTABLES -t broute -A BROUTING -p arp -i $INT_EXTERNE -d broadcast --arp-ip-dst $IP_EXTERNE -j \
> redirect --redirect-target DROP
> $EBTABLES -t broute -A BROUTING -p ipv4 -i $INT_INTERNE --ip-src $RX_INTERNE -j redirect \
> --redirect-target DROP
> 
> When i want to make an arp broadcast from this brouter with arping for example arping -B.
> 
> The kernel panic : Unable to handle kernel NULL pointer dereference at virtual address 00000170

I couldn't reproduce your bug. Please provide the oops report for more
details.
What kernel are you using?

Note that I'll be away next week and won't be able to answer any mail.

cheers,
Bart

> Could you explain me if it is a bug or an error of utilisation?

It's a bug.

cheers,
Bart

[Ebtables-devel] [2.6 patch] BRIDGE_EBT_ARPREPLY must depend on INET

From: Adrian B. <bu...@st...> - 2005-07-19 21:32:29

BRIDGE_EBT_ARPREPLY=y and INET=n results in the following compile error:

<--  snip  -->

...
  LD      .tmp_vmlinux1
net/built-in.o: In function `ebt_target_reply':
ebt_arpreply.c:(.text+0x68fb9): undefined reference to `arp_send'
make: *** [.tmp_vmlinux1] Error 1

<--  snip  -->

Signed-off-by: Adrian Bunk <bu...@st...>

--- linux-2.6.13-rc3-mm1-full/net/bridge/netfilter/Kconfig.old	2005-07-19 08:48:41.000000000 +0200
+++ linux-2.6.13-rc3-mm1-full/net/bridge/netfilter/Kconfig	2005-07-19 08:49:20.000000000 +0200
@@ -138,7 +138,7 @@
 #
 config BRIDGE_EBT_ARPREPLY
 	tristate "ebt: arp reply target support"
-	depends on BRIDGE_NF_EBTABLES
+	depends on BRIDGE_NF_EBTABLES && INET
 	help
 	  This option adds the arp reply target, which allows
 	  automatically sending arp replies to arp requests.

-
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to maj...@vg...
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

[Ebtables-devel] ebtables bug ???

From: julien W. <j.w...@ne...> - 2005-07-19 12:40:20

Hello,

i'm using ebtables 2.0.6-3 (from stable debian distribution) to make a brouter.

Here are the rules used:
$EBTABLES -t broute -A BROUTING -p ipv4 -i $INT_INTERNE --ip-dst $IP_INTERNE -j redirect \
--redirect-target DROP
$EBTABLES -t broute -A BROUTING -p ipv4 -i $INT_EXTERNE --ip-dst $IP_EXTERNE -j redirect \
--redirect-target DROP
$EBTABLES -t broute -A BROUTING -p arp -i $INT_INTERNE -d $MAC_INTERNE -j redirect \
--redirect-target  DROP
$EBTABLES -t broute -A BROUTING -p arp -i $INT_EXTERNE -d $MAC_EXTERNE -j redirect \
--redirect-target DROP
$EBTABLES -t broute -A BROUTING -p arp -i $INT_INTERNE -d broadcast --arp-ip-dst $IP_INTERNE -j \
redirect --redirect-target DROP
$EBTABLES -t broute -A BROUTING -p arp -i $INT_EXTERNE -d broadcast --arp-ip-dst $IP_EXTERNE -j \
redirect --redirect-target DROP
$EBTABLES -t broute -A BROUTING -p ipv4 -i $INT_INTERNE --ip-src $RX_INTERNE -j redirect \
--redirect-target DROP

When i want to make an arp broadcast from this brouter with arping for example arping -B.

The kernel panic : Unable to handle kernel NULL pointer dereference at virtual address 00000170

Could you explain me if it is a bug or an error of utilisation?

Here's the /etc/network/interfaces file:
# The loopback network interface
auto lo
iface lo inet loopback
auto br0
iface br0 inet static
        address 0.0.0.0
        netmask 0.0.0.0
        bridge_bridgeprio 10001
        bridge_ports all
        bridge_stp on
        bridge_maxwait 0
        bridge_fd 5

auto eth0
iface eth0 inet static
        address 10.50.22.102
        netmask 255.255.255.0
        network 10.50.22.0
        broadcast 10.50.22.255
        gateway 10.50.22.254
        dns-nameservers 10.50.22.254
        dns-search interne

auto eth1
iface eth1 inet static
        address 10.70.12.102
        netmask 255.255.255.0
        network 10.70.12.0
        broadcast 10.70.12.255

Thanks.

-- 

--
Julien WICQUART				NEWTECH MULTIMEDIA
Responsable Exploitation		3 ch du Pigeonnier de la Cépière
Tel: +33 5 61 43 14 80			31081 TOULOUSE
Gsm: +33 6 88 17 16 30			http://www.newtech.fr/
Fax: +33 5 61 43 20 11
j.w...@ne...