dect
/
linux-2.6
Archived
13
0
Fork 0
Code Releases Activity

V4L/DVB (3966): Core: ULE fixes and RFC4326 additions 

Fix some problems regarding support for Unidirectional Lightweight
Encapsulation (ULE) in dvbnet.c.
The original ULE code was based on a draft.  In the meantime, ULE has been
published in RFC 4326 (ftp://ftp.rfc-editor.org/in-notes/rfc4326.txt).
With these fixes, and some additions (which are included in the patch), the
decaps code should now be complient to RFC4326.

Signed-off-by: Christian Praehauser <cpraehaus@cosy.sbg.ac.at>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
This commit is contained in:
Christian Praehauser 2006-05-22 10:31:47 -03:00 committed by Mauro Carvalho Chehab
parent adcb0fa250
commit 18232ca61b
1 changed files with 156 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

234
drivers/media/dvb/dvb-core/dvb_net.c
View File

@ -12,7 +12,7 @@
* Hilmar Linder <hlinder@cosy.sbg.ac.at>
* and Wolfram Stering <wstering@cosy.sbg.ac.at>
*
* ULE Decaps according to draft-ietf-ipdvb-ule-03.txt.
* ULE Decaps according to RFC 4326.
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
@ -42,6 +42,9 @@
* Bugfixes and robustness improvements.
* Filtering on dest MAC addresses, if present (D-Bit = 0)
* ULE_DEBUG compile-time option.
* Apr 2006: cp v3: Bugfixes and compliency with RFC 4326 (ULE) by
* Christian Praehauser <cpraehaus@cosy.sbg.ac.at>,
* Paris Lodron University of Salzburg.
*/
/*
@ -49,9 +52,6 @@
*
* Unloading does not work for 2.6.9 kernels: a refcount doesn't go to zero.
*
* TS_FEED callback is called once for every single TS cell although it is
* registered (in dvb_net_feed_start()) for 100 TS cells (used for dvb_net_ule()).
*
*/
#include <linux/module.h>
@ -89,6 +89,9 @@ static inline __u32 iov_crc32( __u32 c, struct kvec *iov, unsigned int cnt )
#ifdef ULE_DEBUG
#define MAC_ADDR_PRINTFMT "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x"
#define MAX_ADDR_PRINTFMT_ARGS(macap) (macap)[0],(macap)[1],(macap)[2],(macap)[3],(macap)[4],(macap)[5]
#define isprint(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
static void hexdump( const unsigned char *buf, unsigned short len )
@ -214,6 +217,8 @@ static unsigned short dvb_net_eth_type_trans(struct sk_buff *skb,
#define ULE_TEST 0
#define ULE_BRIDGED 1
#define ULE_OPTEXTHDR_PADDING 0
static int ule_test_sndu( struct dvb_net_priv *p )
{
return -1;
@ -221,14 +226,28 @@ static int ule_test_sndu( struct dvb_net_priv *p )
static int ule_bridged_sndu( struct dvb_net_priv *p )
{
/* BRIDGE SNDU handling sucks in draft-ietf-ipdvb-ule-03.txt.
* This has to be the last extension header, otherwise it won't work.
* Blame the authors!
struct ethhdr *hdr = (struct ethhdr*) p->ule_next_hdr;
if(ntohs(hdr->h_proto) < 1536) {
int framelen = p->ule_sndu_len - ((p->ule_next_hdr+sizeof(struct ethhdr)) - p->ule_skb->data);
/* A frame Type < 1536 for a bridged frame, introduces a LLC Length field. */
if(framelen != ntohs(hdr->h_proto)) {
return -1;
}
}
/* Note:
* From RFC4326:
* "A bridged SNDU is a Mandatory Extension Header of Type 1.
* It must be the final (or only) extension header specified in the header chain of a SNDU."
* The 'ule_bridged' flag will cause the extension header processing loop to terminate.
*/
p->ule_bridged = 1;
return 0;
}
static int ule_exthdr_padding(struct dvb_net_priv *p)
{
return 0;
}
/** Handle ULE extension headers.
* Function is called after a successful CRC32 verification of an ULE SNDU to complete its decoding.
@ -242,7 +261,8 @@ static int handle_one_ule_extension( struct dvb_net_priv *p )
{ [0] = ule_test_sndu, [1] = ule_bridged_sndu, [2] = NULL, };
/* Table of optional extension header handlers. The header type is the index. */
static int (*ule_optional_ext_handlers[255])( struct dvb_net_priv *p ) = { NULL, };
static int (*ule_optional_ext_handlers[255])( struct dvb_net_priv *p ) =
{ [0] = ule_exthdr_padding, [1] = NULL, };
int ext_len = 0;
unsigned char hlen = (p->ule_sndu_type & 0x0700) >> 8;
@ -253,25 +273,31 @@ static int handle_one_ule_extension( struct dvb_net_priv *p )
/* Mandatory extension header */
if (ule_mandatory_ext_handlers[htype]) {
ext_len = ule_mandatory_ext_handlers[htype]( p );
p->ule_next_hdr += ext_len;
if (! p->ule_bridged) {
p->ule_sndu_type = ntohs( *(unsigned short *)p->ule_next_hdr );
p->ule_next_hdr += 2;
} else {
p->ule_sndu_type = ntohs( *(unsigned short *)(p->ule_next_hdr + ((p->ule_dbit ? 2 : 3) * ETH_ALEN)) );
/* This assures the extension handling loop will terminate. */
if(ext_len >= 0) {
p->ule_next_hdr += ext_len;
if (!p->ule_bridged) {
p->ule_sndu_type = ntohs(*(unsigned short *)p->ule_next_hdr);
p->ule_next_hdr += 2;
} else {
p->ule_sndu_type = ntohs(*(unsigned short *)(p->ule_next_hdr + ((p->ule_dbit ? 2 : 3) * ETH_ALEN)));
/* This assures the extension handling loop will terminate. */
}
}
// else: extension handler failed or SNDU should be discarded
} else
ext_len = -1; /* SNDU has to be discarded. */
} else {
/* Optional extension header. Calculate the length. */
ext_len = hlen << 2;
ext_len = hlen << 1;
/* Process the optional extension header according to its type. */
if (ule_optional_ext_handlers[htype])
(void)ule_optional_ext_handlers[htype]( p );
p->ule_next_hdr += ext_len;
p->ule_sndu_type = ntohs( *(unsigned short *)p->ule_next_hdr );
p->ule_next_hdr += 2;
p->ule_sndu_type = ntohs( *(unsigned short *)(p->ule_next_hdr-2) );
/*
* note: the length of the next header type is included in the
* length of THIS optional extension header
*/
}
return ext_len;
@ -284,8 +310,14 @@ static int handle_ule_extensions( struct dvb_net_priv *p )
p->ule_next_hdr = p->ule_skb->data;
do {
l = handle_one_ule_extension( p );
if (l == -1) return -1; /* Stop extension header processing and discard SNDU. */
if (l < 0)
return l; /* Stop extension header processing and discard SNDU. */
total_ext_len += l;
#ifdef ULE_DEBUG
dprintk("handle_ule_extensions: ule_next_hdr=%p, ule_sndu_type=%i, "
"l=%i, total_ext_len=%i\n", p->ule_next_hdr,
(int) p->ule_sndu_type, l, total_ext_len);
#endif
} while (p->ule_sndu_type < 1536);
@ -355,8 +387,8 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
if (priv->ule_skb) {
dev_kfree_skb( priv->ule_skb );
/* Prepare for next SNDU. */
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_frame_errors++;
priv->stats.rx_errors++;
priv->stats.rx_frame_errors++;
}
reset_ule(priv);
priv->need_pusi = 1;
@ -396,27 +428,25 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
}
}
/* Check continuity counter. */
if (new_ts) {
/* Check continuity counter. */
if ((ts[3] & 0x0F) == priv->tscc)
priv->tscc = (priv->tscc + 1) & 0x0F;
else {
/* TS discontinuity handling: */
printk(KERN_WARNING "%lu: TS discontinuity: got %#x, "
"exptected %#x.\n", priv->ts_count, ts[3] & 0x0F, priv->tscc);
"expected %#x.\n", priv->ts_count, ts[3] & 0x0F, priv->tscc);
/* Drop partly decoded SNDU, reset state, resync on PUSI. */
if (priv->ule_skb) {
dev_kfree_skb( priv->ule_skb );
/* Prepare for next SNDU. */
// reset_ule(priv); moved to below.
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_frame_errors++;
priv->stats.rx_errors++;
priv->stats.rx_frame_errors++;
}
reset_ule(priv);
/* skip to next PUSI. */
priv->need_pusi = 1;
ts += TS_SZ;
priv->ts_count++;
continue;
}
/* If we still have an incomplete payload, but PUSI is
@ -425,7 +455,7 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
* cells (continuity counter wrap). */
if (ts[1] & TS_PUSI) {
if (! priv->need_pusi) {
if (*from_where > 181) {
if (!(*from_where < (ts_remain-1)) || *from_where != priv->ule_sndu_remain) {
/* Pointer field is invalid. Drop this TS cell and any started ULE SNDU. */
printk(KERN_WARNING "%lu: Invalid pointer "
"field: %u.\n", priv->ts_count, *from_where);
@ -438,8 +468,6 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
}
reset_ule(priv);
priv->need_pusi = 1;
ts += TS_SZ;
priv->ts_count++;
continue;
}
/* Skip pointer field (we're processing a
@ -452,8 +480,8 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
if (priv->ule_sndu_remain > 183) {
/* Current SNDU lacks more data than there could be available in the
* current TS cell. */
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_length_errors++;
priv->stats.rx_errors++;
priv->stats.rx_length_errors++;
printk(KERN_WARNING "%lu: Expected %d more SNDU bytes, but "
"got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n",
priv->ts_count, priv->ule_sndu_remain, ts[4], ts_remain);
@ -492,9 +520,11 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
} else
priv->ule_dbit = 0;
if (priv->ule_sndu_len > 32763) {
if (priv->ule_sndu_len < 5) {
printk(KERN_WARNING "%lu: Invalid ULE SNDU length %u. "
"Resyncing.\n", priv->ts_count, priv->ule_sndu_len);
priv->stats.rx_errors++;
priv->stats.rx_length_errors++;
priv->ule_sndu_len = 0;
priv->need_pusi = 1;
new_ts = 1;
@ -608,58 +638,103 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
ule_dump = 1;
#endif
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_crc_errors++;
priv->stats.rx_errors++;
priv->stats.rx_crc_errors++;
dev_kfree_skb(priv->ule_skb);
} else {
/* CRC32 verified OK. */
/* Handle ULE Extension Headers. */
if (priv->ule_sndu_type < 1536) {
/* There is an extension header. Handle it accordingly. */
int l = handle_ule_extensions( priv );
if (l < 0) {
/* Mandatory extension header unknown or TEST SNDU. Drop it. */
// printk( KERN_WARNING "Dropping SNDU, extension headers.\n" );
dev_kfree_skb( priv->ule_skb );
goto sndu_done;
}
skb_pull( priv->ule_skb, l );
}
u8 dest_addr[ETH_ALEN];
static const u8 bc_addr[ETH_ALEN] =
{ [ 0 ... ETH_ALEN-1] = 0xff };
/* CRC32 was OK. Remove it from skb. */
priv->ule_skb->tail -= 4;
priv->ule_skb->len -= 4;
/* Filter on receiver's destination MAC address, if present. */
if (!priv->ule_dbit) {
/* The destination MAC address is the next data in the skb. */
if (memcmp( priv->ule_skb->data, dev->dev_addr, ETH_ALEN )) {
/* MAC addresses don't match. Drop SNDU. */
// printk( KERN_WARNING "Dropping SNDU, MAC address.\n" );
dev_kfree_skb( priv->ule_skb );
/*
* The destination MAC address is the
* next data in the skb. It comes
* before any extension headers.
*
* Check if the payload of this SNDU
* should be passed up the stack.
*/
register int drop = 0;
if (priv->rx_mode != RX_MODE_PROMISC) {
if (priv->ule_skb->data[0] & 0x01) {
/* multicast or broadcast */
if (memcmp(priv->ule_skb->data, bc_addr, ETH_ALEN)) {
/* multicast */
if (priv->rx_mode == RX_MODE_MULTI) {
int i;
for(i = 0; i < priv->multi_num && memcmp(priv->ule_skb->data, priv->multi_macs[i], ETH_ALEN); i++)
;
if (i == priv->multi_num)
drop = 1;
} else if (priv->rx_mode != RX_MODE_ALL_MULTI)
drop = 1; /* no broadcast; */
/* else: all multicast mode: accept all multicast packets */
}
/* else: broadcast */
}
else if (memcmp(priv->ule_skb->data, dev->dev_addr, ETH_ALEN))
drop = 1;
/* else: destination address matches the MAC address of our receiver device */
}
/* else: promiscious mode; pass everything up the stack */
if (drop) {
#ifdef ULE_DEBUG
dprintk("Dropping SNDU: MAC destination address does not match: dest addr: "MAC_ADDR_PRINTFMT", dev addr: "MAC_ADDR_PRINTFMT"\n",
MAX_ADDR_PRINTFMT_ARGS(priv->ule_skb->data), MAX_ADDR_PRINTFMT_ARGS(dev->dev_addr));
#endif
dev_kfree_skb(priv->ule_skb);
goto sndu_done;
}
if (! priv->ule_bridged) {
skb_push( priv->ule_skb, ETH_ALEN + 2 );
ethh = (struct ethhdr *)priv->ule_skb->data;
memcpy( ethh->h_dest, ethh->h_source, ETH_ALEN );
memset( ethh->h_source, 0, ETH_ALEN );
ethh->h_proto = htons( priv->ule_sndu_type );
} else {
/* Skip the Receiver destination MAC address. */
skb_pull( priv->ule_skb, ETH_ALEN );
}
} else {
if (! priv->ule_bridged) {
skb_push( priv->ule_skb, ETH_HLEN );
ethh = (struct ethhdr *)priv->ule_skb->data;
memcpy( ethh->h_dest, dev->dev_addr, ETH_ALEN );
memset( ethh->h_source, 0, ETH_ALEN );
ethh->h_proto = htons( priv->ule_sndu_type );
} else {
/* skb is in correct state; nothing to do. */
else
{
memcpy(dest_addr, priv->ule_skb->data, ETH_ALEN);
skb_pull(priv->ule_skb, ETH_ALEN);
}
}
/* Handle ULE Extension Headers. */
if (priv->ule_sndu_type < 1536) {
/* There is an extension header. Handle it accordingly. */
int l = handle_ule_extensions(priv);
if (l < 0) {
/* Mandatory extension header unknown or TEST SNDU. Drop it. */
// printk( KERN_WARNING "Dropping SNDU, extension headers.\n" );
dev_kfree_skb(priv->ule_skb);
goto sndu_done;
}
skb_pull(priv->ule_skb, l);
}
/*
* Construct/assure correct ethernet header.
* Note: in bridged mode (priv->ule_bridged !=
* 0) we already have the (original) ethernet
* header at the start of the payload (after
* optional dest. address and any extension
* headers).
*/
if (!priv->ule_bridged) {
skb_push(priv->ule_skb, ETH_HLEN);
ethh = (struct ethhdr *)priv->ule_skb->data;
if (!priv->ule_dbit) {
/* dest_addr buffer is only valid if priv->ule_dbit == 0 */
memcpy(ethh->h_dest, dest_addr, ETH_ALEN);
memset(ethh->h_source, 0, ETH_ALEN);
}
else /* zeroize source and dest */
memset( ethh, 0, ETH_ALEN*2 );
ethh->h_proto = htons(priv->ule_sndu_type);
}
/* else: skb is in correct state; nothing to do. */
priv->ule_bridged = 0;
/* Stuff into kernel's protocol stack. */
@ -668,8 +743,8 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
* receive the packet anyhow. */
/* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)
priv->ule_skb->pkt_type = PACKET_HOST; */
((struct dvb_net_priv *) dev->priv)->stats.rx_packets++;
((struct dvb_net_priv *) dev->priv)->stats.rx_bytes += priv->ule_skb->len;
priv->stats.rx_packets++;
priv->stats.rx_bytes += priv->ule_skb->len;
netif_rx(priv->ule_skb);
}
sndu_done:
@ -944,7 +1019,7 @@ static int dvb_net_feed_start(struct net_device *dev)
dprintk("%s: start filtering\n", __FUNCTION__);
priv->secfeed->start_filtering(priv->secfeed);
} else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {
struct timespec timeout = { 0, 30000000 }; // 30 msec
struct timespec timeout = { 0, 10000000 }; // 10 msec
/* we have payloads encapsulated in TS */
dprintk("%s: alloc tsfeed\n", __FUNCTION__);
@ -956,10 +1031,13 @@ static int dvb_net_feed_start(struct net_device *dev)
/* Set netdevice pointer for ts decaps callback. */
priv->tsfeed->priv = (void *)dev;
ret = priv->tsfeed->set(priv->tsfeed, priv->pid,
TS_PACKET, DMX_TS_PES_OTHER,
ret = priv->tsfeed->set(priv->tsfeed,
priv->pid, /* pid */
TS_PACKET, /* type */
DMX_TS_PES_OTHER, /* pes type */
32768, /* circular buffer size */
timeout);
timeout /* timeout */
);
if (ret < 0) {
printk("%s: could not set ts feed\n", dev->name);