hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki 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> * Hilmar Linder <hlinder@cosy.sbg.ac.at>
* and Wolfram Stering <wstering@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 * This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License * modify it under the terms of the GNU General Public License
@ -42,6 +42,9 @@
* Bugfixes and robustness improvements. * Bugfixes and robustness improvements.
* Filtering on dest MAC addresses, if present (D-Bit = 0) * Filtering on dest MAC addresses, if present (D-Bit = 0)
* ULE_DEBUG compile-time option. * 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. * 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> #include <linux/module.h>
@ -89,6 +89,9 @@ static inline __u32 iov_crc32( __u32 c, struct kvec *iov, unsigned int cnt )
#ifdef ULE_DEBUG #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')) #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 ) 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_TEST 0
#define ULE_BRIDGED 1 #define ULE_BRIDGED 1
#define ULE_OPTEXTHDR_PADDING 0
static int ule_test_sndu( struct dvb_net_priv *p ) static int ule_test_sndu( struct dvb_net_priv *p )
{ {
return -1; 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 ) static int ule_bridged_sndu( struct dvb_net_priv *p )
{ {
/* BRIDGE SNDU handling sucks in draft-ietf-ipdvb-ule-03.txt. struct ethhdr *hdr = (struct ethhdr*) p->ule_next_hdr;
* This has to be the last extension header, otherwise it won't work. if(ntohs(hdr->h_proto) < 1536) {
* Blame the authors! 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; p->ule_bridged = 1;
return 0; return 0;
} }
static int ule_exthdr_padding(struct dvb_net_priv *p)
{
return 0;
}
/** Handle ULE extension headers. /** Handle ULE extension headers.
* Function is called after a successful CRC32 verification of an ULE SNDU to complete its decoding. * 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, }; { [0] = ule_test_sndu, [1] = ule_bridged_sndu, [2] = NULL, };
/* Table of optional extension header handlers. The header type is the index. */ /* 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; int ext_len = 0;
unsigned char hlen = (p->ule_sndu_type & 0x0700) >> 8; 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 */ /* Mandatory extension header */
if (ule_mandatory_ext_handlers[htype]) { if (ule_mandatory_ext_handlers[htype]) {
ext_len = ule_mandatory_ext_handlers[htype]( p ); ext_len = ule_mandatory_ext_handlers[htype]( p );
p->ule_next_hdr += ext_len; if(ext_len >= 0) {
if (! p->ule_bridged) { p->ule_next_hdr += ext_len;
p->ule_sndu_type = ntohs( *(unsigned short *)p->ule_next_hdr ); if (!p->ule_bridged) {
p->ule_next_hdr += 2; p->ule_sndu_type = ntohs(*(unsigned short *)p->ule_next_hdr);
} else { p->ule_next_hdr += 2;
p->ule_sndu_type = ntohs( *(unsigned short *)(p->ule_next_hdr + ((p->ule_dbit ? 2 : 3) * ETH_ALEN)) ); } else {
/* This assures the extension handling loop will terminate. */ 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 } else
ext_len = -1; /* SNDU has to be discarded. */ ext_len = -1; /* SNDU has to be discarded. */
} else { } else {
/* Optional extension header. Calculate the length. */ /* Optional extension header. Calculate the length. */
ext_len = hlen << 2; ext_len = hlen << 1;
/* Process the optional extension header according to its type. */ /* Process the optional extension header according to its type. */
if (ule_optional_ext_handlers[htype]) if (ule_optional_ext_handlers[htype])
(void)ule_optional_ext_handlers[htype]( p ); (void)ule_optional_ext_handlers[htype]( p );
p->ule_next_hdr += ext_len; p->ule_next_hdr += ext_len;
p->ule_sndu_type = ntohs( *(unsigned short *)p->ule_next_hdr ); p->ule_sndu_type = ntohs( *(unsigned short *)(p->ule_next_hdr-2) );
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; 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; p->ule_next_hdr = p->ule_skb->data;
do { do {
l = handle_one_ule_extension( p ); 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; 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); } 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) { if (priv->ule_skb) {
dev_kfree_skb( priv->ule_skb ); dev_kfree_skb( priv->ule_skb );
/* Prepare for next SNDU. */ /* Prepare for next SNDU. */
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++; priv->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_frame_errors++; priv->stats.rx_frame_errors++;
} }
reset_ule(priv); reset_ule(priv);
priv->need_pusi = 1; 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) { if (new_ts) {
/* Check continuity counter. */
if ((ts[3] & 0x0F) == priv->tscc) if ((ts[3] & 0x0F) == priv->tscc)
priv->tscc = (priv->tscc + 1) & 0x0F; priv->tscc = (priv->tscc + 1) & 0x0F;
else { else {
/* TS discontinuity handling: */ /* TS discontinuity handling: */
printk(KERN_WARNING "%lu: TS discontinuity: got %#x, " 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. */ /* Drop partly decoded SNDU, reset state, resync on PUSI. */
if (priv->ule_skb) { if (priv->ule_skb) {
dev_kfree_skb( priv->ule_skb ); dev_kfree_skb( priv->ule_skb );
/* Prepare for next SNDU. */ /* Prepare for next SNDU. */
// reset_ule(priv); moved to below. // reset_ule(priv); moved to below.
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++; priv->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_frame_errors++; priv->stats.rx_frame_errors++;
} }
reset_ule(priv); reset_ule(priv);
/* skip to next PUSI. */ /* skip to next PUSI. */
priv->need_pusi = 1; priv->need_pusi = 1;
ts += TS_SZ;
priv->ts_count++;
continue; continue;
} }
/* If we still have an incomplete payload, but PUSI is /* 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). */ * cells (continuity counter wrap). */
if (ts[1] & TS_PUSI) { if (ts[1] & TS_PUSI) {
if (! priv->need_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. */ /* Pointer field is invalid. Drop this TS cell and any started ULE SNDU. */
printk(KERN_WARNING "%lu: Invalid pointer " printk(KERN_WARNING "%lu: Invalid pointer "
"field: %u.\n", priv->ts_count, *from_where); "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); reset_ule(priv);
priv->need_pusi = 1; priv->need_pusi = 1;
ts += TS_SZ;
priv->ts_count++;
continue; continue;
} }
/* Skip pointer field (we're processing a /* 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) { if (priv->ule_sndu_remain > 183) {
/* Current SNDU lacks more data than there could be available in the /* Current SNDU lacks more data than there could be available in the
* current TS cell. */ * current TS cell. */
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++; priv->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_length_errors++; priv->stats.rx_length_errors++;
printk(KERN_WARNING "%lu: Expected %d more SNDU bytes, but " printk(KERN_WARNING "%lu: Expected %d more SNDU bytes, but "
"got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n", "got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n",
priv->ts_count, priv->ule_sndu_remain, ts[4], ts_remain); 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 } else
priv->ule_dbit = 0; 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. " printk(KERN_WARNING "%lu: Invalid ULE SNDU length %u. "
"Resyncing.\n", priv->ts_count, priv->ule_sndu_len); "Resyncing.\n", priv->ts_count, priv->ule_sndu_len);
priv->stats.rx_errors++;
priv->stats.rx_length_errors++;
priv->ule_sndu_len = 0; priv->ule_sndu_len = 0;
priv->need_pusi = 1; priv->need_pusi = 1;
new_ts = 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; ule_dump = 1;
#endif #endif
((struct dvb_net_priv *) dev->priv)->stats.rx_errors++; priv->stats.rx_errors++;
((struct dvb_net_priv *) dev->priv)->stats.rx_crc_errors++; priv->stats.rx_crc_errors++;
dev_kfree_skb(priv->ule_skb); dev_kfree_skb(priv->ule_skb);
} else { } else {
/* CRC32 verified OK. */ /* CRC32 verified OK. */
/* Handle ULE Extension Headers. */ u8 dest_addr[ETH_ALEN];
if (priv->ule_sndu_type < 1536) { static const u8 bc_addr[ETH_ALEN] =
/* There is an extension header. Handle it accordingly. */ { [ 0 ... ETH_ALEN-1] = 0xff };
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 );
}
/* CRC32 was OK. Remove it from skb. */ /* CRC32 was OK. Remove it from skb. */
priv->ule_skb->tail -= 4; priv->ule_skb->tail -= 4;
priv->ule_skb->len -= 4; priv->ule_skb->len -= 4;
/* Filter on receiver's destination MAC address, if present. */
if (!priv->ule_dbit) { 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 )) { * The destination MAC address is the
/* MAC addresses don't match. Drop SNDU. */ * next data in the skb. It comes
// printk( KERN_WARNING "Dropping SNDU, MAC address.\n" ); * before any extension headers.
dev_kfree_skb( priv->ule_skb ); *
* 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; goto sndu_done;
} }
if (! priv->ule_bridged) { else
skb_push( priv->ule_skb, ETH_ALEN + 2 ); {
ethh = (struct ethhdr *)priv->ule_skb->data; memcpy(dest_addr, priv->ule_skb->data, ETH_ALEN);
memcpy( ethh->h_dest, ethh->h_source, ETH_ALEN ); skb_pull(priv->ule_skb, 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. */
} }
} }
/* 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; priv->ule_bridged = 0;
/* Stuff into kernel's protocol stack. */ /* 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. */ * receive the packet anyhow. */
/* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST) /* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)
priv->ule_skb->pkt_type = PACKET_HOST; */ priv->ule_skb->pkt_type = PACKET_HOST; */
((struct dvb_net_priv *) dev->priv)->stats.rx_packets++; priv->stats.rx_packets++;
((struct dvb_net_priv *) dev->priv)->stats.rx_bytes += priv->ule_skb->len; priv->stats.rx_bytes += priv->ule_skb->len;
netif_rx(priv->ule_skb); netif_rx(priv->ule_skb);
} }
sndu_done: sndu_done:
@ -944,7 +1019,7 @@ static int dvb_net_feed_start(struct net_device *dev)
dprintk("%s: start filtering\n", __FUNCTION__); dprintk("%s: start filtering\n", __FUNCTION__);
priv->secfeed->start_filtering(priv->secfeed); priv->secfeed->start_filtering(priv->secfeed);
} else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) { } 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 */ /* we have payloads encapsulated in TS */
dprintk("%s: alloc tsfeed\n", __FUNCTION__); 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. */ /* Set netdevice pointer for ts decaps callback. */
priv->tsfeed->priv = (void *)dev; priv->tsfeed->priv = (void *)dev;
ret = priv->tsfeed->set(priv->tsfeed, priv->pid, ret = priv->tsfeed->set(priv->tsfeed,
TS_PACKET, DMX_TS_PES_OTHER, priv->pid, /* pid */
TS_PACKET, /* type */
DMX_TS_PES_OTHER, /* pes type */
32768, /* circular buffer size */ 32768, /* circular buffer size */
timeout); timeout /* timeout */
);
if (ret < 0) { if (ret < 0) {
printk("%s: could not set ts feed\n", dev->name); printk("%s: could not set ts feed\n", dev->name);