12874c5fdSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * INET An implementation of the TCP/IP protocol suite for the LINUX
41da177e4SLinus Torvalds * operating system. INET is implemented using the BSD Socket
51da177e4SLinus Torvalds * interface as the means of communication with the user level.
61da177e4SLinus Torvalds *
71da177e4SLinus Torvalds * RAW - implementation of IP "raw" sockets.
81da177e4SLinus Torvalds *
902c30a84SJesper Juhl * Authors: Ross Biro
101da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
111da177e4SLinus Torvalds *
121da177e4SLinus Torvalds * Fixes:
131da177e4SLinus Torvalds * Alan Cox : verify_area() fixed up
141da177e4SLinus Torvalds * Alan Cox : ICMP error handling
151da177e4SLinus Torvalds * Alan Cox : EMSGSIZE if you send too big a packet
161da177e4SLinus Torvalds * Alan Cox : Now uses generic datagrams and shared
171da177e4SLinus Torvalds * skbuff library. No more peek crashes,
181da177e4SLinus Torvalds * no more backlogs
191da177e4SLinus Torvalds * Alan Cox : Checks sk->broadcast.
201da177e4SLinus Torvalds * Alan Cox : Uses skb_free_datagram/skb_copy_datagram
211da177e4SLinus Torvalds * Alan Cox : Raw passes ip options too
221da177e4SLinus Torvalds * Alan Cox : Setsocketopt added
231da177e4SLinus Torvalds * Alan Cox : Fixed error return for broadcasts
241da177e4SLinus Torvalds * Alan Cox : Removed wake_up calls
251da177e4SLinus Torvalds * Alan Cox : Use ttl/tos
261da177e4SLinus Torvalds * Alan Cox : Cleaned up old debugging
271da177e4SLinus Torvalds * Alan Cox : Use new kernel side addresses
281da177e4SLinus Torvalds * Arnt Gulbrandsen : Fixed MSG_DONTROUTE in raw sockets.
291da177e4SLinus Torvalds * Alan Cox : BSD style RAW socket demultiplexing.
301da177e4SLinus Torvalds * Alan Cox : Beginnings of mrouted support.
311da177e4SLinus Torvalds * Alan Cox : Added IP_HDRINCL option.
321da177e4SLinus Torvalds * Alan Cox : Skip broadcast check if BSDism set.
331da177e4SLinus Torvalds * David S. Miller : New socket lookup architecture.
341da177e4SLinus Torvalds */
351da177e4SLinus Torvalds
36715b49efSAlan Cox #include <linux/types.h>
3760063497SArun Sharma #include <linux/atomic.h>
381da177e4SLinus Torvalds #include <asm/byteorder.h>
391da177e4SLinus Torvalds #include <asm/current.h>
407c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
411da177e4SLinus Torvalds #include <asm/ioctls.h>
421da177e4SLinus Torvalds #include <linux/stddef.h>
431da177e4SLinus Torvalds #include <linux/slab.h>
441da177e4SLinus Torvalds #include <linux/errno.h>
451da177e4SLinus Torvalds #include <linux/kernel.h>
46bc3b2d7fSPaul Gortmaker #include <linux/export.h>
471da177e4SLinus Torvalds #include <linux/spinlock.h>
481da177e4SLinus Torvalds #include <linux/sockios.h>
491da177e4SLinus Torvalds #include <linux/socket.h>
501da177e4SLinus Torvalds #include <linux/in.h>
511da177e4SLinus Torvalds #include <linux/mroute.h>
521da177e4SLinus Torvalds #include <linux/netdevice.h>
531da177e4SLinus Torvalds #include <linux/in_route.h>
541da177e4SLinus Torvalds #include <linux/route.h>
551da177e4SLinus Torvalds #include <linux/skbuff.h>
56f5220d63SQuentin Armitage #include <linux/igmp.h>
57457c4cbcSEric W. Biederman #include <net/net_namespace.h>
581da177e4SLinus Torvalds #include <net/dst.h>
591da177e4SLinus Torvalds #include <net/sock.h>
601da177e4SLinus Torvalds #include <linux/ip.h>
611da177e4SLinus Torvalds #include <linux/net.h>
621da177e4SLinus Torvalds #include <net/ip.h>
631da177e4SLinus Torvalds #include <net/icmp.h>
641da177e4SLinus Torvalds #include <net/udp.h>
651da177e4SLinus Torvalds #include <net/raw.h>
661da177e4SLinus Torvalds #include <net/snmp.h>
67c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h>
681da177e4SLinus Torvalds #include <net/inet_common.h>
691da177e4SLinus Torvalds #include <net/checksum.h>
701da177e4SLinus Torvalds #include <net/xfrm.h>
711da177e4SLinus Torvalds #include <linux/rtnetlink.h>
721da177e4SLinus Torvalds #include <linux/proc_fs.h>
731da177e4SLinus Torvalds #include <linux/seq_file.h>
741da177e4SLinus Torvalds #include <linux/netfilter.h>
751da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h>
76709b46e8SEric W. Biederman #include <linux/compat.h>
77c008ba5bSHerbert Xu #include <linux/uio.h>
78c008ba5bSHerbert Xu
79c008ba5bSHerbert Xu struct raw_frag_vec {
80b61e9dccSAl Viro struct msghdr *msg;
81c008ba5bSHerbert Xu union {
82c008ba5bSHerbert Xu struct icmphdr icmph;
83c008ba5bSHerbert Xu char c[1];
84c008ba5bSHerbert Xu } hdr;
85c008ba5bSHerbert Xu int hlen;
86c008ba5bSHerbert Xu };
871da177e4SLinus Torvalds
880daf07e5SEric Dumazet struct raw_hashinfo raw_v4_hashinfo;
89432490f9SCyrill Gorcunov EXPORT_SYMBOL_GPL(raw_v4_hashinfo);
901da177e4SLinus Torvalds
raw_hash_sk(struct sock * sk)91086c653fSCraig Gallek int raw_hash_sk(struct sock *sk)
921da177e4SLinus Torvalds {
93fc8717baSPavel Emelyanov struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
940a78cf72SKuniyuki Iwashima struct hlist_head *hlist;
951da177e4SLinus Torvalds
966579f5baSEric Dumazet hlist = &h->ht[raw_hashfunc(sock_net(sk), inet_sk(sk)->inet_num)];
9765b4c50bSPavel Emelyanov
98af185d8cSEric Dumazet spin_lock(&h->lock);
990a78cf72SKuniyuki Iwashima sk_add_node_rcu(sk, hlist);
1000daf07e5SEric Dumazet sock_set_flag(sk, SOCK_RCU_FREE);
101af185d8cSEric Dumazet spin_unlock(&h->lock);
102b3cb764aSEric Dumazet sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
103086c653fSCraig Gallek
104086c653fSCraig Gallek return 0;
10565b4c50bSPavel Emelyanov }
10665b4c50bSPavel Emelyanov EXPORT_SYMBOL_GPL(raw_hash_sk);
10765b4c50bSPavel Emelyanov
raw_unhash_sk(struct sock * sk)108fc8717baSPavel Emelyanov void raw_unhash_sk(struct sock *sk)
109ab70768eSPavel Emelyanov {
110fc8717baSPavel Emelyanov struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
111fc8717baSPavel Emelyanov
112af185d8cSEric Dumazet spin_lock(&h->lock);
1130a78cf72SKuniyuki Iwashima if (sk_del_node_init_rcu(sk))
114c29a0bc4SPavel Emelyanov sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
115af185d8cSEric Dumazet spin_unlock(&h->lock);
116ab70768eSPavel Emelyanov }
117ab70768eSPavel Emelyanov EXPORT_SYMBOL_GPL(raw_unhash_sk);
118ab70768eSPavel Emelyanov
raw_v4_match(struct net * net,const struct sock * sk,unsigned short num,__be32 raddr,__be32 laddr,int dif,int sdif)1190a8c2568SEric Dumazet bool raw_v4_match(struct net *net, const struct sock *sk, unsigned short num,
120ba44f818SEric Dumazet __be32 raddr, __be32 laddr, int dif, int sdif)
1211da177e4SLinus Torvalds {
1220a8c2568SEric Dumazet const struct inet_sock *inet = inet_sk(sk);
1231da177e4SLinus Torvalds
124c720c7e8SEric Dumazet if (net_eq(sock_net(sk), net) && inet->inet_num == num &&
125c720c7e8SEric Dumazet !(inet->inet_daddr && inet->inet_daddr != raddr) &&
126c720c7e8SEric Dumazet !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
1277055420fSDuncan Eastoe raw_sk_bound_dev_eq(net, sk->sk_bound_dev_if, dif, sdif))
128ba44f818SEric Dumazet return true;
129ba44f818SEric Dumazet return false;
1301da177e4SLinus Torvalds }
131ba44f818SEric Dumazet EXPORT_SYMBOL_GPL(raw_v4_match);
1321da177e4SLinus Torvalds
1331da177e4SLinus Torvalds /*
1341da177e4SLinus Torvalds * 0 - deliver
1351da177e4SLinus Torvalds * 1 - block
1361da177e4SLinus Torvalds */
icmp_filter(const struct sock * sk,const struct sk_buff * skb)137ab43ed8bSEric Dumazet static int icmp_filter(const struct sock *sk, const struct sk_buff *skb)
1381da177e4SLinus Torvalds {
139ab43ed8bSEric Dumazet struct icmphdr _hdr;
140ab43ed8bSEric Dumazet const struct icmphdr *hdr;
1411da177e4SLinus Torvalds
142ab43ed8bSEric Dumazet hdr = skb_header_pointer(skb, skb_transport_offset(skb),
143ab43ed8bSEric Dumazet sizeof(_hdr), &_hdr);
144ab43ed8bSEric Dumazet if (!hdr)
1451da177e4SLinus Torvalds return 1;
1461da177e4SLinus Torvalds
147ab43ed8bSEric Dumazet if (hdr->type < 32) {
1481da177e4SLinus Torvalds __u32 data = raw_sk(sk)->filter.data;
1491da177e4SLinus Torvalds
150ab43ed8bSEric Dumazet return ((1U << hdr->type) & data) != 0;
1511da177e4SLinus Torvalds }
1521da177e4SLinus Torvalds
1531da177e4SLinus Torvalds /* Do not block unknown ICMP types */
1541da177e4SLinus Torvalds return 0;
1551da177e4SLinus Torvalds }
1561da177e4SLinus Torvalds
1571da177e4SLinus Torvalds /* IP input processing comes here for RAW socket delivery.
1581da177e4SLinus Torvalds * Caller owns SKB, so we must make clones.
1591da177e4SLinus Torvalds *
1601da177e4SLinus Torvalds * RFC 1122: SHOULD pass TOS value up to the transport layer.
1611da177e4SLinus Torvalds * -> It does. And not only TOS, but all IP header.
1621da177e4SLinus Torvalds */
raw_v4_input(struct net * net,struct sk_buff * skb,const struct iphdr * iph,int hash)1636579f5baSEric Dumazet static int raw_v4_input(struct net *net, struct sk_buff *skb,
1646579f5baSEric Dumazet const struct iphdr *iph, int hash)
1651da177e4SLinus Torvalds {
16667359930SDavid Ahern int sdif = inet_sdif(skb);
1670a78cf72SKuniyuki Iwashima struct hlist_head *hlist;
16819e4e768SDavid Ahern int dif = inet_iif(skb);
169d13964f4SPatrick McHardy int delivered = 0;
170ba44f818SEric Dumazet struct sock *sk;
1711da177e4SLinus Torvalds
1720daf07e5SEric Dumazet hlist = &raw_v4_hashinfo.ht[hash];
1730daf07e5SEric Dumazet rcu_read_lock();
1740a78cf72SKuniyuki Iwashima sk_for_each_rcu(sk, hlist) {
175ba44f818SEric Dumazet if (!raw_v4_match(net, sk, iph->protocol,
176ba44f818SEric Dumazet iph->saddr, iph->daddr, dif, sdif))
177ba44f818SEric Dumazet continue;
178d721812aSEric Dumazet
179d721812aSEric Dumazet if (atomic_read(&sk->sk_rmem_alloc) >=
180d721812aSEric Dumazet READ_ONCE(sk->sk_rcvbuf)) {
181d721812aSEric Dumazet atomic_inc(&sk->sk_drops);
182d721812aSEric Dumazet continue;
183d721812aSEric Dumazet }
184d721812aSEric Dumazet
185d13964f4SPatrick McHardy delivered = 1;
186f5220d63SQuentin Armitage if ((iph->protocol != IPPROTO_ICMP || !icmp_filter(sk, skb)) &&
187f5220d63SQuentin Armitage ip_mc_sf_allow(sk, iph->daddr, iph->saddr,
18860d9b031SDavid Ahern skb->dev->ifindex, sdif)) {
1891da177e4SLinus Torvalds struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
1901da177e4SLinus Torvalds
1911da177e4SLinus Torvalds /* Not releasing hash table! */
1921da177e4SLinus Torvalds if (clone)
1931da177e4SLinus Torvalds raw_rcv(sk, clone);
1941da177e4SLinus Torvalds }
1951da177e4SLinus Torvalds }
1960daf07e5SEric Dumazet rcu_read_unlock();
197d13964f4SPatrick McHardy return delivered;
1981da177e4SLinus Torvalds }
1991da177e4SLinus Torvalds
raw_local_deliver(struct sk_buff * skb,int protocol)2007bc54c90SPavel Emelyanov int raw_local_deliver(struct sk_buff *skb, int protocol)
2017bc54c90SPavel Emelyanov {
2026579f5baSEric Dumazet struct net *net = dev_net(skb->dev);
2037bc54c90SPavel Emelyanov
2046579f5baSEric Dumazet return raw_v4_input(net, skb, ip_hdr(skb),
2056579f5baSEric Dumazet raw_hashfunc(net, protocol));
2067bc54c90SPavel Emelyanov }
2077bc54c90SPavel Emelyanov
raw_err(struct sock * sk,struct sk_buff * skb,u32 info)2087bc54c90SPavel Emelyanov static void raw_err(struct sock *sk, struct sk_buff *skb, u32 info)
2091da177e4SLinus Torvalds {
2101da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk);
21188c7664fSArnaldo Carvalho de Melo const int type = icmp_hdr(skb)->type;
21288c7664fSArnaldo Carvalho de Melo const int code = icmp_hdr(skb)->code;
2131da177e4SLinus Torvalds int harderr = 0;
2146b5f43eaSEric Dumazet bool recverr;
2156b5f43eaSEric Dumazet int err = 0;
2161da177e4SLinus Torvalds
21736393395SDavid S. Miller if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
21836393395SDavid S. Miller ipv4_sk_update_pmtu(skb, sk, info);
2198d65b119SDuan Jiong else if (type == ICMP_REDIRECT) {
22055be7a9cSDavid S. Miller ipv4_sk_redirect(skb, sk);
2218d65b119SDuan Jiong return;
2228d65b119SDuan Jiong }
22336393395SDavid S. Miller
2241da177e4SLinus Torvalds /* Report error on raw socket, if:
2251da177e4SLinus Torvalds 1. User requested ip_recverr.
2261da177e4SLinus Torvalds 2. Socket is connected (otherwise the error indication
2271da177e4SLinus Torvalds is useless without ip_recverr and error is hard.
2281da177e4SLinus Torvalds */
2296b5f43eaSEric Dumazet recverr = inet_test_bit(RECVERR, sk);
2306b5f43eaSEric Dumazet if (!recverr && sk->sk_state != TCP_ESTABLISHED)
2311da177e4SLinus Torvalds return;
2321da177e4SLinus Torvalds
2331da177e4SLinus Torvalds switch (type) {
2341da177e4SLinus Torvalds default:
2351da177e4SLinus Torvalds case ICMP_TIME_EXCEEDED:
2361da177e4SLinus Torvalds err = EHOSTUNREACH;
2371da177e4SLinus Torvalds break;
2381da177e4SLinus Torvalds case ICMP_SOURCE_QUENCH:
2391da177e4SLinus Torvalds return;
2401da177e4SLinus Torvalds case ICMP_PARAMETERPROB:
2411da177e4SLinus Torvalds err = EPROTO;
2421da177e4SLinus Torvalds harderr = 1;
2431da177e4SLinus Torvalds break;
2441da177e4SLinus Torvalds case ICMP_DEST_UNREACH:
2451da177e4SLinus Torvalds err = EHOSTUNREACH;
2461da177e4SLinus Torvalds if (code > NR_ICMP_UNREACH)
2471da177e4SLinus Torvalds break;
2481da177e4SLinus Torvalds if (code == ICMP_FRAG_NEEDED) {
249ceaa7141SEric Dumazet harderr = READ_ONCE(inet->pmtudisc) != IP_PMTUDISC_DONT;
2501da177e4SLinus Torvalds err = EMSGSIZE;
25175511449SMiaohe Lin } else {
25275511449SMiaohe Lin err = icmp_err_convert[code].errno;
25375511449SMiaohe Lin harderr = icmp_err_convert[code].fatal;
2541da177e4SLinus Torvalds }
2551da177e4SLinus Torvalds }
2561da177e4SLinus Torvalds
2576b5f43eaSEric Dumazet if (recverr) {
258b71d1d42SEric Dumazet const struct iphdr *iph = (const struct iphdr *)skb->data;
2591da177e4SLinus Torvalds u8 *payload = skb->data + (iph->ihl << 2);
2601da177e4SLinus Torvalds
261cafbe182SEric Dumazet if (inet_test_bit(HDRINCL, sk))
2621da177e4SLinus Torvalds payload = skb->data;
2631da177e4SLinus Torvalds ip_icmp_error(sk, skb, err, 0, info, payload);
2641da177e4SLinus Torvalds }
2651da177e4SLinus Torvalds
2666b5f43eaSEric Dumazet if (recverr || harderr) {
2671da177e4SLinus Torvalds sk->sk_err = err;
268e3ae2365SAlexander Aring sk_error_report(sk);
2691da177e4SLinus Torvalds }
2701da177e4SLinus Torvalds }
2711da177e4SLinus Torvalds
raw_icmp_error(struct sk_buff * skb,int protocol,u32 info)2727bc54c90SPavel Emelyanov void raw_icmp_error(struct sk_buff *skb, int protocol, u32 info)
2737bc54c90SPavel Emelyanov {
2745da39e31SKuniyuki Iwashima struct net *net = dev_net(skb->dev);
27567359930SDavid Ahern int dif = skb->dev->ifindex;
27667359930SDavid Ahern int sdif = inet_sdif(skb);
2770a78cf72SKuniyuki Iwashima struct hlist_head *hlist;
278ba44f818SEric Dumazet const struct iphdr *iph;
279ba44f818SEric Dumazet struct sock *sk;
280ba44f818SEric Dumazet int hash;
28167359930SDavid Ahern
2826579f5baSEric Dumazet hash = raw_hashfunc(net, protocol);
2830daf07e5SEric Dumazet hlist = &raw_v4_hashinfo.ht[hash];
284be185884SPavel Emelyanov
2850daf07e5SEric Dumazet rcu_read_lock();
2860a78cf72SKuniyuki Iwashima sk_for_each_rcu(sk, hlist) {
287b71d1d42SEric Dumazet iph = (const struct iphdr *)skb->data;
288ba44f818SEric Dumazet if (!raw_v4_match(net, sk, iph->protocol,
28997a4d46bSEric Dumazet iph->daddr, iph->saddr, dif, sdif))
290ba44f818SEric Dumazet continue;
291ba44f818SEric Dumazet raw_err(sk, skb, info);
2927bc54c90SPavel Emelyanov }
2930daf07e5SEric Dumazet rcu_read_unlock();
2947bc54c90SPavel Emelyanov }
2957bc54c90SPavel Emelyanov
raw_rcv_skb(struct sock * sk,struct sk_buff * skb)2961da177e4SLinus Torvalds static int raw_rcv_skb(struct sock *sk, struct sk_buff *skb)
2971da177e4SLinus Torvalds {
29842186e6cSEric Dumazet enum skb_drop_reason reason;
29942186e6cSEric Dumazet
3001da177e4SLinus Torvalds /* Charge it to the socket. */
3011da177e4SLinus Torvalds
302e622502cSNicolas Dichtel ipv4_pktinfo_prepare(sk, skb, true);
30342186e6cSEric Dumazet if (sock_queue_rcv_skb_reason(sk, skb, &reason) < 0) {
304*ce9a2424SYan Zhai sk_skb_reason_drop(sk, skb, reason);
3051da177e4SLinus Torvalds return NET_RX_DROP;
3061da177e4SLinus Torvalds }
3071da177e4SLinus Torvalds
3081da177e4SLinus Torvalds return NET_RX_SUCCESS;
3091da177e4SLinus Torvalds }
3101da177e4SLinus Torvalds
raw_rcv(struct sock * sk,struct sk_buff * skb)3111da177e4SLinus Torvalds int raw_rcv(struct sock *sk, struct sk_buff *skb)
3121da177e4SLinus Torvalds {
3131da177e4SLinus Torvalds if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) {
31433c732c3SWang Chen atomic_inc(&sk->sk_drops);
315*ce9a2424SYan Zhai sk_skb_reason_drop(sk, skb, SKB_DROP_REASON_XFRM_POLICY);
3161da177e4SLinus Torvalds return NET_RX_DROP;
3171da177e4SLinus Torvalds }
318895b5c9fSFlorian Westphal nf_reset_ct(skb);
3191da177e4SLinus Torvalds
32080bfab79SEric Dumazet skb_push(skb, -skb_network_offset(skb));
3211da177e4SLinus Torvalds
3221da177e4SLinus Torvalds raw_rcv_skb(sk, skb);
3231da177e4SLinus Torvalds return 0;
3241da177e4SLinus Torvalds }
3251da177e4SLinus Torvalds
raw_send_hdrinc(struct sock * sk,struct flowi4 * fl4,struct msghdr * msg,size_t length,struct rtable ** rtp,unsigned int flags,const struct sockcm_cookie * sockc)32677968b78SDavid S. Miller static int raw_send_hdrinc(struct sock *sk, struct flowi4 *fl4,
3277ae9abfdSAl Viro struct msghdr *msg, size_t length,
328c14ac945SSoheil Hassas Yeganeh struct rtable **rtp, unsigned int flags,
329c14ac945SSoheil Hassas Yeganeh const struct sockcm_cookie *sockc)
3301da177e4SLinus Torvalds {
3311da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk);
3320388b004SPavel Emelyanov struct net *net = sock_net(sk);
3331da177e4SLinus Torvalds struct iphdr *iph;
3341da177e4SLinus Torvalds struct sk_buff *skb;
335f844c74fSHerbert Xu unsigned int iphlen;
3361da177e4SLinus Torvalds int err;
3371789a640SEric Dumazet struct rtable *rt = *rtp;
33866088243SHerbert Xu int hlen, tlen;
3391da177e4SLinus Torvalds
340d8d1f30bSChangli Gao if (length > rt->dst.dev->mtu) {
34177968b78SDavid S. Miller ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
342d8d1f30bSChangli Gao rt->dst.dev->mtu);
3431da177e4SLinus Torvalds return -EMSGSIZE;
3441da177e4SLinus Torvalds }
34586f4c90aSAlexander Potapenko if (length < sizeof(struct iphdr))
34686f4c90aSAlexander Potapenko return -EINVAL;
34786f4c90aSAlexander Potapenko
3481da177e4SLinus Torvalds if (flags&MSG_PROBE)
3491da177e4SLinus Torvalds goto out;
3501da177e4SLinus Torvalds
35166088243SHerbert Xu hlen = LL_RESERVED_SPACE(rt->dst.dev);
35266088243SHerbert Xu tlen = rt->dst.dev->needed_tailroom;
353f5184d26SJohannes Berg skb = sock_alloc_send_skb(sk,
35466088243SHerbert Xu length + hlen + tlen + 15,
3551da177e4SLinus Torvalds flags & MSG_DONTWAIT, &err);
35651456b29SIan Morris if (!skb)
3571da177e4SLinus Torvalds goto error;
35866088243SHerbert Xu skb_reserve(skb, hlen);
3591da177e4SLinus Torvalds
360c9b3b817STobias Brunner skb->protocol = htons(ETH_P_IP);
3618bf43be7SEric Dumazet skb->priority = READ_ONCE(sk->sk_priority);
362c6af0c22SWillem de Bruijn skb->mark = sockc->mark;
3631693c5dbSAbhishek Chauhan skb_set_delivery_type_by_clockid(skb, sockc->transmit_time, sk->sk_clockid);
364d8d1f30bSChangli Gao skb_dst_set(skb, &rt->dst);
3651789a640SEric Dumazet *rtp = NULL;
3661da177e4SLinus Torvalds
3677e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb);
368eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb);
3697e28ecc2SArnaldo Carvalho de Melo skb_put(skb, length);
3701da177e4SLinus Torvalds
3711da177e4SLinus Torvalds skb->ip_summed = CHECKSUM_NONE;
3721da177e4SLinus Torvalds
3738f932f76SWillem de Bruijn skb_setup_tx_timestamp(skb, sockc->tsflags);
37411878b40SWillem de Bruijn
3750dec879fSJulian Anastasov if (flags & MSG_CONFIRM)
3760dec879fSJulian Anastasov skb_set_dst_pending_confirm(skb, 1);
3770dec879fSJulian Anastasov
378b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header;
37955888dfbSNeil Horman err = -EFAULT;
38021226abbSAl Viro if (memcpy_from_msg(iph, msg, length))
38155888dfbSNeil Horman goto error_free;
3821da177e4SLinus Torvalds
383f844c74fSHerbert Xu iphlen = iph->ihl * 4;
38455888dfbSNeil Horman
38555888dfbSNeil Horman /*
38655888dfbSNeil Horman * We don't want to modify the ip header, but we do need to
38755888dfbSNeil Horman * be sure that it won't cause problems later along the network
38855888dfbSNeil Horman * stack. Specifically we want to make sure that iph->ihl is a
38955888dfbSNeil Horman * sane value. If ihl points beyond the length of the buffer passed
39055888dfbSNeil Horman * in, reject the frame as invalid
39155888dfbSNeil Horman */
39255888dfbSNeil Horman err = -EINVAL;
39355888dfbSNeil Horman if (iphlen > length)
39455888dfbSNeil Horman goto error_free;
39555888dfbSNeil Horman
39655888dfbSNeil Horman if (iphlen >= sizeof(*iph)) {
3971da177e4SLinus Torvalds if (!iph->saddr)
39877968b78SDavid S. Miller iph->saddr = fl4->saddr;
3991da177e4SLinus Torvalds iph->check = 0;
4001da177e4SLinus Torvalds iph->tot_len = htons(length);
4011da177e4SLinus Torvalds if (!iph->id)
402b6a7719aSHannes Frederic Sowa ip_select_ident(net, skb, NULL);
4031da177e4SLinus Torvalds
4041da177e4SLinus Torvalds iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
405027ac58eSBen Cartwright-Cox skb->transport_header += iphlen;
406027ac58eSBen Cartwright-Cox if (iph->protocol == IPPROTO_ICMP &&
407027ac58eSBen Cartwright-Cox length >= iphlen + sizeof(struct icmphdr))
4080388b004SPavel Emelyanov icmp_out_count(net, ((struct icmphdr *)
40996793b48SDavid L Stevens skb_transport_header(skb))->type);
410027ac58eSBen Cartwright-Cox }
4111da177e4SLinus Torvalds
41229a26a56SEric W. Biederman err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT,
41329a26a56SEric W. Biederman net, sk, skb, NULL, rt->dst.dev,
41413206b6bSEric W. Biederman dst_output);
4151da177e4SLinus Torvalds if (err > 0)
4166ce9e7b5SEric Dumazet err = net_xmit_errno(err);
4171da177e4SLinus Torvalds if (err)
4181da177e4SLinus Torvalds goto error;
4191da177e4SLinus Torvalds out:
4201da177e4SLinus Torvalds return 0;
4211da177e4SLinus Torvalds
42255888dfbSNeil Horman error_free:
4231da177e4SLinus Torvalds kfree_skb(skb);
4241da177e4SLinus Torvalds error:
4255e38e270SPavel Emelyanov IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
4266b5f43eaSEric Dumazet if (err == -ENOBUFS && !inet_test_bit(RECVERR, sk))
4276ce9e7b5SEric Dumazet err = 0;
4281da177e4SLinus Torvalds return err;
4291da177e4SLinus Torvalds }
4301da177e4SLinus Torvalds
raw_probe_proto_opt(struct raw_frag_vec * rfv,struct flowi4 * fl4)431c008ba5bSHerbert Xu static int raw_probe_proto_opt(struct raw_frag_vec *rfv, struct flowi4 *fl4)
4321da177e4SLinus Torvalds {
43332b5913aSHerbert Xu int err;
4341da177e4SLinus Torvalds
43532b5913aSHerbert Xu if (fl4->flowi4_proto != IPPROTO_ICMP)
436a27b58feSHeiko Carstens return 0;
4371da177e4SLinus Torvalds
43832b5913aSHerbert Xu /* We only need the first two bytes. */
439c008ba5bSHerbert Xu rfv->hlen = 2;
440c008ba5bSHerbert Xu
441b61e9dccSAl Viro err = memcpy_from_msg(rfv->hdr.c, rfv->msg, rfv->hlen);
44232b5913aSHerbert Xu if (err)
44332b5913aSHerbert Xu return err;
4441da177e4SLinus Torvalds
445c008ba5bSHerbert Xu fl4->fl4_icmp_type = rfv->hdr.icmph.type;
446c008ba5bSHerbert Xu fl4->fl4_icmp_code = rfv->hdr.icmph.code;
4471da177e4SLinus Torvalds
448a27b58feSHeiko Carstens return 0;
4491da177e4SLinus Torvalds }
4501da177e4SLinus Torvalds
raw_getfrag(void * from,char * to,int offset,int len,int odd,struct sk_buff * skb)451c008ba5bSHerbert Xu static int raw_getfrag(void *from, char *to, int offset, int len, int odd,
452c008ba5bSHerbert Xu struct sk_buff *skb)
453c008ba5bSHerbert Xu {
454c008ba5bSHerbert Xu struct raw_frag_vec *rfv = from;
455c008ba5bSHerbert Xu
456c008ba5bSHerbert Xu if (offset < rfv->hlen) {
457c008ba5bSHerbert Xu int copy = min(rfv->hlen - offset, len);
458c008ba5bSHerbert Xu
459c008ba5bSHerbert Xu if (skb->ip_summed == CHECKSUM_PARTIAL)
460c008ba5bSHerbert Xu memcpy(to, rfv->hdr.c + offset, copy);
461c008ba5bSHerbert Xu else
462c008ba5bSHerbert Xu skb->csum = csum_block_add(
463c008ba5bSHerbert Xu skb->csum,
464c008ba5bSHerbert Xu csum_partial_copy_nocheck(rfv->hdr.c + offset,
465cc44c17bSAl Viro to, copy),
466c008ba5bSHerbert Xu odd);
467c008ba5bSHerbert Xu
468c008ba5bSHerbert Xu odd = 0;
469c008ba5bSHerbert Xu offset += copy;
470c008ba5bSHerbert Xu to += copy;
471c008ba5bSHerbert Xu len -= copy;
472c008ba5bSHerbert Xu
473c008ba5bSHerbert Xu if (!len)
474c008ba5bSHerbert Xu return 0;
475c008ba5bSHerbert Xu }
476c008ba5bSHerbert Xu
477c008ba5bSHerbert Xu offset -= rfv->hlen;
478c008ba5bSHerbert Xu
479f69e6d13SAl Viro return ip_generic_getfrag(rfv->msg, to, offset, len, odd, skb);
480c008ba5bSHerbert Xu }
481c008ba5bSHerbert Xu
raw_sendmsg(struct sock * sk,struct msghdr * msg,size_t len)4821b784140SYing Xue static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
4831da177e4SLinus Torvalds {
4841da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk);
485bb191c3eSDavid Ahern struct net *net = sock_net(sk);
4861da177e4SLinus Torvalds struct ipcm_cookie ipc;
4871da177e4SLinus Torvalds struct rtable *rt = NULL;
48877968b78SDavid S. Miller struct flowi4 fl4;
489c85be08fSGuillaume Nault u8 tos, scope;
4901da177e4SLinus Torvalds int free = 0;
4913ca3c68eSAl Viro __be32 daddr;
492c1d18f9fSAl Viro __be32 saddr;
493959d5c11SEric Dumazet int uc_index, err;
494f6d8bd05SEric Dumazet struct ip_options_data opt_copy;
495c008ba5bSHerbert Xu struct raw_frag_vec rfv;
4968f659a03SMohamed Ghannam int hdrincl;
4971da177e4SLinus Torvalds
4981da177e4SLinus Torvalds err = -EMSGSIZE;
499926d4b81SJesper Juhl if (len > 0xFFFF)
5001da177e4SLinus Torvalds goto out;
5011da177e4SLinus Torvalds
502cafbe182SEric Dumazet hdrincl = inet_test_bit(HDRINCL, sk);
503cafbe182SEric Dumazet
5041da177e4SLinus Torvalds /*
5051da177e4SLinus Torvalds * Check the flags.
5061da177e4SLinus Torvalds */
5071da177e4SLinus Torvalds
5081da177e4SLinus Torvalds err = -EOPNOTSUPP;
5091da177e4SLinus Torvalds if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message */
5101da177e4SLinus Torvalds goto out; /* compatibility */
5111da177e4SLinus Torvalds
5121da177e4SLinus Torvalds /*
5131da177e4SLinus Torvalds * Get and verify the address.
5141da177e4SLinus Torvalds */
5151da177e4SLinus Torvalds
5161da177e4SLinus Torvalds if (msg->msg_namelen) {
517342dfc30SSteffen Hurrle DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
5181da177e4SLinus Torvalds err = -EINVAL;
5191da177e4SLinus Torvalds if (msg->msg_namelen < sizeof(*usin))
5201da177e4SLinus Torvalds goto out;
5211da177e4SLinus Torvalds if (usin->sin_family != AF_INET) {
522058bd4d2SJoe Perches pr_info_once("%s: %s forgot to set AF_INET. Fix it!\n",
523058bd4d2SJoe Perches __func__, current->comm);
5241da177e4SLinus Torvalds err = -EAFNOSUPPORT;
5251da177e4SLinus Torvalds if (usin->sin_family)
5261da177e4SLinus Torvalds goto out;
5271da177e4SLinus Torvalds }
5281da177e4SLinus Torvalds daddr = usin->sin_addr.s_addr;
5291da177e4SLinus Torvalds /* ANK: I did not forget to get protocol from port field.
5301da177e4SLinus Torvalds * I just do not know, who uses this weirdness.
5311da177e4SLinus Torvalds * IP_HDRINCL is much more convenient.
5321da177e4SLinus Torvalds */
5331da177e4SLinus Torvalds } else {
5341da177e4SLinus Torvalds err = -EDESTADDRREQ;
5351da177e4SLinus Torvalds if (sk->sk_state != TCP_ESTABLISHED)
5361da177e4SLinus Torvalds goto out;
537c720c7e8SEric Dumazet daddr = inet->inet_daddr;
5381da177e4SLinus Torvalds }
5391da177e4SLinus Torvalds
54035178206SWillem de Bruijn ipcm_init_sk(&ipc, inet);
5413632679dSNicolas Dichtel /* Keep backward compat */
5423632679dSNicolas Dichtel if (hdrincl)
5433632679dSNicolas Dichtel ipc.protocol = IPPROTO_RAW;
5441da177e4SLinus Torvalds
5451da177e4SLinus Torvalds if (msg->msg_controllen) {
54624025c46SSoheil Hassas Yeganeh err = ip_cmsg_send(sk, msg, &ipc, false);
54791948309SEric Dumazet if (unlikely(err)) {
54891948309SEric Dumazet kfree(ipc.opt);
5491da177e4SLinus Torvalds goto out;
55091948309SEric Dumazet }
5511da177e4SLinus Torvalds if (ipc.opt)
5521da177e4SLinus Torvalds free = 1;
5531da177e4SLinus Torvalds }
5541da177e4SLinus Torvalds
5551da177e4SLinus Torvalds saddr = ipc.addr;
5561da177e4SLinus Torvalds ipc.addr = daddr;
5571da177e4SLinus Torvalds
558f6d8bd05SEric Dumazet if (!ipc.opt) {
559f6d8bd05SEric Dumazet struct ip_options_rcu *inet_opt;
560f6d8bd05SEric Dumazet
561f6d8bd05SEric Dumazet rcu_read_lock();
562f6d8bd05SEric Dumazet inet_opt = rcu_dereference(inet->inet_opt);
563f6d8bd05SEric Dumazet if (inet_opt) {
564f6d8bd05SEric Dumazet memcpy(&opt_copy, inet_opt,
565f6d8bd05SEric Dumazet sizeof(*inet_opt) + inet_opt->opt.optlen);
566f6d8bd05SEric Dumazet ipc.opt = &opt_copy.opt;
567f6d8bd05SEric Dumazet }
568f6d8bd05SEric Dumazet rcu_read_unlock();
569f6d8bd05SEric Dumazet }
5701da177e4SLinus Torvalds
5711da177e4SLinus Torvalds if (ipc.opt) {
5721da177e4SLinus Torvalds err = -EINVAL;
5731da177e4SLinus Torvalds /* Linux does not mangle headers on raw sockets,
5741da177e4SLinus Torvalds * so that IP options + IP_HDRINCL is non-sense.
5751da177e4SLinus Torvalds */
5768f659a03SMohamed Ghannam if (hdrincl)
5771da177e4SLinus Torvalds goto done;
578f6d8bd05SEric Dumazet if (ipc.opt->opt.srr) {
5791da177e4SLinus Torvalds if (!daddr)
5801da177e4SLinus Torvalds goto done;
581f6d8bd05SEric Dumazet daddr = ipc.opt->opt.faddr;
5821da177e4SLinus Torvalds }
5831da177e4SLinus Torvalds }
584c85be08fSGuillaume Nault tos = get_rttos(&ipc, inet);
585c85be08fSGuillaume Nault scope = ip_sendmsg_scope(inet, &ipc, msg);
5861da177e4SLinus Torvalds
587959d5c11SEric Dumazet uc_index = READ_ONCE(inet->uc_index);
588f97c1e0cSJoe Perches if (ipv4_is_multicast(daddr)) {
589854da991SRobert Shearman if (!ipc.oif || netif_index_is_l3_master(sock_net(sk), ipc.oif))
59002715925SEric Dumazet ipc.oif = READ_ONCE(inet->mc_index);
5911da177e4SLinus Torvalds if (!saddr)
59202715925SEric Dumazet saddr = READ_ONCE(inet->mc_addr);
5939515a2e0SDavid Ahern } else if (!ipc.oif) {
594959d5c11SEric Dumazet ipc.oif = uc_index;
595959d5c11SEric Dumazet } else if (ipv4_is_lbcast(daddr) && uc_index) {
596645f0897SMiaohe Lin /* oif is set, packet is to local broadcast
5979515a2e0SDavid Ahern * and uc_index is set. oif is most likely set
5989515a2e0SDavid Ahern * by sk_bound_dev_if. If uc_index != oif check if the
5999515a2e0SDavid Ahern * oif is an L3 master and uc_index is an L3 slave.
6009515a2e0SDavid Ahern * If so, we want to allow the send using the uc_index.
6019515a2e0SDavid Ahern */
602959d5c11SEric Dumazet if (ipc.oif != uc_index &&
6039515a2e0SDavid Ahern ipc.oif == l3mdev_master_ifindex_by_index(sock_net(sk),
604959d5c11SEric Dumazet uc_index)) {
605959d5c11SEric Dumazet ipc.oif = uc_index;
6069515a2e0SDavid Ahern }
6079515a2e0SDavid Ahern }
6081da177e4SLinus Torvalds
609c85be08fSGuillaume Nault flowi4_init_output(&fl4, ipc.oif, ipc.sockc.mark, tos, scope,
6103632679dSNicolas Dichtel hdrincl ? ipc.protocol : sk->sk_protocol,
6110e0d44abSSteffen Klassert inet_sk_flowi_flags(sk) |
6128f659a03SMohamed Ghannam (hdrincl ? FLOWI_FLAG_KNOWN_NH : 0),
613e2d118a1SLorenzo Colitti daddr, saddr, 0, 0, sk->sk_uid);
614ef164ae3SDavid S. Miller
615fc1092f5SShigeru Yoshida fl4.fl4_icmp_type = 0;
616fc1092f5SShigeru Yoshida fl4.fl4_icmp_code = 0;
617fc1092f5SShigeru Yoshida
6188f659a03SMohamed Ghannam if (!hdrincl) {
619b61e9dccSAl Viro rfv.msg = msg;
620c008ba5bSHerbert Xu rfv.hlen = 0;
621c008ba5bSHerbert Xu
622c008ba5bSHerbert Xu err = raw_probe_proto_opt(&rfv, &fl4);
623a27b58feSHeiko Carstens if (err)
624a27b58feSHeiko Carstens goto done;
625a27b58feSHeiko Carstens }
6261da177e4SLinus Torvalds
6273df98d79SPaul Moore security_sk_classify_flow(sk, flowi4_to_flowi_common(&fl4));
628bb191c3eSDavid Ahern rt = ip_route_output_flow(net, &fl4, sk);
629b23dd4feSDavid S. Miller if (IS_ERR(rt)) {
630b23dd4feSDavid S. Miller err = PTR_ERR(rt);
6314910ac6cSDavid S. Miller rt = NULL;
6321da177e4SLinus Torvalds goto done;
633b23dd4feSDavid S. Miller }
6341da177e4SLinus Torvalds
6351da177e4SLinus Torvalds err = -EACCES;
6361da177e4SLinus Torvalds if (rt->rt_flags & RTCF_BROADCAST && !sock_flag(sk, SOCK_BROADCAST))
6371da177e4SLinus Torvalds goto done;
6381da177e4SLinus Torvalds
6391da177e4SLinus Torvalds if (msg->msg_flags & MSG_CONFIRM)
6401da177e4SLinus Torvalds goto do_confirm;
6411da177e4SLinus Torvalds back_from_confirm:
6421da177e4SLinus Torvalds
6438f659a03SMohamed Ghannam if (hdrincl)
6447ae9abfdSAl Viro err = raw_send_hdrinc(sk, &fl4, msg, len,
645c14ac945SSoheil Hassas Yeganeh &rt, msg->msg_flags, &ipc.sockc);
6461da177e4SLinus Torvalds
6471da177e4SLinus Torvalds else {
6481da177e4SLinus Torvalds if (!ipc.addr)
64977968b78SDavid S. Miller ipc.addr = fl4.daddr;
6501da177e4SLinus Torvalds lock_sock(sk);
651c008ba5bSHerbert Xu err = ip_append_data(sk, &fl4, raw_getfrag,
652c008ba5bSHerbert Xu &rfv, len, 0,
6532e77d89bSEric Dumazet &ipc, &rt, msg->msg_flags);
6541da177e4SLinus Torvalds if (err)
6551da177e4SLinus Torvalds ip_flush_pending_frames(sk);
6566ce9e7b5SEric Dumazet else if (!(msg->msg_flags & MSG_MORE)) {
65777968b78SDavid S. Miller err = ip_push_pending_frames(sk, &fl4);
6586b5f43eaSEric Dumazet if (err == -ENOBUFS && !inet_test_bit(RECVERR, sk))
6596ce9e7b5SEric Dumazet err = 0;
6606ce9e7b5SEric Dumazet }
6611da177e4SLinus Torvalds release_sock(sk);
6621da177e4SLinus Torvalds }
6631da177e4SLinus Torvalds done:
6641da177e4SLinus Torvalds if (free)
6651da177e4SLinus Torvalds kfree(ipc.opt);
6661da177e4SLinus Torvalds ip_rt_put(rt);
6671da177e4SLinus Torvalds
6685418c692SJesper Juhl out:
6695418c692SJesper Juhl if (err < 0)
6705418c692SJesper Juhl return err;
6715418c692SJesper Juhl return len;
6721da177e4SLinus Torvalds
6731da177e4SLinus Torvalds do_confirm:
6740dec879fSJulian Anastasov if (msg->msg_flags & MSG_PROBE)
6750dec879fSJulian Anastasov dst_confirm_neigh(&rt->dst, &fl4.daddr);
6761da177e4SLinus Torvalds if (!(msg->msg_flags & MSG_PROBE) || len)
6771da177e4SLinus Torvalds goto back_from_confirm;
6781da177e4SLinus Torvalds err = 0;
6791da177e4SLinus Torvalds goto done;
6801da177e4SLinus Torvalds }
6811da177e4SLinus Torvalds
raw_close(struct sock * sk,long timeout)6821da177e4SLinus Torvalds static void raw_close(struct sock *sk, long timeout)
6831da177e4SLinus Torvalds {
6841da177e4SLinus Torvalds /*
68525985edcSLucas De Marchi * Raw sockets may have direct kernel references. Kill them.
6861da177e4SLinus Torvalds */
6871da177e4SLinus Torvalds ip_ra_control(sk, 0, NULL);
6881da177e4SLinus Torvalds
6891da177e4SLinus Torvalds sk_common_release(sk);
6901da177e4SLinus Torvalds }
6911da177e4SLinus Torvalds
raw_destroy(struct sock * sk)6927d06b2e0SBrian Haley static void raw_destroy(struct sock *sk)
69322dd4850SDenis V. Lunev {
69422dd4850SDenis V. Lunev lock_sock(sk);
69522dd4850SDenis V. Lunev ip_flush_pending_frames(sk);
69622dd4850SDenis V. Lunev release_sock(sk);
69722dd4850SDenis V. Lunev }
69822dd4850SDenis V. Lunev
6991da177e4SLinus Torvalds /* This gets rid of all the nasties in af_inet. -DaveM */
raw_bind(struct sock * sk,struct sockaddr * uaddr,int addr_len)7001da177e4SLinus Torvalds static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
7011da177e4SLinus Torvalds {
7021da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk);
7031da177e4SLinus Torvalds struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
7048ff978b8SRiccardo Paolo Bestetti struct net *net = sock_net(sk);
705cd2c0f45SDavid Ahern u32 tb_id = RT_TABLE_LOCAL;
7061da177e4SLinus Torvalds int ret = -EINVAL;
7071da177e4SLinus Torvalds int chk_addr_ret;
7081da177e4SLinus Torvalds
709153a0d18SEric Dumazet lock_sock(sk);
7101da177e4SLinus Torvalds if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in))
7111da177e4SLinus Torvalds goto out;
712cd2c0f45SDavid Ahern
713cd2c0f45SDavid Ahern if (sk->sk_bound_dev_if)
7148ff978b8SRiccardo Paolo Bestetti tb_id = l3mdev_fib_table_by_index(net,
715cd2c0f45SDavid Ahern sk->sk_bound_dev_if) ? : tb_id;
716cd2c0f45SDavid Ahern
7178ff978b8SRiccardo Paolo Bestetti chk_addr_ret = inet_addr_type_table(net, addr->sin_addr.s_addr, tb_id);
718cd2c0f45SDavid Ahern
7191da177e4SLinus Torvalds ret = -EADDRNOTAVAIL;
7208ff978b8SRiccardo Paolo Bestetti if (!inet_addr_valid_or_nonlocal(net, inet, addr->sin_addr.s_addr,
7218ff978b8SRiccardo Paolo Bestetti chk_addr_ret))
7221da177e4SLinus Torvalds goto out;
7238ff978b8SRiccardo Paolo Bestetti
724c720c7e8SEric Dumazet inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
7251da177e4SLinus Torvalds if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
726c720c7e8SEric Dumazet inet->inet_saddr = 0; /* Use device */
7271da177e4SLinus Torvalds sk_dst_reset(sk);
7281da177e4SLinus Torvalds ret = 0;
729153a0d18SEric Dumazet out:
730153a0d18SEric Dumazet release_sock(sk);
731153a0d18SEric Dumazet return ret;
7321da177e4SLinus Torvalds }
7331da177e4SLinus Torvalds
7341da177e4SLinus Torvalds /*
7351da177e4SLinus Torvalds * This should be easy, if there is something there
7361da177e4SLinus Torvalds * we return it, otherwise we block.
7371da177e4SLinus Torvalds */
7381da177e4SLinus Torvalds
raw_recvmsg(struct sock * sk,struct msghdr * msg,size_t len,int flags,int * addr_len)7391b784140SYing Xue static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
740ec095263SOliver Hartkopp int flags, int *addr_len)
7411da177e4SLinus Torvalds {
7421da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk);
7431da177e4SLinus Torvalds size_t copied = 0;
7441da177e4SLinus Torvalds int err = -EOPNOTSUPP;
745342dfc30SSteffen Hurrle DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
7461da177e4SLinus Torvalds struct sk_buff *skb;
7471da177e4SLinus Torvalds
7481da177e4SLinus Torvalds if (flags & MSG_OOB)
7491da177e4SLinus Torvalds goto out;
7501da177e4SLinus Torvalds
7511da177e4SLinus Torvalds if (flags & MSG_ERRQUEUE) {
75285fbaa75SHannes Frederic Sowa err = ip_recv_error(sk, msg, len, addr_len);
7531da177e4SLinus Torvalds goto out;
7541da177e4SLinus Torvalds }
7551da177e4SLinus Torvalds
756f4b41f06SOliver Hartkopp skb = skb_recv_datagram(sk, flags, &err);
7571da177e4SLinus Torvalds if (!skb)
7581da177e4SLinus Torvalds goto out;
7591da177e4SLinus Torvalds
7601da177e4SLinus Torvalds copied = skb->len;
7611da177e4SLinus Torvalds if (len < copied) {
7621da177e4SLinus Torvalds msg->msg_flags |= MSG_TRUNC;
7631da177e4SLinus Torvalds copied = len;
7641da177e4SLinus Torvalds }
7651da177e4SLinus Torvalds
76651f3d02bSDavid S. Miller err = skb_copy_datagram_msg(skb, 0, msg, copied);
7671da177e4SLinus Torvalds if (err)
7681da177e4SLinus Torvalds goto done;
7691da177e4SLinus Torvalds
7706fd1d51cSErin MacNeil sock_recv_cmsgs(msg, sk, skb);
7711da177e4SLinus Torvalds
7721da177e4SLinus Torvalds /* Copy the address. */
7731da177e4SLinus Torvalds if (sin) {
7741da177e4SLinus Torvalds sin->sin_family = AF_INET;
775eddc9ec5SArnaldo Carvalho de Melo sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
776f59fc7f3STetsuo Handa sin->sin_port = 0;
7771da177e4SLinus Torvalds memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
778bceaa902SHannes Frederic Sowa *addr_len = sizeof(*sin);
7791da177e4SLinus Torvalds }
780c274af22SEric Dumazet if (inet_cmsg_flags(inet))
7811da177e4SLinus Torvalds ip_cmsg_recv(msg, skb);
7821da177e4SLinus Torvalds if (flags & MSG_TRUNC)
7831da177e4SLinus Torvalds copied = skb->len;
7841da177e4SLinus Torvalds done:
7851da177e4SLinus Torvalds skb_free_datagram(sk, skb);
7865418c692SJesper Juhl out:
7875418c692SJesper Juhl if (err)
7885418c692SJesper Juhl return err;
7895418c692SJesper Juhl return copied;
7901da177e4SLinus Torvalds }
7911da177e4SLinus Torvalds
raw_sk_init(struct sock * sk)7926897445fSMike Manning static int raw_sk_init(struct sock *sk)
7931da177e4SLinus Torvalds {
7941da177e4SLinus Torvalds struct raw_sock *rp = raw_sk(sk);
7951da177e4SLinus Torvalds
796c720c7e8SEric Dumazet if (inet_sk(sk)->inet_num == IPPROTO_ICMP)
7971da177e4SLinus Torvalds memset(&rp->filter, 0, sizeof(rp->filter));
7981da177e4SLinus Torvalds return 0;
7991da177e4SLinus Torvalds }
8001da177e4SLinus Torvalds
raw_seticmpfilter(struct sock * sk,sockptr_t optval,int optlen)801a7b75c5aSChristoph Hellwig static int raw_seticmpfilter(struct sock *sk, sockptr_t optval, int optlen)
8021da177e4SLinus Torvalds {
8031da177e4SLinus Torvalds if (optlen > sizeof(struct icmp_filter))
8041da177e4SLinus Torvalds optlen = sizeof(struct icmp_filter);
805a7b75c5aSChristoph Hellwig if (copy_from_sockptr(&raw_sk(sk)->filter, optval, optlen))
8061da177e4SLinus Torvalds return -EFAULT;
8071da177e4SLinus Torvalds return 0;
8081da177e4SLinus Torvalds }
8091da177e4SLinus Torvalds
raw_geticmpfilter(struct sock * sk,char __user * optval,int __user * optlen)8101da177e4SLinus Torvalds static int raw_geticmpfilter(struct sock *sk, char __user *optval, int __user *optlen)
8111da177e4SLinus Torvalds {
8121da177e4SLinus Torvalds int len, ret = -EFAULT;
8131da177e4SLinus Torvalds
8141da177e4SLinus Torvalds if (get_user(len, optlen))
8151da177e4SLinus Torvalds goto out;
8161da177e4SLinus Torvalds ret = -EINVAL;
8171da177e4SLinus Torvalds if (len < 0)
8181da177e4SLinus Torvalds goto out;
8191da177e4SLinus Torvalds if (len > sizeof(struct icmp_filter))
8201da177e4SLinus Torvalds len = sizeof(struct icmp_filter);
8211da177e4SLinus Torvalds ret = -EFAULT;
8221da177e4SLinus Torvalds if (put_user(len, optlen) ||
8231da177e4SLinus Torvalds copy_to_user(optval, &raw_sk(sk)->filter, len))
8241da177e4SLinus Torvalds goto out;
8251da177e4SLinus Torvalds ret = 0;
8261da177e4SLinus Torvalds out: return ret;
8271da177e4SLinus Torvalds }
8281da177e4SLinus Torvalds
do_raw_setsockopt(struct sock * sk,int optname,sockptr_t optval,unsigned int optlen)8298b2b1e62SZhengchao Shao static int do_raw_setsockopt(struct sock *sk, int optname,
830a7b75c5aSChristoph Hellwig sockptr_t optval, unsigned int optlen)
8311da177e4SLinus Torvalds {
8321da177e4SLinus Torvalds if (optname == ICMP_FILTER) {
833c720c7e8SEric Dumazet if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
8341da177e4SLinus Torvalds return -EOPNOTSUPP;
8351da177e4SLinus Torvalds else
8361da177e4SLinus Torvalds return raw_seticmpfilter(sk, optval, optlen);
8371da177e4SLinus Torvalds }
8381da177e4SLinus Torvalds return -ENOPROTOOPT;
8391da177e4SLinus Torvalds }
8401da177e4SLinus Torvalds
raw_setsockopt(struct sock * sk,int level,int optname,sockptr_t optval,unsigned int optlen)8413fdadf7dSDmitry Mishin static int raw_setsockopt(struct sock *sk, int level, int optname,
842a7b75c5aSChristoph Hellwig sockptr_t optval, unsigned int optlen)
8431da177e4SLinus Torvalds {
8441da177e4SLinus Torvalds if (level != SOL_RAW)
8453fdadf7dSDmitry Mishin return ip_setsockopt(sk, level, optname, optval, optlen);
8468b2b1e62SZhengchao Shao return do_raw_setsockopt(sk, optname, optval, optlen);
8473fdadf7dSDmitry Mishin }
8481da177e4SLinus Torvalds
do_raw_getsockopt(struct sock * sk,int optname,char __user * optval,int __user * optlen)8498b2b1e62SZhengchao Shao static int do_raw_getsockopt(struct sock *sk, int optname,
8503fdadf7dSDmitry Mishin char __user *optval, int __user *optlen)
8513fdadf7dSDmitry Mishin {
8521da177e4SLinus Torvalds if (optname == ICMP_FILTER) {
853c720c7e8SEric Dumazet if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
8541da177e4SLinus Torvalds return -EOPNOTSUPP;
8551da177e4SLinus Torvalds else
8561da177e4SLinus Torvalds return raw_geticmpfilter(sk, optval, optlen);
8571da177e4SLinus Torvalds }
8581da177e4SLinus Torvalds return -ENOPROTOOPT;
8591da177e4SLinus Torvalds }
8601da177e4SLinus Torvalds
raw_getsockopt(struct sock * sk,int level,int optname,char __user * optval,int __user * optlen)8613fdadf7dSDmitry Mishin static int raw_getsockopt(struct sock *sk, int level, int optname,
8623fdadf7dSDmitry Mishin char __user *optval, int __user *optlen)
8633fdadf7dSDmitry Mishin {
8643fdadf7dSDmitry Mishin if (level != SOL_RAW)
8653fdadf7dSDmitry Mishin return ip_getsockopt(sk, level, optname, optval, optlen);
8668b2b1e62SZhengchao Shao return do_raw_getsockopt(sk, optname, optval, optlen);
8673fdadf7dSDmitry Mishin }
8683fdadf7dSDmitry Mishin
raw_ioctl(struct sock * sk,int cmd,int * karg)869e1d001faSBreno Leitao static int raw_ioctl(struct sock *sk, int cmd, int *karg)
8701da177e4SLinus Torvalds {
8711da177e4SLinus Torvalds switch (cmd) {
8721da177e4SLinus Torvalds case SIOCOUTQ: {
873e1d001faSBreno Leitao *karg = sk_wmem_alloc_get(sk);
874e1d001faSBreno Leitao return 0;
8751da177e4SLinus Torvalds }
8761da177e4SLinus Torvalds case SIOCINQ: {
8771da177e4SLinus Torvalds struct sk_buff *skb;
8781da177e4SLinus Torvalds
879e0f9f858SHerbert Xu spin_lock_bh(&sk->sk_receive_queue.lock);
8801da177e4SLinus Torvalds skb = skb_peek(&sk->sk_receive_queue);
88100db4124SIan Morris if (skb)
882e1d001faSBreno Leitao *karg = skb->len;
883e1d001faSBreno Leitao else
884e1d001faSBreno Leitao *karg = 0;
885e0f9f858SHerbert Xu spin_unlock_bh(&sk->sk_receive_queue.lock);
886e1d001faSBreno Leitao return 0;
8871da177e4SLinus Torvalds }
8881da177e4SLinus Torvalds
8891da177e4SLinus Torvalds default:
8901da177e4SLinus Torvalds #ifdef CONFIG_IP_MROUTE
891e1d001faSBreno Leitao return ipmr_ioctl(sk, cmd, karg);
8921da177e4SLinus Torvalds #else
8931da177e4SLinus Torvalds return -ENOIOCTLCMD;
8941da177e4SLinus Torvalds #endif
8951da177e4SLinus Torvalds }
8961da177e4SLinus Torvalds }
8971da177e4SLinus Torvalds
898709b46e8SEric W. Biederman #ifdef CONFIG_COMPAT
compat_raw_ioctl(struct sock * sk,unsigned int cmd,unsigned long arg)899709b46e8SEric W. Biederman static int compat_raw_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
900709b46e8SEric W. Biederman {
901709b46e8SEric W. Biederman switch (cmd) {
902709b46e8SEric W. Biederman case SIOCOUTQ:
903709b46e8SEric W. Biederman case SIOCINQ:
904709b46e8SEric W. Biederman return -ENOIOCTLCMD;
905709b46e8SEric W. Biederman default:
906709b46e8SEric W. Biederman #ifdef CONFIG_IP_MROUTE
907709b46e8SEric W. Biederman return ipmr_compat_ioctl(sk, cmd, compat_ptr(arg));
908709b46e8SEric W. Biederman #else
909709b46e8SEric W. Biederman return -ENOIOCTLCMD;
910709b46e8SEric W. Biederman #endif
911709b46e8SEric W. Biederman }
912709b46e8SEric W. Biederman }
913709b46e8SEric W. Biederman #endif
914709b46e8SEric W. Biederman
raw_abort(struct sock * sk,int err)915432490f9SCyrill Gorcunov int raw_abort(struct sock *sk, int err)
916432490f9SCyrill Gorcunov {
917432490f9SCyrill Gorcunov lock_sock(sk);
918432490f9SCyrill Gorcunov
919432490f9SCyrill Gorcunov sk->sk_err = err;
920e3ae2365SAlexander Aring sk_error_report(sk);
9213de864f8SCyrill Gorcunov __udp_disconnect(sk, 0);
922432490f9SCyrill Gorcunov
923432490f9SCyrill Gorcunov release_sock(sk);
924432490f9SCyrill Gorcunov
925432490f9SCyrill Gorcunov return 0;
926432490f9SCyrill Gorcunov }
927432490f9SCyrill Gorcunov EXPORT_SYMBOL_GPL(raw_abort);
928432490f9SCyrill Gorcunov
9291da177e4SLinus Torvalds struct proto raw_prot = {
9301da177e4SLinus Torvalds .name = "RAW",
9311da177e4SLinus Torvalds .owner = THIS_MODULE,
9321da177e4SLinus Torvalds .close = raw_close,
93322dd4850SDenis V. Lunev .destroy = raw_destroy,
9341da177e4SLinus Torvalds .connect = ip4_datagram_connect,
935286c72deSEric Dumazet .disconnect = __udp_disconnect,
9361da177e4SLinus Torvalds .ioctl = raw_ioctl,
9376897445fSMike Manning .init = raw_sk_init,
9381da177e4SLinus Torvalds .setsockopt = raw_setsockopt,
9391da177e4SLinus Torvalds .getsockopt = raw_getsockopt,
9401da177e4SLinus Torvalds .sendmsg = raw_sendmsg,
9411da177e4SLinus Torvalds .recvmsg = raw_recvmsg,
9421da177e4SLinus Torvalds .bind = raw_bind,
9431da177e4SLinus Torvalds .backlog_rcv = raw_rcv_skb,
9448141ed9fSSteffen Klassert .release_cb = ip4_datagram_release_cb,
945fc8717baSPavel Emelyanov .hash = raw_hash_sk,
946fc8717baSPavel Emelyanov .unhash = raw_unhash_sk,
9471da177e4SLinus Torvalds .obj_size = sizeof(struct raw_sock),
9488c2bc895SDavid Windsor .useroffset = offsetof(struct raw_sock, filter),
9498c2bc895SDavid Windsor .usersize = sizeof_field(struct raw_sock, filter),
950fc8717baSPavel Emelyanov .h.raw_hash = &raw_v4_hashinfo,
951543d9cfeSArnaldo Carvalho de Melo #ifdef CONFIG_COMPAT
952709b46e8SEric W. Biederman .compat_ioctl = compat_raw_ioctl,
953543d9cfeSArnaldo Carvalho de Melo #endif
954432490f9SCyrill Gorcunov .diag_destroy = raw_abort,
9551da177e4SLinus Torvalds };
9561da177e4SLinus Torvalds
9571da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS
raw_get_first(struct seq_file * seq,int bucket)9580daf07e5SEric Dumazet static struct sock *raw_get_first(struct seq_file *seq, int bucket)
9591da177e4SLinus Torvalds {
960359745d7SMuchun Song struct raw_hashinfo *h = pde_data(file_inode(seq->file));
9611da177e4SLinus Torvalds struct raw_iter_state *state = raw_seq_private(seq);
9620a78cf72SKuniyuki Iwashima struct hlist_head *hlist;
9630daf07e5SEric Dumazet struct sock *sk;
9641da177e4SLinus Torvalds
9650daf07e5SEric Dumazet for (state->bucket = bucket; state->bucket < RAW_HTABLE_SIZE;
966b673e4dfSPavel Emelyanov ++state->bucket) {
9670daf07e5SEric Dumazet hlist = &h->ht[state->bucket];
9680a78cf72SKuniyuki Iwashima sk_for_each(sk, hlist) {
9691218854aSYOSHIFUJI Hideaki if (sock_net(sk) == seq_file_net(seq))
9701da177e4SLinus Torvalds return sk;
9711da177e4SLinus Torvalds }
9720daf07e5SEric Dumazet }
9730daf07e5SEric Dumazet return NULL;
9740daf07e5SEric Dumazet }
9751da177e4SLinus Torvalds
raw_get_next(struct seq_file * seq,struct sock * sk)9761da177e4SLinus Torvalds static struct sock *raw_get_next(struct seq_file *seq, struct sock *sk)
9771da177e4SLinus Torvalds {
9781da177e4SLinus Torvalds struct raw_iter_state *state = raw_seq_private(seq);
9791da177e4SLinus Torvalds
9801da177e4SLinus Torvalds do {
9810a78cf72SKuniyuki Iwashima sk = sk_next(sk);
9821218854aSYOSHIFUJI Hideaki } while (sk && sock_net(sk) != seq_file_net(seq));
9831da177e4SLinus Torvalds
9840daf07e5SEric Dumazet if (!sk)
9850daf07e5SEric Dumazet return raw_get_first(seq, state->bucket + 1);
9861da177e4SLinus Torvalds return sk;
9871da177e4SLinus Torvalds }
9881da177e4SLinus Torvalds
raw_get_idx(struct seq_file * seq,loff_t pos)9891da177e4SLinus Torvalds static struct sock *raw_get_idx(struct seq_file *seq, loff_t pos)
9901da177e4SLinus Torvalds {
9910daf07e5SEric Dumazet struct sock *sk = raw_get_first(seq, 0);
9921da177e4SLinus Torvalds
9931da177e4SLinus Torvalds if (sk)
9941da177e4SLinus Torvalds while (pos && (sk = raw_get_next(seq, sk)) != NULL)
9951da177e4SLinus Torvalds --pos;
9961da177e4SLinus Torvalds return pos ? NULL : sk;
9971da177e4SLinus Torvalds }
9981da177e4SLinus Torvalds
raw_seq_start(struct seq_file * seq,loff_t * pos)99942a73808SPavel Emelyanov void *raw_seq_start(struct seq_file *seq, loff_t *pos)
10000a78cf72SKuniyuki Iwashima __acquires(&h->lock)
10011da177e4SLinus Torvalds {
10020a78cf72SKuniyuki Iwashima struct raw_hashinfo *h = pde_data(file_inode(seq->file));
10030a78cf72SKuniyuki Iwashima
10040a78cf72SKuniyuki Iwashima spin_lock(&h->lock);
10050a78cf72SKuniyuki Iwashima
10061da177e4SLinus Torvalds return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
10071da177e4SLinus Torvalds }
100842a73808SPavel Emelyanov EXPORT_SYMBOL_GPL(raw_seq_start);
10091da177e4SLinus Torvalds
raw_seq_next(struct seq_file * seq,void * v,loff_t * pos)101042a73808SPavel Emelyanov void *raw_seq_next(struct seq_file *seq, void *v, loff_t *pos)
10111da177e4SLinus Torvalds {
10121da177e4SLinus Torvalds struct sock *sk;
10131da177e4SLinus Torvalds
10141da177e4SLinus Torvalds if (v == SEQ_START_TOKEN)
10150daf07e5SEric Dumazet sk = raw_get_first(seq, 0);
10161da177e4SLinus Torvalds else
10171da177e4SLinus Torvalds sk = raw_get_next(seq, v);
10181da177e4SLinus Torvalds ++*pos;
10191da177e4SLinus Torvalds return sk;
10201da177e4SLinus Torvalds }
102142a73808SPavel Emelyanov EXPORT_SYMBOL_GPL(raw_seq_next);
10221da177e4SLinus Torvalds
raw_seq_stop(struct seq_file * seq,void * v)102342a73808SPavel Emelyanov void raw_seq_stop(struct seq_file *seq, void *v)
10240a78cf72SKuniyuki Iwashima __releases(&h->lock)
10251da177e4SLinus Torvalds {
10260a78cf72SKuniyuki Iwashima struct raw_hashinfo *h = pde_data(file_inode(seq->file));
10270a78cf72SKuniyuki Iwashima
10280a78cf72SKuniyuki Iwashima spin_unlock(&h->lock);
10291da177e4SLinus Torvalds }
103042a73808SPavel Emelyanov EXPORT_SYMBOL_GPL(raw_seq_stop);
10311da177e4SLinus Torvalds
raw_sock_seq_show(struct seq_file * seq,struct sock * sp,int i)10328cd850efSDenis V. Lunev static void raw_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
10331da177e4SLinus Torvalds {
10341da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sp);
1035c720c7e8SEric Dumazet __be32 dest = inet->inet_daddr,
1036c720c7e8SEric Dumazet src = inet->inet_rcv_saddr;
10371da177e4SLinus Torvalds __u16 destp = 0,
1038c720c7e8SEric Dumazet srcp = inet->inet_num;
10391da177e4SLinus Torvalds
10408cd850efSDenis V. Lunev seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
1041ea9a0379SPatrick Talbert " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
10421da177e4SLinus Torvalds i, src, srcp, dest, destp, sp->sk_state,
104331e6d363SEric Dumazet sk_wmem_alloc_get(sp),
104431e6d363SEric Dumazet sk_rmem_alloc_get(sp),
1045a7cb5a49SEric W. Biederman 0, 0L, 0,
1046a7cb5a49SEric W. Biederman from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
1047a7cb5a49SEric W. Biederman 0, sock_i_ino(sp),
104841c6d650SReshetova, Elena refcount_read(&sp->sk_refcnt), sp, atomic_read(&sp->sk_drops));
10491da177e4SLinus Torvalds }
10501da177e4SLinus Torvalds
raw_seq_show(struct seq_file * seq,void * v)10511da177e4SLinus Torvalds static int raw_seq_show(struct seq_file *seq, void *v)
10521da177e4SLinus Torvalds {
10531da177e4SLinus Torvalds if (v == SEQ_START_TOKEN)
10548cd850efSDenis V. Lunev seq_printf(seq, " sl local_address rem_address st tx_queue "
10551da177e4SLinus Torvalds "rx_queue tr tm->when retrnsmt uid timeout "
1056cb61cb9bSEric Dumazet "inode ref pointer drops\n");
10578cd850efSDenis V. Lunev else
10588cd850efSDenis V. Lunev raw_sock_seq_show(seq, v, raw_seq_private(seq)->bucket);
10591da177e4SLinus Torvalds return 0;
10601da177e4SLinus Torvalds }
10611da177e4SLinus Torvalds
1062f690808eSStephen Hemminger static const struct seq_operations raw_seq_ops = {
10631da177e4SLinus Torvalds .start = raw_seq_start,
10641da177e4SLinus Torvalds .next = raw_seq_next,
10651da177e4SLinus Torvalds .stop = raw_seq_stop,
10661da177e4SLinus Torvalds .show = raw_seq_show,
10671da177e4SLinus Torvalds };
10681da177e4SLinus Torvalds
raw_init_net(struct net * net)1069a308da16SPavel Emelyanov static __net_init int raw_init_net(struct net *net)
1070a308da16SPavel Emelyanov {
1071c3506372SChristoph Hellwig if (!proc_create_net_data("raw", 0444, net->proc_net, &raw_seq_ops,
1072c3506372SChristoph Hellwig sizeof(struct raw_iter_state), &raw_v4_hashinfo))
1073a308da16SPavel Emelyanov return -ENOMEM;
1074a308da16SPavel Emelyanov
1075a308da16SPavel Emelyanov return 0;
1076a308da16SPavel Emelyanov }
1077a308da16SPavel Emelyanov
raw_exit_net(struct net * net)1078a308da16SPavel Emelyanov static __net_exit void raw_exit_net(struct net *net)
1079a308da16SPavel Emelyanov {
1080ece31ffdSGao feng remove_proc_entry("raw", net->proc_net);
1081a308da16SPavel Emelyanov }
1082a308da16SPavel Emelyanov
1083a308da16SPavel Emelyanov static __net_initdata struct pernet_operations raw_net_ops = {
1084a308da16SPavel Emelyanov .init = raw_init_net,
1085a308da16SPavel Emelyanov .exit = raw_exit_net,
1086a308da16SPavel Emelyanov };
1087a308da16SPavel Emelyanov
raw_proc_init(void)10881da177e4SLinus Torvalds int __init raw_proc_init(void)
10891da177e4SLinus Torvalds {
10900daf07e5SEric Dumazet
1091a308da16SPavel Emelyanov return register_pernet_subsys(&raw_net_ops);
10921da177e4SLinus Torvalds }
10931da177e4SLinus Torvalds
raw_proc_exit(void)10941da177e4SLinus Torvalds void __init raw_proc_exit(void)
10951da177e4SLinus Torvalds {
1096a308da16SPavel Emelyanov unregister_pernet_subsys(&raw_net_ops);
10971da177e4SLinus Torvalds }
109886d1d8b7SDavid Ahern #endif /* CONFIG_PROC_FS */
10996897445fSMike Manning
raw_sysctl_init_net(struct net * net)11006897445fSMike Manning static void raw_sysctl_init_net(struct net *net)
11016897445fSMike Manning {
11026897445fSMike Manning #ifdef CONFIG_NET_L3_MASTER_DEV
11036897445fSMike Manning net->ipv4.sysctl_raw_l3mdev_accept = 1;
11046897445fSMike Manning #endif
11056897445fSMike Manning }
11066897445fSMike Manning
raw_sysctl_init(struct net * net)11076897445fSMike Manning static int __net_init raw_sysctl_init(struct net *net)
11086897445fSMike Manning {
11096897445fSMike Manning raw_sysctl_init_net(net);
11106897445fSMike Manning return 0;
11116897445fSMike Manning }
11126897445fSMike Manning
11136897445fSMike Manning static struct pernet_operations __net_initdata raw_sysctl_ops = {
11146897445fSMike Manning .init = raw_sysctl_init,
11156897445fSMike Manning };
11166897445fSMike Manning
raw_init(void)11176897445fSMike Manning void __init raw_init(void)
11186897445fSMike Manning {
11196897445fSMike Manning raw_sysctl_init_net(&init_net);
11206897445fSMike Manning if (register_pernet_subsys(&raw_sysctl_ops))
11216897445fSMike Manning panic("RAW: failed to init sysctl parameters.\n");
11226897445fSMike Manning }
1123