iv/linux
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[media] dvb_net: prepare to split a very complex function

Browse Source 
The dvb_net code has a really complex function, meant to handle
DVB network packages: it is long, has several loops and ifs
inside, and even cause warnings with gcc5.

Prepare it to be split into smaller functions by storing all
arguments and internal vars inside a struct.

Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
This commit is contained in:
Mauro Carvalho Chehab 2016-11-19 12:56:58 -02:00
parent 4cc5bed1ca
commit efb9ab6725
1 changed files with 245 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -311,323 +311,348 @@ static inline void reset_ule( struct dvb_net_priv *p )
* Decode ULE SNDUs according to draft-ietf-ipdvb-ule-03.txt from a sequence of * Decode ULE SNDUs according to draft-ietf-ipdvb-ule-03.txt from a sequence of
* TS cells of a single PID. * TS cells of a single PID.
*/ */
static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
{
struct dvb_net_priv *priv = netdev_priv(dev);
unsigned long skipped = 0L;
const u8 *ts, *ts_end, *from_where = NULL;
u8 ts_remain = 0, how_much = 0, new_ts = 1;
struct ethhdr *ethh = NULL;
bool error = false;
struct dvb_net_ule_handle {
struct net_device *dev;
struct dvb_net_priv *priv;
struct ethhdr *ethh;
const u8 *buf;
size_t buf_len;
unsigned long skipped;
const u8 *ts, *ts_end, *from_where;
u8 ts_remain, how_much, new_ts;
bool error;
#ifdef ULE_DEBUG #ifdef ULE_DEBUG
/* The code inside ULE_DEBUG keeps a history of the last 100 TS cells processed. */ /*
* The code inside ULE_DEBUG keeps a history of the
* last 100 TS cells processed.
*/
static unsigned char ule_hist[100*TS_SZ]; static unsigned char ule_hist[100*TS_SZ];
static unsigned char *ule_where = ule_hist, ule_dump; static unsigned char *ule_where = ule_hist, ule_dump;
#endif #endif
};
static void dvb_net_ule(struct net_device *dev, const u8 *buf, size_t buf_len)
{
struct dvb_net_ule_handle h = {
.dev = dev,
.buf = buf,
.buf_len = buf_len,
.skipped = 0L,
.ts = NULL,
.ts_end = NULL,
.from_where = NULL,
.ts_remain = 0,
.how_much = 0,
.new_ts = 1,
.ethh = NULL,
.error = false,
#ifdef ULE_DEBUG
.ule_where = ule_hist,
#endif
};
/* For all TS cells in current buffer. /* For all TS cells in current buffer.
* Appearently, we are called for every single TS cell. * Appearently, we are called for every single TS cell.
*/ */
for (ts = buf, ts_end = buf + buf_len; ts < ts_end; /* no default incr. */ ) { for (h.ts = h.buf, h.ts_end = h.buf + h.buf_len; h.ts < h.ts_end; /* no incr. */ ) {
if (h.new_ts) {
if (new_ts) {
/* We are about to process a new TS cell. */ /* We are about to process a new TS cell. */
#ifdef ULE_DEBUG #ifdef ULE_DEBUG
if (ule_where >= &ule_hist[100*TS_SZ]) ule_where = ule_hist; if (h.ule_where >= &h.ule_hist[100*TS_SZ]) h.ule_where = h.ule_hist;
memcpy( ule_where, ts, TS_SZ ); memcpy( h.ule_where, h.ts, TS_SZ );
if (ule_dump) { if (h.ule_dump) {
hexdump( ule_where, TS_SZ ); hexdump( h.ule_where, TS_SZ );
ule_dump = 0; h.ule_dump = 0;
} }
ule_where += TS_SZ; h.ule_where += TS_SZ;
#endif #endif
/* Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control . */ /* Check TS h.error conditions: sync_byte, transport_error_indicator, scrambling_control . */
if ((ts[0] != TS_SYNC) || (ts[1] & TS_TEI) || ((ts[3] & TS_SC) != 0)) { if ((h.ts[0] != TS_SYNC) || (h.ts[1] & TS_TEI) || ((h.ts[3] & TS_SC) != 0)) {
pr_warn("%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n", pr_warn("%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
priv->ts_count, ts[0], h.priv->ts_count, h.ts[0],
(ts[1] & TS_TEI) >> 7, (h.ts[1] & TS_TEI) >> 7,
(ts[3] & TS_SC) >> 6); (h.ts[3] & TS_SC) >> 6);
/* Drop partly decoded SNDU, reset state, resync on PUSI. */ /* Drop partly decoded SNDU, reset state, resync on PUSI. */
if (priv->ule_skb) { if (h.priv->ule_skb) {
dev_kfree_skb( priv->ule_skb ); dev_kfree_skb( h.priv->ule_skb );
/* Prepare for next SNDU. */ /* Prepare for next SNDU. */
dev->stats.rx_errors++; h.dev->stats.rx_errors++;
dev->stats.rx_frame_errors++; h.dev->stats.rx_frame_errors++;
} }
reset_ule(priv); reset_ule(h.priv);
priv->need_pusi = 1; h.priv->need_pusi = 1;
/* Continue with next TS cell. */ /* Continue with next TS cell. */
ts += TS_SZ; h.ts += TS_SZ;
priv->ts_count++; h.priv->ts_count++;
continue; continue;
} }
ts_remain = 184; h.ts_remain = 184;
from_where = ts + 4; h.from_where = h.ts + 4;
} }
/* Synchronize on PUSI, if required. */ /* Synchronize on PUSI, if required. */
if (priv->need_pusi) { if (h.priv->need_pusi) {
if (ts[1] & TS_PUSI) { if (h.ts[1] & TS_PUSI) {
/* Find beginning of first ULE SNDU in current TS cell. */ /* Find beginning of first ULE SNDU in current TS cell. */
/* Synchronize continuity counter. */ /* Synchronize continuity counter. */
priv->tscc = ts[3] & 0x0F; h.priv->tscc = h.ts[3] & 0x0F;
/* There is a pointer field here. */ /* There is a pointer field here. */
if (ts[4] > ts_remain) { if (h.ts[4] > h.ts_remain) {
pr_err("%lu: Invalid ULE packet (pointer field %d)\n", pr_err("%lu: Invalid ULE packet (pointer field %d)\n",
priv->ts_count, ts[4]); h.priv->ts_count, h.ts[4]);
ts += TS_SZ; h.ts += TS_SZ;
priv->ts_count++; h.priv->ts_count++;
continue; continue;
} }
/* Skip to destination of pointer field. */ /* Skip to destination of pointer field. */
from_where = &ts[5] + ts[4]; h.from_where = &h.ts[5] + h.ts[4];
ts_remain -= 1 + ts[4]; h.ts_remain -= 1 + h.ts[4];
skipped = 0; h.skipped = 0;
} else { } else {
skipped++; h.skipped++;
ts += TS_SZ; h.ts += TS_SZ;
priv->ts_count++; h.priv->ts_count++;
continue; continue;
} }
} }
if (new_ts) { if (h.new_ts) {
/* Check continuity counter. */ /* Check continuity counter. */
if ((ts[3] & 0x0F) == priv->tscc) if ((h.ts[3] & 0x0F) == h.priv->tscc)
priv->tscc = (priv->tscc + 1) & 0x0F; h.priv->tscc = (h.priv->tscc + 1) & 0x0F;
else { else {
/* TS discontinuity handling: */ /* TS discontinuity handling: */
pr_warn("%lu: TS discontinuity: got %#x, expected %#x.\n", pr_warn("%lu: TS discontinuity: got %#x, expected %#x.\n",
priv->ts_count, ts[3] & 0x0F, h.priv->ts_count, h.ts[3] & 0x0F,
priv->tscc); h.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 (h.priv->ule_skb) {
dev_kfree_skb( priv->ule_skb ); dev_kfree_skb( h.priv->ule_skb );
/* Prepare for next SNDU. */ /* Prepare for next SNDU. */
// reset_ule(priv); moved to below. // reset_ule(h.priv); moved to below.
dev->stats.rx_errors++; h.dev->stats.rx_errors++;
dev->stats.rx_frame_errors++; h.dev->stats.rx_frame_errors++;
} }
reset_ule(priv); reset_ule(h.priv);
/* skip to next PUSI. */ /* skip to next PUSI. */
priv->need_pusi = 1; h.priv->need_pusi = 1;
continue; continue;
} }
/* If we still have an incomplete payload, but PUSI is /* If we still have an incomplete payload, but PUSI is
* set; some TS cells are missing. * set; some TS cells are missing.
* This is only possible here, if we missed exactly 16 TS * This is only possible here, if we missed exactly 16 TS
* cells (continuity counter wrap). */ * cells (continuity counter wrap). */
if (ts[1] & TS_PUSI) { if (h.ts[1] & TS_PUSI) {
if (! priv->need_pusi) { if (! h.priv->need_pusi) {
if (!(*from_where < (ts_remain-1)) || *from_where != priv->ule_sndu_remain) { if (!(*h.from_where < (h.ts_remain-1)) || *h.from_where != h.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. */
pr_warn("%lu: Invalid pointer field: %u.\n", pr_warn("%lu: Invalid pointer field: %u.\n",
priv->ts_count, h.priv->ts_count,
*from_where); *h.from_where);
/* Drop partly decoded SNDU, reset state, resync on PUSI. */ /* Drop partly decoded SNDU, reset state, resync on PUSI. */
if (priv->ule_skb) { if (h.priv->ule_skb) {
error = true; h.error = true;
dev_kfree_skb(priv->ule_skb); dev_kfree_skb(h.priv->ule_skb);
} }
if (error || priv->ule_sndu_remain) { if (h.error || h.priv->ule_sndu_remain) {
dev->stats.rx_errors++; h.dev->stats.rx_errors++;
dev->stats.rx_frame_errors++; h.dev->stats.rx_frame_errors++;
error = false; h.error = false;
} }
reset_ule(priv); reset_ule(h.priv);
priv->need_pusi = 1; h.priv->need_pusi = 1;
continue; continue;
} }
/* Skip pointer field (we're processing a /* Skip pointer field (we're processing a
* packed payload). */ * packed payload). */
from_where += 1; h.from_where += 1;
ts_remain -= 1; h.ts_remain -= 1;
} else } else
priv->need_pusi = 0; h.priv->need_pusi = 0;
if (priv->ule_sndu_remain > 183) { if (h.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. */
dev->stats.rx_errors++; h.dev->stats.rx_errors++;
dev->stats.rx_length_errors++; h.dev->stats.rx_length_errors++;
pr_warn("%lu: Expected %d more SNDU bytes, but got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n", pr_warn("%lu: Expected %d more SNDU bytes, but got PUSI (pf %d, h.ts_remain %d). Flushing incomplete payload.\n",
priv->ts_count, h.priv->ts_count,
priv->ule_sndu_remain, h.priv->ule_sndu_remain,
ts[4], ts_remain); h.ts[4], h.ts_remain);
dev_kfree_skb(priv->ule_skb); dev_kfree_skb(h.priv->ule_skb);
/* Prepare for next SNDU. */ /* Prepare for next SNDU. */
reset_ule(priv); reset_ule(h.priv);
/* Resync: go to where pointer field points to: start of next ULE SNDU. */ /* Resync: go to where pointer field points to: start of next ULE SNDU. */
from_where += ts[4]; h.from_where += h.ts[4];
ts_remain -= ts[4]; h.ts_remain -= h.ts[4];
} }
} }
} }
/* Check if new payload needs to be started. */ /* Check if new payload needs to be started. */
if (priv->ule_skb == NULL) { if (h.priv->ule_skb == NULL) {
/* Start a new payload with skb. /* Start a new payload with skb.
* Find ULE header. It is only guaranteed that the * Find ULE header. It is only guaranteed that the
* length field (2 bytes) is contained in the current * length field (2 bytes) is contained in the current
* TS. * TS.
* Check ts_remain has to be >= 2 here. */ * Check h.ts_remain has to be >= 2 here. */
if (ts_remain < 2) { if (h.ts_remain < 2) {
pr_warn("Invalid payload packing: only %d bytes left in TS. Resyncing.\n", pr_warn("Invalid payload packing: only %d bytes left in TS. Resyncing.\n",
ts_remain); h.ts_remain);
priv->ule_sndu_len = 0; h.priv->ule_sndu_len = 0;
priv->need_pusi = 1; h.priv->need_pusi = 1;
ts += TS_SZ; h.ts += TS_SZ;
continue; continue;
} }
if (! priv->ule_sndu_len) { if (! h.priv->ule_sndu_len) {
/* Got at least two bytes, thus extrace the SNDU length. */ /* Got at least two bytes, thus extrace the SNDU length. */
priv->ule_sndu_len = from_where[0] << 8 | from_where[1]; h.priv->ule_sndu_len = h.from_where[0] << 8 | h.from_where[1];
if (priv->ule_sndu_len & 0x8000) { if (h.priv->ule_sndu_len & 0x8000) {
/* D-Bit is set: no dest mac present. */ /* D-Bit is set: no dest mac present. */
priv->ule_sndu_len &= 0x7FFF; h.priv->ule_sndu_len &= 0x7FFF;
priv->ule_dbit = 1; h.priv->ule_dbit = 1;
} else } else
priv->ule_dbit = 0; h.priv->ule_dbit = 0;
if (priv->ule_sndu_len < 5) { if (h.priv->ule_sndu_len < 5) {
pr_warn("%lu: Invalid ULE SNDU length %u. Resyncing.\n", pr_warn("%lu: Invalid ULE SNDU length %u. Resyncing.\n",
priv->ts_count, h.priv->ts_count,
priv->ule_sndu_len); h.priv->ule_sndu_len);
dev->stats.rx_errors++; h.dev->stats.rx_errors++;
dev->stats.rx_length_errors++; h.dev->stats.rx_length_errors++;
priv->ule_sndu_len = 0; h.priv->ule_sndu_len = 0;
priv->need_pusi = 1; h.priv->need_pusi = 1;
new_ts = 1; h.new_ts = 1;
ts += TS_SZ; h.ts += TS_SZ;
priv->ts_count++; h.priv->ts_count++;
continue; continue;
} }
ts_remain -= 2; /* consume the 2 bytes SNDU length. */ h.ts_remain -= 2; /* consume the 2 bytes SNDU length. */
from_where += 2; h.from_where += 2;
} }
priv->ule_sndu_remain = priv->ule_sndu_len + 2; h.priv->ule_sndu_remain = h.priv->ule_sndu_len + 2;
/* /*
* State of current TS: * State of current TS:
* ts_remain (remaining bytes in the current TS cell) * h.ts_remain (remaining bytes in the current TS cell)
* 0 ule_type is not available now, we need the next TS cell * 0 ule_type is not available now, we need the next TS cell
* 1 the first byte of the ule_type is present * 1 the first byte of the ule_type is present
* >=2 full ULE header present, maybe some payload data as well. * >=2 full ULE header present, maybe some payload data as well.
*/ */
switch (ts_remain) { switch (h.ts_remain) {
case 1: case 1:
priv->ule_sndu_remain--; h.priv->ule_sndu_remain--;
priv->ule_sndu_type = from_where[0] << 8; h.priv->ule_sndu_type = h.from_where[0] << 8;
priv->ule_sndu_type_1 = 1; /* first byte of ule_type is set. */ h.priv->ule_sndu_type_1 = 1; /* first byte of ule_type is set. */
ts_remain -= 1; from_where += 1; h.ts_remain -= 1; h.from_where += 1;
/* Continue w/ next TS. */ /* Continue w/ next TS. */
case 0: case 0:
new_ts = 1; h.new_ts = 1;
ts += TS_SZ; h.ts += TS_SZ;
priv->ts_count++; h.priv->ts_count++;
continue; continue;
default: /* complete ULE header is present in current TS. */ default: /* complete ULE header is present in current TS. */
/* Extract ULE type field. */ /* Extract ULE type field. */
if (priv->ule_sndu_type_1) { if (h.priv->ule_sndu_type_1) {
priv->ule_sndu_type_1 = 0; h.priv->ule_sndu_type_1 = 0;
priv->ule_sndu_type |= from_where[0]; h.priv->ule_sndu_type |= h.from_where[0];
from_where += 1; /* points to payload start. */ h.from_where += 1; /* points to payload start. */
ts_remain -= 1; h.ts_remain -= 1;
} else { } else {
/* Complete type is present in new TS. */ /* Complete type is present in new TS. */
priv->ule_sndu_type = from_where[0] << 8 | from_where[1]; h.priv->ule_sndu_type = h.from_where[0] << 8 | h.from_where[1];
from_where += 2; /* points to payload start. */ h.from_where += 2; /* points to payload start. */
ts_remain -= 2; h.ts_remain -= 2;
} }
break; break;
} }
/* Allocate the skb (decoder target buffer) with the correct size, as follows: /* Allocate the skb (decoder target buffer) with the correct size, as follows:
* prepare for the largest case: bridged SNDU with MAC address (dbit = 0). */ * prepare for the largest case: bridged SNDU with MAC address (dbit = 0). */
priv->ule_skb = dev_alloc_skb( priv->ule_sndu_len + ETH_HLEN + ETH_ALEN ); h.priv->ule_skb = dev_alloc_skb( h.priv->ule_sndu_len + ETH_HLEN + ETH_ALEN );
if (priv->ule_skb == NULL) { if (h.priv->ule_skb == NULL) {
pr_notice("%s: Memory squeeze, dropping packet.\n", pr_notice("%s: Memory squeeze, dropping packet.\n",
dev->name); h.dev->name);
dev->stats.rx_dropped++; h.dev->stats.rx_dropped++;
return; return;
} }
/* This includes the CRC32 _and_ dest mac, if !dbit. */ /* This includes the CRC32 _and_ dest mac, if !dbit. */
priv->ule_sndu_remain = priv->ule_sndu_len; h.priv->ule_sndu_remain = h.priv->ule_sndu_len;
priv->ule_skb->dev = dev; h.priv->ule_skb->dev = h.dev;
/* Leave space for Ethernet or bridged SNDU header (eth hdr plus one MAC addr). */ /* Leave space for Ethernet or bridged SNDU header (eth hdr plus one MAC addr). */
skb_reserve( priv->ule_skb, ETH_HLEN + ETH_ALEN ); skb_reserve( h.priv->ule_skb, ETH_HLEN + ETH_ALEN );
} }
/* Copy data into our current skb. */ /* Copy data into our current skb. */
how_much = min(priv->ule_sndu_remain, (int)ts_remain); h.how_much = min(h.priv->ule_sndu_remain, (int)h.ts_remain);
memcpy(skb_put(priv->ule_skb, how_much), from_where, how_much); memcpy(skb_put(h.priv->ule_skb, h.how_much), h.from_where, h.how_much);
priv->ule_sndu_remain -= how_much; h.priv->ule_sndu_remain -= h.how_much;
ts_remain -= how_much; h.ts_remain -= h.how_much;
from_where += how_much; h.from_where += h.how_much;
/* Check for complete payload. */ /* Check for complete payload. */
if (priv->ule_sndu_remain <= 0) { if (h.priv->ule_sndu_remain <= 0) {
/* Check CRC32, we've got it in our skb already. */ /* Check CRC32, we've got it in our skb already. */
__be16 ulen = htons(priv->ule_sndu_len); __be16 ulen = htons(h.priv->ule_sndu_len);
__be16 utype = htons(priv->ule_sndu_type); __be16 utype = htons(h.priv->ule_sndu_type);
const u8 *tail; const u8 *tail;
struct kvec iov[3] = { struct kvec iov[3] = {
{ &ulen, sizeof ulen }, { &ulen, sizeof ulen },
{ &utype, sizeof utype }, { &utype, sizeof utype },
{ priv->ule_skb->data, priv->ule_skb->len - 4 } { h.priv->ule_skb->data, h.priv->ule_skb->len - 4 }
}; };
u32 ule_crc = ~0L, expected_crc; u32 ule_crc = ~0L, expected_crc;
if (priv->ule_dbit) { if (h.priv->ule_dbit) {
/* Set D-bit for CRC32 verification, /* Set D-bit for CRC32 verification,
* if it was set originally. */ * if it was set originally. */
ulen |= htons(0x8000); ulen |= htons(0x8000);
} }
ule_crc = iov_crc32(ule_crc, iov, 3); ule_crc = iov_crc32(ule_crc, iov, 3);
tail = skb_tail_pointer(priv->ule_skb); tail = skb_tail_pointer(h.priv->ule_skb);
expected_crc = *(tail - 4) << 24 | expected_crc = *(tail - 4) << 24 |
*(tail - 3) << 16 | *(tail - 3) << 16 |
*(tail - 2) << 8 | *(tail - 2) << 8 |
*(tail - 1); *(tail - 1);
if (ule_crc != expected_crc) { if (ule_crc != expected_crc) {
pr_warn("%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n", pr_warn("%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, h.ts_remain %d, next 2: %x.\n",
priv->ts_count, ule_crc, expected_crc, h.priv->ts_count, ule_crc, expected_crc,
priv->ule_sndu_len, priv->ule_sndu_type, h.priv->ule_sndu_len, h.priv->ule_sndu_type,
ts_remain, h.ts_remain,
ts_remain > 2 ? *(unsigned short *)from_where : 0); h.ts_remain > 2 ? *(unsigned short *)h.from_where : 0);
#ifdef ULE_DEBUG #ifdef ULE_DEBUG
hexdump( iov[0].iov_base, iov[0].iov_len ); hexdump( iov[0].iov_base, iov[0].iov_len );
hexdump( iov[1].iov_base, iov[1].iov_len ); hexdump( iov[1].iov_base, iov[1].iov_len );
hexdump( iov[2].iov_base, iov[2].iov_len ); hexdump( iov[2].iov_base, iov[2].iov_len );
if (ule_where == ule_hist) { if (h.ule_where == h.ule_hist) {
hexdump( &ule_hist[98*TS_SZ], TS_SZ ); hexdump( &h.ule_hist[98*TS_SZ], TS_SZ );
hexdump( &ule_hist[99*TS_SZ], TS_SZ ); hexdump( &h.ule_hist[99*TS_SZ], TS_SZ );
} else if (ule_where == &ule_hist[TS_SZ]) { } else if (h.ule_where == &h.ule_hist[TS_SZ]) {
hexdump( &ule_hist[99*TS_SZ], TS_SZ ); hexdump( &h.ule_hist[99*TS_SZ], TS_SZ );
hexdump( ule_hist, TS_SZ ); hexdump( h.ule_hist, TS_SZ );
} else { } else {
hexdump( ule_where - TS_SZ - TS_SZ, TS_SZ ); hexdump( h.ule_where - TS_SZ - TS_SZ, TS_SZ );
hexdump( ule_where - TS_SZ, TS_SZ ); hexdump( h.ule_where - TS_SZ, TS_SZ );
} }
ule_dump = 1; h.ule_dump = 1;
#endif #endif
dev->stats.rx_errors++; h.dev->stats.rx_errors++;
dev->stats.rx_crc_errors++; h.dev->stats.rx_crc_errors++;
dev_kfree_skb(priv->ule_skb); dev_kfree_skb(h.priv->ule_skb);
} else { } else {
/* CRC32 verified OK. */ /* CRC32 verified OK. */
u8 dest_addr[ETH_ALEN]; u8 dest_addr[ETH_ALEN];
@ -635,10 +660,10 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
{ [ 0 ... ETH_ALEN-1] = 0xff }; { [ 0 ... ETH_ALEN-1] = 0xff };
/* CRC32 was OK. Remove it from skb. */ /* CRC32 was OK. Remove it from skb. */
priv->ule_skb->tail -= 4; h.priv->ule_skb->tail -= 4;
priv->ule_skb->len -= 4; h.priv->ule_skb->len -= 4;
if (!priv->ule_dbit) { if (!h.priv->ule_dbit) {
/* /*
* The destination MAC address is the * The destination MAC address is the
* next data in the skb. It comes * next data in the skb. It comes
@ -648,26 +673,26 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
* should be passed up the stack. * should be passed up the stack.
*/ */
register int drop = 0; register int drop = 0;
if (priv->rx_mode != RX_MODE_PROMISC) { if (h.priv->rx_mode != RX_MODE_PROMISC) {
if (priv->ule_skb->data[0] & 0x01) { if (h.priv->ule_skb->data[0] & 0x01) {
/* multicast or broadcast */ /* multicast or broadcast */
if (!ether_addr_equal(priv->ule_skb->data, bc_addr)) { if (!ether_addr_equal(h.priv->ule_skb->data, bc_addr)) {
/* multicast */ /* multicast */
if (priv->rx_mode == RX_MODE_MULTI) { if (h.priv->rx_mode == RX_MODE_MULTI) {
int i; int i;
for(i = 0; i < priv->multi_num && for(i = 0; i < h.priv->multi_num &&
!ether_addr_equal(priv->ule_skb->data, !ether_addr_equal(h.priv->ule_skb->data,
priv->multi_macs[i]); i++) h.priv->multi_macs[i]); i++)
; ;
if (i == priv->multi_num) if (i == h.priv->multi_num)
drop = 1; drop = 1;
} else if (priv->rx_mode != RX_MODE_ALL_MULTI) } else if (h.priv->rx_mode != RX_MODE_ALL_MULTI)
drop = 1; /* no broadcast; */ drop = 1; /* no broadcast; */
/* else: all multicast mode: accept all multicast packets */ /* else: all multicast mode: accept all multicast packets */
} }
/* else: broadcast */ /* else: broadcast */
} }
else if (!ether_addr_equal(priv->ule_skb->data, dev->dev_addr)) else if (!ether_addr_equal(h.priv->ule_skb->data, h.dev->dev_addr))
drop = 1; drop = 1;
/* else: destination address matches the MAC address of our receiver device */ /* else: destination address matches the MAC address of our receiver device */
} }
@ -675,94 +700,94 @@ static void dvb_net_ule( struct net_device *dev, const u8 *buf, size_t buf_len )
if (drop) { if (drop) {
#ifdef ULE_DEBUG #ifdef ULE_DEBUG
netdev_dbg(dev, "Dropping SNDU: MAC destination address does not match: dest addr: %pM, dev addr: %pM\n", netdev_dbg(h.dev, "Dropping SNDU: MAC destination address does not match: dest addr: %pM, h.dev addr: %pM\n",
priv->ule_skb->data, dev->dev_addr); h.priv->ule_skb->data, h.dev->dev_addr);
#endif #endif
dev_kfree_skb(priv->ule_skb); dev_kfree_skb(h.priv->ule_skb);
goto sndu_done; goto sndu_done;
} }
else else
{ {
skb_copy_from_linear_data(priv->ule_skb, skb_copy_from_linear_data(h.priv->ule_skb,
dest_addr, dest_addr,
ETH_ALEN); ETH_ALEN);
skb_pull(priv->ule_skb, ETH_ALEN); skb_pull(h.priv->ule_skb, ETH_ALEN);
} }
} }
/* Handle ULE Extension Headers. */ /* Handle ULE Extension Headers. */
if (priv->ule_sndu_type < ETH_P_802_3_MIN) { if (h.priv->ule_sndu_type < ETH_P_802_3_MIN) {
/* There is an extension header. Handle it accordingly. */ /* There is an extension header. Handle it accordingly. */
int l = handle_ule_extensions(priv); int l = handle_ule_extensions(h.priv);
if (l < 0) { if (l < 0) {
/* Mandatory extension header unknown or TEST SNDU. Drop it. */ /* Mandatory extension header unknown or TEST SNDU. Drop it. */
// pr_warn("Dropping SNDU, extension headers.\n" ); // pr_warn("Dropping SNDU, extension headers.\n" );
dev_kfree_skb(priv->ule_skb); dev_kfree_skb(h.priv->ule_skb);
goto sndu_done; goto sndu_done;
} }
skb_pull(priv->ule_skb, l); skb_pull(h.priv->ule_skb, l);
} }
/* /*
* Construct/assure correct ethernet header. * Construct/assure correct ethernet header.
* Note: in bridged mode (priv->ule_bridged != * Note: in bridged mode (h.priv->ule_bridged !=
* 0) we already have the (original) ethernet * 0) we already have the (original) ethernet
* header at the start of the payload (after * header at the start of the payload (after
* optional dest. address and any extension * optional dest. address and any extension
* headers). * headers).
*/ */
if (!priv->ule_bridged) { if (!h.priv->ule_bridged) {
skb_push(priv->ule_skb, ETH_HLEN); skb_push(h.priv->ule_skb, ETH_HLEN);
ethh = (struct ethhdr *)priv->ule_skb->data; h.ethh = (struct ethhdr *)h.priv->ule_skb->data;
if (!priv->ule_dbit) { if (!h.priv->ule_dbit) {
/* dest_addr buffer is only valid if priv->ule_dbit == 0 */ /* dest_addr buffer is only valid if h.priv->ule_dbit == 0 */
memcpy(ethh->h_dest, dest_addr, ETH_ALEN); memcpy(h.ethh->h_dest, dest_addr, ETH_ALEN);
eth_zero_addr(ethh->h_source); eth_zero_addr(h.ethh->h_source);
} }
else /* zeroize source and dest */ else /* zeroize source and dest */
memset( ethh, 0, ETH_ALEN*2 ); memset( h.ethh, 0, ETH_ALEN*2 );
ethh->h_proto = htons(priv->ule_sndu_type); h.ethh->h_proto = htons(h.priv->ule_sndu_type);
} }
/* else: skb is in correct state; nothing to do. */ /* else: skb is in correct state; nothing to do. */
priv->ule_bridged = 0; h.priv->ule_bridged = 0;
/* Stuff into kernel's protocol stack. */ /* Stuff into kernel's protocol stack. */
priv->ule_skb->protocol = dvb_net_eth_type_trans(priv->ule_skb, dev); h.priv->ule_skb->protocol = dvb_net_eth_type_trans(h.priv->ule_skb, h.dev);
/* If D-bit is set (i.e. destination MAC address not present), /* If D-bit is set (i.e. destination MAC address not present),
* receive the packet anyhow. */ * receive the packet anyhow. */
/* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST) /* if (h.priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)
priv->ule_skb->pkt_type = PACKET_HOST; */ h.priv->ule_skb->pkt_type = PACKET_HOST; */
dev->stats.rx_packets++; h.dev->stats.rx_packets++;
dev->stats.rx_bytes += priv->ule_skb->len; h.dev->stats.rx_bytes += h.priv->ule_skb->len;
netif_rx(priv->ule_skb); netif_rx(h.priv->ule_skb);
} }
sndu_done: sndu_done:
/* Prepare for next SNDU. */ /* Prepare for next SNDU. */
reset_ule(priv); reset_ule(h.priv);
} }
/* More data in current TS (look at the bytes following the CRC32)? */ /* More data in current TS (look at the bytes following the CRC32)? */
if (ts_remain >= 2 && *((unsigned short *)from_where) != 0xFFFF) { if (h.ts_remain >= 2 && *((unsigned short *)h.from_where) != 0xFFFF) {
/* Next ULE SNDU starts right there. */ /* Next ULE SNDU starts right there. */
new_ts = 0; h.new_ts = 0;
priv->ule_skb = NULL; h.priv->ule_skb = NULL;
priv->ule_sndu_type_1 = 0; h.priv->ule_sndu_type_1 = 0;
priv->ule_sndu_len = 0; h.priv->ule_sndu_len = 0;
// pr_warn("More data in current TS: [%#x %#x %#x %#x]\n", // pr_warn("More data in current TS: [%#x %#x %#x %#x]\n",
// *(from_where + 0), *(from_where + 1), // *(h.from_where + 0), *(h.from_where + 1),
// *(from_where + 2), *(from_where + 3)); // *(h.from_where + 2), *(h.from_where + 3));
// pr_warn("ts @ %p, stopped @ %p:\n", ts, from_where + 0); // pr_warn("h.ts @ %p, stopped @ %p:\n", h.ts, h.from_where + 0);
// hexdump(ts, 188); // hexdump(h.ts, 188);
} else { } else {
new_ts = 1; h.new_ts = 1;
ts += TS_SZ; h.ts += TS_SZ;
priv->ts_count++; h.priv->ts_count++;
if (priv->ule_skb == NULL) { if (h.priv->ule_skb == NULL) {
priv->need_pusi = 1; h.priv->need_pusi = 1;
priv->ule_sndu_type_1 = 0; h.priv->ule_sndu_type_1 = 0;
priv->ule_sndu_len = 0; h.priv->ule_sndu_len = 0;
} }
} }
} /* for all available TS cells */ } /* for all available TS cells */