1665 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/*3 * dvb_net.c4 *5 * Copyright (C) 2001 Convergence integrated media GmbH6 * Ralph Metzler <ralph@convergence.de>7 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>8 *9 * ULE Decapsulation code:10 * Copyright (C) 2003, 2004 gcs - Global Communication & Services GmbH.11 * and Department of Scientific Computing12 * Paris Lodron University of Salzburg.13 * Hilmar Linder <hlinder@cosy.sbg.ac.at>14 * and Wolfram Stering <wstering@cosy.sbg.ac.at>15 *16 * ULE Decaps according to RFC 4326.17 */18 19/*20 * ULE ChangeLog:21 * Feb 2004: hl/ws v1: Implementing draft-fair-ipdvb-ule-01.txt22 *23 * Dec 2004: hl/ws v2: Implementing draft-ietf-ipdvb-ule-03.txt:24 * ULE Extension header handling.25 * Bugreports by Moritz Vieth and Hanno Tersteegen,26 * Fraunhofer Institute for Open Communication Systems27 * Competence Center for Advanced Satellite Communications.28 * Bugfixes and robustness improvements.29 * Filtering on dest MAC addresses, if present (D-Bit = 0)30 * DVB_ULE_DEBUG compile-time option.31 * Apr 2006: cp v3: Bugfixes and compliency with RFC 4326 (ULE) by32 * Christian Praehauser <cpraehaus@cosy.sbg.ac.at>,33 * Paris Lodron University of Salzburg.34 */35 36/*37 * FIXME / TODO (dvb_net.c):38 *39 * Unloading does not work for 2.6.9 kernels: a refcount doesn't go to zero.40 *41 */42 43#define pr_fmt(fmt) "dvb_net: " fmt44 45#include <linux/module.h>46#include <linux/kernel.h>47#include <linux/netdevice.h>48#include <linux/nospec.h>49#include <linux/etherdevice.h>50#include <linux/dvb/net.h>51#include <linux/uio.h>52#include <linux/uaccess.h>53#include <linux/crc32.h>54#include <linux/mutex.h>55#include <linux/sched.h>56 57#include <media/dvb_demux.h>58#include <media/dvb_net.h>59 60static inline __u32 iov_crc32( __u32 c, struct kvec *iov, unsigned int cnt )61{62 unsigned int j;63 for (j = 0; j < cnt; j++)64 c = crc32_be( c, iov[j].iov_base, iov[j].iov_len );65 return c;66}67 68 69#define DVB_NET_MULTICAST_MAX 1070 71#ifdef DVB_ULE_DEBUG72/*73 * The code inside DVB_ULE_DEBUG keeps a history of the74 * last 100 TS cells processed.75 */76static unsigned char ule_hist[100*TS_SZ] = { 0 };77static unsigned char *ule_where = ule_hist, ule_dump;78 79static void hexdump(const unsigned char *buf, unsigned short len)80{81 print_hex_dump_debug("", DUMP_PREFIX_OFFSET, 16, 1, buf, len, true);82}83#endif84 85struct dvb_net_priv {86 int in_use;87 u16 pid;88 struct net_device *net;89 struct dvb_net *host;90 struct dmx_demux *demux;91 struct dmx_section_feed *secfeed;92 struct dmx_section_filter *secfilter;93 struct dmx_ts_feed *tsfeed;94 int multi_num;95 struct dmx_section_filter *multi_secfilter[DVB_NET_MULTICAST_MAX];96 unsigned char multi_macs[DVB_NET_MULTICAST_MAX][6];97 int rx_mode;98#define RX_MODE_UNI 099#define RX_MODE_MULTI 1100#define RX_MODE_ALL_MULTI 2101#define RX_MODE_PROMISC 3102 struct work_struct set_multicast_list_wq;103 struct work_struct restart_net_feed_wq;104 unsigned char feedtype; /* Either FEED_TYPE_ or FEED_TYPE_ULE */105 int need_pusi; /* Set to 1, if synchronization on PUSI required. */106 unsigned char tscc; /* TS continuity counter after sync on PUSI. */107 struct sk_buff *ule_skb; /* ULE SNDU decodes into this buffer. */108 unsigned char *ule_next_hdr; /* Pointer into skb to next ULE extension header. */109 unsigned short ule_sndu_len; /* ULE SNDU length in bytes, w/o D-Bit. */110 unsigned short ule_sndu_type; /* ULE SNDU type field, complete. */111 unsigned char ule_sndu_type_1; /* ULE SNDU type field, if split across 2 TS cells. */112 unsigned char ule_dbit; /* Whether the DestMAC address present113 * or not (bit is set). */114 unsigned char ule_bridged; /* Whether the ULE_BRIDGED extension header was found. */115 int ule_sndu_remain; /* Nr. of bytes still required for current ULE SNDU. */116 unsigned long ts_count; /* Current ts cell counter. */117 struct mutex mutex;118};119 120 121/*122 * Determine the packet's protocol ID. The rule here is that we123 * assume 802.3 if the type field is short enough to be a length.124 * This is normal practice and works for any 'now in use' protocol.125 *126 * stolen from eth.c out of the linux kernel, hacked for dvb-device127 * by Michael Holzt <kju@debian.org>128 */129static __be16 dvb_net_eth_type_trans(struct sk_buff *skb,130 struct net_device *dev)131{132 struct ethhdr *eth;133 unsigned char *rawp;134 135 skb_reset_mac_header(skb);136 skb_pull(skb,dev->hard_header_len);137 eth = eth_hdr(skb);138 139 if (*eth->h_dest & 1) {140 if(ether_addr_equal(eth->h_dest,dev->broadcast))141 skb->pkt_type=PACKET_BROADCAST;142 else143 skb->pkt_type=PACKET_MULTICAST;144 }145 146 if (ntohs(eth->h_proto) >= ETH_P_802_3_MIN)147 return eth->h_proto;148 149 rawp = skb->data;150 151 /*152 * This is a magic hack to spot IPX packets. Older Novell breaks153 * the protocol design and runs IPX over 802.3 without an 802.2 LLC154 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This155 * won't work for fault tolerant netware but does for the rest.156 */157 if (*(unsigned short *)rawp == 0xFFFF)158 return htons(ETH_P_802_3);159 160 /*161 * Real 802.2 LLC162 */163 return htons(ETH_P_802_2);164}165 166#define TS_SZ 188167#define TS_SYNC 0x47168#define TS_TEI 0x80169#define TS_SC 0xC0170#define TS_PUSI 0x40171#define TS_AF_A 0x20172#define TS_AF_D 0x10173 174/* ULE Extension Header handlers. */175 176#define ULE_TEST 0177#define ULE_BRIDGED 1178 179#define ULE_OPTEXTHDR_PADDING 0180 181static int ule_test_sndu( struct dvb_net_priv *p )182{183 return -1;184}185 186static int ule_bridged_sndu( struct dvb_net_priv *p )187{188 struct ethhdr *hdr = (struct ethhdr*) p->ule_next_hdr;189 if(ntohs(hdr->h_proto) < ETH_P_802_3_MIN) {190 int framelen = p->ule_sndu_len - ((p->ule_next_hdr+sizeof(struct ethhdr)) - p->ule_skb->data);191 /* A frame Type < ETH_P_802_3_MIN for a bridged frame, introduces a LLC Length field. */192 if(framelen != ntohs(hdr->h_proto)) {193 return -1;194 }195 }196 /* Note:197 * From RFC4326:198 * "A bridged SNDU is a Mandatory Extension Header of Type 1.199 * It must be the final (or only) extension header specified in the header chain of a SNDU."200 * The 'ule_bridged' flag will cause the extension header processing loop to terminate.201 */202 p->ule_bridged = 1;203 return 0;204}205 206static int ule_exthdr_padding(struct dvb_net_priv *p)207{208 return 0;209}210 211/*212 * Handle ULE extension headers.213 * Function is called after a successful CRC32 verification of an ULE SNDU to complete its decoding.214 * Returns: >= 0: nr. of bytes consumed by next extension header215 * -1: Mandatory extension header that is not recognized or TEST SNDU; discard.216 */217static int handle_one_ule_extension( struct dvb_net_priv *p )218{219 /* Table of mandatory extension header handlers. The header type is the index. */220 static int (*ule_mandatory_ext_handlers[255])( struct dvb_net_priv *p ) =221 { [0] = ule_test_sndu, [1] = ule_bridged_sndu, [2] = NULL, };222 223 /* Table of optional extension header handlers. The header type is the index. */224 static int (*ule_optional_ext_handlers[255])( struct dvb_net_priv *p ) =225 { [0] = ule_exthdr_padding, [1] = NULL, };226 227 int ext_len = 0;228 unsigned char hlen = (p->ule_sndu_type & 0x0700) >> 8;229 unsigned char htype = p->ule_sndu_type & 0x00FF;230 231 /* Discriminate mandatory and optional extension headers. */232 if (hlen == 0) {233 /* Mandatory extension header */234 if (ule_mandatory_ext_handlers[htype]) {235 ext_len = ule_mandatory_ext_handlers[htype]( p );236 if(ext_len >= 0) {237 p->ule_next_hdr += ext_len;238 if (!p->ule_bridged) {239 p->ule_sndu_type = ntohs(*(__be16 *)p->ule_next_hdr);240 p->ule_next_hdr += 2;241 } else {242 p->ule_sndu_type = ntohs(*(__be16 *)(p->ule_next_hdr + ((p->ule_dbit ? 2 : 3) * ETH_ALEN)));243 /* This assures the extension handling loop will terminate. */244 }245 }246 // else: extension handler failed or SNDU should be discarded247 } else248 ext_len = -1; /* SNDU has to be discarded. */249 } else {250 /* Optional extension header. Calculate the length. */251 ext_len = hlen << 1;252 /* Process the optional extension header according to its type. */253 if (ule_optional_ext_handlers[htype])254 (void)ule_optional_ext_handlers[htype]( p );255 p->ule_next_hdr += ext_len;256 p->ule_sndu_type = ntohs( *(__be16 *)(p->ule_next_hdr-2) );257 /*258 * note: the length of the next header type is included in the259 * length of THIS optional extension header260 */261 }262 263 return ext_len;264}265 266static int handle_ule_extensions( struct dvb_net_priv *p )267{268 int total_ext_len = 0, l;269 270 p->ule_next_hdr = p->ule_skb->data;271 do {272 l = handle_one_ule_extension( p );273 if (l < 0)274 return l; /* Stop extension header processing and discard SNDU. */275 total_ext_len += l;276 pr_debug("ule_next_hdr=%p, ule_sndu_type=%i, l=%i, total_ext_len=%i\n",277 p->ule_next_hdr, (int)p->ule_sndu_type,278 l, total_ext_len);279 280 } while (p->ule_sndu_type < ETH_P_802_3_MIN);281 282 return total_ext_len;283}284 285 286/* Prepare for a new ULE SNDU: reset the decoder state. */287static inline void reset_ule( struct dvb_net_priv *p )288{289 p->ule_skb = NULL;290 p->ule_next_hdr = NULL;291 p->ule_sndu_len = 0;292 p->ule_sndu_type = 0;293 p->ule_sndu_type_1 = 0;294 p->ule_sndu_remain = 0;295 p->ule_dbit = 0xFF;296 p->ule_bridged = 0;297}298 299/*300 * Decode ULE SNDUs according to draft-ietf-ipdvb-ule-03.txt from a sequence of301 * TS cells of a single PID.302 */303 304struct dvb_net_ule_handle {305 struct net_device *dev;306 struct dvb_net_priv *priv;307 struct ethhdr *ethh;308 const u8 *buf;309 size_t buf_len;310 unsigned long skipped;311 const u8 *ts, *ts_end, *from_where;312 u8 ts_remain, how_much, new_ts;313 bool error;314};315 316static int dvb_net_ule_new_ts_cell(struct dvb_net_ule_handle *h)317{318 /* We are about to process a new TS cell. */319 320#ifdef DVB_ULE_DEBUG321 if (ule_where >= &ule_hist[100*TS_SZ])322 ule_where = ule_hist;323 memcpy(ule_where, h->ts, TS_SZ);324 if (ule_dump) {325 hexdump(ule_where, TS_SZ);326 ule_dump = 0;327 }328 ule_where += TS_SZ;329#endif330 331 /*332 * Check TS h->error conditions: sync_byte, transport_error_indicator,333 * scrambling_control .334 */335 if ((h->ts[0] != TS_SYNC) || (h->ts[1] & TS_TEI) ||336 ((h->ts[3] & TS_SC) != 0)) {337 pr_warn("%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",338 h->priv->ts_count, h->ts[0],339 (h->ts[1] & TS_TEI) >> 7,340 (h->ts[3] & TS_SC) >> 6);341 342 /* Drop partly decoded SNDU, reset state, resync on PUSI. */343 if (h->priv->ule_skb) {344 dev_kfree_skb(h->priv->ule_skb);345 /* Prepare for next SNDU. */346 h->dev->stats.rx_errors++;347 h->dev->stats.rx_frame_errors++;348 }349 reset_ule(h->priv);350 h->priv->need_pusi = 1;351 352 /* Continue with next TS cell. */353 h->ts += TS_SZ;354 h->priv->ts_count++;355 return 1;356 }357 358 h->ts_remain = 184;359 h->from_where = h->ts + 4;360 361 return 0;362}363 364static int dvb_net_ule_ts_pusi(struct dvb_net_ule_handle *h)365{366 if (h->ts[1] & TS_PUSI) {367 /* Find beginning of first ULE SNDU in current TS cell. */368 /* Synchronize continuity counter. */369 h->priv->tscc = h->ts[3] & 0x0F;370 /* There is a pointer field here. */371 if (h->ts[4] > h->ts_remain) {372 pr_err("%lu: Invalid ULE packet (pointer field %d)\n",373 h->priv->ts_count, h->ts[4]);374 h->ts += TS_SZ;375 h->priv->ts_count++;376 return 1;377 }378 /* Skip to destination of pointer field. */379 h->from_where = &h->ts[5] + h->ts[4];380 h->ts_remain -= 1 + h->ts[4];381 h->skipped = 0;382 } else {383 h->skipped++;384 h->ts += TS_SZ;385 h->priv->ts_count++;386 return 1;387 }388 389 return 0;390}391 392static int dvb_net_ule_new_ts(struct dvb_net_ule_handle *h)393{394 /* Check continuity counter. */395 if ((h->ts[3] & 0x0F) == h->priv->tscc)396 h->priv->tscc = (h->priv->tscc + 1) & 0x0F;397 else {398 /* TS discontinuity handling: */399 pr_warn("%lu: TS discontinuity: got %#x, expected %#x.\n",400 h->priv->ts_count, h->ts[3] & 0x0F,401 h->priv->tscc);402 /* Drop partly decoded SNDU, reset state, resync on PUSI. */403 if (h->priv->ule_skb) {404 dev_kfree_skb(h->priv->ule_skb);405 /* Prepare for next SNDU. */406 // reset_ule(h->priv); moved to below.407 h->dev->stats.rx_errors++;408 h->dev->stats.rx_frame_errors++;409 }410 reset_ule(h->priv);411 /* skip to next PUSI. */412 h->priv->need_pusi = 1;413 return 1;414 }415 /*416 * If we still have an incomplete payload, but PUSI is417 * set; some TS cells are missing.418 * This is only possible here, if we missed exactly 16 TS419 * cells (continuity counter wrap).420 */421 if (h->ts[1] & TS_PUSI) {422 if (!h->priv->need_pusi) {423 if (!(*h->from_where < (h->ts_remain-1)) ||424 *h->from_where != h->priv->ule_sndu_remain) {425 /*426 * Pointer field is invalid.427 * Drop this TS cell and any started ULE SNDU.428 */429 pr_warn("%lu: Invalid pointer field: %u.\n",430 h->priv->ts_count,431 *h->from_where);432 433 /*434 * Drop partly decoded SNDU, reset state,435 * resync on PUSI.436 */437 if (h->priv->ule_skb) {438 h->error = true;439 dev_kfree_skb(h->priv->ule_skb);440 }441 442 if (h->error || h->priv->ule_sndu_remain) {443 h->dev->stats.rx_errors++;444 h->dev->stats.rx_frame_errors++;445 h->error = false;446 }447 448 reset_ule(h->priv);449 h->priv->need_pusi = 1;450 return 1;451 }452 /*453 * Skip pointer field (we're processing a454 * packed payload).455 */456 h->from_where += 1;457 h->ts_remain -= 1;458 } else459 h->priv->need_pusi = 0;460 461 if (h->priv->ule_sndu_remain > 183) {462 /*463 * Current SNDU lacks more data than there464 * could be available in the current TS cell.465 */466 h->dev->stats.rx_errors++;467 h->dev->stats.rx_length_errors++;468 pr_warn("%lu: Expected %d more SNDU bytes, but got PUSI (pf %d, h->ts_remain %d). Flushing incomplete payload.\n",469 h->priv->ts_count,470 h->priv->ule_sndu_remain,471 h->ts[4], h->ts_remain);472 dev_kfree_skb(h->priv->ule_skb);473 /* Prepare for next SNDU. */474 reset_ule(h->priv);475 /*476 * Resync: go to where pointer field points to:477 * start of next ULE SNDU.478 */479 h->from_where += h->ts[4];480 h->ts_remain -= h->ts[4];481 }482 }483 return 0;484}485 486 487/*488 * Start a new payload with skb.489 * Find ULE header. It is only guaranteed that the490 * length field (2 bytes) is contained in the current491 * TS.492 * Check h.ts_remain has to be >= 2 here.493 */494static int dvb_net_ule_new_payload(struct dvb_net_ule_handle *h)495{496 if (h->ts_remain < 2) {497 pr_warn("Invalid payload packing: only %d bytes left in TS. Resyncing.\n",498 h->ts_remain);499 h->priv->ule_sndu_len = 0;500 h->priv->need_pusi = 1;501 h->ts += TS_SZ;502 return 1;503 }504 505 if (!h->priv->ule_sndu_len) {506 /* Got at least two bytes, thus extrace the SNDU length. */507 h->priv->ule_sndu_len = h->from_where[0] << 8 |508 h->from_where[1];509 if (h->priv->ule_sndu_len & 0x8000) {510 /* D-Bit is set: no dest mac present. */511 h->priv->ule_sndu_len &= 0x7FFF;512 h->priv->ule_dbit = 1;513 } else514 h->priv->ule_dbit = 0;515 516 if (h->priv->ule_sndu_len < 5) {517 pr_warn("%lu: Invalid ULE SNDU length %u. Resyncing.\n",518 h->priv->ts_count,519 h->priv->ule_sndu_len);520 h->dev->stats.rx_errors++;521 h->dev->stats.rx_length_errors++;522 h->priv->ule_sndu_len = 0;523 h->priv->need_pusi = 1;524 h->new_ts = 1;525 h->ts += TS_SZ;526 h->priv->ts_count++;527 return 1;528 }529 h->ts_remain -= 2; /* consume the 2 bytes SNDU length. */530 h->from_where += 2;531 }532 533 h->priv->ule_sndu_remain = h->priv->ule_sndu_len + 2;534 /*535 * State of current TS:536 * h->ts_remain (remaining bytes in the current TS cell)537 * 0 ule_type is not available now, we need the next TS cell538 * 1 the first byte of the ule_type is present539 * >=2 full ULE header present, maybe some payload data as well.540 */541 switch (h->ts_remain) {542 case 1:543 h->priv->ule_sndu_remain--;544 h->priv->ule_sndu_type = h->from_where[0] << 8;545 546 /* first byte of ule_type is set. */547 h->priv->ule_sndu_type_1 = 1;548 h->ts_remain -= 1;549 h->from_where += 1;550 fallthrough;551 case 0:552 h->new_ts = 1;553 h->ts += TS_SZ;554 h->priv->ts_count++;555 return 1;556 557 default: /* complete ULE header is present in current TS. */558 /* Extract ULE type field. */559 if (h->priv->ule_sndu_type_1) {560 h->priv->ule_sndu_type_1 = 0;561 h->priv->ule_sndu_type |= h->from_where[0];562 h->from_where += 1; /* points to payload start. */563 h->ts_remain -= 1;564 } else {565 /* Complete type is present in new TS. */566 h->priv->ule_sndu_type = h->from_where[0] << 8 |567 h->from_where[1];568 h->from_where += 2; /* points to payload start. */569 h->ts_remain -= 2;570 }571 break;572 }573 574 /*575 * Allocate the skb (decoder target buffer) with the correct size,576 * as follows:577 *578 * prepare for the largest case: bridged SNDU with MAC address579 * (dbit = 0).580 */581 h->priv->ule_skb = dev_alloc_skb(h->priv->ule_sndu_len +582 ETH_HLEN + ETH_ALEN);583 if (!h->priv->ule_skb) {584 pr_notice("%s: Memory squeeze, dropping packet.\n",585 h->dev->name);586 h->dev->stats.rx_dropped++;587 return -1;588 }589 590 /* This includes the CRC32 _and_ dest mac, if !dbit. */591 h->priv->ule_sndu_remain = h->priv->ule_sndu_len;592 h->priv->ule_skb->dev = h->dev;593 /*594 * Leave space for Ethernet or bridged SNDU header595 * (eth hdr plus one MAC addr).596 */597 skb_reserve(h->priv->ule_skb, ETH_HLEN + ETH_ALEN);598 599 return 0;600}601 602 603static int dvb_net_ule_should_drop(struct dvb_net_ule_handle *h)604{605 static const u8 bc_addr[ETH_ALEN] = { [0 ... ETH_ALEN - 1] = 0xff };606 607 /*608 * The destination MAC address is the next data in the skb. It comes609 * before any extension headers.610 *611 * Check if the payload of this SNDU should be passed up the stack.612 */613 if (h->priv->rx_mode == RX_MODE_PROMISC)614 return 0;615 616 if (h->priv->ule_skb->data[0] & 0x01) {617 /* multicast or broadcast */618 if (!ether_addr_equal(h->priv->ule_skb->data, bc_addr)) {619 /* multicast */620 if (h->priv->rx_mode == RX_MODE_MULTI) {621 int i;622 623 for (i = 0; i < h->priv->multi_num &&624 !ether_addr_equal(h->priv->ule_skb->data,625 h->priv->multi_macs[i]);626 i++)627 ;628 if (i == h->priv->multi_num)629 return 1;630 } else if (h->priv->rx_mode != RX_MODE_ALL_MULTI)631 return 1; /* no broadcast; */632 /*633 * else:634 * all multicast mode: accept all multicast packets635 */636 }637 /* else: broadcast */638 } else if (!ether_addr_equal(h->priv->ule_skb->data, h->dev->dev_addr))639 return 1;640 641 return 0;642}643 644 645static void dvb_net_ule_check_crc(struct dvb_net_ule_handle *h,646 struct kvec iov[3],647 u32 ule_crc, u32 expected_crc)648{649 u8 dest_addr[ETH_ALEN];650 651 if (ule_crc != expected_crc) {652 pr_warn("%lu: CRC32 check FAILED: %08x / %08x, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",653 h->priv->ts_count, ule_crc, expected_crc,654 h->priv->ule_sndu_len, h->priv->ule_sndu_type,655 h->ts_remain,656 h->ts_remain > 2 ?657 *(unsigned short *)h->from_where : 0);658 659 #ifdef DVB_ULE_DEBUG660 hexdump(iov[0].iov_base, iov[0].iov_len);661 hexdump(iov[1].iov_base, iov[1].iov_len);662 hexdump(iov[2].iov_base, iov[2].iov_len);663 664 if (ule_where == ule_hist) {665 hexdump(&ule_hist[98*TS_SZ], TS_SZ);666 hexdump(&ule_hist[99*TS_SZ], TS_SZ);667 } else if (ule_where == &ule_hist[TS_SZ]) {668 hexdump(&ule_hist[99*TS_SZ], TS_SZ);669 hexdump(ule_hist, TS_SZ);670 } else {671 hexdump(ule_where - TS_SZ - TS_SZ, TS_SZ);672 hexdump(ule_where - TS_SZ, TS_SZ);673 }674 ule_dump = 1;675 #endif676 677 h->dev->stats.rx_errors++;678 h->dev->stats.rx_crc_errors++;679 dev_kfree_skb(h->priv->ule_skb);680 681 return;682 }683 684 /* CRC32 verified OK. */685 686 /* CRC32 was OK, so remove it from skb. */687 h->priv->ule_skb->tail -= 4;688 h->priv->ule_skb->len -= 4;689 690 if (!h->priv->ule_dbit) {691 if (dvb_net_ule_should_drop(h)) {692 netdev_dbg(h->dev,693 "Dropping SNDU: MAC destination address does not match: dest addr: %pM, h->dev addr: %pM\n",694 h->priv->ule_skb->data, h->dev->dev_addr);695 dev_kfree_skb(h->priv->ule_skb);696 return;697 }698 699 skb_copy_from_linear_data(h->priv->ule_skb, dest_addr,700 ETH_ALEN);701 skb_pull(h->priv->ule_skb, ETH_ALEN);702 } else {703 /* dest_addr buffer is only valid if h->priv->ule_dbit == 0 */704 eth_zero_addr(dest_addr);705 }706 707 /* Handle ULE Extension Headers. */708 if (h->priv->ule_sndu_type < ETH_P_802_3_MIN) {709 /* There is an extension header. Handle it accordingly. */710 int l = handle_ule_extensions(h->priv);711 712 if (l < 0) {713 /*714 * Mandatory extension header unknown or TEST SNDU.715 * Drop it.716 */717 718 // pr_warn("Dropping SNDU, extension headers.\n" );719 dev_kfree_skb(h->priv->ule_skb);720 return;721 }722 skb_pull(h->priv->ule_skb, l);723 }724 725 /*726 * Construct/assure correct ethernet header.727 * Note: in bridged mode (h->priv->ule_bridged != 0)728 * we already have the (original) ethernet729 * header at the start of the payload (after730 * optional dest. address and any extension731 * headers).732 */733 if (!h->priv->ule_bridged) {734 skb_push(h->priv->ule_skb, ETH_HLEN);735 h->ethh = (struct ethhdr *)h->priv->ule_skb->data;736 memcpy(h->ethh->h_dest, dest_addr, ETH_ALEN);737 eth_zero_addr(h->ethh->h_source);738 h->ethh->h_proto = htons(h->priv->ule_sndu_type);739 }740 /* else: skb is in correct state; nothing to do. */741 h->priv->ule_bridged = 0;742 743 /* Stuff into kernel's protocol stack. */744 h->priv->ule_skb->protocol = dvb_net_eth_type_trans(h->priv->ule_skb,745 h->dev);746 /*747 * If D-bit is set (i.e. destination MAC address not present),748 * receive the packet anyhow.749 */750#if 0751 if (h->priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)752 h->priv->ule_skb->pkt_type = PACKET_HOST;753#endif754 h->dev->stats.rx_packets++;755 h->dev->stats.rx_bytes += h->priv->ule_skb->len;756 netif_rx(h->priv->ule_skb);757}758 759static void dvb_net_ule(struct net_device *dev, const u8 *buf, size_t buf_len)760{761 int ret;762 struct dvb_net_ule_handle h = {763 .dev = dev,764 .priv = netdev_priv(dev),765 .ethh = NULL,766 .buf = buf,767 .buf_len = buf_len,768 .skipped = 0L,769 .ts = NULL,770 .ts_end = NULL,771 .from_where = NULL,772 .ts_remain = 0,773 .how_much = 0,774 .new_ts = 1,775 .error = false,776 };777 778 /*779 * For all TS cells in current buffer.780 * Appearently, we are called for every single TS cell.781 */782 for (h.ts = h.buf, h.ts_end = h.buf + h.buf_len;783 h.ts < h.ts_end; /* no incr. */) {784 if (h.new_ts) {785 /* We are about to process a new TS cell. */786 if (dvb_net_ule_new_ts_cell(&h))787 continue;788 }789 790 /* Synchronize on PUSI, if required. */791 if (h.priv->need_pusi) {792 if (dvb_net_ule_ts_pusi(&h))793 continue;794 }795 796 if (h.new_ts) {797 if (dvb_net_ule_new_ts(&h))798 continue;799 }800 801 /* Check if new payload needs to be started. */802 if (h.priv->ule_skb == NULL) {803 ret = dvb_net_ule_new_payload(&h);804 if (ret < 0)805 return;806 if (ret)807 continue;808 }809 810 /* Copy data into our current skb. */811 h.how_much = min(h.priv->ule_sndu_remain, (int)h.ts_remain);812 skb_put_data(h.priv->ule_skb, h.from_where, h.how_much);813 h.priv->ule_sndu_remain -= h.how_much;814 h.ts_remain -= h.how_much;815 h.from_where += h.how_much;816 817 /* Check for complete payload. */818 if (h.priv->ule_sndu_remain <= 0) {819 /* Check CRC32, we've got it in our skb already. */820 __be16 ulen = htons(h.priv->ule_sndu_len);821 __be16 utype = htons(h.priv->ule_sndu_type);822 const u8 *tail;823 struct kvec iov[3] = {824 { &ulen, sizeof ulen },825 { &utype, sizeof utype },826 { h.priv->ule_skb->data,827 h.priv->ule_skb->len - 4 }828 };829 u32 ule_crc = ~0L, expected_crc;830 if (h.priv->ule_dbit) {831 /* Set D-bit for CRC32 verification,832 * if it was set originally. */833 ulen |= htons(0x8000);834 }835 836 ule_crc = iov_crc32(ule_crc, iov, 3);837 tail = skb_tail_pointer(h.priv->ule_skb);838 expected_crc = *(tail - 4) << 24 |839 *(tail - 3) << 16 |840 *(tail - 2) << 8 |841 *(tail - 1);842 843 dvb_net_ule_check_crc(&h, iov, ule_crc, expected_crc);844 845 /* Prepare for next SNDU. */846 reset_ule(h.priv);847 }848 849 /* More data in current TS (look at the bytes following the CRC32)? */850 if (h.ts_remain >= 2 && *((unsigned short *)h.from_where) != 0xFFFF) {851 /* Next ULE SNDU starts right there. */852 h.new_ts = 0;853 h.priv->ule_skb = NULL;854 h.priv->ule_sndu_type_1 = 0;855 h.priv->ule_sndu_len = 0;856 // pr_warn("More data in current TS: [%#x %#x %#x %#x]\n",857 // *(h.from_where + 0), *(h.from_where + 1),858 // *(h.from_where + 2), *(h.from_where + 3));859 // pr_warn("h.ts @ %p, stopped @ %p:\n", h.ts, h.from_where + 0);860 // hexdump(h.ts, 188);861 } else {862 h.new_ts = 1;863 h.ts += TS_SZ;864 h.priv->ts_count++;865 if (h.priv->ule_skb == NULL) {866 h.priv->need_pusi = 1;867 h.priv->ule_sndu_type_1 = 0;868 h.priv->ule_sndu_len = 0;869 }870 }871 } /* for all available TS cells */872}873 874static int dvb_net_ts_callback(const u8 *buffer1, size_t buffer1_len,875 const u8 *buffer2, size_t buffer2_len,876 struct dmx_ts_feed *feed,877 u32 *buffer_flags)878{879 struct net_device *dev = feed->priv;880 881 if (buffer2)882 pr_warn("buffer2 not NULL: %p.\n", buffer2);883 if (buffer1_len > 32768)884 pr_warn("length > 32k: %zu.\n", buffer1_len);885 /* pr_info("TS callback: %u bytes, %u TS cells @ %p.\n",886 buffer1_len, buffer1_len / TS_SZ, buffer1); */887 dvb_net_ule(dev, buffer1, buffer1_len);888 return 0;889}890 891 892static void dvb_net_sec(struct net_device *dev,893 const u8 *pkt, int pkt_len)894{895 u8 *eth;896 struct sk_buff *skb;897 struct net_device_stats *stats = &dev->stats;898 int snap = 0;899 900 /* note: pkt_len includes a 32bit checksum */901 if (pkt_len < 16) {902 pr_warn("%s: IP/MPE packet length = %d too small.\n",903 dev->name, pkt_len);904 stats->rx_errors++;905 stats->rx_length_errors++;906 return;907 }908/* it seems some ISPs manage to screw up here, so we have to909 * relax the error checks... */910#if 0911 if ((pkt[5] & 0xfd) != 0xc1) {912 /* drop scrambled or broken packets */913#else914 if ((pkt[5] & 0x3c) != 0x00) {915 /* drop scrambled */916#endif917 stats->rx_errors++;918 stats->rx_crc_errors++;919 return;920 }921 if (pkt[5] & 0x02) {922 /* handle LLC/SNAP, see rfc-1042 */923 if (pkt_len < 24 || memcmp(&pkt[12], "\xaa\xaa\x03\0\0\0", 6)) {924 stats->rx_dropped++;925 return;926 }927 snap = 8;928 }929 if (pkt[7]) {930 /* FIXME: assemble datagram from multiple sections */931 stats->rx_errors++;932 stats->rx_frame_errors++;933 return;934 }935 936 /* we have 14 byte ethernet header (ip header follows);937 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment, 8 byte LLC/SNAP938 */939 if (!(skb = dev_alloc_skb(pkt_len - 4 - 12 + 14 + 2 - snap))) {940 //pr_notice("%s: Memory squeeze, dropping packet.\n", dev->name);941 stats->rx_dropped++;942 return;943 }944 skb_reserve(skb, 2); /* longword align L3 header */945 skb->dev = dev;946 947 /* copy L3 payload */948 eth = skb_put(skb, pkt_len - 12 - 4 + 14 - snap);949 memcpy(eth + 14, pkt + 12 + snap, pkt_len - 12 - 4 - snap);950 951 /* create ethernet header: */952 eth[0]=pkt[0x0b];953 eth[1]=pkt[0x0a];954 eth[2]=pkt[0x09];955 eth[3]=pkt[0x08];956 eth[4]=pkt[0x04];957 eth[5]=pkt[0x03];958 959 eth[6]=eth[7]=eth[8]=eth[9]=eth[10]=eth[11]=0;960 961 if (snap) {962 eth[12] = pkt[18];963 eth[13] = pkt[19];964 } else {965 /* protocol numbers are from rfc-1700 or966 * http://www.iana.org/assignments/ethernet-numbers967 */968 if (pkt[12] >> 4 == 6) { /* version field from IP header */969 eth[12] = 0x86; /* IPv6 */970 eth[13] = 0xdd;971 } else {972 eth[12] = 0x08; /* IPv4 */973 eth[13] = 0x00;974 }975 }976 977 skb->protocol = dvb_net_eth_type_trans(skb, dev);978 979 stats->rx_packets++;980 stats->rx_bytes+=skb->len;981 netif_rx(skb);982}983 984static int dvb_net_sec_callback(const u8 *buffer1, size_t buffer1_len,985 const u8 *buffer2, size_t buffer2_len,986 struct dmx_section_filter *filter, u32 *buffer_flags)987{988 struct net_device *dev = filter->priv;989 990 /*991 * we rely on the DVB API definition where exactly one complete992 * section is delivered in buffer1993 */994 dvb_net_sec (dev, buffer1, buffer1_len);995 return 0;996}997 998static netdev_tx_t dvb_net_tx(struct sk_buff *skb, struct net_device *dev)999{1000 dev_kfree_skb(skb);1001 return NETDEV_TX_OK;1002}1003 1004static u8 mask_normal[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};1005static u8 mask_allmulti[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};1006static u8 mac_allmulti[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};1007static u8 mask_promisc[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};1008 1009static int dvb_net_filter_sec_set(struct net_device *dev,1010 struct dmx_section_filter **secfilter,1011 const u8 *mac, u8 *mac_mask)1012{1013 struct dvb_net_priv *priv = netdev_priv(dev);1014 int ret;1015 1016 *secfilter=NULL;1017 ret = priv->secfeed->allocate_filter(priv->secfeed, secfilter);1018 if (ret<0) {1019 pr_err("%s: could not get filter\n", dev->name);1020 return ret;1021 }1022 1023 (*secfilter)->priv=(void *) dev;1024 1025 memset((*secfilter)->filter_value, 0x00, DMX_MAX_FILTER_SIZE);1026 memset((*secfilter)->filter_mask, 0x00, DMX_MAX_FILTER_SIZE);1027 memset((*secfilter)->filter_mode, 0xff, DMX_MAX_FILTER_SIZE);1028 1029 (*secfilter)->filter_value[0]=0x3e;1030 (*secfilter)->filter_value[3]=mac[5];1031 (*secfilter)->filter_value[4]=mac[4];1032 (*secfilter)->filter_value[8]=mac[3];1033 (*secfilter)->filter_value[9]=mac[2];1034 (*secfilter)->filter_value[10]=mac[1];1035 (*secfilter)->filter_value[11]=mac[0];1036 1037 (*secfilter)->filter_mask[0] = 0xff;1038 (*secfilter)->filter_mask[3] = mac_mask[5];1039 (*secfilter)->filter_mask[4] = mac_mask[4];1040 (*secfilter)->filter_mask[8] = mac_mask[3];1041 (*secfilter)->filter_mask[9] = mac_mask[2];1042 (*secfilter)->filter_mask[10] = mac_mask[1];1043 (*secfilter)->filter_mask[11]=mac_mask[0];1044 1045 netdev_dbg(dev, "filter mac=%pM mask=%pM\n", mac, mac_mask);1046 1047 return 0;1048}1049 1050static int dvb_net_feed_start(struct net_device *dev)1051{1052 int ret = 0, i;1053 struct dvb_net_priv *priv = netdev_priv(dev);1054 struct dmx_demux *demux = priv->demux;1055 const unsigned char *mac = (const unsigned char *) dev->dev_addr;1056 1057 netdev_dbg(dev, "rx_mode %i\n", priv->rx_mode);1058 mutex_lock(&priv->mutex);1059 if (priv->tsfeed || priv->secfeed || priv->secfilter || priv->multi_secfilter[0])1060 pr_err("%s: BUG %d\n", __func__, __LINE__);1061 1062 priv->secfeed=NULL;1063 priv->secfilter=NULL;1064 priv->tsfeed = NULL;1065 1066 if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {1067 netdev_dbg(dev, "alloc secfeed\n");1068 ret=demux->allocate_section_feed(demux, &priv->secfeed,1069 dvb_net_sec_callback);1070 if (ret<0) {1071 pr_err("%s: could not allocate section feed\n",1072 dev->name);1073 goto error;1074 }1075 1076 ret = priv->secfeed->set(priv->secfeed, priv->pid, 1);1077 1078 if (ret<0) {1079 pr_err("%s: could not set section feed\n", dev->name);1080 priv->demux->release_section_feed(priv->demux, priv->secfeed);1081 priv->secfeed=NULL;1082 goto error;1083 }1084 1085 if (priv->rx_mode != RX_MODE_PROMISC) {1086 netdev_dbg(dev, "set secfilter\n");1087 dvb_net_filter_sec_set(dev, &priv->secfilter, mac, mask_normal);1088 }1089 1090 switch (priv->rx_mode) {1091 case RX_MODE_MULTI:1092 for (i = 0; i < priv->multi_num; i++) {1093 netdev_dbg(dev, "set multi_secfilter[%d]\n", i);1094 dvb_net_filter_sec_set(dev, &priv->multi_secfilter[i],1095 priv->multi_macs[i], mask_normal);1096 }1097 break;1098 case RX_MODE_ALL_MULTI:1099 priv->multi_num=1;1100 netdev_dbg(dev, "set multi_secfilter[0]\n");1101 dvb_net_filter_sec_set(dev, &priv->multi_secfilter[0],1102 mac_allmulti, mask_allmulti);1103 break;1104 case RX_MODE_PROMISC:1105 priv->multi_num=0;1106 netdev_dbg(dev, "set secfilter\n");1107 dvb_net_filter_sec_set(dev, &priv->secfilter, mac, mask_promisc);1108 break;1109 }1110 1111 netdev_dbg(dev, "start filtering\n");1112 priv->secfeed->start_filtering(priv->secfeed);1113 } else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {1114 ktime_t timeout = ns_to_ktime(10 * NSEC_PER_MSEC);1115 1116 /* we have payloads encapsulated in TS */1117 netdev_dbg(dev, "alloc tsfeed\n");1118 ret = demux->allocate_ts_feed(demux, &priv->tsfeed, dvb_net_ts_callback);1119 if (ret < 0) {1120 pr_err("%s: could not allocate ts feed\n", dev->name);1121 goto error;1122 }1123 1124 /* Set netdevice pointer for ts decaps callback. */1125 priv->tsfeed->priv = (void *)dev;1126 ret = priv->tsfeed->set(priv->tsfeed,1127 priv->pid, /* pid */1128 TS_PACKET, /* type */1129 DMX_PES_OTHER, /* pes type */1130 timeout /* timeout */1131 );1132 1133 if (ret < 0) {1134 pr_err("%s: could not set ts feed\n", dev->name);1135 priv->demux->release_ts_feed(priv->demux, priv->tsfeed);1136 priv->tsfeed = NULL;1137 goto error;1138 }1139 1140 netdev_dbg(dev, "start filtering\n");1141 priv->tsfeed->start_filtering(priv->tsfeed);1142 } else1143 ret = -EINVAL;1144 1145error:1146 mutex_unlock(&priv->mutex);1147 return ret;1148}1149 1150static int dvb_net_feed_stop(struct net_device *dev)1151{1152 struct dvb_net_priv *priv = netdev_priv(dev);1153 int i, ret = 0;1154 1155 mutex_lock(&priv->mutex);1156 if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {1157 if (priv->secfeed) {1158 if (priv->secfeed->is_filtering) {1159 netdev_dbg(dev, "stop secfeed\n");1160 priv->secfeed->stop_filtering(priv->secfeed);1161 }1162 1163 if (priv->secfilter) {1164 netdev_dbg(dev, "release secfilter\n");1165 priv->secfeed->release_filter(priv->secfeed,1166 priv->secfilter);1167 priv->secfilter=NULL;1168 }1169 1170 for (i=0; i<priv->multi_num; i++) {1171 if (priv->multi_secfilter[i]) {1172 netdev_dbg(dev, "release multi_filter[%d]\n",1173 i);1174 priv->secfeed->release_filter(priv->secfeed,1175 priv->multi_secfilter[i]);1176 priv->multi_secfilter[i] = NULL;1177 }1178 }1179 1180 priv->demux->release_section_feed(priv->demux, priv->secfeed);1181 priv->secfeed = NULL;1182 } else1183 pr_err("%s: no feed to stop\n", dev->name);1184 } else if (priv->feedtype == DVB_NET_FEEDTYPE_ULE) {1185 if (priv->tsfeed) {1186 if (priv->tsfeed->is_filtering) {1187 netdev_dbg(dev, "stop tsfeed\n");1188 priv->tsfeed->stop_filtering(priv->tsfeed);1189 }1190 priv->demux->release_ts_feed(priv->demux, priv->tsfeed);1191 priv->tsfeed = NULL;1192 }1193 else1194 pr_err("%s: no ts feed to stop\n", dev->name);1195 } else1196 ret = -EINVAL;1197 mutex_unlock(&priv->mutex);1198 return ret;1199}1200 1201 1202static int dvb_set_mc_filter(struct net_device *dev, unsigned char *addr)1203{1204 struct dvb_net_priv *priv = netdev_priv(dev);1205 1206 if (priv->multi_num == DVB_NET_MULTICAST_MAX)1207 return -ENOMEM;1208 1209 memcpy(priv->multi_macs[priv->multi_num], addr, ETH_ALEN);1210 1211 priv->multi_num++;1212 return 0;1213}1214 1215 1216static void wq_set_multicast_list (struct work_struct *work)1217{1218 struct dvb_net_priv *priv =1219 container_of(work, struct dvb_net_priv, set_multicast_list_wq);1220 struct net_device *dev = priv->net;1221 1222 dvb_net_feed_stop(dev);1223 priv->rx_mode = RX_MODE_UNI;1224 netif_addr_lock_bh(dev);1225 1226 if (dev->flags & IFF_PROMISC) {1227 netdev_dbg(dev, "promiscuous mode\n");1228 priv->rx_mode = RX_MODE_PROMISC;1229 } else if ((dev->flags & IFF_ALLMULTI)) {1230 netdev_dbg(dev, "allmulti mode\n");1231 priv->rx_mode = RX_MODE_ALL_MULTI;1232 } else if (!netdev_mc_empty(dev)) {1233 struct netdev_hw_addr *ha;1234 1235 netdev_dbg(dev, "set_mc_list, %d entries\n",1236 netdev_mc_count(dev));1237 1238 priv->rx_mode = RX_MODE_MULTI;1239 priv->multi_num = 0;1240 1241 netdev_for_each_mc_addr(ha, dev)1242 dvb_set_mc_filter(dev, ha->addr);1243 }1244 1245 netif_addr_unlock_bh(dev);1246 dvb_net_feed_start(dev);1247}1248 1249 1250static void dvb_net_set_multicast_list (struct net_device *dev)1251{1252 struct dvb_net_priv *priv = netdev_priv(dev);1253 schedule_work(&priv->set_multicast_list_wq);1254}1255 1256 1257static void wq_restart_net_feed (struct work_struct *work)1258{1259 struct dvb_net_priv *priv =1260 container_of(work, struct dvb_net_priv, restart_net_feed_wq);1261 struct net_device *dev = priv->net;1262 1263 if (netif_running(dev)) {1264 dvb_net_feed_stop(dev);1265 dvb_net_feed_start(dev);1266 }1267}1268 1269 1270static int dvb_net_set_mac (struct net_device *dev, void *p)1271{1272 struct dvb_net_priv *priv = netdev_priv(dev);1273 struct sockaddr *addr=p;1274 1275 eth_hw_addr_set(dev, addr->sa_data);1276 1277 if (netif_running(dev))1278 schedule_work(&priv->restart_net_feed_wq);1279 1280 return 0;1281}1282 1283 1284static int dvb_net_open(struct net_device *dev)1285{1286 struct dvb_net_priv *priv = netdev_priv(dev);1287 1288 priv->in_use++;1289 dvb_net_feed_start(dev);1290 return 0;1291}1292 1293 1294static int dvb_net_stop(struct net_device *dev)1295{1296 struct dvb_net_priv *priv = netdev_priv(dev);1297 1298 priv->in_use--;1299 return dvb_net_feed_stop(dev);1300}1301 1302static const struct header_ops dvb_header_ops = {1303 .create = eth_header,1304 .parse = eth_header_parse,1305};1306 1307 1308static const struct net_device_ops dvb_netdev_ops = {1309 .ndo_open = dvb_net_open,1310 .ndo_stop = dvb_net_stop,1311 .ndo_start_xmit = dvb_net_tx,1312 .ndo_set_rx_mode = dvb_net_set_multicast_list,1313 .ndo_set_mac_address = dvb_net_set_mac,1314 .ndo_validate_addr = eth_validate_addr,1315};1316 1317static void dvb_net_setup(struct net_device *dev)1318{1319 ether_setup(dev);1320 1321 dev->header_ops = &dvb_header_ops;1322 dev->netdev_ops = &dvb_netdev_ops;1323 dev->mtu = 4096;1324 dev->max_mtu = 4096;1325 1326 dev->flags |= IFF_NOARP;1327}1328 1329static int get_if(struct dvb_net *dvbnet)1330{1331 int i;1332 1333 for (i=0; i<DVB_NET_DEVICES_MAX; i++)1334 if (!dvbnet->state[i])1335 break;1336 1337 if (i == DVB_NET_DEVICES_MAX)1338 return -1;1339 1340 dvbnet->state[i]=1;1341 return i;1342}1343 1344static int dvb_net_add_if(struct dvb_net *dvbnet, u16 pid, u8 feedtype)1345{1346 struct net_device *net;1347 struct dvb_net_priv *priv;1348 int result;1349 int if_num;1350 1351 if (feedtype != DVB_NET_FEEDTYPE_MPE && feedtype != DVB_NET_FEEDTYPE_ULE)1352 return -EINVAL;1353 if ((if_num = get_if(dvbnet)) < 0)1354 return -EINVAL;1355 1356 net = alloc_netdev(sizeof(struct dvb_net_priv), "dvb",1357 NET_NAME_UNKNOWN, dvb_net_setup);1358 if (!net)1359 return -ENOMEM;1360 1361 if (dvbnet->dvbdev->id)1362 snprintf(net->name, IFNAMSIZ, "dvb%d%u%d",1363 dvbnet->dvbdev->adapter->num, dvbnet->dvbdev->id, if_num);1364 else1365 /* compatibility fix to keep dvb0_0 format */1366 snprintf(net->name, IFNAMSIZ, "dvb%d_%d",1367 dvbnet->dvbdev->adapter->num, if_num);1368 1369 net->addr_len = 6;1370 eth_hw_addr_set(net, dvbnet->dvbdev->adapter->proposed_mac);1371 1372 dvbnet->device[if_num] = net;1373 1374 priv = netdev_priv(net);1375 priv->net = net;1376 priv->demux = dvbnet->demux;1377 priv->pid = pid;1378 priv->rx_mode = RX_MODE_UNI;1379 priv->need_pusi = 1;1380 priv->tscc = 0;1381 priv->feedtype = feedtype;1382 reset_ule(priv);1383 1384 INIT_WORK(&priv->set_multicast_list_wq, wq_set_multicast_list);1385 INIT_WORK(&priv->restart_net_feed_wq, wq_restart_net_feed);1386 mutex_init(&priv->mutex);1387 1388 net->base_addr = pid;1389 1390 if ((result = register_netdev(net)) < 0) {1391 dvbnet->device[if_num] = NULL;1392 free_netdev(net);1393 return result;1394 }1395 pr_info("created network interface %s\n", net->name);1396 1397 return if_num;1398}1399 1400static int dvb_net_remove_if(struct dvb_net *dvbnet, unsigned long num)1401{1402 struct net_device *net = dvbnet->device[num];1403 struct dvb_net_priv *priv;1404 1405 if (!dvbnet->state[num])1406 return -EINVAL;1407 priv = netdev_priv(net);1408 if (priv->in_use)1409 return -EBUSY;1410 1411 dvb_net_stop(net);1412 flush_work(&priv->set_multicast_list_wq);1413 flush_work(&priv->restart_net_feed_wq);1414 pr_info("removed network interface %s\n", net->name);1415 unregister_netdev(net);1416 dvbnet->state[num]=0;1417 dvbnet->device[num] = NULL;1418 free_netdev(net);1419 1420 return 0;1421}1422 1423static int dvb_net_do_ioctl(struct file *file,1424 unsigned int cmd, void *parg)1425{1426 struct dvb_device *dvbdev = file->private_data;1427 struct dvb_net *dvbnet = dvbdev->priv;1428 int ret = 0;1429 1430 if (((file->f_flags&O_ACCMODE)==O_RDONLY))1431 return -EPERM;1432 1433 if (mutex_lock_interruptible(&dvbnet->ioctl_mutex))1434 return -ERESTARTSYS;1435 1436 switch (cmd) {1437 case NET_ADD_IF:1438 {1439 struct dvb_net_if *dvbnetif = parg;1440 int result;1441 1442 if (!capable(CAP_SYS_ADMIN)) {1443 ret = -EPERM;1444 goto ioctl_error;1445 }1446 1447 if (!try_module_get(dvbdev->adapter->module)) {1448 ret = -EPERM;1449 goto ioctl_error;1450 }1451 1452 result=dvb_net_add_if(dvbnet, dvbnetif->pid, dvbnetif->feedtype);1453 if (result<0) {1454 module_put(dvbdev->adapter->module);1455 ret = result;1456 goto ioctl_error;1457 }1458 dvbnetif->if_num=result;1459 break;1460 }1461 case NET_GET_IF:1462 {1463 struct net_device *netdev;1464 struct dvb_net_priv *priv_data;1465 struct dvb_net_if *dvbnetif = parg;1466 int if_num = dvbnetif->if_num;1467 1468 if (if_num >= DVB_NET_DEVICES_MAX) {1469 ret = -EINVAL;1470 goto ioctl_error;1471 }1472 if_num = array_index_nospec(if_num, DVB_NET_DEVICES_MAX);1473 1474 if (!dvbnet->state[if_num]) {1475 ret = -EINVAL;1476 goto ioctl_error;1477 }1478 1479 netdev = dvbnet->device[if_num];1480 1481 priv_data = netdev_priv(netdev);1482 dvbnetif->pid=priv_data->pid;1483 dvbnetif->feedtype=priv_data->feedtype;1484 break;1485 }1486 case NET_REMOVE_IF:1487 {1488 if (!capable(CAP_SYS_ADMIN)) {1489 ret = -EPERM;1490 goto ioctl_error;1491 }1492 if ((unsigned long) parg >= DVB_NET_DEVICES_MAX) {1493 ret = -EINVAL;1494 goto ioctl_error;1495 }1496 ret = dvb_net_remove_if(dvbnet, (unsigned long) parg);1497 if (!ret)1498 module_put(dvbdev->adapter->module);1499 break;1500 }1501 1502 /* binary compatibility cruft */1503 case __NET_ADD_IF_OLD:1504 {1505 struct __dvb_net_if_old *dvbnetif = parg;1506 int result;1507 1508 if (!capable(CAP_SYS_ADMIN)) {1509 ret = -EPERM;1510 goto ioctl_error;1511 }1512 1513 if (!try_module_get(dvbdev->adapter->module)) {1514 ret = -EPERM;1515 goto ioctl_error;1516 }1517 1518 result=dvb_net_add_if(dvbnet, dvbnetif->pid, DVB_NET_FEEDTYPE_MPE);1519 if (result<0) {1520 module_put(dvbdev->adapter->module);1521 ret = result;1522 goto ioctl_error;1523 }1524 dvbnetif->if_num=result;1525 break;1526 }1527 case __NET_GET_IF_OLD:1528 {1529 struct net_device *netdev;1530 struct dvb_net_priv *priv_data;1531 struct __dvb_net_if_old *dvbnetif = parg;1532 int if_num = dvbnetif->if_num;1533 1534 if (if_num >= DVB_NET_DEVICES_MAX) {1535 ret = -EINVAL;1536 goto ioctl_error;1537 }1538 if_num = array_index_nospec(if_num, DVB_NET_DEVICES_MAX);1539 1540 if (!dvbnet->state[if_num]) {1541 ret = -EINVAL;1542 goto ioctl_error;1543 }1544 1545 netdev = dvbnet->device[if_num];1546 1547 priv_data = netdev_priv(netdev);1548 dvbnetif->pid=priv_data->pid;1549 break;1550 }1551 default:1552 ret = -ENOTTY;1553 break;1554 }1555 1556ioctl_error:1557 mutex_unlock(&dvbnet->ioctl_mutex);1558 return ret;1559}1560 1561static long dvb_net_ioctl(struct file *file,1562 unsigned int cmd, unsigned long arg)1563{1564 return dvb_usercopy(file, cmd, arg, dvb_net_do_ioctl);1565}1566 1567static int locked_dvb_net_open(struct inode *inode, struct file *file)1568{1569 struct dvb_device *dvbdev = file->private_data;1570 struct dvb_net *dvbnet = dvbdev->priv;1571 int ret;1572 1573 if (mutex_lock_interruptible(&dvbnet->remove_mutex))1574 return -ERESTARTSYS;1575 1576 if (dvbnet->exit) {1577 mutex_unlock(&dvbnet->remove_mutex);1578 return -ENODEV;1579 }1580 1581 ret = dvb_generic_open(inode, file);1582 1583 mutex_unlock(&dvbnet->remove_mutex);1584 1585 return ret;1586}1587 1588static int dvb_net_close(struct inode *inode, struct file *file)1589{1590 struct dvb_device *dvbdev = file->private_data;1591 struct dvb_net *dvbnet = dvbdev->priv;1592 1593 mutex_lock(&dvbnet->remove_mutex);1594 1595 dvb_generic_release(inode, file);1596 1597 if (dvbdev->users == 1 && dvbnet->exit == 1) {1598 mutex_unlock(&dvbnet->remove_mutex);1599 wake_up(&dvbdev->wait_queue);1600 } else {1601 mutex_unlock(&dvbnet->remove_mutex);1602 }1603 1604 return 0;1605}1606 1607 1608static const struct file_operations dvb_net_fops = {1609 .owner = THIS_MODULE,1610 .unlocked_ioctl = dvb_net_ioctl,1611 .open = locked_dvb_net_open,1612 .release = dvb_net_close,1613 .llseek = noop_llseek,1614};1615 1616static const struct dvb_device dvbdev_net = {1617 .priv = NULL,1618 .users = 1,1619 .writers = 1,1620#if defined(CONFIG_MEDIA_CONTROLLER_DVB)1621 .name = "dvb-net",1622#endif1623 .fops = &dvb_net_fops,1624};1625 1626void dvb_net_release (struct dvb_net *dvbnet)1627{1628 int i;1629 1630 mutex_lock(&dvbnet->remove_mutex);1631 dvbnet->exit = 1;1632 mutex_unlock(&dvbnet->remove_mutex);1633 1634 if (dvbnet->dvbdev->users < 1)1635 wait_event(dvbnet->dvbdev->wait_queue,1636 dvbnet->dvbdev->users == 1);1637 1638 dvb_unregister_device(dvbnet->dvbdev);1639 1640 for (i=0; i<DVB_NET_DEVICES_MAX; i++) {1641 if (!dvbnet->state[i])1642 continue;1643 dvb_net_remove_if(dvbnet, i);1644 }1645}1646EXPORT_SYMBOL(dvb_net_release);1647 1648 1649int dvb_net_init (struct dvb_adapter *adap, struct dvb_net *dvbnet,1650 struct dmx_demux *dmx)1651{1652 int i;1653 1654 mutex_init(&dvbnet->ioctl_mutex);1655 mutex_init(&dvbnet->remove_mutex);1656 dvbnet->demux = dmx;1657 1658 for (i=0; i<DVB_NET_DEVICES_MAX; i++)1659 dvbnet->state[i] = 0;1660 1661 return dvb_register_device(adap, &dvbnet->dvbdev, &dvbdev_net,1662 dvbnet, DVB_DEVICE_NET, 0);1663}1664EXPORT_SYMBOL(dvb_net_init);1665