]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - net/packet/af_packet.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] severing uaccess.h -> sched.h
[mirror_ubuntu-artful-kernel.git] / net / packet / af_packet.c
CommitLineData
1da177e4
LT		 1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * PACKET - implements raw packet sockets.
7 *
8 * Version: $Id: af_packet.c,v 1.61 2002/02/08 03:57:19 davem Exp $
9 *
02c30a84 10 * Authors: Ross Biro
1da177e4
LT		 11 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Alan Cox, <gw4pts@gw4pts.ampr.org>
13 *
14 * Fixes:
15 * Alan Cox : verify_area() now used correctly
16 * Alan Cox : new skbuff lists, look ma no backlogs!
17 * Alan Cox : tidied skbuff lists.
18 * Alan Cox : Now uses generic datagram routines I
19 * added. Also fixed the peek/read crash
20 * from all old Linux datagram code.
21 * Alan Cox : Uses the improved datagram code.
22 * Alan Cox : Added NULL's for socket options.
23 * Alan Cox : Re-commented the code.
24 * Alan Cox : Use new kernel side addressing
25 * Rob Janssen : Correct MTU usage.
26 * Dave Platt : Counter leaks caused by incorrect
27 * interrupt locking and some slightly
28 * dubious gcc output. Can you read
29 * compiler: it said _VOLATILE_
30 * Richard Kooijman : Timestamp fixes.
31 * Alan Cox : New buffers. Use sk->mac.raw.
32 * Alan Cox : sendmsg/recvmsg support.
33 * Alan Cox : Protocol setting support
34 * Alexey Kuznetsov : Untied from IPv4 stack.
35 * Cyrus Durgin : Fixed kerneld for kmod.
36 * Michal Ostrowski : Module initialization cleanup.
37 * Ulises Alonso : Frame number limit removal and
38 * packet_set_ring memory leak.
0fb375fb
EB		 39 * Eric Biederman : Allow for > 8 byte hardware addresses.
40 * The convention is that longer addresses
41 * will simply extend the hardware address
42 * byte arrays at the end of sockaddr_ll
43 * and packet_mreq.
1da177e4
LT		 44 *
45 * This program is free software; you can redistribute it and/or
46 * modify it under the terms of the GNU General Public License
47 * as published by the Free Software Foundation; either version
48 * 2 of the License, or (at your option) any later version.
49 *
50 */
51
1da177e4
LT		 52#include <linux/types.h>
53#include <linux/sched.h>
54#include <linux/mm.h>
4fc268d2 55#include <linux/capability.h>
1da177e4
LT		 56#include <linux/fcntl.h>
57#include <linux/socket.h>
58#include <linux/in.h>
59#include <linux/inet.h>
60#include <linux/netdevice.h>
61#include <linux/if_packet.h>
62#include <linux/wireless.h>
63#include <linux/kmod.h>
64#include <net/ip.h>
65#include <net/protocol.h>
66#include <linux/skbuff.h>
67#include <net/sock.h>
68#include <linux/errno.h>
69#include <linux/timer.h>
70#include <asm/system.h>
71#include <asm/uaccess.h>
72#include <asm/ioctls.h>
73#include <asm/page.h>
74#include <asm/io.h>
75#include <linux/proc_fs.h>
76#include <linux/seq_file.h>
77#include <linux/poll.h>
78#include <linux/module.h>
79#include <linux/init.h>
80
81#ifdef CONFIG_INET
82#include <net/inet_common.h>
83#endif
84
85#define CONFIG_SOCK_PACKET 1
86
87/*
88 Proposed replacement for SIOC{ADD,DEL}MULTI and
89 IFF_PROMISC, IFF_ALLMULTI flags.
90
91 It is more expensive, but I believe,
92 it is really correct solution: reentereble, safe and fault tolerant.
93
94 IFF_PROMISC/IFF_ALLMULTI/SIOC{ADD/DEL}MULTI are faked by keeping
95 reference count and global flag, so that real status is
96 (gflag|(count != 0)), so that we can use obsolete faulty interface
97 not harming clever users.
98 */
99#define CONFIG_PACKET_MULTICAST 1
100
101/*
102 Assumptions:
103 - if device has no dev->hard_header routine, it adds and removes ll header
104 inside itself. In this case ll header is invisible outside of device,
105 but higher levels still should reserve dev->hard_header_len.
106 Some devices are enough clever to reallocate skb, when header
107 will not fit to reserved space (tunnel), another ones are silly
108 (PPP).
109 - packet socket receives packets with pulled ll header,
110 so that SOCK_RAW should push it back.
111
112On receive:
113-----------
114
115Incoming, dev->hard_header!=NULL
116 mac.raw -> ll header
117 data -> data
118
119Outgoing, dev->hard_header!=NULL
120 mac.raw -> ll header
121 data -> ll header
122
123Incoming, dev->hard_header==NULL
124 mac.raw -> UNKNOWN position. It is very likely, that it points to ll header.
125 PPP makes it, that is wrong, because introduce assymetry
126 between rx and tx paths.
127 data -> data
128
129Outgoing, dev->hard_header==NULL
130 mac.raw -> data. ll header is still not built!
131 data -> data
132
133Resume
134 If dev->hard_header==NULL we are unlikely to restore sensible ll header.
135
136
137On transmit:
138------------
139
140dev->hard_header != NULL
141 mac.raw -> ll header
142 data -> ll header
143
144dev->hard_header == NULL (ll header is added by device, we cannot control it)
145 mac.raw -> data
146 data -> data
147
148 We should set nh.raw on output to correct posistion,
149 packet classifier depends on it.
150 */
151
152/* List of all packet sockets. */
153static HLIST_HEAD(packet_sklist);
154static DEFINE_RWLOCK(packet_sklist_lock);
155
156static atomic_t packet_socks_nr;
157
158
159/* Private packet socket structures. */
160
161#ifdef CONFIG_PACKET_MULTICAST
162struct packet_mclist
163{
164 struct packet_mclist *next;
165 int ifindex;
166 int count;
167 unsigned short type;
168 unsigned short alen;
0fb375fb
EB		 169 unsigned char addr[MAX_ADDR_LEN];
170};
171/* identical to struct packet_mreq except it has
172 * a longer address field.
173 */
174struct packet_mreq_max
175{
176 int mr_ifindex;
177 unsigned short mr_type;
178 unsigned short mr_alen;
179 unsigned char mr_address[MAX_ADDR_LEN];
1da177e4
LT		 180};
181#endif
182#ifdef CONFIG_PACKET_MMAP
183static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing);
184#endif
185
186static void packet_flush_mclist(struct sock *sk);
187
188struct packet_sock {
189 /* struct sock has to be the first member of packet_sock */
190 struct sock sk;
191 struct tpacket_stats stats;
192#ifdef CONFIG_PACKET_MMAP
193 char * *pg_vec;
194 unsigned int head;
195 unsigned int frames_per_block;
196 unsigned int frame_size;
197 unsigned int frame_max;
198 int copy_thresh;
199#endif
200 struct packet_type prot_hook;
201 spinlock_t bind_lock;
202 char running; /* prot_hook is attached*/
203 int ifindex; /* bound device */
0e11c91e 204 __be16 num;
1da177e4
LT		 205#ifdef CONFIG_PACKET_MULTICAST
206 struct packet_mclist *mclist;
207#endif
208#ifdef CONFIG_PACKET_MMAP
209 atomic_t mapped;
210 unsigned int pg_vec_order;
211 unsigned int pg_vec_pages;
212 unsigned int pg_vec_len;
213#endif
214};
215
216#ifdef CONFIG_PACKET_MMAP
217
218static inline char *packet_lookup_frame(struct packet_sock *po, unsigned int position)
219{
220 unsigned int pg_vec_pos, frame_offset;
221 char *frame;
222
223 pg_vec_pos = position / po->frames_per_block;
224 frame_offset = position % po->frames_per_block;
225
226 frame = po->pg_vec[pg_vec_pos] + (frame_offset * po->frame_size);
227
228 return frame;
229}
230#endif
231
232static inline struct packet_sock *pkt_sk(struct sock *sk)
233{
234 return (struct packet_sock *)sk;
235}
236
237static void packet_sock_destruct(struct sock *sk)
238{
239 BUG_TRAP(!atomic_read(&sk->sk_rmem_alloc));
240 BUG_TRAP(!atomic_read(&sk->sk_wmem_alloc));
241
242 if (!sock_flag(sk, SOCK_DEAD)) {
243 printk("Attempt to release alive packet socket: %p\n", sk);
244 return;
245 }
246
247 atomic_dec(&packet_socks_nr);
248#ifdef PACKET_REFCNT_DEBUG
249 printk(KERN_DEBUG "PACKET socket %p is free, %d are alive\n", sk, atomic_read(&packet_socks_nr));
250#endif
251}
252
253
90ddc4f0 254static const struct proto_ops packet_ops;
1da177e4
LT		 255
256#ifdef CONFIG_SOCK_PACKET
90ddc4f0 257static const struct proto_ops packet_ops_spkt;
1da177e4 258
f2ccd8fa 259static int packet_rcv_spkt(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1da177e4
LT		 260{
261 struct sock *sk;
262 struct sockaddr_pkt *spkt;
263
264 /*
265 * When we registered the protocol we saved the socket in the data
266 * field for just this event.
267 */
268
269 sk = pt->af_packet_priv;
270
271 /*
272 * Yank back the headers [hope the device set this
273 * right or kerboom...]
274 *
275 * Incoming packets have ll header pulled,
276 * push it back.
277 *
278 * For outgoing ones skb->data == skb->mac.raw
279 * so that this procedure is noop.
280 */
281
282 if (skb->pkt_type == PACKET_LOOPBACK)
283 goto out;
284
285 if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL)
286 goto oom;
287
288 /* drop any routing info */
289 dst_release(skb->dst);
290 skb->dst = NULL;
291
84531c24
PO		 292 /* drop conntrack reference */
293 nf_reset(skb);
294
1da177e4
LT		 295 spkt = (struct sockaddr_pkt*)skb->cb;
296
297 skb_push(skb, skb->data-skb->mac.raw);
298
299 /*
300 * The SOCK_PACKET socket receives _all_ frames.
301 */
302
303 spkt->spkt_family = dev->type;
304 strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device));
305 spkt->spkt_protocol = skb->protocol;
306
307 /*
308 * Charge the memory to the socket. This is done specifically
309 * to prevent sockets using all the memory up.
310 */
311
312 if (sock_queue_rcv_skb(sk,skb) == 0)
313 return 0;
314
315out:
316 kfree_skb(skb);
317oom:
318 return 0;
319}
320
321
322/*
323 * Output a raw packet to a device layer. This bypasses all the other
324 * protocol layers and you must therefore supply it with a complete frame
325 */
326
327static int packet_sendmsg_spkt(struct kiocb *iocb, struct socket *sock,
328 struct msghdr *msg, size_t len)
329{
330 struct sock *sk = sock->sk;
331 struct sockaddr_pkt *saddr=(struct sockaddr_pkt *)msg->msg_name;
332 struct sk_buff *skb;
333 struct net_device *dev;
0e11c91e 334 __be16 proto=0;
1da177e4
LT		 335 int err;
336
337 /*
338 * Get and verify the address.
339 */
340
341 if (saddr)
342 {
343 if (msg->msg_namelen < sizeof(struct sockaddr))
344 return(-EINVAL);
345 if (msg->msg_namelen==sizeof(struct sockaddr_pkt))
346 proto=saddr->spkt_protocol;
347 }
348 else
349 return(-ENOTCONN); /* SOCK_PACKET must be sent giving an address */
350
351 /*
352 * Find the device first to size check it
353 */
354
355 saddr->spkt_device[13] = 0;
356 dev = dev_get_by_name(saddr->spkt_device);
357 err = -ENODEV;
358 if (dev == NULL)
359 goto out_unlock;
360
361 /*
362 * You may not queue a frame bigger than the mtu. This is the lowest level
363 * raw protocol and you must do your own fragmentation at this level.
364 */
365
366 err = -EMSGSIZE;
8ae55f04 367 if (len > dev->mtu + dev->hard_header_len)
1da177e4
LT		 368 goto out_unlock;
369
370 err = -ENOBUFS;
371 skb = sock_wmalloc(sk, len + LL_RESERVED_SPACE(dev), 0, GFP_KERNEL);
372
373 /*
374 * If the write buffer is full, then tough. At this level the user gets to
375 * deal with the problem - do your own algorithmic backoffs. That's far
376 * more flexible.
377 */
378
379 if (skb == NULL)
380 goto out_unlock;
381
382 /*
383 * Fill it in
384 */
385
386 /* FIXME: Save some space for broken drivers that write a
387 * hard header at transmission time by themselves. PPP is the
388 * notable one here. This should really be fixed at the driver level.
389 */
390 skb_reserve(skb, LL_RESERVED_SPACE(dev));
391 skb->nh.raw = skb->data;
392
393 /* Try to align data part correctly */
394 if (dev->hard_header) {
395 skb->data -= dev->hard_header_len;
396 skb->tail -= dev->hard_header_len;
397 if (len < dev->hard_header_len)
398 skb->nh.raw = skb->data;
399 }
400
401 /* Returns -EFAULT on error */
402 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
403 skb->protocol = proto;
404 skb->dev = dev;
405 skb->priority = sk->sk_priority;
406 if (err)
407 goto out_free;
408
409 err = -ENETDOWN;
410 if (!(dev->flags & IFF_UP))
411 goto out_free;
412
413 /*
414 * Now send it
415 */
416
417 dev_queue_xmit(skb);
418 dev_put(dev);
419 return(len);
420
421out_free:
422 kfree_skb(skb);
423out_unlock:
424 if (dev)
425 dev_put(dev);
426 return err;
427}
428#endif
429
fda9ef5d
DM		 430static inline int run_filter(struct sk_buff *skb, struct sock *sk,
431 unsigned *snaplen)
1da177e4
LT		 432{
433 struct sk_filter *filter;
fda9ef5d
DM		 434 int err = 0;
435
436 rcu_read_lock_bh();
437 filter = rcu_dereference(sk->sk_filter);
438 if (filter != NULL) {
439 err = sk_run_filter(skb, filter->insns, filter->len);
440 if (!err)
441 err = -EPERM;
442 else if (*snaplen > err)
443 *snaplen = err;
444 }
445 rcu_read_unlock_bh();
1da177e4 446
fda9ef5d 447 return err;
1da177e4
LT		 448}
449
450/*
451 This function makes lazy skb cloning in hope that most of packets
452 are discarded by BPF.
453
454 Note tricky part: we DO mangle shared skb! skb->data, skb->len
455 and skb->cb are mangled. It works because (and until) packets
456 falling here are owned by current CPU. Output packets are cloned
457 by dev_queue_xmit_nit(), input packets are processed by net_bh
458 sequencially, so that if we return skb to original state on exit,
459 we will not harm anyone.
460 */
461
f2ccd8fa 462static int packet_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1da177e4
LT		 463{
464 struct sock *sk;
465 struct sockaddr_ll *sll;
466 struct packet_sock *po;
467 u8 * skb_head = skb->data;
468 int skb_len = skb->len;
469 unsigned snaplen;
470
471 if (skb->pkt_type == PACKET_LOOPBACK)
472 goto drop;
473
474 sk = pt->af_packet_priv;
475 po = pkt_sk(sk);
476
477 skb->dev = dev;
478
479 if (dev->hard_header) {
480 /* The device has an explicit notion of ll header,
481 exported to higher levels.
482
483 Otherwise, the device hides datails of it frame
484 structure, so that corresponding packet head
485 never delivered to user.
486 */
487 if (sk->sk_type != SOCK_DGRAM)
488 skb_push(skb, skb->data - skb->mac.raw);
489 else if (skb->pkt_type == PACKET_OUTGOING) {
490 /* Special case: outgoing packets have ll header at head */
491 skb_pull(skb, skb->nh.raw - skb->data);
492 }
493 }
494
495 snaplen = skb->len;
496
fda9ef5d
DM		 497 if (run_filter(skb, sk, &snaplen) < 0)
498 goto drop_n_restore;
1da177e4
LT		 499
500 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
501 (unsigned)sk->sk_rcvbuf)
502 goto drop_n_acct;
503
504 if (skb_shared(skb)) {
505 struct sk_buff *nskb = skb_clone(skb, GFP_ATOMIC);
506 if (nskb == NULL)
507 goto drop_n_acct;
508
509 if (skb_head != skb->data) {
510 skb->data = skb_head;
511 skb->len = skb_len;
512 }
513 kfree_skb(skb);
514 skb = nskb;
515 }
516
517 sll = (struct sockaddr_ll*)skb->cb;
518 sll->sll_family = AF_PACKET;
519 sll->sll_hatype = dev->type;
520 sll->sll_protocol = skb->protocol;
521 sll->sll_pkttype = skb->pkt_type;
522 sll->sll_ifindex = dev->ifindex;
523 sll->sll_halen = 0;
524
525 if (dev->hard_header_parse)
526 sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
527
528 if (pskb_trim(skb, snaplen))
529 goto drop_n_acct;
530
531 skb_set_owner_r(skb, sk);
532 skb->dev = NULL;
533 dst_release(skb->dst);
534 skb->dst = NULL;
535
84531c24
PO		 536 /* drop conntrack reference */
537 nf_reset(skb);
538
1da177e4
LT		 539 spin_lock(&sk->sk_receive_queue.lock);
540 po->stats.tp_packets++;
541 __skb_queue_tail(&sk->sk_receive_queue, skb);
542 spin_unlock(&sk->sk_receive_queue.lock);
543 sk->sk_data_ready(sk, skb->len);
544 return 0;
545
546drop_n_acct:
547 spin_lock(&sk->sk_receive_queue.lock);
548 po->stats.tp_drops++;
549 spin_unlock(&sk->sk_receive_queue.lock);
550
551drop_n_restore:
552 if (skb_head != skb->data && skb_shared(skb)) {
553 skb->data = skb_head;
554 skb->len = skb_len;
555 }
556drop:
557 kfree_skb(skb);
558 return 0;
559}
560
561#ifdef CONFIG_PACKET_MMAP
f2ccd8fa 562static int tpacket_rcv(struct sk_buff *skb, struct net_device *dev, struct packet_type *pt, struct net_device *orig_dev)
1da177e4
LT		 563{
564 struct sock *sk;
565 struct packet_sock *po;
566 struct sockaddr_ll *sll;
567 struct tpacket_hdr *h;
568 u8 * skb_head = skb->data;
569 int skb_len = skb->len;
570 unsigned snaplen;
571 unsigned long status = TP_STATUS_LOSING|TP_STATUS_USER;
572 unsigned short macoff, netoff;
573 struct sk_buff *copy_skb = NULL;
574
575 if (skb->pkt_type == PACKET_LOOPBACK)
576 goto drop;
577
578 sk = pt->af_packet_priv;
579 po = pkt_sk(sk);
580
581 if (dev->hard_header) {
582 if (sk->sk_type != SOCK_DGRAM)
583 skb_push(skb, skb->data - skb->mac.raw);
584 else if (skb->pkt_type == PACKET_OUTGOING) {
585 /* Special case: outgoing packets have ll header at head */
586 skb_pull(skb, skb->nh.raw - skb->data);
84fa7933 587 if (skb->ip_summed == CHECKSUM_PARTIAL)
1da177e4
LT		 588 status |= TP_STATUS_CSUMNOTREADY;
589 }
590 }
591
592 snaplen = skb->len;
593
fda9ef5d
DM		 594 if (run_filter(skb, sk, &snaplen) < 0)
595 goto drop_n_restore;
1da177e4
LT		 596
597 if (sk->sk_type == SOCK_DGRAM) {
598 macoff = netoff = TPACKET_ALIGN(TPACKET_HDRLEN) + 16;
599 } else {
600 unsigned maclen = skb->nh.raw - skb->data;
601 netoff = TPACKET_ALIGN(TPACKET_HDRLEN + (maclen < 16 ? 16 : maclen));
602 macoff = netoff - maclen;
603 }
604
605 if (macoff + snaplen > po->frame_size) {
606 if (po->copy_thresh &&
607 atomic_read(&sk->sk_rmem_alloc) + skb->truesize <
608 (unsigned)sk->sk_rcvbuf) {
609 if (skb_shared(skb)) {
610 copy_skb = skb_clone(skb, GFP_ATOMIC);
611 } else {
612 copy_skb = skb_get(skb);
613 skb_head = skb->data;
614 }
615 if (copy_skb)
616 skb_set_owner_r(copy_skb, sk);
617 }
618 snaplen = po->frame_size - macoff;
619 if ((int)snaplen < 0)
620 snaplen = 0;
621 }
1da177e4
LT		 622
623 spin_lock(&sk->sk_receive_queue.lock);
624 h = (struct tpacket_hdr *)packet_lookup_frame(po, po->head);
625
626 if (h->tp_status)
627 goto ring_is_full;
628 po->head = po->head != po->frame_max ? po->head+1 : 0;
629 po->stats.tp_packets++;
630 if (copy_skb) {
631 status |= TP_STATUS_COPY;
632 __skb_queue_tail(&sk->sk_receive_queue, copy_skb);
633 }
634 if (!po->stats.tp_drops)
635 status &= ~TP_STATUS_LOSING;
636 spin_unlock(&sk->sk_receive_queue.lock);
637
cbe21d8f 638 skb_copy_bits(skb, 0, (u8*)h + macoff, snaplen);
1da177e4
LT		 639
640 h->tp_len = skb->len;
641 h->tp_snaplen = snaplen;
642 h->tp_mac = macoff;
643 h->tp_net = netoff;
a61bbcf2
PM		 644 if (skb->tstamp.off_sec == 0) {
645 __net_timestamp(skb);
1da177e4
LT		 646 sock_enable_timestamp(sk);
647 }
325ed823
HX		 648 h->tp_sec = skb->tstamp.off_sec;
649 h->tp_usec = skb->tstamp.off_usec;
1da177e4
LT		 650
651 sll = (struct sockaddr_ll*)((u8*)h + TPACKET_ALIGN(sizeof(*h)));
652 sll->sll_halen = 0;
653 if (dev->hard_header_parse)
654 sll->sll_halen = dev->hard_header_parse(skb, sll->sll_addr);
655 sll->sll_family = AF_PACKET;
656 sll->sll_hatype = dev->type;
657 sll->sll_protocol = skb->protocol;
658 sll->sll_pkttype = skb->pkt_type;
659 sll->sll_ifindex = dev->ifindex;
660
661 h->tp_status = status;
662 mb();
663
664 {
665 struct page *p_start, *p_end;
666 u8 *h_end = (u8 *)h + macoff + snaplen - 1;
667
668 p_start = virt_to_page(h);
669 p_end = virt_to_page(h_end);
670 while (p_start <= p_end) {
671 flush_dcache_page(p_start);
672 p_start++;
673 }
674 }
675
676 sk->sk_data_ready(sk, 0);
677
678drop_n_restore:
679 if (skb_head != skb->data && skb_shared(skb)) {
680 skb->data = skb_head;
681 skb->len = skb_len;
682 }
683drop:
684 kfree_skb(skb);
685 return 0;
686
687ring_is_full:
688 po->stats.tp_drops++;
689 spin_unlock(&sk->sk_receive_queue.lock);
690
691 sk->sk_data_ready(sk, 0);
692 if (copy_skb)
693 kfree_skb(copy_skb);
694 goto drop_n_restore;
695}
696
697#endif
698
699
700static int packet_sendmsg(struct kiocb *iocb, struct socket *sock,
701 struct msghdr *msg, size_t len)
702{
703 struct sock *sk = sock->sk;
704 struct sockaddr_ll *saddr=(struct sockaddr_ll *)msg->msg_name;
705 struct sk_buff *skb;
706 struct net_device *dev;
0e11c91e 707 __be16 proto;
1da177e4
LT		 708 unsigned char *addr;
709 int ifindex, err, reserve = 0;
710
711 /*
712 * Get and verify the address.
713 */
714
715 if (saddr == NULL) {
716 struct packet_sock *po = pkt_sk(sk);
717
718 ifindex = po->ifindex;
719 proto = po->num;
720 addr = NULL;
721 } else {
722 err = -EINVAL;
723 if (msg->msg_namelen < sizeof(struct sockaddr_ll))
724 goto out;
0fb375fb
EB		 725 if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr)))
726 goto out;
1da177e4
LT		 727 ifindex = saddr->sll_ifindex;
728 proto = saddr->sll_protocol;
729 addr = saddr->sll_addr;
730 }
731
732
733 dev = dev_get_by_index(ifindex);
734 err = -ENXIO;
735 if (dev == NULL)
736 goto out_unlock;
737 if (sock->type == SOCK_RAW)
738 reserve = dev->hard_header_len;
739
740 err = -EMSGSIZE;
741 if (len > dev->mtu+reserve)
742 goto out_unlock;
743
744 skb = sock_alloc_send_skb(sk, len + LL_RESERVED_SPACE(dev),
745 msg->msg_flags & MSG_DONTWAIT, &err);
746 if (skb==NULL)
747 goto out_unlock;
748
749 skb_reserve(skb, LL_RESERVED_SPACE(dev));
750 skb->nh.raw = skb->data;
751
752 if (dev->hard_header) {
753 int res;
754 err = -EINVAL;
755 res = dev->hard_header(skb, dev, ntohs(proto), addr, NULL, len);
756 if (sock->type != SOCK_DGRAM) {
757 skb->tail = skb->data;
758 skb->len = 0;
759 } else if (res < 0)
760 goto out_free;
761 }
762
763 /* Returns -EFAULT on error */
764 err = memcpy_fromiovec(skb_put(skb,len), msg->msg_iov, len);
765 if (err)
766 goto out_free;
767
768 skb->protocol = proto;
769 skb->dev = dev;
770 skb->priority = sk->sk_priority;
771
772 err = -ENETDOWN;
773 if (!(dev->flags & IFF_UP))
774 goto out_free;
775
776 /*
777 * Now send it
778 */
779
780 err = dev_queue_xmit(skb);
781 if (err > 0 && (err = net_xmit_errno(err)) != 0)
782 goto out_unlock;
783
784 dev_put(dev);
785
786 return(len);
787
788out_free:
789 kfree_skb(skb);
790out_unlock:
791 if (dev)
792 dev_put(dev);
793out:
794 return err;
795}
796
797/*
798 * Close a PACKET socket. This is fairly simple. We immediately go
799 * to 'closed' state and remove our protocol entry in the device list.
800 */
801
802static int packet_release(struct socket *sock)
803{
804 struct sock *sk = sock->sk;
805 struct packet_sock *po;
806
807 if (!sk)
808 return 0;
809
810 po = pkt_sk(sk);
811
812 write_lock_bh(&packet_sklist_lock);
813 sk_del_node_init(sk);
814 write_unlock_bh(&packet_sklist_lock);
815
816 /*
817 * Unhook packet receive handler.
818 */
819
820 if (po->running) {
821 /*
822 * Remove the protocol hook
823 */
824 dev_remove_pack(&po->prot_hook);
825 po->running = 0;
826 po->num = 0;
827 __sock_put(sk);
828 }
829
830#ifdef CONFIG_PACKET_MULTICAST
831 packet_flush_mclist(sk);
832#endif
833
834#ifdef CONFIG_PACKET_MMAP
835 if (po->pg_vec) {
836 struct tpacket_req req;
837 memset(&req, 0, sizeof(req));
838 packet_set_ring(sk, &req, 1);
839 }
840#endif
841
842 /*
843 * Now the socket is dead. No more input will appear.
844 */
845
846 sock_orphan(sk);
847 sock->sk = NULL;
848
849 /* Purge queues */
850
851 skb_queue_purge(&sk->sk_receive_queue);
852
853 sock_put(sk);
854 return 0;
855}
856
857/*
858 * Attach a packet hook.
859 */
860
0e11c91e 861static int packet_do_bind(struct sock *sk, struct net_device *dev, __be16 protocol)
1da177e4
LT		 862{
863 struct packet_sock *po = pkt_sk(sk);
864 /*
865 * Detach an existing hook if present.
866 */
867
868 lock_sock(sk);
869
870 spin_lock(&po->bind_lock);
871 if (po->running) {
872 __sock_put(sk);
873 po->running = 0;
874 po->num = 0;
875 spin_unlock(&po->bind_lock);
876 dev_remove_pack(&po->prot_hook);
877 spin_lock(&po->bind_lock);
878 }
879
880 po->num = protocol;
881 po->prot_hook.type = protocol;
882 po->prot_hook.dev = dev;
883
884 po->ifindex = dev ? dev->ifindex : 0;
885
886 if (protocol == 0)
887 goto out_unlock;
888
889 if (dev) {
890 if (dev->flags&IFF_UP) {
891 dev_add_pack(&po->prot_hook);
892 sock_hold(sk);
893 po->running = 1;
894 } else {
895 sk->sk_err = ENETDOWN;
896 if (!sock_flag(sk, SOCK_DEAD))
897 sk->sk_error_report(sk);
898 }
899 } else {
900 dev_add_pack(&po->prot_hook);
901 sock_hold(sk);
902 po->running = 1;
903 }
904
905out_unlock:
906 spin_unlock(&po->bind_lock);
907 release_sock(sk);
908 return 0;
909}
910
911/*
912 * Bind a packet socket to a device
913 */
914
915#ifdef CONFIG_SOCK_PACKET
916
917static int packet_bind_spkt(struct socket *sock, struct sockaddr *uaddr, int addr_len)
918{
919 struct sock *sk=sock->sk;
920 char name[15];
921 struct net_device *dev;
922 int err = -ENODEV;
923
924 /*
925 * Check legality
926 */
927
8ae55f04 928 if (addr_len != sizeof(struct sockaddr))
1da177e4
LT		 929 return -EINVAL;
930 strlcpy(name,uaddr->sa_data,sizeof(name));
931
932 dev = dev_get_by_name(name);
933 if (dev) {
934 err = packet_do_bind(sk, dev, pkt_sk(sk)->num);
935 dev_put(dev);
936 }
937 return err;
938}
939#endif
940
941static int packet_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
942{
943 struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
944 struct sock *sk=sock->sk;
945 struct net_device *dev = NULL;
946 int err;
947
948
949 /*
950 * Check legality
951 */
952
953 if (addr_len < sizeof(struct sockaddr_ll))
954 return -EINVAL;
955 if (sll->sll_family != AF_PACKET)
956 return -EINVAL;
957
958 if (sll->sll_ifindex) {
959 err = -ENODEV;
960 dev = dev_get_by_index(sll->sll_ifindex);
961 if (dev == NULL)
962 goto out;
963 }
964 err = packet_do_bind(sk, dev, sll->sll_protocol ? : pkt_sk(sk)->num);
965 if (dev)
966 dev_put(dev);
967
968out:
969 return err;
970}
971
972static struct proto packet_proto = {
973 .name = "PACKET",
974 .owner = THIS_MODULE,
975 .obj_size = sizeof(struct packet_sock),
976};
977
978/*
979 * Create a packet of type SOCK_PACKET.
980 */
981
982static int packet_create(struct socket *sock, int protocol)
983{
984 struct sock *sk;
985 struct packet_sock *po;
0e11c91e 986 __be16 proto = (__force __be16)protocol; /* weird, but documented */
1da177e4
LT		 987 int err;
988
989 if (!capable(CAP_NET_RAW))
990 return -EPERM;
991 if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW
992#ifdef CONFIG_SOCK_PACKET
993 && sock->type != SOCK_PACKET
994#endif
995 )
996 return -ESOCKTNOSUPPORT;
997
998 sock->state = SS_UNCONNECTED;
999
1000 err = -ENOBUFS;
1001 sk = sk_alloc(PF_PACKET, GFP_KERNEL, &packet_proto, 1);
1002 if (sk == NULL)
1003 goto out;
1004
1005 sock->ops = &packet_ops;
1006#ifdef CONFIG_SOCK_PACKET
1007 if (sock->type == SOCK_PACKET)
1008 sock->ops = &packet_ops_spkt;
1009#endif
1010 sock_init_data(sock, sk);
1011
1012 po = pkt_sk(sk);
1013 sk->sk_family = PF_PACKET;
0e11c91e 1014 po->num = proto;
1da177e4
LT		 1015
1016 sk->sk_destruct = packet_sock_destruct;
1017 atomic_inc(&packet_socks_nr);
1018
1019 /*
1020 * Attach a protocol block
1021 */
1022
1023 spin_lock_init(&po->bind_lock);
1024 po->prot_hook.func = packet_rcv;
1025#ifdef CONFIG_SOCK_PACKET
1026 if (sock->type == SOCK_PACKET)
1027 po->prot_hook.func = packet_rcv_spkt;
1028#endif
1029 po->prot_hook.af_packet_priv = sk;
1030
0e11c91e
AV		 1031 if (proto) {
1032 po->prot_hook.type = proto;
1da177e4
LT		 1033 dev_add_pack(&po->prot_hook);
1034 sock_hold(sk);
1035 po->running = 1;
1036 }
1037
1038 write_lock_bh(&packet_sklist_lock);
1039 sk_add_node(sk, &packet_sklist);
1040 write_unlock_bh(&packet_sklist_lock);
1041 return(0);
1042out:
1043 return err;
1044}
1045
1046/*
1047 * Pull a packet from our receive queue and hand it to the user.
1048 * If necessary we block.
1049 */
1050
1051static int packet_recvmsg(struct kiocb *iocb, struct socket *sock,
1052 struct msghdr *msg, size_t len, int flags)
1053{
1054 struct sock *sk = sock->sk;
1055 struct sk_buff *skb;
1056 int copied, err;
0fb375fb 1057 struct sockaddr_ll *sll;
1da177e4
LT		 1058
1059 err = -EINVAL;
1060 if (flags & ~(MSG_PEEK|MSG_DONTWAIT|MSG_TRUNC|MSG_CMSG_COMPAT))
1061 goto out;
1062
1063#if 0
1064 /* What error should we return now? EUNATTACH? */
1065 if (pkt_sk(sk)->ifindex < 0)
1066 return -ENODEV;
1067#endif
1068
1da177e4
LT		 1069 /*
1070 * Call the generic datagram receiver. This handles all sorts
1071 * of horrible races and re-entrancy so we can forget about it
1072 * in the protocol layers.
1073 *
1074 * Now it will return ENETDOWN, if device have just gone down,
1075 * but then it will block.
1076 */
1077
1078 skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
1079
1080 /*
1081 * An error occurred so return it. Because skb_recv_datagram()
1082 * handles the blocking we don't see and worry about blocking
1083 * retries.
1084 */
1085
8ae55f04 1086 if (skb == NULL)
1da177e4
LT		 1087 goto out;
1088
0fb375fb
EB		 1089 /*
1090 * If the address length field is there to be filled in, we fill
1091 * it in now.
1092 */
1093
1094 sll = (struct sockaddr_ll*)skb->cb;
1095 if (sock->type == SOCK_PACKET)
1096 msg->msg_namelen = sizeof(struct sockaddr_pkt);
1097 else
1098 msg->msg_namelen = sll->sll_halen + offsetof(struct sockaddr_ll, sll_addr);
1099
1da177e4
LT		 1100 /*
1101 * You lose any data beyond the buffer you gave. If it worries a
1102 * user program they can ask the device for its MTU anyway.
1103 */
1104
1105 copied = skb->len;
1106 if (copied > len)
1107 {
1108 copied=len;
1109 msg->msg_flags|=MSG_TRUNC;
1110 }
1111
1112 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1113 if (err)
1114 goto out_free;
1115
1116 sock_recv_timestamp(msg, sk, skb);
1117
1118 if (msg->msg_name)
1119 memcpy(msg->msg_name, skb->cb, msg->msg_namelen);
1120
1121 /*
1122 * Free or return the buffer as appropriate. Again this
1123 * hides all the races and re-entrancy issues from us.
1124 */
1125 err = (flags&MSG_TRUNC) ? skb->len : copied;
1126
1127out_free:
1128 skb_free_datagram(sk, skb);
1129out:
1130 return err;
1131}
1132
1133#ifdef CONFIG_SOCK_PACKET
1134static int packet_getname_spkt(struct socket *sock, struct sockaddr *uaddr,
1135 int *uaddr_len, int peer)
1136{
1137 struct net_device *dev;
1138 struct sock *sk = sock->sk;
1139
1140 if (peer)
1141 return -EOPNOTSUPP;
1142
1143 uaddr->sa_family = AF_PACKET;
1144 dev = dev_get_by_index(pkt_sk(sk)->ifindex);
1145 if (dev) {
1146 strlcpy(uaddr->sa_data, dev->name, 15);
1147 dev_put(dev);
1148 } else
1149 memset(uaddr->sa_data, 0, 14);
1150 *uaddr_len = sizeof(*uaddr);
1151
1152 return 0;
1153}
1154#endif
1155
1156static int packet_getname(struct socket *sock, struct sockaddr *uaddr,
1157 int *uaddr_len, int peer)
1158{
1159 struct net_device *dev;
1160 struct sock *sk = sock->sk;
1161 struct packet_sock *po = pkt_sk(sk);
1162 struct sockaddr_ll *sll = (struct sockaddr_ll*)uaddr;
1163
1164 if (peer)
1165 return -EOPNOTSUPP;
1166
1167 sll->sll_family = AF_PACKET;
1168 sll->sll_ifindex = po->ifindex;
1169 sll->sll_protocol = po->num;
1170 dev = dev_get_by_index(po->ifindex);
1171 if (dev) {
1172 sll->sll_hatype = dev->type;
1173 sll->sll_halen = dev->addr_len;
1174 memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len);
1175 dev_put(dev);
1176 } else {
1177 sll->sll_hatype = 0; /* Bad: we have no ARPHRD_UNSPEC */
1178 sll->sll_halen = 0;
1179 }
0fb375fb 1180 *uaddr_len = offsetof(struct sockaddr_ll, sll_addr) + sll->sll_halen;
1da177e4
LT		 1181
1182 return 0;
1183}
1184
1185#ifdef CONFIG_PACKET_MULTICAST
1186static void packet_dev_mc(struct net_device *dev, struct packet_mclist *i, int what)
1187{
1188 switch (i->type) {
1189 case PACKET_MR_MULTICAST:
1190 if (what > 0)
1191 dev_mc_add(dev, i->addr, i->alen, 0);
1192 else
1193 dev_mc_delete(dev, i->addr, i->alen, 0);
1194 break;
1195 case PACKET_MR_PROMISC:
1196 dev_set_promiscuity(dev, what);
1197 break;
1198 case PACKET_MR_ALLMULTI:
1199 dev_set_allmulti(dev, what);
1200 break;
1201 default:;
1202 }
1203}
1204
1205static void packet_dev_mclist(struct net_device *dev, struct packet_mclist *i, int what)
1206{
1207 for ( ; i; i=i->next) {
1208 if (i->ifindex == dev->ifindex)
1209 packet_dev_mc(dev, i, what);
1210 }
1211}
1212
0fb375fb 1213static int packet_mc_add(struct sock *sk, struct packet_mreq_max *mreq)
1da177e4
LT		 1214{
1215 struct packet_sock *po = pkt_sk(sk);
1216 struct packet_mclist *ml, *i;
1217 struct net_device *dev;
1218 int err;
1219
1220 rtnl_lock();
1221
1222 err = -ENODEV;
1223 dev = __dev_get_by_index(mreq->mr_ifindex);
1224 if (!dev)
1225 goto done;
1226
1227 err = -EINVAL;
1228 if (mreq->mr_alen > dev->addr_len)
1229 goto done;
1230
1231 err = -ENOBUFS;
8b3a7005 1232 i = kmalloc(sizeof(*i), GFP_KERNEL);
1da177e4
LT		 1233 if (i == NULL)
1234 goto done;
1235
1236 err = 0;
1237 for (ml = po->mclist; ml; ml = ml->next) {
1238 if (ml->ifindex == mreq->mr_ifindex &&
1239 ml->type == mreq->mr_type &&
1240 ml->alen == mreq->mr_alen &&
1241 memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1242 ml->count++;
1243 /* Free the new element ... */
1244 kfree(i);
1245 goto done;
1246 }
1247 }
1248
1249 i->type = mreq->mr_type;
1250 i->ifindex = mreq->mr_ifindex;
1251 i->alen = mreq->mr_alen;
1252 memcpy(i->addr, mreq->mr_address, i->alen);
1253 i->count = 1;
1254 i->next = po->mclist;
1255 po->mclist = i;
1256 packet_dev_mc(dev, i, +1);
1257
1258done:
1259 rtnl_unlock();
1260 return err;
1261}
1262
0fb375fb 1263static int packet_mc_drop(struct sock *sk, struct packet_mreq_max *mreq)
1da177e4
LT		 1264{
1265 struct packet_mclist *ml, **mlp;
1266
1267 rtnl_lock();
1268
1269 for (mlp = &pkt_sk(sk)->mclist; (ml = *mlp) != NULL; mlp = &ml->next) {
1270 if (ml->ifindex == mreq->mr_ifindex &&
1271 ml->type == mreq->mr_type &&
1272 ml->alen == mreq->mr_alen &&
1273 memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) {
1274 if (--ml->count == 0) {
1275 struct net_device *dev;
1276 *mlp = ml->next;
1277 dev = dev_get_by_index(ml->ifindex);
1278 if (dev) {
1279 packet_dev_mc(dev, ml, -1);
1280 dev_put(dev);
1281 }
1282 kfree(ml);
1283 }
1284 rtnl_unlock();
1285 return 0;
1286 }
1287 }
1288 rtnl_unlock();
1289 return -EADDRNOTAVAIL;
1290}
1291
1292static void packet_flush_mclist(struct sock *sk)
1293{
1294 struct packet_sock *po = pkt_sk(sk);
1295 struct packet_mclist *ml;
1296
1297 if (!po->mclist)
1298 return;
1299
1300 rtnl_lock();
1301 while ((ml = po->mclist) != NULL) {
1302 struct net_device *dev;
1303
1304 po->mclist = ml->next;
1305 if ((dev = dev_get_by_index(ml->ifindex)) != NULL) {
1306 packet_dev_mc(dev, ml, -1);
1307 dev_put(dev);
1308 }
1309 kfree(ml);
1310 }
1311 rtnl_unlock();
1312}
1313#endif
1314
1315static int
1316packet_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int optlen)
1317{
1318 struct sock *sk = sock->sk;
1319 int ret;
1320
1321 if (level != SOL_PACKET)
1322 return -ENOPROTOOPT;
1323
1324 switch(optname) {
1325#ifdef CONFIG_PACKET_MULTICAST
1326 case PACKET_ADD_MEMBERSHIP:
1327 case PACKET_DROP_MEMBERSHIP:
1328 {
0fb375fb
EB		 1329 struct packet_mreq_max mreq;
1330 int len = optlen;
1331 memset(&mreq, 0, sizeof(mreq));
1332 if (len < sizeof(struct packet_mreq))
1da177e4 1333 return -EINVAL;
0fb375fb
EB		 1334 if (len > sizeof(mreq))
1335 len = sizeof(mreq);
1336 if (copy_from_user(&mreq,optval,len))
1da177e4 1337 return -EFAULT;
0fb375fb
EB		 1338 if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address)))
1339 return -EINVAL;
1da177e4
LT		 1340 if (optname == PACKET_ADD_MEMBERSHIP)
1341 ret = packet_mc_add(sk, &mreq);
1342 else
1343 ret = packet_mc_drop(sk, &mreq);
1344 return ret;
1345 }
1346#endif
1347#ifdef CONFIG_PACKET_MMAP
1348 case PACKET_RX_RING:
1349 {
1350 struct tpacket_req req;
1351
1352 if (optlen<sizeof(req))
1353 return -EINVAL;
1354 if (copy_from_user(&req,optval,sizeof(req)))
1355 return -EFAULT;
1356 return packet_set_ring(sk, &req, 0);
1357 }
1358 case PACKET_COPY_THRESH:
1359 {
1360 int val;
1361
1362 if (optlen!=sizeof(val))
1363 return -EINVAL;
1364 if (copy_from_user(&val,optval,sizeof(val)))
1365 return -EFAULT;
1366
1367 pkt_sk(sk)->copy_thresh = val;
1368 return 0;
1369 }
1370#endif
1371 default:
1372 return -ENOPROTOOPT;
1373 }
1374}
1375
1376static int packet_getsockopt(struct socket *sock, int level, int optname,
1377 char __user *optval, int __user *optlen)
1378{
1379 int len;
1380 struct sock *sk = sock->sk;
1381 struct packet_sock *po = pkt_sk(sk);
1382
1383 if (level != SOL_PACKET)
1384 return -ENOPROTOOPT;
1385
8ae55f04
KK		 1386 if (get_user(len, optlen))
1387 return -EFAULT;
1da177e4
LT		 1388
1389 if (len < 0)
1390 return -EINVAL;
1391
1392 switch(optname) {
1393 case PACKET_STATISTICS:
1394 {
1395 struct tpacket_stats st;
1396
1397 if (len > sizeof(struct tpacket_stats))
1398 len = sizeof(struct tpacket_stats);
1399 spin_lock_bh(&sk->sk_receive_queue.lock);
1400 st = po->stats;
1401 memset(&po->stats, 0, sizeof(st));
1402 spin_unlock_bh(&sk->sk_receive_queue.lock);
1403 st.tp_packets += st.tp_drops;
1404
1405 if (copy_to_user(optval, &st, len))
1406 return -EFAULT;
1407 break;
1408 }
1409 default:
1410 return -ENOPROTOOPT;
1411 }
1412
8ae55f04
KK		 1413 if (put_user(len, optlen))
1414 return -EFAULT;
1415 return 0;
1da177e4
LT		 1416}
1417
1418
1419static int packet_notifier(struct notifier_block *this, unsigned long msg, void *data)
1420{
1421 struct sock *sk;
1422 struct hlist_node *node;
1423 struct net_device *dev = (struct net_device*)data;
1424
1425 read_lock(&packet_sklist_lock);
1426 sk_for_each(sk, node, &packet_sklist) {
1427 struct packet_sock *po = pkt_sk(sk);
1428
1429 switch (msg) {
1430 case NETDEV_UNREGISTER:
1431#ifdef CONFIG_PACKET_MULTICAST
1432 if (po->mclist)
1433 packet_dev_mclist(dev, po->mclist, -1);
1434 // fallthrough
1435#endif
1436 case NETDEV_DOWN:
1437 if (dev->ifindex == po->ifindex) {
1438 spin_lock(&po->bind_lock);
1439 if (po->running) {
1440 __dev_remove_pack(&po->prot_hook);
1441 __sock_put(sk);
1442 po->running = 0;
1443 sk->sk_err = ENETDOWN;
1444 if (!sock_flag(sk, SOCK_DEAD))
1445 sk->sk_error_report(sk);
1446 }
1447 if (msg == NETDEV_UNREGISTER) {
1448 po->ifindex = -1;
1449 po->prot_hook.dev = NULL;
1450 }
1451 spin_unlock(&po->bind_lock);
1452 }
1453 break;
1454 case NETDEV_UP:
1455 spin_lock(&po->bind_lock);
1456 if (dev->ifindex == po->ifindex && po->num &&
1457 !po->running) {
1458 dev_add_pack(&po->prot_hook);
1459 sock_hold(sk);
1460 po->running = 1;
1461 }
1462 spin_unlock(&po->bind_lock);
1463 break;
1464 }
1465 }
1466 read_unlock(&packet_sklist_lock);
1467 return NOTIFY_DONE;
1468}
1469
1470
1471static int packet_ioctl(struct socket *sock, unsigned int cmd,
1472 unsigned long arg)
1473{
1474 struct sock *sk = sock->sk;
1475
1476 switch(cmd) {
1477 case SIOCOUTQ:
1478 {
1479 int amount = atomic_read(&sk->sk_wmem_alloc);
1480 return put_user(amount, (int __user *)arg);
1481 }
1482 case SIOCINQ:
1483 {
1484 struct sk_buff *skb;
1485 int amount = 0;
1486
1487 spin_lock_bh(&sk->sk_receive_queue.lock);
1488 skb = skb_peek(&sk->sk_receive_queue);
1489 if (skb)
1490 amount = skb->len;
1491 spin_unlock_bh(&sk->sk_receive_queue.lock);
1492 return put_user(amount, (int __user *)arg);
1493 }
1494 case SIOCGSTAMP:
1495 return sock_get_timestamp(sk, (struct timeval __user *)arg);
1496
1497#ifdef CONFIG_INET
1498 case SIOCADDRT:
1499 case SIOCDELRT:
1500 case SIOCDARP:
1501 case SIOCGARP:
1502 case SIOCSARP:
1503 case SIOCGIFADDR:
1504 case SIOCSIFADDR:
1505 case SIOCGIFBRDADDR:
1506 case SIOCSIFBRDADDR:
1507 case SIOCGIFNETMASK:
1508 case SIOCSIFNETMASK:
1509 case SIOCGIFDSTADDR:
1510 case SIOCSIFDSTADDR:
1511 case SIOCSIFFLAGS:
1512 return inet_dgram_ops.ioctl(sock, cmd, arg);
1513#endif
1514
1515 default:
b5e5fa5e 1516 return -ENOIOCTLCMD;
1da177e4
LT		 1517 }
1518 return 0;
1519}
1520
1521#ifndef CONFIG_PACKET_MMAP
1522#define packet_mmap sock_no_mmap
1523#define packet_poll datagram_poll
1524#else
1525
1526static unsigned int packet_poll(struct file * file, struct socket *sock,
1527 poll_table *wait)
1528{
1529 struct sock *sk = sock->sk;
1530 struct packet_sock *po = pkt_sk(sk);
1531 unsigned int mask = datagram_poll(file, sock, wait);
1532
1533 spin_lock_bh(&sk->sk_receive_queue.lock);
1534 if (po->pg_vec) {
1535 unsigned last = po->head ? po->head-1 : po->frame_max;
1536 struct tpacket_hdr *h;
1537
1538 h = (struct tpacket_hdr *)packet_lookup_frame(po, last);
1539
1540 if (h->tp_status)
1541 mask |= POLLIN | POLLRDNORM;
1542 }
1543 spin_unlock_bh(&sk->sk_receive_queue.lock);
1544 return mask;
1545}
1546
1547
1548/* Dirty? Well, I still did not learn better way to account
1549 * for user mmaps.
1550 */
1551
1552static void packet_mm_open(struct vm_area_struct *vma)
1553{
1554 struct file *file = vma->vm_file;
b69aee04 1555 struct socket * sock = file->private_data;
1da177e4
LT		 1556 struct sock *sk = sock->sk;
1557
1558 if (sk)
1559 atomic_inc(&pkt_sk(sk)->mapped);
1560}
1561
1562static void packet_mm_close(struct vm_area_struct *vma)
1563{
1564 struct file *file = vma->vm_file;
b69aee04 1565 struct socket * sock = file->private_data;
1da177e4
LT		 1566 struct sock *sk = sock->sk;
1567
1568 if (sk)
1569 atomic_dec(&pkt_sk(sk)->mapped);
1570}
1571
1572static struct vm_operations_struct packet_mmap_ops = {
1573 .open = packet_mm_open,
1574 .close =packet_mm_close,
1575};
1576
1577static inline struct page *pg_vec_endpage(char *one_pg_vec, unsigned int order)
1578{
1579 return virt_to_page(one_pg_vec + (PAGE_SIZE << order) - 1);
1580}
1581
4ebf0ae2 1582static void free_pg_vec(char **pg_vec, unsigned int order, unsigned int len)
1da177e4
LT		 1583{
1584 int i;
1585
4ebf0ae2
DM		 1586 for (i = 0; i < len; i++) {
1587 if (likely(pg_vec[i]))
1588 free_pages((unsigned long) pg_vec[i], order);
1da177e4
LT		 1589 }
1590 kfree(pg_vec);
1591}
1592
4ebf0ae2
DM		 1593static inline char *alloc_one_pg_vec_page(unsigned long order)
1594{
1595 return (char *) __get_free_pages(GFP_KERNEL | __GFP_COMP | __GFP_ZERO,
1596 order);
1597}
1598
1599static char **alloc_pg_vec(struct tpacket_req *req, int order)
1600{
1601 unsigned int block_nr = req->tp_block_nr;
1602 char **pg_vec;
1603 int i;
1604
1605 pg_vec = kzalloc(block_nr * sizeof(char *), GFP_KERNEL);
1606 if (unlikely(!pg_vec))
1607 goto out;
1608
1609 for (i = 0; i < block_nr; i++) {
1610 pg_vec[i] = alloc_one_pg_vec_page(order);
1611 if (unlikely(!pg_vec[i]))
1612 goto out_free_pgvec;
1613 }
1614
1615out:
1616 return pg_vec;
1617
1618out_free_pgvec:
1619 free_pg_vec(pg_vec, order, block_nr);
1620 pg_vec = NULL;
1621 goto out;
1622}
1da177e4
LT		 1623
1624static int packet_set_ring(struct sock *sk, struct tpacket_req *req, int closing)
1625{
1626 char **pg_vec = NULL;
1627 struct packet_sock *po = pkt_sk(sk);
0e11c91e
AV		 1628 int was_running, order = 0;
1629 __be16 num;
1da177e4
LT		 1630 int err = 0;
1631
1632 if (req->tp_block_nr) {
1633 int i, l;
1634
1635 /* Sanity tests and some calculations */
1636
4ebf0ae2 1637 if (unlikely(po->pg_vec))
1da177e4
LT		 1638 return -EBUSY;
1639
4ebf0ae2 1640 if (unlikely((int)req->tp_block_size <= 0))
1da177e4 1641 return -EINVAL;
4ebf0ae2 1642 if (unlikely(req->tp_block_size & (PAGE_SIZE - 1)))
1da177e4 1643 return -EINVAL;
4ebf0ae2 1644 if (unlikely(req->tp_frame_size < TPACKET_HDRLEN))
1da177e4 1645 return -EINVAL;
4ebf0ae2 1646 if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1)))
1da177e4
LT		 1647 return -EINVAL;
1648
1649 po->frames_per_block = req->tp_block_size/req->tp_frame_size;
4ebf0ae2 1650 if (unlikely(po->frames_per_block <= 0))
1da177e4 1651 return -EINVAL;
4ebf0ae2
DM		 1652 if (unlikely((po->frames_per_block * req->tp_block_nr) !=
1653 req->tp_frame_nr))
1da177e4 1654 return -EINVAL;
1da177e4
LT		 1655
1656 err = -ENOMEM;
4ebf0ae2
DM		 1657 order = get_order(req->tp_block_size);
1658 pg_vec = alloc_pg_vec(req, order);
1659 if (unlikely(!pg_vec))
1da177e4 1660 goto out;
1da177e4
LT		 1661
1662 l = 0;
4ebf0ae2 1663 for (i = 0; i < req->tp_block_nr; i++) {
1da177e4
LT		 1664 char *ptr = pg_vec[i];
1665 struct tpacket_hdr *header;
1666 int k;
1667
4ebf0ae2
DM		 1668 for (k = 0; k < po->frames_per_block; k++) {
1669 header = (struct tpacket_hdr *) ptr;
1da177e4
LT		 1670 header->tp_status = TP_STATUS_KERNEL;
1671 ptr += req->tp_frame_size;
1672 }
1673 }
1674 /* Done */
1675 } else {
4ebf0ae2 1676 if (unlikely(req->tp_frame_nr))
1da177e4
LT		 1677 return -EINVAL;
1678 }
1679
1680 lock_sock(sk);
1681
1682 /* Detach socket from network */
1683 spin_lock(&po->bind_lock);
1684 was_running = po->running;
1685 num = po->num;
1686 if (was_running) {
1687 __dev_remove_pack(&po->prot_hook);
1688 po->num = 0;
1689 po->running = 0;
1690 __sock_put(sk);
1691 }
1692 spin_unlock(&po->bind_lock);
1693
1694 synchronize_net();
1695
1696 err = -EBUSY;
1697 if (closing || atomic_read(&po->mapped) == 0) {
1698 err = 0;
1699#define XC(a, b) ({ __typeof__ ((a)) __t; __t = (a); (a) = (b); __t; })
1700
1701 spin_lock_bh(&sk->sk_receive_queue.lock);
1702 pg_vec = XC(po->pg_vec, pg_vec);
4ebf0ae2 1703 po->frame_max = (req->tp_frame_nr - 1);
1da177e4
LT		 1704 po->head = 0;
1705 po->frame_size = req->tp_frame_size;
1706 spin_unlock_bh(&sk->sk_receive_queue.lock);
1707
1708 order = XC(po->pg_vec_order, order);
1709 req->tp_block_nr = XC(po->pg_vec_len, req->tp_block_nr);
1710
1711 po->pg_vec_pages = req->tp_block_size/PAGE_SIZE;
1712 po->prot_hook.func = po->pg_vec ? tpacket_rcv : packet_rcv;
1713 skb_queue_purge(&sk->sk_receive_queue);
1714#undef XC
1715 if (atomic_read(&po->mapped))
1716 printk(KERN_DEBUG "packet_mmap: vma is busy: %d\n", atomic_read(&po->mapped));
1717 }
1718
1719 spin_lock(&po->bind_lock);
1720 if (was_running && !po->running) {
1721 sock_hold(sk);
1722 po->running = 1;
1723 po->num = num;
1724 dev_add_pack(&po->prot_hook);
1725 }
1726 spin_unlock(&po->bind_lock);
1727
1728 release_sock(sk);
1729
1da177e4
LT		 1730 if (pg_vec)
1731 free_pg_vec(pg_vec, order, req->tp_block_nr);
1732out:
1733 return err;
1734}
1735
1736static int packet_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1737{
1738 struct sock *sk = sock->sk;
1739 struct packet_sock *po = pkt_sk(sk);
1740 unsigned long size;
1741 unsigned long start;
1742 int err = -EINVAL;
1743 int i;
1744
1745 if (vma->vm_pgoff)
1746 return -EINVAL;
1747
1748 size = vma->vm_end - vma->vm_start;
1749
1750 lock_sock(sk);
1751 if (po->pg_vec == NULL)
1752 goto out;
1753 if (size != po->pg_vec_len*po->pg_vec_pages*PAGE_SIZE)
1754 goto out;
1755
1da177e4 1756 start = vma->vm_start;
4ebf0ae2
DM		 1757 for (i = 0; i < po->pg_vec_len; i++) {
1758 struct page *page = virt_to_page(po->pg_vec[i]);
1759 int pg_num;
1760
1761 for (pg_num = 0; pg_num < po->pg_vec_pages; pg_num++, page++) {
1762 err = vm_insert_page(vma, start, page);
1763 if (unlikely(err))
1764 goto out;
1765 start += PAGE_SIZE;
1766 }
1da177e4 1767 }
4ebf0ae2 1768 atomic_inc(&po->mapped);
1da177e4
LT		 1769 vma->vm_ops = &packet_mmap_ops;
1770 err = 0;
1771
1772out:
1773 release_sock(sk);
1774 return err;
1775}
1776#endif
1777
1778
1779#ifdef CONFIG_SOCK_PACKET
90ddc4f0 1780static const struct proto_ops packet_ops_spkt = {
1da177e4
LT		 1781 .family = PF_PACKET,
1782 .owner = THIS_MODULE,
1783 .release = packet_release,
1784 .bind = packet_bind_spkt,
1785 .connect = sock_no_connect,
1786 .socketpair = sock_no_socketpair,
1787 .accept = sock_no_accept,
1788 .getname = packet_getname_spkt,
1789 .poll = datagram_poll,
1790 .ioctl = packet_ioctl,
1791 .listen = sock_no_listen,
1792 .shutdown = sock_no_shutdown,
1793 .setsockopt = sock_no_setsockopt,
1794 .getsockopt = sock_no_getsockopt,
1795 .sendmsg = packet_sendmsg_spkt,
1796 .recvmsg = packet_recvmsg,
1797 .mmap = sock_no_mmap,
1798 .sendpage = sock_no_sendpage,
1799};
1800#endif
1801
90ddc4f0 1802static const struct proto_ops packet_ops = {
1da177e4
LT		 1803 .family = PF_PACKET,
1804 .owner = THIS_MODULE,
1805 .release = packet_release,
1806 .bind = packet_bind,
1807 .connect = sock_no_connect,
1808 .socketpair = sock_no_socketpair,
1809 .accept = sock_no_accept,
1810 .getname = packet_getname,
1811 .poll = packet_poll,
1812 .ioctl = packet_ioctl,
1813 .listen = sock_no_listen,
1814 .shutdown = sock_no_shutdown,
1815 .setsockopt = packet_setsockopt,
1816 .getsockopt = packet_getsockopt,
1817 .sendmsg = packet_sendmsg,
1818 .recvmsg = packet_recvmsg,
1819 .mmap = packet_mmap,
1820 .sendpage = sock_no_sendpage,
1821};
1822
1823static struct net_proto_family packet_family_ops = {
1824 .family = PF_PACKET,
1825 .create = packet_create,
1826 .owner = THIS_MODULE,
1827};
1828
1829static struct notifier_block packet_netdev_notifier = {
1830 .notifier_call =packet_notifier,
1831};
1832
1833#ifdef CONFIG_PROC_FS
1834static inline struct sock *packet_seq_idx(loff_t off)
1835{
1836 struct sock *s;
1837 struct hlist_node *node;
1838
1839 sk_for_each(s, node, &packet_sklist) {
1840 if (!off--)
1841 return s;
1842 }
1843 return NULL;
1844}
1845
1846static void *packet_seq_start(struct seq_file *seq, loff_t *pos)
1847{
1848 read_lock(&packet_sklist_lock);
1849 return *pos ? packet_seq_idx(*pos - 1) : SEQ_START_TOKEN;
1850}
1851
1852static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1853{
1854 ++*pos;
1855 return (v == SEQ_START_TOKEN)
1856 ? sk_head(&packet_sklist)
1857 : sk_next((struct sock*)v) ;
1858}
1859
1860static void packet_seq_stop(struct seq_file *seq, void *v)
1861{
1862 read_unlock(&packet_sklist_lock);
1863}
1864
1865static int packet_seq_show(struct seq_file *seq, void *v)
1866{
1867 if (v == SEQ_START_TOKEN)
1868 seq_puts(seq, "sk RefCnt Type Proto Iface R Rmem User Inode\n");
1869 else {
1870 struct sock *s = v;
1871 const struct packet_sock *po = pkt_sk(s);
1872
1873 seq_printf(seq,
1874 "%p %-6d %-4d %04x %-5d %1d %-6u %-6u %-6lu\n",
1875 s,
1876 atomic_read(&s->sk_refcnt),
1877 s->sk_type,
1878 ntohs(po->num),
1879 po->ifindex,
1880 po->running,
1881 atomic_read(&s->sk_rmem_alloc),
1882 sock_i_uid(s),
1883 sock_i_ino(s) );
1884 }
1885
1886 return 0;
1887}
1888
1889static struct seq_operations packet_seq_ops = {
1890 .start = packet_seq_start,
1891 .next = packet_seq_next,
1892 .stop = packet_seq_stop,
1893 .show = packet_seq_show,
1894};
1895
1896static int packet_seq_open(struct inode *inode, struct file *file)
1897{
1898 return seq_open(file, &packet_seq_ops);
1899}
1900
1901static struct file_operations packet_seq_fops = {
1902 .owner = THIS_MODULE,
1903 .open = packet_seq_open,
1904 .read = seq_read,
1905 .llseek = seq_lseek,
1906 .release = seq_release,
1907};
1908
1909#endif
1910
1911static void __exit packet_exit(void)
1912{
1913 proc_net_remove("packet");
1914 unregister_netdevice_notifier(&packet_netdev_notifier);
1915 sock_unregister(PF_PACKET);
1916 proto_unregister(&packet_proto);
1917}
1918
1919static int __init packet_init(void)
1920{
1921 int rc = proto_register(&packet_proto, 0);
1922
1923 if (rc != 0)
1924 goto out;
1925
1926 sock_register(&packet_family_ops);
1927 register_netdevice_notifier(&packet_netdev_notifier);
1928 proc_net_fops_create("packet", 0, &packet_seq_fops);
1929out:
1930 return rc;
1931}
1932
1933module_init(packet_init);
1934module_exit(packet_exit);
1935MODULE_LICENSE("GPL");
1936MODULE_ALIAS_NETPROTO(PF_PACKET);
Ubuntu Artful kernel mirror