40 #include <linux/types.h>
42 #include <asm/byteorder.h>
43 #include <asm/current.h>
44 #include <asm/uaccess.h>
45 #include <asm/ioctls.h>
46 #include <linux/stddef.h>
47 #include <linux/slab.h>
48 #include <linux/errno.h>
50 #include <linux/kernel.h>
51 #include <linux/export.h>
54 #include <linux/socket.h>
56 #include <linux/mroute.h>
57 #include <linux/netdevice.h>
65 #include <linux/net.h>
75 #include <linux/rtnetlink.h>
78 #include <linux/netfilter.h>
79 #include <linux/netfilter_ipv4.h>
94 sk_add_node(sk, head);
95 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
105 if (sk_del_node_init(sk))
106 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
119 if (net_eq(sock_net(sk), net) && inet->
inet_num == num &&
120 !(inet->inet_daddr && inet->inet_daddr != raddr) &&
121 !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
122 !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif))
139 hdr = skb_header_pointer(skb, skb_transport_offset(skb),
140 sizeof(_hdr), &_hdr);
144 if (hdr->
type < 32) {
147 return ((1
U << hdr->
type) & data) != 0;
160 static int raw_v4_input(
struct sk_buff *skb,
const struct iphdr *iph,
int hash)
168 head = &raw_v4_hashinfo.
ht[
hash];
169 if (hlist_empty(head))
172 net = dev_net(skb->
dev);
173 sk = __raw_v4_lookup(net, __sk_head(head), iph->
protocol,
186 sk = __raw_v4_lookup(net, sk_next(sk), iph->
protocol,
201 raw_sk = sk_head(&raw_v4_hashinfo.
ht[hash]);
206 if (raw_sk && !raw_v4_input(skb, ip_hdr(skb), hash))
209 return raw_sk !=
NULL;
216 const int type = icmp_hdr(skb)->type;
217 const int code = icmp_hdr(skb)->code;
266 if (inet->
recverr || harderr) {
276 const struct iphdr *iph;
282 raw_sk = sk_head(&raw_v4_hashinfo.
ht[hash]);
283 if (raw_sk !=
NULL) {
285 net = dev_net(skb->
dev);
287 while ((raw_sk = __raw_v4_lookup(net, raw_sk, protocol,
290 raw_err(raw_sk, skb, info);
291 raw_sk = sk_next(raw_sk);
298 static int raw_rcv_skb(
struct sock *sk,
struct sk_buff *skb)
322 raw_rcv_skb(sk, skb);
326 static int raw_send_hdrinc(
struct sock *sk,
struct flowi4 *fl4,
332 struct net *net = sock_net(sk);
340 if (length > rt->
dst.dev->mtu) {
349 tlen = rt->
dst.dev->needed_tailroom;
351 length + hlen + tlen + 15,
355 skb_reserve(skb, hlen);
359 skb_dst_set(skb, &rt->
dst);
362 skb_reset_network_header(skb);
373 iphlen = iph->ihl * 4;
386 if (iphlen >=
sizeof(*iph)) {
392 ip_select_ident(iph, &rt->
dst,
NULL);
398 skb_transport_header(skb))->type);
401 rt->
dst.dev, dst_output);
434 switch (fl4->flowi4_proto) {
449 if (
get_user(fl4->fl4_icmp_type, type) ||
516 daddr = inet->inet_daddr;
522 ipc.oif = sk->sk_bound_dev_if;
541 memcpy(&opt_copy, inet_opt,
542 sizeof(*inet_opt) + inet_opt->
opt.optlen);
543 ipc.opt = &opt_copy.opt;
555 if (ipc.opt->opt.srr) {
558 daddr = ipc.opt->opt.faddr;
565 if (ipv4_is_multicast(daddr)) {
573 flowi4_init_output(&fl4, ipc.oif, sk->
sk_mark, tos,
580 err = raw_probe_proto_opt(&fl4, msg);
585 security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
602 err = raw_send_hdrinc(sk, &fl4, msg->
msg_iov, len,
607 ipc.addr = fl4.
daddr;
632 dst_confirm(&rt->
dst);
633 if (!(msg->
msg_flags & MSG_PROBE) || len)
634 goto back_from_confirm;
639 static void raw_close(
struct sock *sk,
long timeout)
649 static void raw_destroy(
struct sock *sk)
684 static int raw_recvmsg(
struct kiocb *iocb,
struct sock *sk,
struct msghdr *msg,
685 size_t len,
int noblock,
int flags,
int *addr_len)
697 *addr_len =
sizeof(*sin);
718 sock_recv_ts_and_drops(msg, sk, skb);
723 sin->
sin_addr.s_addr = ip_hdr(skb)->saddr;
725 memset(&sin->sin_zero, 0,
sizeof(sin->sin_zero));
739 static int raw_init(
struct sock *sk)
748 static int raw_seticmpfilter(
struct sock *sk,
char __user *optval,
int optlen)
757 static int raw_geticmpfilter(
struct sock *sk,
char __user *optval,
int __user *optlen)
776 static int do_raw_setsockopt(
struct sock *sk,
int level,
int optname,
777 char __user *optval,
unsigned int optlen)
783 return raw_seticmpfilter(sk, optval, optlen);
788 static int raw_setsockopt(
struct sock *sk,
int level,
int optname,
789 char __user *optval,
unsigned int optlen)
793 return do_raw_setsockopt(sk, level, optname, optval, optlen);
797 static int compat_raw_setsockopt(
struct sock *sk,
int level,
int optname,
798 char __user *optval,
unsigned int optlen)
802 return do_raw_setsockopt(sk, level, optname, optval, optlen);
806 static int do_raw_getsockopt(
struct sock *sk,
int level,
int optname,
807 char __user *optval,
int __user *optlen)
813 return raw_geticmpfilter(sk, optval, optlen);
818 static int raw_getsockopt(
struct sock *sk,
int level,
int optname,
819 char __user *optval,
int __user *optlen)
823 return do_raw_getsockopt(sk, level, optname, optval, optlen);
827 static int compat_raw_getsockopt(
struct sock *sk,
int level,
int optname,
828 char __user *optval,
int __user *optlen)
832 return do_raw_getsockopt(sk, level, optname, optval, optlen);
836 static int raw_ioctl(
struct sock *sk,
int cmd,
unsigned long arg)
840 int amount = sk_wmem_alloc_get(sk);
842 return put_user(amount, (
int __user *)arg);
853 return put_user(amount, (
int __user *)arg);
857 #ifdef CONFIG_IP_MROUTE
858 return ipmr_ioctl(sk, cmd, (
void __user *)arg);
866 static int compat_raw_ioctl(
struct sock *sk,
unsigned int cmd,
unsigned long arg)
873 #ifdef CONFIG_IP_MROUTE
874 return ipmr_compat_ioctl(sk, cmd, compat_ptr(arg));
886 .destroy = raw_destroy,
891 .setsockopt = raw_setsockopt,
892 .getsockopt = raw_getsockopt,
893 .sendmsg = raw_sendmsg,
894 .recvmsg = raw_recvmsg,
896 .backlog_rcv = raw_rcv_skb,
899 .obj_size =
sizeof(
struct raw_sock),
900 .h.raw_hash = &raw_v4_hashinfo,
902 .compat_setsockopt = compat_raw_setsockopt,
903 .compat_getsockopt = compat_raw_getsockopt,
904 .compat_ioctl = compat_raw_ioctl,
908 #ifdef CONFIG_PROC_FS
912 struct raw_iter_state *
state = raw_seq_private(seq);
918 sk_for_each(sk, node, &state->h->ht[state->bucket])
919 if (sock_net(sk) == seq_file_net(seq))
929 struct raw_iter_state *state = raw_seq_private(seq);
935 }
while (sk && sock_net(sk) != seq_file_net(seq));
938 sk = sk_head(&state->h->ht[state->bucket]);
946 struct sock *sk = raw_get_first(seq);
949 while (pos && (sk = raw_get_next(seq, sk)) != NULL)
951 return pos ? NULL :
sk;
954 void *raw_seq_start(
struct seq_file *seq, loff_t *pos)
956 struct raw_iter_state *state = raw_seq_private(seq);
963 void *raw_seq_next(
struct seq_file *seq,
void *
v, loff_t *pos)
968 sk = raw_get_first(seq);
970 sk = raw_get_next(seq, v);
976 void raw_seq_stop(
struct seq_file *seq,
void *v)
978 struct raw_iter_state *state = raw_seq_private(seq);
984 static void raw_sock_seq_show(
struct seq_file *seq,
struct sock *
sp,
int i)
988 src = inet->inet_rcv_saddr;
993 " %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %pK %d\n",
994 i,
src, srcp, dest, destp, sp->sk_state,
995 sk_wmem_alloc_get(sp),
996 sk_rmem_alloc_get(sp),
1003 static int raw_seq_show(
struct seq_file *seq,
void *v)
1006 seq_printf(seq,
" sl local_address rem_address st tx_queue "
1007 "rx_queue tr tm->when retrnsmt uid timeout "
1008 "inode ref pointer drops\n");
1010 raw_sock_seq_show(seq, v, raw_seq_private(seq)->bucket);
1015 .
start = raw_seq_start,
1016 .next = raw_seq_next,
1017 .stop = raw_seq_stop,
1018 .show = raw_seq_show,
1025 struct raw_iter_state *
i;
1027 err =
seq_open_net(ino, file, ops,
sizeof(
struct raw_iter_state));
1037 static int raw_v4_seq_open(
struct inode *
inode,
struct file *file)
1039 return raw_seq_open(inode, file, &raw_v4_hashinfo, &raw_seq_ops);
1044 .open = raw_v4_seq_open,
1050 static __net_init int raw_init_net(
struct net *net)
1058 static __net_exit void raw_exit_net(
struct net *net)
1064 .
init = raw_init_net,
1065 .exit = raw_exit_net,
1068 int __init raw_proc_init(
void)
1073 void __init raw_proc_exit(
void)