* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
* Alan Cox, <gw4pts@gw4pts.ampr.org>
*
- * Fixes:
+ * Fixes:
* Alan Cox : verify_area() now used correctly
* Alan Cox : new skbuff lists, look ma no backlogs!
* Alan Cox : tidied skbuff lists.
* Alexey Kuznetsov : Untied from IPv4 stack.
* Cyrus Durgin : Fixed kerneld for kmod.
* Michal Ostrowski : Module initialization cleanup.
- * Ulises Alonso : Frame number limit removal and
+ * Ulises Alonso : Frame number limit removal and
* packet_set_ring memory leak.
* Eric Biederman : Allow for > 8 byte hardware addresses.
* The convention is that longer addresses
* will simply extend the hardware address
- * byte arrays at the end of sockaddr_ll
+ * byte arrays at the end of sockaddr_ll
* and packet_mreq.
*
* This program is free software; you can redistribute it and/or
* 2 of the License, or (at your option) any later version.
*
*/
-
+
#include <linux/types.h>
#include <linux/sched.h>
#include <linux/mm.h>
Incoming, dev->hard_header==NULL
mac.raw -> UNKNOWN position. It is very likely, that it points to ll header.
- PPP makes it, that is wrong, because introduce assymetry
+ PPP makes it, that is wrong, because introduce assymetry
between rx and tx paths.
data -> data
frame_offset = position % po->frames_per_block;
frame = po->pg_vec[pg_vec_pos] + (frame_offset * po->frame_size);
-
+
return frame;
}
#endif
*/
sk = pt->af_packet_priv;
-
+
/*
* Yank back the headers [hope the device set this
* right or kerboom...]
* Output a raw packet to a device layer. This bypasses all the other
* protocol layers and you must therefore supply it with a complete frame
*/
-
+
static int packet_sendmsg_spkt(struct kiocb *iocb, struct socket *sock,
struct msghdr *msg, size_t len)
{
struct net_device *dev;
__be16 proto=0;
int err;
-
+
/*
- * Get and verify the address.
+ * Get and verify the address.
*/
if (saddr)
return(-ENOTCONN); /* SOCK_PACKET must be sent giving an address */
/*
- * Find the device first to size check it
+ * Find the device first to size check it
*/
saddr->spkt_device[13] = 0;
err = -ENODEV;
if (dev == NULL)
goto out_unlock;
-
+
err = -ENETDOWN;
if (!(dev->flags & IFF_UP))
goto out_unlock;
* You may not queue a frame bigger than the mtu. This is the lowest level
* raw protocol and you must do your own fragmentation at this level.
*/
-
+
err = -EMSGSIZE;
if (len > dev->mtu + dev->hard_header_len)
goto out_unlock;
* deal with the problem - do your own algorithmic backoffs. That's far
* more flexible.
*/
-
- if (skb == NULL)
+
+ if (skb == NULL)
goto out_unlock;
/*
- * Fill it in
+ * Fill it in
*/
-
+
/* FIXME: Save some space for broken drivers that write a
* hard header at transmission time by themselves. PPP is the
* notable one here. This should really be fixed at the driver level.
spin_lock(&sk->sk_receive_queue.lock);
h = (struct tpacket_hdr *)packet_lookup_frame(po, po->head);
-
+
if (h->tp_status)
goto ring_is_full;
po->head = po->head != po->frame_max ? po->head+1 : 0;
h->tp_snaplen = snaplen;
h->tp_mac = macoff;
h->tp_net = netoff;
- if (skb->tstamp.off_sec == 0) {
+ if (skb->tstamp.off_sec == 0) {
__net_timestamp(skb);
sock_enable_timestamp(sk);
}
skb->len = skb_len;
}
drop:
- kfree_skb(skb);
+ kfree_skb(skb);
return 0;
ring_is_full:
int ifindex, err, reserve = 0;
/*
- * Get and verify the address.
+ * Get and verify the address.
*/
-
+
if (saddr == NULL) {
struct packet_sock *po = pkt_sk(sk);
char name[15];
struct net_device *dev;
int err = -ENODEV;
-
+
/*
* Check legality
*/
-
+
if (addr_len != sizeof(struct sockaddr))
return -EINVAL;
strlcpy(name,uaddr->sa_data,sizeof(name));
/*
* Check legality
*/
-
+
if (addr_len < sizeof(struct sockaddr_ll))
return -EINVAL;
if (sll->sll_family != AF_PACKET)
};
/*
- * Create a packet of type SOCK_PACKET.
+ * Create a packet of type SOCK_PACKET.
*/
static int packet_create(struct socket *sock, int protocol)
skb=skb_recv_datagram(sk,flags,flags&MSG_DONTWAIT,&err);
/*
- * An error occurred so return it. Because skb_recv_datagram()
+ * An error occurred so return it. Because skb_recv_datagram()
* handles the blocking we don't see and worry about blocking
* retries.
*/
switch(optname) {
#ifdef CONFIG_PACKET_MULTICAST
- case PACKET_ADD_MEMBERSHIP:
+ case PACKET_ADD_MEMBERSHIP:
case PACKET_DROP_MEMBERSHIP:
{
struct packet_mreq_max mreq;
if (len < 0)
return -EINVAL;
-
+
switch(optname) {
case PACKET_STATISTICS:
if (len > sizeof(struct tpacket_stats))
}
case SIOCGSTAMP:
return sock_get_timestamp(sk, (struct timeval __user *)arg);
-
+
#ifdef CONFIG_INET
case SIOCADDRT:
case SIOCDELRT:
struct file *file = vma->vm_file;
struct socket * sock = file->private_data;
struct sock *sk = sock->sk;
-
+
if (sk)
atomic_inc(&pkt_sk(sk)->mapped);
}
struct file *file = vma->vm_file;
struct socket * sock = file->private_data;
struct sock *sk = sock->sk;
-
+
if (sk)
atomic_dec(&pkt_sk(sk)->mapped);
}
int was_running, order = 0;
__be16 num;
int err = 0;
-
+
if (req->tp_block_nr) {
int i, l;
__sock_put(sk);
}
spin_unlock(&po->bind_lock);
-
+
synchronize_net();
err = -EBUSY;
.connect = sock_no_connect,
.socketpair = sock_no_socketpair,
.accept = sock_no_accept,
- .getname = packet_getname,
+ .getname = packet_getname,
.poll = packet_poll,
.ioctl = packet_ioctl,
.listen = sock_no_listen,
static void *packet_seq_next(struct seq_file *seq, void *v, loff_t *pos)
{
++*pos;
- return (v == SEQ_START_TOKEN)
- ? sk_head(&packet_sklist)
+ return (v == SEQ_START_TOKEN)
+ ? sk_head(&packet_sklist)
: sk_next((struct sock*)v) ;
}
static void packet_seq_stop(struct seq_file *seq, void *v)
{
- read_unlock(&packet_sklist_lock);
+ read_unlock(&packet_sklist_lock);
}
-static int packet_seq_show(struct seq_file *seq, void *v)
+static int packet_seq_show(struct seq_file *seq, void *v)
{
if (v == SEQ_START_TOKEN)
seq_puts(seq, "sk RefCnt Type Proto Iface R Rmem User Inode\n");
projects / linux-2.6 / commitdiff