4 * Copyright (C) 2001 Convergence integrated media GmbH
5 * Ralph Metzler <ralph@convergence.de>
6 * Copyright (C) 2002 Ralph Metzler <rjkm@metzlerbros.de>
8 * ULE Decapsulation code:
9 * Copyright (C) 2003, 2004 gcs - Global Communication & Services GmbH.
10 * and Department of Scientific Computing
11 * Paris Lodron University of Salzburg.
12 * Hilmar Linder <hlinder@cosy.sbg.ac.at>
13 * and Wolfram Stering <wstering@cosy.sbg.ac.at>
15 * ULE Decaps according to RFC 4326.
17 * This program is free software; you can redistribute it and/or
18 * modify it under the terms of the GNU General Public License
19 * as published by the Free Software Foundation; either version 2
20 * of the License, or (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, write to the Free Software
29 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
30 * Or, point your browser to http://www.gnu.org/copyleft/gpl.html
35 * Feb 2004: hl/ws v1: Implementing draft-fair-ipdvb-ule-01.txt
37 * Dec 2004: hl/ws v2: Implementing draft-ietf-ipdvb-ule-03.txt:
38 * ULE Extension header handling.
39 * Bugreports by Moritz Vieth and Hanno Tersteegen,
40 * Fraunhofer Institute for Open Communication Systems
41 * Competence Center for Advanced Satellite Communications.
42 * Bugfixes and robustness improvements.
43 * Filtering on dest MAC addresses, if present (D-Bit = 0)
44 * ULE_DEBUG compile-time option.
45 * Apr 2006: cp v3: Bugfixes and compliency with RFC 4326 (ULE) by
46 * Christian Praehauser <cpraehaus@cosy.sbg.ac.at>,
47 * Paris Lodron University of Salzburg.
51 * FIXME / TODO (dvb_net.c):
53 * Unloading does not work for 2.6.9 kernels: a refcount doesn't go to zero.
57 #include <linux/module.h>
58 #include <linux/kernel.h>
59 #include <linux/netdevice.h>
60 #include <linux/etherdevice.h>
61 #include <linux/dvb/net.h>
62 #include <linux/uio.h>
63 #include <asm/uaccess.h>
64 #include <linux/crc32.h>
65 #include <linux/mutex.h>
67 #include "dvb_demux.h"
70 static int dvb_net_debug
;
71 module_param(dvb_net_debug
, int, 0444);
72 MODULE_PARM_DESC(dvb_net_debug
, "enable debug messages");
74 #define dprintk(x...) do { if (dvb_net_debug) printk(x); } while (0)
77 static inline __u32
iov_crc32( __u32 c
, struct kvec
*iov
, unsigned int cnt
)
80 for (j
= 0; j
< cnt
; j
++)
81 c
= crc32_be( c
, iov
[j
].iov_base
, iov
[j
].iov_len
);
86 #define DVB_NET_MULTICAST_MAX 10
92 #define MAC_ADDR_PRINTFMT "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x"
93 #define MAX_ADDR_PRINTFMT_ARGS(macap) (macap)[0],(macap)[1],(macap)[2],(macap)[3],(macap)[4],(macap)[5]
95 #define isprint(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'))
97 static void hexdump( const unsigned char *buf
, unsigned short len
)
99 char str
[80], octet
[10];
102 for (ofs
= 0; ofs
< len
; ofs
+= 16) {
103 sprintf( str
, "%03d: ", ofs
);
105 for (i
= 0; i
< 16; i
++) {
107 sprintf( octet
, "%02x ", buf
[ofs
+ i
] );
109 strcpy( octet
, " " );
111 strcat( str
, octet
);
116 for (i
= 0; (i
< 16) && ((i
+ ofs
) < len
); i
++)
117 str
[l
++] = isprint( buf
[ofs
+ i
] ) ? buf
[ofs
+ i
] : '.';
120 printk( KERN_WARNING
"%s\n", str
);
126 struct dvb_net_priv
{
128 struct net_device_stats stats
;
130 struct dvb_net
*host
;
131 struct dmx_demux
*demux
;
132 struct dmx_section_feed
*secfeed
;
133 struct dmx_section_filter
*secfilter
;
134 struct dmx_ts_feed
*tsfeed
;
136 struct dmx_section_filter
*multi_secfilter
[DVB_NET_MULTICAST_MAX
];
137 unsigned char multi_macs
[DVB_NET_MULTICAST_MAX
][6];
139 #define RX_MODE_UNI 0
140 #define RX_MODE_MULTI 1
141 #define RX_MODE_ALL_MULTI 2
142 #define RX_MODE_PROMISC 3
143 struct work_struct set_multicast_list_wq
;
144 struct work_struct restart_net_feed_wq
;
145 unsigned char feedtype
; /* Either FEED_TYPE_ or FEED_TYPE_ULE */
146 int need_pusi
; /* Set to 1, if synchronization on PUSI required. */
147 unsigned char tscc
; /* TS continuity counter after sync on PUSI. */
148 struct sk_buff
*ule_skb
; /* ULE SNDU decodes into this buffer. */
149 unsigned char *ule_next_hdr
; /* Pointer into skb to next ULE extension header. */
150 unsigned short ule_sndu_len
; /* ULE SNDU length in bytes, w/o D-Bit. */
151 unsigned short ule_sndu_type
; /* ULE SNDU type field, complete. */
152 unsigned char ule_sndu_type_1
; /* ULE SNDU type field, if split across 2 TS cells. */
153 unsigned char ule_dbit
; /* Whether the DestMAC address present
154 * or not (bit is set). */
155 unsigned char ule_bridged
; /* Whether the ULE_BRIDGED extension header was found. */
156 int ule_sndu_remain
; /* Nr. of bytes still required for current ULE SNDU. */
157 unsigned long ts_count
; /* Current ts cell counter. */
163 * Determine the packet's protocol ID. The rule here is that we
164 * assume 802.3 if the type field is short enough to be a length.
165 * This is normal practice and works for any 'now in use' protocol.
167 * stolen from eth.c out of the linux kernel, hacked for dvb-device
168 * by Michael Holzt <kju@debian.org>
170 static unsigned short dvb_net_eth_type_trans(struct sk_buff
*skb
,
171 struct net_device
*dev
)
176 skb
->mac
.raw
=skb
->data
;
177 skb_pull(skb
,dev
->hard_header_len
);
180 if (*eth
->h_dest
& 1) {
181 if(memcmp(eth
->h_dest
,dev
->broadcast
, ETH_ALEN
)==0)
182 skb
->pkt_type
=PACKET_BROADCAST
;
184 skb
->pkt_type
=PACKET_MULTICAST
;
187 if (ntohs(eth
->h_proto
) >= 1536)
193 * This is a magic hack to spot IPX packets. Older Novell breaks
194 * the protocol design and runs IPX over 802.3 without an 802.2 LLC
195 * layer. We look for FFFF which isn't a used 802.2 SSAP/DSAP. This
196 * won't work for fault tolerant netware but does for the rest.
198 if (*(unsigned short *)rawp
== 0xFFFF)
199 return htons(ETH_P_802_3
);
204 return htons(ETH_P_802_2
);
215 /* ULE Extension Header handlers. */
218 #define ULE_BRIDGED 1
220 #define ULE_OPTEXTHDR_PADDING 0
222 static int ule_test_sndu( struct dvb_net_priv
*p
)
227 static int ule_bridged_sndu( struct dvb_net_priv
*p
)
229 struct ethhdr
*hdr
= (struct ethhdr
*) p
->ule_next_hdr
;
230 if(ntohs(hdr
->h_proto
) < 1536) {
231 int framelen
= p
->ule_sndu_len
- ((p
->ule_next_hdr
+sizeof(struct ethhdr
)) - p
->ule_skb
->data
);
232 /* A frame Type < 1536 for a bridged frame, introduces a LLC Length field. */
233 if(framelen
!= ntohs(hdr
->h_proto
)) {
239 * "A bridged SNDU is a Mandatory Extension Header of Type 1.
240 * It must be the final (or only) extension header specified in the header chain of a SNDU."
241 * The 'ule_bridged' flag will cause the extension header processing loop to terminate.
247 static int ule_exthdr_padding(struct dvb_net_priv
*p
)
252 /** Handle ULE extension headers.
253 * Function is called after a successful CRC32 verification of an ULE SNDU to complete its decoding.
254 * Returns: >= 0: nr. of bytes consumed by next extension header
255 * -1: Mandatory extension header that is not recognized or TEST SNDU; discard.
257 static int handle_one_ule_extension( struct dvb_net_priv
*p
)
259 /* Table of mandatory extension header handlers. The header type is the index. */
260 static int (*ule_mandatory_ext_handlers
[255])( struct dvb_net_priv
*p
) =
261 { [0] = ule_test_sndu
, [1] = ule_bridged_sndu
, [2] = NULL
, };
263 /* Table of optional extension header handlers. The header type is the index. */
264 static int (*ule_optional_ext_handlers
[255])( struct dvb_net_priv
*p
) =
265 { [0] = ule_exthdr_padding
, [1] = NULL
, };
268 unsigned char hlen
= (p
->ule_sndu_type
& 0x0700) >> 8;
269 unsigned char htype
= p
->ule_sndu_type
& 0x00FF;
271 /* Discriminate mandatory and optional extension headers. */
273 /* Mandatory extension header */
274 if (ule_mandatory_ext_handlers
[htype
]) {
275 ext_len
= ule_mandatory_ext_handlers
[htype
]( p
);
277 p
->ule_next_hdr
+= ext_len
;
278 if (!p
->ule_bridged
) {
279 p
->ule_sndu_type
= ntohs(*(unsigned short *)p
->ule_next_hdr
);
280 p
->ule_next_hdr
+= 2;
282 p
->ule_sndu_type
= ntohs(*(unsigned short *)(p
->ule_next_hdr
+ ((p
->ule_dbit
? 2 : 3) * ETH_ALEN
)));
283 /* This assures the extension handling loop will terminate. */
286 // else: extension handler failed or SNDU should be discarded
288 ext_len
= -1; /* SNDU has to be discarded. */
290 /* Optional extension header. Calculate the length. */
292 /* Process the optional extension header according to its type. */
293 if (ule_optional_ext_handlers
[htype
])
294 (void)ule_optional_ext_handlers
[htype
]( p
);
295 p
->ule_next_hdr
+= ext_len
;
296 p
->ule_sndu_type
= ntohs( *(unsigned short *)(p
->ule_next_hdr
-2) );
298 * note: the length of the next header type is included in the
299 * length of THIS optional extension header
306 static int handle_ule_extensions( struct dvb_net_priv
*p
)
308 int total_ext_len
= 0, l
;
310 p
->ule_next_hdr
= p
->ule_skb
->data
;
312 l
= handle_one_ule_extension( p
);
314 return l
; /* Stop extension header processing and discard SNDU. */
317 dprintk("handle_ule_extensions: ule_next_hdr=%p, ule_sndu_type=%i, "
318 "l=%i, total_ext_len=%i\n", p
->ule_next_hdr
,
319 (int) p
->ule_sndu_type
, l
, total_ext_len
);
322 } while (p
->ule_sndu_type
< 1536);
324 return total_ext_len
;
328 /** Prepare for a new ULE SNDU: reset the decoder state. */
329 static inline void reset_ule( struct dvb_net_priv
*p
)
332 p
->ule_next_hdr
= NULL
;
334 p
->ule_sndu_type
= 0;
335 p
->ule_sndu_type_1
= 0;
336 p
->ule_sndu_remain
= 0;
342 * Decode ULE SNDUs according to draft-ietf-ipdvb-ule-03.txt from a sequence of
343 * TS cells of a single PID.
345 static void dvb_net_ule( struct net_device
*dev
, const u8
*buf
, size_t buf_len
)
347 struct dvb_net_priv
*priv
= dev
->priv
;
348 unsigned long skipped
= 0L;
349 u8
*ts
, *ts_end
, *from_where
= NULL
, ts_remain
= 0, how_much
= 0, new_ts
= 1;
350 struct ethhdr
*ethh
= NULL
;
353 /* The code inside ULE_DEBUG keeps a history of the last 100 TS cells processed. */
354 static unsigned char ule_hist
[100*TS_SZ
];
355 static unsigned char *ule_where
= ule_hist
, ule_dump
= 0;
359 printk( KERN_ERR
"NO netdev struct!\n" );
363 /* For all TS cells in current buffer.
364 * Appearently, we are called for every single TS cell.
366 for (ts
= (char *)buf
, ts_end
= (char *)buf
+ buf_len
; ts
< ts_end
; /* no default incr. */ ) {
369 /* We are about to process a new TS cell. */
372 if (ule_where
>= &ule_hist
[100*TS_SZ
]) ule_where
= ule_hist
;
373 memcpy( ule_where
, ts
, TS_SZ
);
375 hexdump( ule_where
, TS_SZ
);
381 /* Check TS error conditions: sync_byte, transport_error_indicator, scrambling_control . */
382 if ((ts
[0] != TS_SYNC
) || (ts
[1] & TS_TEI
) || ((ts
[3] & TS_SC
) != 0)) {
383 printk(KERN_WARNING
"%lu: Invalid TS cell: SYNC %#x, TEI %u, SC %#x.\n",
384 priv
->ts_count
, ts
[0], ts
[1] & TS_TEI
>> 7, ts
[3] & 0xC0 >> 6);
386 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
388 dev_kfree_skb( priv
->ule_skb
);
389 /* Prepare for next SNDU. */
390 priv
->stats
.rx_errors
++;
391 priv
->stats
.rx_frame_errors
++;
396 /* Continue with next TS cell. */
405 /* Synchronize on PUSI, if required. */
406 if (priv
->need_pusi
) {
407 if (ts
[1] & TS_PUSI
) {
408 /* Find beginning of first ULE SNDU in current TS cell. */
409 /* Synchronize continuity counter. */
410 priv
->tscc
= ts
[3] & 0x0F;
411 /* There is a pointer field here. */
412 if (ts
[4] > ts_remain
) {
413 printk(KERN_ERR
"%lu: Invalid ULE packet "
414 "(pointer field %d)\n", priv
->ts_count
, ts
[4]);
419 /* Skip to destination of pointer field. */
420 from_where
= &ts
[5] + ts
[4];
421 ts_remain
-= 1 + ts
[4];
432 /* Check continuity counter. */
433 if ((ts
[3] & 0x0F) == priv
->tscc
)
434 priv
->tscc
= (priv
->tscc
+ 1) & 0x0F;
436 /* TS discontinuity handling: */
437 printk(KERN_WARNING
"%lu: TS discontinuity: got %#x, "
438 "expected %#x.\n", priv
->ts_count
, ts
[3] & 0x0F, priv
->tscc
);
439 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
441 dev_kfree_skb( priv
->ule_skb
);
442 /* Prepare for next SNDU. */
443 // reset_ule(priv); moved to below.
444 priv
->stats
.rx_errors
++;
445 priv
->stats
.rx_frame_errors
++;
448 /* skip to next PUSI. */
452 /* If we still have an incomplete payload, but PUSI is
453 * set; some TS cells are missing.
454 * This is only possible here, if we missed exactly 16 TS
455 * cells (continuity counter wrap). */
456 if (ts
[1] & TS_PUSI
) {
457 if (! priv
->need_pusi
) {
458 if (!(*from_where
< (ts_remain
-1)) || *from_where
!= priv
->ule_sndu_remain
) {
459 /* Pointer field is invalid. Drop this TS cell and any started ULE SNDU. */
460 printk(KERN_WARNING
"%lu: Invalid pointer "
461 "field: %u.\n", priv
->ts_count
, *from_where
);
463 /* Drop partly decoded SNDU, reset state, resync on PUSI. */
465 dev_kfree_skb( priv
->ule_skb
);
466 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_errors
++;
467 ((struct dvb_net_priv
*) dev
->priv
)->stats
.rx_frame_errors
++;
473 /* Skip pointer field (we're processing a
474 * packed payload). */
480 if (priv
->ule_sndu_remain
> 183) {
481 /* Current SNDU lacks more data than there could be available in the
482 * current TS cell. */
483 priv
->stats
.rx_errors
++;
484 priv
->stats
.rx_length_errors
++;
485 printk(KERN_WARNING
"%lu: Expected %d more SNDU bytes, but "
486 "got PUSI (pf %d, ts_remain %d). Flushing incomplete payload.\n",
487 priv
->ts_count
, priv
->ule_sndu_remain
, ts
[4], ts_remain
);
488 dev_kfree_skb(priv
->ule_skb
);
489 /* Prepare for next SNDU. */
491 /* Resync: go to where pointer field points to: start of next ULE SNDU. */
498 /* Check if new payload needs to be started. */
499 if (priv
->ule_skb
== NULL
) {
500 /* Start a new payload with skb.
501 * Find ULE header. It is only guaranteed that the
502 * length field (2 bytes) is contained in the current
504 * Check ts_remain has to be >= 2 here. */
506 printk(KERN_WARNING
"Invalid payload packing: only %d "
507 "bytes left in TS. Resyncing.\n", ts_remain
);
508 priv
->ule_sndu_len
= 0;
513 if (! priv
->ule_sndu_len
) {
514 /* Got at least two bytes, thus extrace the SNDU length. */
515 priv
->ule_sndu_len
= from_where
[0] << 8 | from_where
[1];
516 if (priv
->ule_sndu_len
& 0x8000) {
517 /* D-Bit is set: no dest mac present. */
518 priv
->ule_sndu_len
&= 0x7FFF;
523 if (priv
->ule_sndu_len
< 5) {
524 printk(KERN_WARNING
"%lu: Invalid ULE SNDU length %u. "
525 "Resyncing.\n", priv
->ts_count
, priv
->ule_sndu_len
);
526 priv
->stats
.rx_errors
++;
527 priv
->stats
.rx_length_errors
++;
528 priv
->ule_sndu_len
= 0;
535 ts_remain
-= 2; /* consume the 2 bytes SNDU length. */
540 * State of current TS:
541 * ts_remain (remaining bytes in the current TS cell)
542 * 0 ule_type is not available now, we need the next TS cell
543 * 1 the first byte of the ule_type is present
544 * >=2 full ULE header present, maybe some payload data as well.
548 priv
->ule_sndu_type
= from_where
[0] << 8;
549 priv
->ule_sndu_type_1
= 1; /* first byte of ule_type is set. */
550 ts_remain
-= 1; from_where
+= 1;
551 /* Continue w/ next TS. */
558 default: /* complete ULE header is present in current TS. */
559 /* Extract ULE type field. */
560 if (priv
->ule_sndu_type_1
) {
561 priv
->ule_sndu_type
|= from_where
[0];
562 from_where
+= 1; /* points to payload start. */
565 /* Complete type is present in new TS. */
566 priv
->ule_sndu_type
= from_where
[0] << 8 | from_where
[1];
567 from_where
+= 2; /* points to payload start. */
573 /* Allocate the skb (decoder target buffer) with the correct size, as follows:
574 * prepare for the largest case: bridged SNDU with MAC address (dbit = 0). */
575 priv
->ule_skb
= dev_alloc_skb( priv
->ule_sndu_len
+ ETH_HLEN
+ ETH_ALEN
);
576 if (priv
->ule_skb
== NULL
) {
577 printk(KERN_NOTICE
"%s: Memory squeeze, dropping packet.\n",
579 ((struct dvb_net_priv
*)dev
->priv
)->stats
.rx_dropped
++;
583 /* This includes the CRC32 _and_ dest mac, if !dbit. */
584 priv
->ule_sndu_remain
= priv
->ule_sndu_len
;
585 priv
->ule_skb
->dev
= dev
;
586 /* Leave space for Ethernet or bridged SNDU header (eth hdr plus one MAC addr). */
587 skb_reserve( priv
->ule_skb
, ETH_HLEN
+ ETH_ALEN
);
590 /* Copy data into our current skb. */
591 how_much
= min(priv
->ule_sndu_remain
, (int)ts_remain
);
592 memcpy(skb_put(priv
->ule_skb
, how_much
), from_where
, how_much
);
593 priv
->ule_sndu_remain
-= how_much
;
594 ts_remain
-= how_much
;
595 from_where
+= how_much
;
597 /* Check for complete payload. */
598 if (priv
->ule_sndu_remain
<= 0) {
599 /* Check CRC32, we've got it in our skb already. */
600 unsigned short ulen
= htons(priv
->ule_sndu_len
);
601 unsigned short utype
= htons(priv
->ule_sndu_type
);
602 struct kvec iov
[3] = {
603 { &ulen
, sizeof ulen
},
604 { &utype
, sizeof utype
},
605 { priv
->ule_skb
->data
, priv
->ule_skb
->len
- 4 }
607 unsigned long ule_crc
= ~0L, expected_crc
;
608 if (priv
->ule_dbit
) {
609 /* Set D-bit for CRC32 verification,
610 * if it was set originally. */
614 ule_crc
= iov_crc32(ule_crc
, iov
, 3);
615 expected_crc
= *((u8
*)priv
->ule_skb
->tail
- 4) << 24 |
616 *((u8
*)priv
->ule_skb
->tail
- 3) << 16 |
617 *((u8
*)priv
->ule_skb
->tail
- 2) << 8 |
618 *((u8
*)priv
->ule_skb
->tail
- 1);
619 if (ule_crc
!= expected_crc
) {
620 printk(KERN_WARNING
"%lu: CRC32 check FAILED: %#lx / %#lx, SNDU len %d type %#x, ts_remain %d, next 2: %x.\n",
621 priv
->ts_count
, ule_crc
, expected_crc
, priv
->ule_sndu_len
, priv
->ule_sndu_type
, ts_remain
, ts_remain
> 2 ? *(unsigned short *)from_where
: 0);
624 hexdump( iov
[0].iov_base
, iov
[0].iov_len
);
625 hexdump( iov
[1].iov_base
, iov
[1].iov_len
);
626 hexdump( iov
[2].iov_base
, iov
[2].iov_len
);
628 if (ule_where
== ule_hist
) {
629 hexdump( &ule_hist
[98*TS_SZ
], TS_SZ
);
630 hexdump( &ule_hist
[99*TS_SZ
], TS_SZ
);
631 } else if (ule_where
== &ule_hist
[TS_SZ
]) {
632 hexdump( &ule_hist
[99*TS_SZ
], TS_SZ
);
633 hexdump( ule_hist
, TS_SZ
);
635 hexdump( ule_where
- TS_SZ
- TS_SZ
, TS_SZ
);
636 hexdump( ule_where
- TS_SZ
, TS_SZ
);
641 priv
->stats
.rx_errors
++;
642 priv
->stats
.rx_crc_errors
++;
643 dev_kfree_skb(priv
->ule_skb
);
645 /* CRC32 verified OK. */
646 u8 dest_addr
[ETH_ALEN
];
647 static const u8 bc_addr
[ETH_ALEN
] =
648 { [ 0 ... ETH_ALEN
-1] = 0xff };
650 /* CRC32 was OK. Remove it from skb. */
651 priv
->ule_skb
->tail
-= 4;
652 priv
->ule_skb
->len
-= 4;
654 if (!priv
->ule_dbit
) {
656 * The destination MAC address is the
657 * next data in the skb. It comes
658 * before any extension headers.
660 * Check if the payload of this SNDU
661 * should be passed up the stack.
663 register int drop
= 0;
664 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
665 if (priv
->ule_skb
->data
[0] & 0x01) {
666 /* multicast or broadcast */
667 if (memcmp(priv
->ule_skb
->data
, bc_addr
, ETH_ALEN
)) {
669 if (priv
->rx_mode
== RX_MODE_MULTI
) {
671 for(i
= 0; i
< priv
->multi_num
&& memcmp(priv
->ule_skb
->data
, priv
->multi_macs
[i
], ETH_ALEN
); i
++)
673 if (i
== priv
->multi_num
)
675 } else if (priv
->rx_mode
!= RX_MODE_ALL_MULTI
)
676 drop
= 1; /* no broadcast; */
677 /* else: all multicast mode: accept all multicast packets */
679 /* else: broadcast */
681 else if (memcmp(priv
->ule_skb
->data
, dev
->dev_addr
, ETH_ALEN
))
683 /* else: destination address matches the MAC address of our receiver device */
685 /* else: promiscious mode; pass everything up the stack */
689 dprintk("Dropping SNDU: MAC destination address does not match: dest addr: "MAC_ADDR_PRINTFMT
", dev addr: "MAC_ADDR_PRINTFMT
"\n",
690 MAX_ADDR_PRINTFMT_ARGS(priv
->ule_skb
->data
), MAX_ADDR_PRINTFMT_ARGS(dev
->dev_addr
));
692 dev_kfree_skb(priv
->ule_skb
);
697 memcpy(dest_addr
, priv
->ule_skb
->data
, ETH_ALEN
);
698 skb_pull(priv
->ule_skb
, ETH_ALEN
);
702 /* Handle ULE Extension Headers. */
703 if (priv
->ule_sndu_type
< 1536) {
704 /* There is an extension header. Handle it accordingly. */
705 int l
= handle_ule_extensions(priv
);
707 /* Mandatory extension header unknown or TEST SNDU. Drop it. */
708 // printk( KERN_WARNING "Dropping SNDU, extension headers.\n" );
709 dev_kfree_skb(priv
->ule_skb
);
712 skb_pull(priv
->ule_skb
, l
);
716 * Construct/assure correct ethernet header.
717 * Note: in bridged mode (priv->ule_bridged !=
718 * 0) we already have the (original) ethernet
719 * header at the start of the payload (after
720 * optional dest. address and any extension
724 if (!priv
->ule_bridged
) {
725 skb_push(priv
->ule_skb
, ETH_HLEN
);
726 ethh
= (struct ethhdr
*)priv
->ule_skb
->data
;
727 if (!priv
->ule_dbit
) {
728 /* dest_addr buffer is only valid if priv->ule_dbit == 0 */
729 memcpy(ethh
->h_dest
, dest_addr
, ETH_ALEN
);
730 memset(ethh
->h_source
, 0, ETH_ALEN
);
732 else /* zeroize source and dest */
733 memset( ethh
, 0, ETH_ALEN
*2 );
735 ethh
->h_proto
= htons(priv
->ule_sndu_type
);
737 /* else: skb is in correct state; nothing to do. */
738 priv
->ule_bridged
= 0;
740 /* Stuff into kernel's protocol stack. */
741 priv
->ule_skb
->protocol
= dvb_net_eth_type_trans(priv
->ule_skb
, dev
);
742 /* If D-bit is set (i.e. destination MAC address not present),
743 * receive the packet anyhow. */
744 /* if (priv->ule_dbit && skb->pkt_type == PACKET_OTHERHOST)
745 priv->ule_skb->pkt_type = PACKET_HOST; */
746 priv
->stats
.rx_packets
++;
747 priv
->stats
.rx_bytes
+= priv
->ule_skb
->len
;
748 netif_rx(priv
->ule_skb
);
751 /* Prepare for next SNDU. */
755 /* More data in current TS (look at the bytes following the CRC32)? */
756 if (ts_remain
>= 2 && *((unsigned short *)from_where
) != 0xFFFF) {
757 /* Next ULE SNDU starts right there. */
759 priv
->ule_skb
= NULL
;
760 priv
->ule_sndu_type_1
= 0;
761 priv
->ule_sndu_len
= 0;
762 // printk(KERN_WARNING "More data in current TS: [%#x %#x %#x %#x]\n",
763 // *(from_where + 0), *(from_where + 1),
764 // *(from_where + 2), *(from_where + 3));
765 // printk(KERN_WARNING "ts @ %p, stopped @ %p:\n", ts, from_where + 0);
771 if (priv
->ule_skb
== NULL
) {
773 priv
->ule_sndu_type_1
= 0;
774 priv
->ule_sndu_len
= 0;
777 } /* for all available TS cells */
780 static int dvb_net_ts_callback(const u8
*buffer1
, size_t buffer1_len
,
781 const u8
*buffer2
, size_t buffer2_len
,
782 struct dmx_ts_feed
*feed
, enum dmx_success success
)
784 struct net_device
*dev
= feed
->priv
;
787 printk(KERN_WARNING
"buffer2 not 0: %p.\n", buffer2
);
788 if (buffer1_len
> 32768)
789 printk(KERN_WARNING
"length > 32k: %zu.\n", buffer1_len
);
790 /* printk("TS callback: %u bytes, %u TS cells @ %p.\n",
791 buffer1_len, buffer1_len / TS_SZ, buffer1); */
792 dvb_net_ule(dev
, buffer1
, buffer1_len
);
797 static void dvb_net_sec(struct net_device
*dev
, u8
*pkt
, int pkt_len
)
801 struct net_device_stats
*stats
= &(((struct dvb_net_priv
*) dev
->priv
)->stats
);
804 /* note: pkt_len includes a 32bit checksum */
806 printk("%s: IP/MPE packet length = %d too small.\n",
809 stats
->rx_length_errors
++;
812 /* it seems some ISPs manage to screw up here, so we have to
813 * relax the error checks... */
815 if ((pkt
[5] & 0xfd) != 0xc1) {
816 /* drop scrambled or broken packets */
818 if ((pkt
[5] & 0x3c) != 0x00) {
822 stats
->rx_crc_errors
++;
826 /* handle LLC/SNAP, see rfc-1042 */
827 if (pkt_len
< 24 || memcmp(&pkt
[12], "\xaa\xaa\x03\0\0\0", 6)) {
834 /* FIXME: assemble datagram from multiple sections */
836 stats
->rx_frame_errors
++;
840 /* we have 14 byte ethernet header (ip header follows);
841 * 12 byte MPE header; 4 byte checksum; + 2 byte alignment, 8 byte LLC/SNAP
843 if (!(skb
= dev_alloc_skb(pkt_len
- 4 - 12 + 14 + 2 - snap
))) {
844 //printk(KERN_NOTICE "%s: Memory squeeze, dropping packet.\n", dev->name);
848 skb_reserve(skb
, 2); /* longword align L3 header */
851 /* copy L3 payload */
852 eth
= (u8
*) skb_put(skb
, pkt_len
- 12 - 4 + 14 - snap
);
853 memcpy(eth
+ 14, pkt
+ 12 + snap
, pkt_len
- 12 - 4 - snap
);
855 /* create ethernet header: */
863 eth
[6]=eth
[7]=eth
[8]=eth
[9]=eth
[10]=eth
[11]=0;
869 /* protocol numbers are from rfc-1700 or
870 * http://www.iana.org/assignments/ethernet-numbers
872 if (pkt
[12] >> 4 == 6) { /* version field from IP header */
873 eth
[12] = 0x86; /* IPv6 */
876 eth
[12] = 0x08; /* IPv4 */
881 skb
->protocol
= dvb_net_eth_type_trans(skb
, dev
);
884 stats
->rx_bytes
+=skb
->len
;
888 static int dvb_net_sec_callback(const u8
*buffer1
, size_t buffer1_len
,
889 const u8
*buffer2
, size_t buffer2_len
,
890 struct dmx_section_filter
*filter
,
891 enum dmx_success success
)
893 struct net_device
*dev
= filter
->priv
;
896 * we rely on the DVB API definition where exactly one complete
897 * section is delivered in buffer1
899 dvb_net_sec (dev
, (u8
*) buffer1
, buffer1_len
);
903 static int dvb_net_tx(struct sk_buff
*skb
, struct net_device
*dev
)
909 static u8 mask_normal
[6]={0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
910 static u8 mask_allmulti
[6]={0xff, 0xff, 0xff, 0x00, 0x00, 0x00};
911 static u8 mac_allmulti
[6]={0x01, 0x00, 0x5e, 0x00, 0x00, 0x00};
912 static u8 mask_promisc
[6]={0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
914 static int dvb_net_filter_sec_set(struct net_device
*dev
,
915 struct dmx_section_filter
**secfilter
,
916 u8
*mac
, u8
*mac_mask
)
918 struct dvb_net_priv
*priv
= dev
->priv
;
922 ret
= priv
->secfeed
->allocate_filter(priv
->secfeed
, secfilter
);
924 printk("%s: could not get filter\n", dev
->name
);
928 (*secfilter
)->priv
=(void *) dev
;
930 memset((*secfilter
)->filter_value
, 0x00, DMX_MAX_FILTER_SIZE
);
931 memset((*secfilter
)->filter_mask
, 0x00, DMX_MAX_FILTER_SIZE
);
932 memset((*secfilter
)->filter_mode
, 0xff, DMX_MAX_FILTER_SIZE
);
934 (*secfilter
)->filter_value
[0]=0x3e;
935 (*secfilter
)->filter_value
[3]=mac
[5];
936 (*secfilter
)->filter_value
[4]=mac
[4];
937 (*secfilter
)->filter_value
[8]=mac
[3];
938 (*secfilter
)->filter_value
[9]=mac
[2];
939 (*secfilter
)->filter_value
[10]=mac
[1];
940 (*secfilter
)->filter_value
[11]=mac
[0];
942 (*secfilter
)->filter_mask
[0] = 0xff;
943 (*secfilter
)->filter_mask
[3] = mac_mask
[5];
944 (*secfilter
)->filter_mask
[4] = mac_mask
[4];
945 (*secfilter
)->filter_mask
[8] = mac_mask
[3];
946 (*secfilter
)->filter_mask
[9] = mac_mask
[2];
947 (*secfilter
)->filter_mask
[10] = mac_mask
[1];
948 (*secfilter
)->filter_mask
[11]=mac_mask
[0];
950 dprintk("%s: filter mac=%02x %02x %02x %02x %02x %02x\n",
951 dev
->name
, mac
[0], mac
[1], mac
[2], mac
[3], mac
[4], mac
[5]);
952 dprintk("%s: filter mask=%02x %02x %02x %02x %02x %02x\n",
953 dev
->name
, mac_mask
[0], mac_mask
[1], mac_mask
[2],
954 mac_mask
[3], mac_mask
[4], mac_mask
[5]);
959 static int dvb_net_feed_start(struct net_device
*dev
)
962 struct dvb_net_priv
*priv
= dev
->priv
;
963 struct dmx_demux
*demux
= priv
->demux
;
964 unsigned char *mac
= (unsigned char *) dev
->dev_addr
;
966 dprintk("%s: rx_mode %i\n", __FUNCTION__
, priv
->rx_mode
);
967 mutex_lock(&priv
->mutex
);
968 if (priv
->tsfeed
|| priv
->secfeed
|| priv
->secfilter
|| priv
->multi_secfilter
[0])
969 printk("%s: BUG %d\n", __FUNCTION__
, __LINE__
);
972 priv
->secfilter
=NULL
;
975 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
976 dprintk("%s: alloc secfeed\n", __FUNCTION__
);
977 ret
=demux
->allocate_section_feed(demux
, &priv
->secfeed
,
978 dvb_net_sec_callback
);
980 printk("%s: could not allocate section feed\n", dev
->name
);
984 ret
= priv
->secfeed
->set(priv
->secfeed
, priv
->pid
, 32768, 1);
987 printk("%s: could not set section feed\n", dev
->name
);
988 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
993 if (priv
->rx_mode
!= RX_MODE_PROMISC
) {
994 dprintk("%s: set secfilter\n", __FUNCTION__
);
995 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_normal
);
998 switch (priv
->rx_mode
) {
1000 for (i
= 0; i
< priv
->multi_num
; i
++) {
1001 dprintk("%s: set multi_secfilter[%d]\n", __FUNCTION__
, i
);
1002 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[i
],
1003 priv
->multi_macs
[i
], mask_normal
);
1006 case RX_MODE_ALL_MULTI
:
1008 dprintk("%s: set multi_secfilter[0]\n", __FUNCTION__
);
1009 dvb_net_filter_sec_set(dev
, &priv
->multi_secfilter
[0],
1010 mac_allmulti
, mask_allmulti
);
1012 case RX_MODE_PROMISC
:
1014 dprintk("%s: set secfilter\n", __FUNCTION__
);
1015 dvb_net_filter_sec_set(dev
, &priv
->secfilter
, mac
, mask_promisc
);
1019 dprintk("%s: start filtering\n", __FUNCTION__
);
1020 priv
->secfeed
->start_filtering(priv
->secfeed
);
1021 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1022 struct timespec timeout
= { 0, 10000000 }; // 10 msec
1024 /* we have payloads encapsulated in TS */
1025 dprintk("%s: alloc tsfeed\n", __FUNCTION__
);
1026 ret
= demux
->allocate_ts_feed(demux
, &priv
->tsfeed
, dvb_net_ts_callback
);
1028 printk("%s: could not allocate ts feed\n", dev
->name
);
1032 /* Set netdevice pointer for ts decaps callback. */
1033 priv
->tsfeed
->priv
= (void *)dev
;
1034 ret
= priv
->tsfeed
->set(priv
->tsfeed
,
1035 priv
->pid
, /* pid */
1036 TS_PACKET
, /* type */
1037 DMX_TS_PES_OTHER
, /* pes type */
1038 32768, /* circular buffer size */
1039 timeout
/* timeout */
1043 printk("%s: could not set ts feed\n", dev
->name
);
1044 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1045 priv
->tsfeed
= NULL
;
1049 dprintk("%s: start filtering\n", __FUNCTION__
);
1050 priv
->tsfeed
->start_filtering(priv
->tsfeed
);
1055 mutex_unlock(&priv
->mutex
);
1059 static int dvb_net_feed_stop(struct net_device
*dev
)
1061 struct dvb_net_priv
*priv
= dev
->priv
;
1064 dprintk("%s\n", __FUNCTION__
);
1065 mutex_lock(&priv
->mutex
);
1066 if (priv
->feedtype
== DVB_NET_FEEDTYPE_MPE
) {
1067 if (priv
->secfeed
) {
1068 if (priv
->secfeed
->is_filtering
) {
1069 dprintk("%s: stop secfeed\n", __FUNCTION__
);
1070 priv
->secfeed
->stop_filtering(priv
->secfeed
);
1073 if (priv
->secfilter
) {
1074 dprintk("%s: release secfilter\n", __FUNCTION__
);
1075 priv
->secfeed
->release_filter(priv
->secfeed
,
1077 priv
->secfilter
=NULL
;
1080 for (i
=0; i
<priv
->multi_num
; i
++) {
1081 if (priv
->multi_secfilter
[i
]) {
1082 dprintk("%s: release multi_filter[%d]\n",
1084 priv
->secfeed
->release_filter(priv
->secfeed
,
1085 priv
->multi_secfilter
[i
]);
1086 priv
->multi_secfilter
[i
] = NULL
;
1090 priv
->demux
->release_section_feed(priv
->demux
, priv
->secfeed
);
1091 priv
->secfeed
= NULL
;
1093 printk("%s: no feed to stop\n", dev
->name
);
1094 } else if (priv
->feedtype
== DVB_NET_FEEDTYPE_ULE
) {
1096 if (priv
->tsfeed
->is_filtering
) {
1097 dprintk("%s: stop tsfeed\n", __FUNCTION__
);
1098 priv
->tsfeed
->stop_filtering(priv
->tsfeed
);
1100 priv
->demux
->release_ts_feed(priv
->demux
, priv
->tsfeed
);
1101 priv
->tsfeed
= NULL
;
1104 printk("%s: no ts feed to stop\n", dev
->name
);
1107 mutex_unlock(&priv
->mutex
);
1112 static int dvb_set_mc_filter (struct net_device
*dev
, struct dev_mc_list
*mc
)
1114 struct dvb_net_priv
*priv
= dev
->priv
;
1116 if (priv
->multi_num
== DVB_NET_MULTICAST_MAX
)
1119 memcpy(priv
->multi_macs
[priv
->multi_num
], mc
->dmi_addr
, 6);
1126 static void wq_set_multicast_list (void *data
)
1128 struct net_device
*dev
= data
;
1129 struct dvb_net_priv
*priv
= dev
->priv
;
1131 dvb_net_feed_stop(dev
);
1132 priv
->rx_mode
= RX_MODE_UNI
;
1133 netif_tx_lock_bh(dev
);
1135 if (dev
->flags
& IFF_PROMISC
) {
1136 dprintk("%s: promiscuous mode\n", dev
->name
);
1137 priv
->rx_mode
= RX_MODE_PROMISC
;
1138 } else if ((dev
->flags
& IFF_ALLMULTI
)) {
1139 dprintk("%s: allmulti mode\n", dev
->name
);
1140 priv
->rx_mode
= RX_MODE_ALL_MULTI
;
1141 } else if (dev
->mc_count
) {
1143 struct dev_mc_list
*mc
;
1145 dprintk("%s: set_mc_list, %d entries\n",
1146 dev
->name
, dev
->mc_count
);
1148 priv
->rx_mode
= RX_MODE_MULTI
;
1149 priv
->multi_num
= 0;
1151 for (mci
= 0, mc
=dev
->mc_list
;
1152 mci
< dev
->mc_count
;
1153 mc
= mc
->next
, mci
++) {
1154 dvb_set_mc_filter(dev
, mc
);
1158 netif_tx_unlock_bh(dev
);
1159 dvb_net_feed_start(dev
);
1163 static void dvb_net_set_multicast_list (struct net_device
*dev
)
1165 struct dvb_net_priv
*priv
= dev
->priv
;
1166 schedule_work(&priv
->set_multicast_list_wq
);
1170 static void wq_restart_net_feed (void *data
)
1172 struct net_device
*dev
= data
;
1174 if (netif_running(dev
)) {
1175 dvb_net_feed_stop(dev
);
1176 dvb_net_feed_start(dev
);
1181 static int dvb_net_set_mac (struct net_device
*dev
, void *p
)
1183 struct dvb_net_priv
*priv
= dev
->priv
;
1184 struct sockaddr
*addr
=p
;
1186 memcpy(dev
->dev_addr
, addr
->sa_data
, dev
->addr_len
);
1188 if (netif_running(dev
))
1189 schedule_work(&priv
->restart_net_feed_wq
);
1195 static int dvb_net_open(struct net_device
*dev
)
1197 struct dvb_net_priv
*priv
= dev
->priv
;
1200 dvb_net_feed_start(dev
);
1205 static int dvb_net_stop(struct net_device
*dev
)
1207 struct dvb_net_priv
*priv
= dev
->priv
;
1210 return dvb_net_feed_stop(dev
);
1213 static struct net_device_stats
* dvb_net_get_stats(struct net_device
*dev
)
1215 return &((struct dvb_net_priv
*) dev
->priv
)->stats
;
1218 static void dvb_net_setup(struct net_device
*dev
)
1222 dev
->open
= dvb_net_open
;
1223 dev
->stop
= dvb_net_stop
;
1224 dev
->hard_start_xmit
= dvb_net_tx
;
1225 dev
->get_stats
= dvb_net_get_stats
;
1226 dev
->set_multicast_list
= dvb_net_set_multicast_list
;
1227 dev
->set_mac_address
= dvb_net_set_mac
;
1230 dev
->hard_header_cache
= NULL
;
1231 dev
->flags
|= IFF_NOARP
;
1234 static int get_if(struct dvb_net
*dvbnet
)
1238 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1239 if (!dvbnet
->state
[i
])
1242 if (i
== DVB_NET_DEVICES_MAX
)
1249 static int dvb_net_add_if(struct dvb_net
*dvbnet
, u16 pid
, u8 feedtype
)
1251 struct net_device
*net
;
1252 struct dvb_net_priv
*priv
;
1256 if (feedtype
!= DVB_NET_FEEDTYPE_MPE
&& feedtype
!= DVB_NET_FEEDTYPE_ULE
)
1258 if ((if_num
= get_if(dvbnet
)) < 0)
1261 net
= alloc_netdev(sizeof(struct dvb_net_priv
), "dvb", dvb_net_setup
);
1265 if (dvbnet
->dvbdev
->id
)
1266 snprintf(net
->name
, IFNAMSIZ
, "dvb%d%u%d",
1267 dvbnet
->dvbdev
->adapter
->num
, dvbnet
->dvbdev
->id
, if_num
);
1269 /* compatibility fix to keep dvb0_0 format */
1270 snprintf(net
->name
, IFNAMSIZ
, "dvb%d_%d",
1271 dvbnet
->dvbdev
->adapter
->num
, if_num
);
1274 memcpy(net
->dev_addr
, dvbnet
->dvbdev
->adapter
->proposed_mac
, 6);
1276 dvbnet
->device
[if_num
] = net
;
1279 priv
->demux
= dvbnet
->demux
;
1281 priv
->rx_mode
= RX_MODE_UNI
;
1282 priv
->need_pusi
= 1;
1284 priv
->feedtype
= feedtype
;
1287 INIT_WORK(&priv
->set_multicast_list_wq
, wq_set_multicast_list
, net
);
1288 INIT_WORK(&priv
->restart_net_feed_wq
, wq_restart_net_feed
, net
);
1289 mutex_init(&priv
->mutex
);
1291 net
->base_addr
= pid
;
1293 if ((result
= register_netdev(net
)) < 0) {
1294 dvbnet
->device
[if_num
] = NULL
;
1298 printk("dvb_net: created network interface %s\n", net
->name
);
1303 static int dvb_net_remove_if(struct dvb_net
*dvbnet
, unsigned long num
)
1305 struct net_device
*net
= dvbnet
->device
[num
];
1306 struct dvb_net_priv
*priv
;
1308 if (!dvbnet
->state
[num
])
1315 flush_scheduled_work();
1316 printk("dvb_net: removed network interface %s\n", net
->name
);
1317 unregister_netdev(net
);
1318 dvbnet
->state
[num
]=0;
1319 dvbnet
->device
[num
] = NULL
;
1325 static int dvb_net_do_ioctl(struct inode
*inode
, struct file
*file
,
1326 unsigned int cmd
, void *parg
)
1328 struct dvb_device
*dvbdev
= file
->private_data
;
1329 struct dvb_net
*dvbnet
= dvbdev
->priv
;
1331 if (((file
->f_flags
&O_ACCMODE
)==O_RDONLY
))
1337 struct dvb_net_if
*dvbnetif
= parg
;
1340 if (!capable(CAP_SYS_ADMIN
))
1343 if (!try_module_get(dvbdev
->adapter
->module
))
1346 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, dvbnetif
->feedtype
);
1348 module_put(dvbdev
->adapter
->module
);
1351 dvbnetif
->if_num
=result
;
1356 struct net_device
*netdev
;
1357 struct dvb_net_priv
*priv_data
;
1358 struct dvb_net_if
*dvbnetif
= parg
;
1360 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1361 !dvbnet
->state
[dvbnetif
->if_num
])
1364 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1366 priv_data
= netdev
->priv
;
1367 dvbnetif
->pid
=priv_data
->pid
;
1368 dvbnetif
->feedtype
=priv_data
->feedtype
;
1375 if (!capable(CAP_SYS_ADMIN
))
1377 if ((unsigned long) parg
>= DVB_NET_DEVICES_MAX
)
1379 ret
= dvb_net_remove_if(dvbnet
, (unsigned long) parg
);
1381 module_put(dvbdev
->adapter
->module
);
1385 /* binary compatiblity cruft */
1386 case __NET_ADD_IF_OLD
:
1388 struct __dvb_net_if_old
*dvbnetif
= parg
;
1391 if (!capable(CAP_SYS_ADMIN
))
1394 if (!try_module_get(dvbdev
->adapter
->module
))
1397 result
=dvb_net_add_if(dvbnet
, dvbnetif
->pid
, DVB_NET_FEEDTYPE_MPE
);
1399 module_put(dvbdev
->adapter
->module
);
1402 dvbnetif
->if_num
=result
;
1405 case __NET_GET_IF_OLD
:
1407 struct net_device
*netdev
;
1408 struct dvb_net_priv
*priv_data
;
1409 struct __dvb_net_if_old
*dvbnetif
= parg
;
1411 if (dvbnetif
->if_num
>= DVB_NET_DEVICES_MAX
||
1412 !dvbnet
->state
[dvbnetif
->if_num
])
1415 netdev
= dvbnet
->device
[dvbnetif
->if_num
];
1417 priv_data
= netdev
->priv
;
1418 dvbnetif
->pid
=priv_data
->pid
;
1427 static int dvb_net_ioctl(struct inode
*inode
, struct file
*file
,
1428 unsigned int cmd
, unsigned long arg
)
1430 return dvb_usercopy(inode
, file
, cmd
, arg
, dvb_net_do_ioctl
);
1433 static struct file_operations dvb_net_fops
= {
1434 .owner
= THIS_MODULE
,
1435 .ioctl
= dvb_net_ioctl
,
1436 .open
= dvb_generic_open
,
1437 .release
= dvb_generic_release
,
1440 static struct dvb_device dvbdev_net
= {
1444 .fops
= &dvb_net_fops
,
1448 void dvb_net_release (struct dvb_net
*dvbnet
)
1452 dvb_unregister_device(dvbnet
->dvbdev
);
1454 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++) {
1455 if (!dvbnet
->state
[i
])
1457 dvb_net_remove_if(dvbnet
, i
);
1460 EXPORT_SYMBOL(dvb_net_release
);
1463 int dvb_net_init (struct dvb_adapter
*adap
, struct dvb_net
*dvbnet
,
1464 struct dmx_demux
*dmx
)
1468 dvbnet
->demux
= dmx
;
1470 for (i
=0; i
<DVB_NET_DEVICES_MAX
; i
++)
1471 dvbnet
->state
[i
] = 0;
1473 dvb_register_device (adap
, &dvbnet
->dvbdev
, &dvbdev_net
,
1474 dvbnet
, DVB_DEVICE_NET
);
1478 EXPORT_SYMBOL(dvb_net_init
);