11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds * INET An implementation of the TCP/IP protocol suite for the LINUX 31da177e4SLinus Torvalds * operating system. INET is implemented using the BSD Socket 41da177e4SLinus Torvalds * interface as the means of communication with the user level. 51da177e4SLinus Torvalds * 61da177e4SLinus Torvalds * RAW - implementation of IP "raw" sockets. 71da177e4SLinus Torvalds * 81da177e4SLinus Torvalds * Version: $Id: raw.c,v 1.64 2002/02/01 22:01:04 davem Exp $ 91da177e4SLinus Torvalds * 1002c30a84SJesper Juhl * Authors: Ross Biro 111da177e4SLinus Torvalds * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> 121da177e4SLinus Torvalds * 131da177e4SLinus Torvalds * Fixes: 141da177e4SLinus Torvalds * Alan Cox : verify_area() fixed up 151da177e4SLinus Torvalds * Alan Cox : ICMP error handling 161da177e4SLinus Torvalds * Alan Cox : EMSGSIZE if you send too big a packet 171da177e4SLinus Torvalds * Alan Cox : Now uses generic datagrams and shared 181da177e4SLinus Torvalds * skbuff library. No more peek crashes, 191da177e4SLinus Torvalds * no more backlogs 201da177e4SLinus Torvalds * Alan Cox : Checks sk->broadcast. 211da177e4SLinus Torvalds * Alan Cox : Uses skb_free_datagram/skb_copy_datagram 221da177e4SLinus Torvalds * Alan Cox : Raw passes ip options too 231da177e4SLinus Torvalds * Alan Cox : Setsocketopt added 241da177e4SLinus Torvalds * Alan Cox : Fixed error return for broadcasts 251da177e4SLinus Torvalds * Alan Cox : Removed wake_up calls 261da177e4SLinus Torvalds * Alan Cox : Use ttl/tos 271da177e4SLinus Torvalds * Alan Cox : Cleaned up old debugging 281da177e4SLinus Torvalds * Alan Cox : Use new kernel side addresses 291da177e4SLinus Torvalds * Arnt Gulbrandsen : Fixed MSG_DONTROUTE in raw sockets. 301da177e4SLinus Torvalds * Alan Cox : BSD style RAW socket demultiplexing. 311da177e4SLinus Torvalds * Alan Cox : Beginnings of mrouted support. 321da177e4SLinus Torvalds * Alan Cox : Added IP_HDRINCL option. 331da177e4SLinus Torvalds * Alan Cox : Skip broadcast check if BSDism set. 341da177e4SLinus Torvalds * David S. Miller : New socket lookup architecture. 351da177e4SLinus Torvalds * 361da177e4SLinus Torvalds * This program is free software; you can redistribute it and/or 371da177e4SLinus Torvalds * modify it under the terms of the GNU General Public License 381da177e4SLinus Torvalds * as published by the Free Software Foundation; either version 391da177e4SLinus Torvalds * 2 of the License, or (at your option) any later version. 401da177e4SLinus Torvalds */ 411da177e4SLinus Torvalds 42715b49efSAlan Cox #include <linux/types.h> 431da177e4SLinus Torvalds #include <asm/atomic.h> 441da177e4SLinus Torvalds #include <asm/byteorder.h> 451da177e4SLinus Torvalds #include <asm/current.h> 461da177e4SLinus Torvalds #include <asm/uaccess.h> 471da177e4SLinus Torvalds #include <asm/ioctls.h> 481da177e4SLinus Torvalds #include <linux/stddef.h> 491da177e4SLinus Torvalds #include <linux/slab.h> 501da177e4SLinus Torvalds #include <linux/errno.h> 511da177e4SLinus Torvalds #include <linux/aio.h> 521da177e4SLinus Torvalds #include <linux/kernel.h> 531da177e4SLinus Torvalds #include <linux/spinlock.h> 541da177e4SLinus Torvalds #include <linux/sockios.h> 551da177e4SLinus Torvalds #include <linux/socket.h> 561da177e4SLinus Torvalds #include <linux/in.h> 571da177e4SLinus Torvalds #include <linux/mroute.h> 581da177e4SLinus Torvalds #include <linux/netdevice.h> 591da177e4SLinus Torvalds #include <linux/in_route.h> 601da177e4SLinus Torvalds #include <linux/route.h> 611da177e4SLinus Torvalds #include <linux/skbuff.h> 62457c4cbcSEric W. Biederman #include <net/net_namespace.h> 631da177e4SLinus Torvalds #include <net/dst.h> 641da177e4SLinus Torvalds #include <net/sock.h> 651da177e4SLinus Torvalds #include <linux/gfp.h> 661da177e4SLinus Torvalds #include <linux/ip.h> 671da177e4SLinus Torvalds #include <linux/net.h> 681da177e4SLinus Torvalds #include <net/ip.h> 691da177e4SLinus Torvalds #include <net/icmp.h> 701da177e4SLinus Torvalds #include <net/udp.h> 711da177e4SLinus Torvalds #include <net/raw.h> 721da177e4SLinus Torvalds #include <net/snmp.h> 73c752f073SArnaldo Carvalho de Melo #include <net/tcp_states.h> 741da177e4SLinus Torvalds #include <net/inet_common.h> 751da177e4SLinus Torvalds #include <net/checksum.h> 761da177e4SLinus Torvalds #include <net/xfrm.h> 771da177e4SLinus Torvalds #include <linux/rtnetlink.h> 781da177e4SLinus Torvalds #include <linux/proc_fs.h> 791da177e4SLinus Torvalds #include <linux/seq_file.h> 801da177e4SLinus Torvalds #include <linux/netfilter.h> 811da177e4SLinus Torvalds #include <linux/netfilter_ipv4.h> 821da177e4SLinus Torvalds 831da177e4SLinus Torvalds struct hlist_head raw_v4_htable[RAWV4_HTABLE_SIZE]; 841da177e4SLinus Torvalds DEFINE_RWLOCK(raw_v4_lock); 851da177e4SLinus Torvalds 861da177e4SLinus Torvalds static void raw_v4_hash(struct sock *sk) 871da177e4SLinus Torvalds { 881da177e4SLinus Torvalds struct hlist_head *head = &raw_v4_htable[inet_sk(sk)->num & 891da177e4SLinus Torvalds (RAWV4_HTABLE_SIZE - 1)]; 901da177e4SLinus Torvalds 911da177e4SLinus Torvalds write_lock_bh(&raw_v4_lock); 921da177e4SLinus Torvalds sk_add_node(sk, head); 931da177e4SLinus Torvalds sock_prot_inc_use(sk->sk_prot); 941da177e4SLinus Torvalds write_unlock_bh(&raw_v4_lock); 951da177e4SLinus Torvalds } 961da177e4SLinus Torvalds 971da177e4SLinus Torvalds static void raw_v4_unhash(struct sock *sk) 981da177e4SLinus Torvalds { 991da177e4SLinus Torvalds write_lock_bh(&raw_v4_lock); 1001da177e4SLinus Torvalds if (sk_del_node_init(sk)) 1011da177e4SLinus Torvalds sock_prot_dec_use(sk->sk_prot); 1021da177e4SLinus Torvalds write_unlock_bh(&raw_v4_lock); 1031da177e4SLinus Torvalds } 1041da177e4SLinus Torvalds 1051da177e4SLinus Torvalds struct sock *__raw_v4_lookup(struct sock *sk, unsigned short num, 1066d741653SAlexey Dobriyan __be32 raddr, __be32 laddr, 1071da177e4SLinus Torvalds int dif) 1081da177e4SLinus Torvalds { 1091da177e4SLinus Torvalds struct hlist_node *node; 1101da177e4SLinus Torvalds 1111da177e4SLinus Torvalds sk_for_each_from(sk, node) { 1121da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 1131da177e4SLinus Torvalds 1141da177e4SLinus Torvalds if (inet->num == num && 1151da177e4SLinus Torvalds !(inet->daddr && inet->daddr != raddr) && 1161da177e4SLinus Torvalds !(inet->rcv_saddr && inet->rcv_saddr != laddr) && 1171da177e4SLinus Torvalds !(sk->sk_bound_dev_if && sk->sk_bound_dev_if != dif)) 1181da177e4SLinus Torvalds goto found; /* gotcha */ 1191da177e4SLinus Torvalds } 1201da177e4SLinus Torvalds sk = NULL; 1211da177e4SLinus Torvalds found: 1221da177e4SLinus Torvalds return sk; 1231da177e4SLinus Torvalds } 1241da177e4SLinus Torvalds 1251da177e4SLinus Torvalds /* 1261da177e4SLinus Torvalds * 0 - deliver 1271da177e4SLinus Torvalds * 1 - block 1281da177e4SLinus Torvalds */ 1291da177e4SLinus Torvalds static __inline__ int icmp_filter(struct sock *sk, struct sk_buff *skb) 1301da177e4SLinus Torvalds { 1311da177e4SLinus Torvalds int type; 1321da177e4SLinus Torvalds 1331da177e4SLinus Torvalds if (!pskb_may_pull(skb, sizeof(struct icmphdr))) 1341da177e4SLinus Torvalds return 1; 1351da177e4SLinus Torvalds 13688c7664fSArnaldo Carvalho de Melo type = icmp_hdr(skb)->type; 1371da177e4SLinus Torvalds if (type < 32) { 1381da177e4SLinus Torvalds __u32 data = raw_sk(sk)->filter.data; 1391da177e4SLinus Torvalds 1401da177e4SLinus Torvalds return ((1 << type) & data) != 0; 1411da177e4SLinus Torvalds } 1421da177e4SLinus Torvalds 1431da177e4SLinus Torvalds /* Do not block unknown ICMP types */ 1441da177e4SLinus Torvalds return 0; 1451da177e4SLinus Torvalds } 1461da177e4SLinus Torvalds 1471da177e4SLinus Torvalds /* IP input processing comes here for RAW socket delivery. 1481da177e4SLinus Torvalds * Caller owns SKB, so we must make clones. 1491da177e4SLinus Torvalds * 1501da177e4SLinus Torvalds * RFC 1122: SHOULD pass TOS value up to the transport layer. 1511da177e4SLinus Torvalds * -> It does. And not only TOS, but all IP header. 1521da177e4SLinus Torvalds */ 153d13964f4SPatrick McHardy int raw_v4_input(struct sk_buff *skb, struct iphdr *iph, int hash) 1541da177e4SLinus Torvalds { 1551da177e4SLinus Torvalds struct sock *sk; 1561da177e4SLinus Torvalds struct hlist_head *head; 157d13964f4SPatrick McHardy int delivered = 0; 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds read_lock(&raw_v4_lock); 1601da177e4SLinus Torvalds head = &raw_v4_htable[hash]; 1611da177e4SLinus Torvalds if (hlist_empty(head)) 1621da177e4SLinus Torvalds goto out; 1631da177e4SLinus Torvalds sk = __raw_v4_lookup(__sk_head(head), iph->protocol, 1641da177e4SLinus Torvalds iph->saddr, iph->daddr, 1651da177e4SLinus Torvalds skb->dev->ifindex); 1661da177e4SLinus Torvalds 1671da177e4SLinus Torvalds while (sk) { 168d13964f4SPatrick McHardy delivered = 1; 1691da177e4SLinus Torvalds if (iph->protocol != IPPROTO_ICMP || !icmp_filter(sk, skb)) { 1701da177e4SLinus Torvalds struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC); 1711da177e4SLinus Torvalds 1721da177e4SLinus Torvalds /* Not releasing hash table! */ 1731da177e4SLinus Torvalds if (clone) 1741da177e4SLinus Torvalds raw_rcv(sk, clone); 1751da177e4SLinus Torvalds } 1761da177e4SLinus Torvalds sk = __raw_v4_lookup(sk_next(sk), iph->protocol, 1771da177e4SLinus Torvalds iph->saddr, iph->daddr, 1781da177e4SLinus Torvalds skb->dev->ifindex); 1791da177e4SLinus Torvalds } 1801da177e4SLinus Torvalds out: 1811da177e4SLinus Torvalds read_unlock(&raw_v4_lock); 182d13964f4SPatrick McHardy return delivered; 1831da177e4SLinus Torvalds } 1841da177e4SLinus Torvalds 1851da177e4SLinus Torvalds void raw_err (struct sock *sk, struct sk_buff *skb, u32 info) 1861da177e4SLinus Torvalds { 1871da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 18888c7664fSArnaldo Carvalho de Melo const int type = icmp_hdr(skb)->type; 18988c7664fSArnaldo Carvalho de Melo const int code = icmp_hdr(skb)->code; 1901da177e4SLinus Torvalds int err = 0; 1911da177e4SLinus Torvalds int harderr = 0; 1921da177e4SLinus Torvalds 1931da177e4SLinus Torvalds /* Report error on raw socket, if: 1941da177e4SLinus Torvalds 1. User requested ip_recverr. 1951da177e4SLinus Torvalds 2. Socket is connected (otherwise the error indication 1961da177e4SLinus Torvalds is useless without ip_recverr and error is hard. 1971da177e4SLinus Torvalds */ 1981da177e4SLinus Torvalds if (!inet->recverr && sk->sk_state != TCP_ESTABLISHED) 1991da177e4SLinus Torvalds return; 2001da177e4SLinus Torvalds 2011da177e4SLinus Torvalds switch (type) { 2021da177e4SLinus Torvalds default: 2031da177e4SLinus Torvalds case ICMP_TIME_EXCEEDED: 2041da177e4SLinus Torvalds err = EHOSTUNREACH; 2051da177e4SLinus Torvalds break; 2061da177e4SLinus Torvalds case ICMP_SOURCE_QUENCH: 2071da177e4SLinus Torvalds return; 2081da177e4SLinus Torvalds case ICMP_PARAMETERPROB: 2091da177e4SLinus Torvalds err = EPROTO; 2101da177e4SLinus Torvalds harderr = 1; 2111da177e4SLinus Torvalds break; 2121da177e4SLinus Torvalds case ICMP_DEST_UNREACH: 2131da177e4SLinus Torvalds err = EHOSTUNREACH; 2141da177e4SLinus Torvalds if (code > NR_ICMP_UNREACH) 2151da177e4SLinus Torvalds break; 2161da177e4SLinus Torvalds err = icmp_err_convert[code].errno; 2171da177e4SLinus Torvalds harderr = icmp_err_convert[code].fatal; 2181da177e4SLinus Torvalds if (code == ICMP_FRAG_NEEDED) { 2191da177e4SLinus Torvalds harderr = inet->pmtudisc != IP_PMTUDISC_DONT; 2201da177e4SLinus Torvalds err = EMSGSIZE; 2211da177e4SLinus Torvalds } 2221da177e4SLinus Torvalds } 2231da177e4SLinus Torvalds 2241da177e4SLinus Torvalds if (inet->recverr) { 2251da177e4SLinus Torvalds struct iphdr *iph = (struct iphdr*)skb->data; 2261da177e4SLinus Torvalds u8 *payload = skb->data + (iph->ihl << 2); 2271da177e4SLinus Torvalds 2281da177e4SLinus Torvalds if (inet->hdrincl) 2291da177e4SLinus Torvalds payload = skb->data; 2301da177e4SLinus Torvalds ip_icmp_error(sk, skb, err, 0, info, payload); 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds 2331da177e4SLinus Torvalds if (inet->recverr || harderr) { 2341da177e4SLinus Torvalds sk->sk_err = err; 2351da177e4SLinus Torvalds sk->sk_error_report(sk); 2361da177e4SLinus Torvalds } 2371da177e4SLinus Torvalds } 2381da177e4SLinus Torvalds 2391da177e4SLinus Torvalds static int raw_rcv_skb(struct sock * sk, struct sk_buff * skb) 2401da177e4SLinus Torvalds { 2411da177e4SLinus Torvalds /* Charge it to the socket. */ 2421da177e4SLinus Torvalds 2431da177e4SLinus Torvalds if (sock_queue_rcv_skb(sk, skb) < 0) { 244*33c732c3SWang Chen atomic_inc(&sk->sk_drops); 2451da177e4SLinus Torvalds kfree_skb(skb); 2461da177e4SLinus Torvalds return NET_RX_DROP; 2471da177e4SLinus Torvalds } 2481da177e4SLinus Torvalds 2491da177e4SLinus Torvalds return NET_RX_SUCCESS; 2501da177e4SLinus Torvalds } 2511da177e4SLinus Torvalds 2521da177e4SLinus Torvalds int raw_rcv(struct sock *sk, struct sk_buff *skb) 2531da177e4SLinus Torvalds { 2541da177e4SLinus Torvalds if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) { 255*33c732c3SWang Chen atomic_inc(&sk->sk_drops); 2561da177e4SLinus Torvalds kfree_skb(skb); 2571da177e4SLinus Torvalds return NET_RX_DROP; 2581da177e4SLinus Torvalds } 259b59c2701SPatrick McHardy nf_reset(skb); 2601da177e4SLinus Torvalds 261d56f90a7SArnaldo Carvalho de Melo skb_push(skb, skb->data - skb_network_header(skb)); 2621da177e4SLinus Torvalds 2631da177e4SLinus Torvalds raw_rcv_skb(sk, skb); 2641da177e4SLinus Torvalds return 0; 2651da177e4SLinus Torvalds } 2661da177e4SLinus Torvalds 267f7d7fc03SJesper Juhl static int raw_send_hdrinc(struct sock *sk, void *from, size_t length, 2681da177e4SLinus Torvalds struct rtable *rt, 2691da177e4SLinus Torvalds unsigned int flags) 2701da177e4SLinus Torvalds { 2711da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 2721da177e4SLinus Torvalds int hh_len; 2731da177e4SLinus Torvalds struct iphdr *iph; 2741da177e4SLinus Torvalds struct sk_buff *skb; 275f844c74fSHerbert Xu unsigned int iphlen; 2761da177e4SLinus Torvalds int err; 2771da177e4SLinus Torvalds 2781da177e4SLinus Torvalds if (length > rt->u.dst.dev->mtu) { 2791da177e4SLinus Torvalds ip_local_error(sk, EMSGSIZE, rt->rt_dst, inet->dport, 2801da177e4SLinus Torvalds rt->u.dst.dev->mtu); 2811da177e4SLinus Torvalds return -EMSGSIZE; 2821da177e4SLinus Torvalds } 2831da177e4SLinus Torvalds if (flags&MSG_PROBE) 2841da177e4SLinus Torvalds goto out; 2851da177e4SLinus Torvalds 2861da177e4SLinus Torvalds hh_len = LL_RESERVED_SPACE(rt->u.dst.dev); 2871da177e4SLinus Torvalds 2881da177e4SLinus Torvalds skb = sock_alloc_send_skb(sk, length+hh_len+15, 2891da177e4SLinus Torvalds flags&MSG_DONTWAIT, &err); 2901da177e4SLinus Torvalds if (skb == NULL) 2911da177e4SLinus Torvalds goto error; 2921da177e4SLinus Torvalds skb_reserve(skb, hh_len); 2931da177e4SLinus Torvalds 2941da177e4SLinus Torvalds skb->priority = sk->sk_priority; 2951da177e4SLinus Torvalds skb->dst = dst_clone(&rt->u.dst); 2961da177e4SLinus Torvalds 2977e28ecc2SArnaldo Carvalho de Melo skb_reset_network_header(skb); 298eddc9ec5SArnaldo Carvalho de Melo iph = ip_hdr(skb); 2997e28ecc2SArnaldo Carvalho de Melo skb_put(skb, length); 3001da177e4SLinus Torvalds 3011da177e4SLinus Torvalds skb->ip_summed = CHECKSUM_NONE; 3021da177e4SLinus Torvalds 303b0e380b1SArnaldo Carvalho de Melo skb->transport_header = skb->network_header; 3041da177e4SLinus Torvalds err = memcpy_fromiovecend((void *)iph, from, 0, length); 3051da177e4SLinus Torvalds if (err) 3061da177e4SLinus Torvalds goto error_fault; 3071da177e4SLinus Torvalds 3081da177e4SLinus Torvalds /* We don't modify invalid header */ 309f844c74fSHerbert Xu iphlen = iph->ihl * 4; 310f844c74fSHerbert Xu if (iphlen >= sizeof(*iph) && iphlen <= length) { 3111da177e4SLinus Torvalds if (!iph->saddr) 3121da177e4SLinus Torvalds iph->saddr = rt->rt_src; 3131da177e4SLinus Torvalds iph->check = 0; 3141da177e4SLinus Torvalds iph->tot_len = htons(length); 3151da177e4SLinus Torvalds if (!iph->id) 3161da177e4SLinus Torvalds ip_select_ident(iph, &rt->u.dst, NULL); 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl); 3191da177e4SLinus Torvalds } 32096793b48SDavid L Stevens if (iph->protocol == IPPROTO_ICMP) 32196793b48SDavid L Stevens icmp_out_count(((struct icmphdr *) 32296793b48SDavid L Stevens skb_transport_header(skb))->type); 3231da177e4SLinus Torvalds 3241da177e4SLinus Torvalds err = NF_HOOK(PF_INET, NF_IP_LOCAL_OUT, skb, NULL, rt->u.dst.dev, 3251da177e4SLinus Torvalds dst_output); 3261da177e4SLinus Torvalds if (err > 0) 3271da177e4SLinus Torvalds err = inet->recverr ? net_xmit_errno(err) : 0; 3281da177e4SLinus Torvalds if (err) 3291da177e4SLinus Torvalds goto error; 3301da177e4SLinus Torvalds out: 3311da177e4SLinus Torvalds return 0; 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds error_fault: 3341da177e4SLinus Torvalds err = -EFAULT; 3351da177e4SLinus Torvalds kfree_skb(skb); 3361da177e4SLinus Torvalds error: 3371da177e4SLinus Torvalds IP_INC_STATS(IPSTATS_MIB_OUTDISCARDS); 3381da177e4SLinus Torvalds return err; 3391da177e4SLinus Torvalds } 3401da177e4SLinus Torvalds 341a27b58feSHeiko Carstens static int raw_probe_proto_opt(struct flowi *fl, struct msghdr *msg) 3421da177e4SLinus Torvalds { 3431da177e4SLinus Torvalds struct iovec *iov; 3441da177e4SLinus Torvalds u8 __user *type = NULL; 3451da177e4SLinus Torvalds u8 __user *code = NULL; 3461da177e4SLinus Torvalds int probed = 0; 34793765d8aSJesper Juhl unsigned int i; 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds if (!msg->msg_iov) 350a27b58feSHeiko Carstens return 0; 3511da177e4SLinus Torvalds 3521da177e4SLinus Torvalds for (i = 0; i < msg->msg_iovlen; i++) { 3531da177e4SLinus Torvalds iov = &msg->msg_iov[i]; 3541da177e4SLinus Torvalds if (!iov) 3551da177e4SLinus Torvalds continue; 3561da177e4SLinus Torvalds 3571da177e4SLinus Torvalds switch (fl->proto) { 3581da177e4SLinus Torvalds case IPPROTO_ICMP: 3591da177e4SLinus Torvalds /* check if one-byte field is readable or not. */ 3601da177e4SLinus Torvalds if (iov->iov_base && iov->iov_len < 1) 3611da177e4SLinus Torvalds break; 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds if (!type) { 3641da177e4SLinus Torvalds type = iov->iov_base; 3651da177e4SLinus Torvalds /* check if code field is readable or not. */ 3661da177e4SLinus Torvalds if (iov->iov_len > 1) 3671da177e4SLinus Torvalds code = type + 1; 3681da177e4SLinus Torvalds } else if (!code) 3691da177e4SLinus Torvalds code = iov->iov_base; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds if (type && code) { 372a27b58feSHeiko Carstens if (get_user(fl->fl_icmp_type, type) || 373a27b58feSHeiko Carstens get_user(fl->fl_icmp_code, code)) 374a27b58feSHeiko Carstens return -EFAULT; 3751da177e4SLinus Torvalds probed = 1; 3761da177e4SLinus Torvalds } 3771da177e4SLinus Torvalds break; 3781da177e4SLinus Torvalds default: 3791da177e4SLinus Torvalds probed = 1; 3801da177e4SLinus Torvalds break; 3811da177e4SLinus Torvalds } 3821da177e4SLinus Torvalds if (probed) 3831da177e4SLinus Torvalds break; 3841da177e4SLinus Torvalds } 385a27b58feSHeiko Carstens return 0; 3861da177e4SLinus Torvalds } 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds static int raw_sendmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 3891da177e4SLinus Torvalds size_t len) 3901da177e4SLinus Torvalds { 3911da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 3921da177e4SLinus Torvalds struct ipcm_cookie ipc; 3931da177e4SLinus Torvalds struct rtable *rt = NULL; 3941da177e4SLinus Torvalds int free = 0; 3953ca3c68eSAl Viro __be32 daddr; 396c1d18f9fSAl Viro __be32 saddr; 3971da177e4SLinus Torvalds u8 tos; 3981da177e4SLinus Torvalds int err; 3991da177e4SLinus Torvalds 4001da177e4SLinus Torvalds err = -EMSGSIZE; 401926d4b81SJesper Juhl if (len > 0xFFFF) 4021da177e4SLinus Torvalds goto out; 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds /* 4051da177e4SLinus Torvalds * Check the flags. 4061da177e4SLinus Torvalds */ 4071da177e4SLinus Torvalds 4081da177e4SLinus Torvalds err = -EOPNOTSUPP; 4091da177e4SLinus Torvalds if (msg->msg_flags & MSG_OOB) /* Mirror BSD error message */ 4101da177e4SLinus Torvalds goto out; /* compatibility */ 4111da177e4SLinus Torvalds 4121da177e4SLinus Torvalds /* 4131da177e4SLinus Torvalds * Get and verify the address. 4141da177e4SLinus Torvalds */ 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds if (msg->msg_namelen) { 4171da177e4SLinus Torvalds struct sockaddr_in *usin = (struct sockaddr_in*)msg->msg_name; 4181da177e4SLinus Torvalds err = -EINVAL; 4191da177e4SLinus Torvalds if (msg->msg_namelen < sizeof(*usin)) 4201da177e4SLinus Torvalds goto out; 4211da177e4SLinus Torvalds if (usin->sin_family != AF_INET) { 4221da177e4SLinus Torvalds static int complained; 4231da177e4SLinus Torvalds if (!complained++) 4241da177e4SLinus Torvalds printk(KERN_INFO "%s forgot to set AF_INET in " 4251da177e4SLinus Torvalds "raw sendmsg. Fix it!\n", 4261da177e4SLinus Torvalds current->comm); 4271da177e4SLinus Torvalds err = -EAFNOSUPPORT; 4281da177e4SLinus Torvalds if (usin->sin_family) 4291da177e4SLinus Torvalds goto out; 4301da177e4SLinus Torvalds } 4311da177e4SLinus Torvalds daddr = usin->sin_addr.s_addr; 4321da177e4SLinus Torvalds /* ANK: I did not forget to get protocol from port field. 4331da177e4SLinus Torvalds * I just do not know, who uses this weirdness. 4341da177e4SLinus Torvalds * IP_HDRINCL is much more convenient. 4351da177e4SLinus Torvalds */ 4361da177e4SLinus Torvalds } else { 4371da177e4SLinus Torvalds err = -EDESTADDRREQ; 4381da177e4SLinus Torvalds if (sk->sk_state != TCP_ESTABLISHED) 4391da177e4SLinus Torvalds goto out; 4401da177e4SLinus Torvalds daddr = inet->daddr; 4411da177e4SLinus Torvalds } 4421da177e4SLinus Torvalds 4431da177e4SLinus Torvalds ipc.addr = inet->saddr; 4441da177e4SLinus Torvalds ipc.opt = NULL; 4451da177e4SLinus Torvalds ipc.oif = sk->sk_bound_dev_if; 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds if (msg->msg_controllen) { 4481da177e4SLinus Torvalds err = ip_cmsg_send(msg, &ipc); 4491da177e4SLinus Torvalds if (err) 4501da177e4SLinus Torvalds goto out; 4511da177e4SLinus Torvalds if (ipc.opt) 4521da177e4SLinus Torvalds free = 1; 4531da177e4SLinus Torvalds } 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds saddr = ipc.addr; 4561da177e4SLinus Torvalds ipc.addr = daddr; 4571da177e4SLinus Torvalds 4581da177e4SLinus Torvalds if (!ipc.opt) 4591da177e4SLinus Torvalds ipc.opt = inet->opt; 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds if (ipc.opt) { 4621da177e4SLinus Torvalds err = -EINVAL; 4631da177e4SLinus Torvalds /* Linux does not mangle headers on raw sockets, 4641da177e4SLinus Torvalds * so that IP options + IP_HDRINCL is non-sense. 4651da177e4SLinus Torvalds */ 4661da177e4SLinus Torvalds if (inet->hdrincl) 4671da177e4SLinus Torvalds goto done; 4681da177e4SLinus Torvalds if (ipc.opt->srr) { 4691da177e4SLinus Torvalds if (!daddr) 4701da177e4SLinus Torvalds goto done; 4711da177e4SLinus Torvalds daddr = ipc.opt->faddr; 4721da177e4SLinus Torvalds } 4731da177e4SLinus Torvalds } 4741da177e4SLinus Torvalds tos = RT_CONN_FLAGS(sk); 4751da177e4SLinus Torvalds if (msg->msg_flags & MSG_DONTROUTE) 4761da177e4SLinus Torvalds tos |= RTO_ONLINK; 4771da177e4SLinus Torvalds 4781da177e4SLinus Torvalds if (MULTICAST(daddr)) { 4791da177e4SLinus Torvalds if (!ipc.oif) 4801da177e4SLinus Torvalds ipc.oif = inet->mc_index; 4811da177e4SLinus Torvalds if (!saddr) 4821da177e4SLinus Torvalds saddr = inet->mc_addr; 4831da177e4SLinus Torvalds } 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds { 4861da177e4SLinus Torvalds struct flowi fl = { .oif = ipc.oif, 4871da177e4SLinus Torvalds .nl_u = { .ip4_u = 4881da177e4SLinus Torvalds { .daddr = daddr, 4891da177e4SLinus Torvalds .saddr = saddr, 4901da177e4SLinus Torvalds .tos = tos } }, 4911da177e4SLinus Torvalds .proto = inet->hdrincl ? IPPROTO_RAW : 4921da177e4SLinus Torvalds sk->sk_protocol, 4931da177e4SLinus Torvalds }; 494a27b58feSHeiko Carstens if (!inet->hdrincl) { 495a27b58feSHeiko Carstens err = raw_probe_proto_opt(&fl, msg); 496a27b58feSHeiko Carstens if (err) 497a27b58feSHeiko Carstens goto done; 498a27b58feSHeiko Carstens } 4991da177e4SLinus Torvalds 500beb8d13bSVenkat Yekkirala security_sk_classify_flow(sk, &fl); 5018eb9086fSDavid S. Miller err = ip_route_output_flow(&rt, &fl, sk, 1); 5021da177e4SLinus Torvalds } 5031da177e4SLinus Torvalds if (err) 5041da177e4SLinus Torvalds goto done; 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds err = -EACCES; 5071da177e4SLinus Torvalds if (rt->rt_flags & RTCF_BROADCAST && !sock_flag(sk, SOCK_BROADCAST)) 5081da177e4SLinus Torvalds goto done; 5091da177e4SLinus Torvalds 5101da177e4SLinus Torvalds if (msg->msg_flags & MSG_CONFIRM) 5111da177e4SLinus Torvalds goto do_confirm; 5121da177e4SLinus Torvalds back_from_confirm: 5131da177e4SLinus Torvalds 5141da177e4SLinus Torvalds if (inet->hdrincl) 5151da177e4SLinus Torvalds err = raw_send_hdrinc(sk, msg->msg_iov, len, 5161da177e4SLinus Torvalds rt, msg->msg_flags); 5171da177e4SLinus Torvalds 5181da177e4SLinus Torvalds else { 5191da177e4SLinus Torvalds if (!ipc.addr) 5201da177e4SLinus Torvalds ipc.addr = rt->rt_dst; 5211da177e4SLinus Torvalds lock_sock(sk); 5221da177e4SLinus Torvalds err = ip_append_data(sk, ip_generic_getfrag, msg->msg_iov, len, 0, 5231da177e4SLinus Torvalds &ipc, rt, msg->msg_flags); 5241da177e4SLinus Torvalds if (err) 5251da177e4SLinus Torvalds ip_flush_pending_frames(sk); 5261da177e4SLinus Torvalds else if (!(msg->msg_flags & MSG_MORE)) 5271da177e4SLinus Torvalds err = ip_push_pending_frames(sk); 5281da177e4SLinus Torvalds release_sock(sk); 5291da177e4SLinus Torvalds } 5301da177e4SLinus Torvalds done: 5311da177e4SLinus Torvalds if (free) 5321da177e4SLinus Torvalds kfree(ipc.opt); 5331da177e4SLinus Torvalds ip_rt_put(rt); 5341da177e4SLinus Torvalds 5355418c692SJesper Juhl out: 5365418c692SJesper Juhl if (err < 0) 5375418c692SJesper Juhl return err; 5385418c692SJesper Juhl return len; 5391da177e4SLinus Torvalds 5401da177e4SLinus Torvalds do_confirm: 5411da177e4SLinus Torvalds dst_confirm(&rt->u.dst); 5421da177e4SLinus Torvalds if (!(msg->msg_flags & MSG_PROBE) || len) 5431da177e4SLinus Torvalds goto back_from_confirm; 5441da177e4SLinus Torvalds err = 0; 5451da177e4SLinus Torvalds goto done; 5461da177e4SLinus Torvalds } 5471da177e4SLinus Torvalds 5481da177e4SLinus Torvalds static void raw_close(struct sock *sk, long timeout) 5491da177e4SLinus Torvalds { 5501da177e4SLinus Torvalds /* 5511da177e4SLinus Torvalds * Raw sockets may have direct kernel refereneces. Kill them. 5521da177e4SLinus Torvalds */ 5531da177e4SLinus Torvalds ip_ra_control(sk, 0, NULL); 5541da177e4SLinus Torvalds 5551da177e4SLinus Torvalds sk_common_release(sk); 5561da177e4SLinus Torvalds } 5571da177e4SLinus Torvalds 5581da177e4SLinus Torvalds /* This gets rid of all the nasties in af_inet. -DaveM */ 5591da177e4SLinus Torvalds static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len) 5601da177e4SLinus Torvalds { 5611da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 5621da177e4SLinus Torvalds struct sockaddr_in *addr = (struct sockaddr_in *) uaddr; 5631da177e4SLinus Torvalds int ret = -EINVAL; 5641da177e4SLinus Torvalds int chk_addr_ret; 5651da177e4SLinus Torvalds 5661da177e4SLinus Torvalds if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in)) 5671da177e4SLinus Torvalds goto out; 5681da177e4SLinus Torvalds chk_addr_ret = inet_addr_type(addr->sin_addr.s_addr); 5691da177e4SLinus Torvalds ret = -EADDRNOTAVAIL; 5701da177e4SLinus Torvalds if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL && 5711da177e4SLinus Torvalds chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST) 5721da177e4SLinus Torvalds goto out; 5731da177e4SLinus Torvalds inet->rcv_saddr = inet->saddr = addr->sin_addr.s_addr; 5741da177e4SLinus Torvalds if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST) 5751da177e4SLinus Torvalds inet->saddr = 0; /* Use device */ 5761da177e4SLinus Torvalds sk_dst_reset(sk); 5771da177e4SLinus Torvalds ret = 0; 5781da177e4SLinus Torvalds out: return ret; 5791da177e4SLinus Torvalds } 5801da177e4SLinus Torvalds 5811da177e4SLinus Torvalds /* 5821da177e4SLinus Torvalds * This should be easy, if there is something there 5831da177e4SLinus Torvalds * we return it, otherwise we block. 5841da177e4SLinus Torvalds */ 5851da177e4SLinus Torvalds 5861da177e4SLinus Torvalds static int raw_recvmsg(struct kiocb *iocb, struct sock *sk, struct msghdr *msg, 5871da177e4SLinus Torvalds size_t len, int noblock, int flags, int *addr_len) 5881da177e4SLinus Torvalds { 5891da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sk); 5901da177e4SLinus Torvalds size_t copied = 0; 5911da177e4SLinus Torvalds int err = -EOPNOTSUPP; 5921da177e4SLinus Torvalds struct sockaddr_in *sin = (struct sockaddr_in *)msg->msg_name; 5931da177e4SLinus Torvalds struct sk_buff *skb; 5941da177e4SLinus Torvalds 5951da177e4SLinus Torvalds if (flags & MSG_OOB) 5961da177e4SLinus Torvalds goto out; 5971da177e4SLinus Torvalds 5981da177e4SLinus Torvalds if (addr_len) 5991da177e4SLinus Torvalds *addr_len = sizeof(*sin); 6001da177e4SLinus Torvalds 6011da177e4SLinus Torvalds if (flags & MSG_ERRQUEUE) { 6021da177e4SLinus Torvalds err = ip_recv_error(sk, msg, len); 6031da177e4SLinus Torvalds goto out; 6041da177e4SLinus Torvalds } 6051da177e4SLinus Torvalds 6061da177e4SLinus Torvalds skb = skb_recv_datagram(sk, flags, noblock, &err); 6071da177e4SLinus Torvalds if (!skb) 6081da177e4SLinus Torvalds goto out; 6091da177e4SLinus Torvalds 6101da177e4SLinus Torvalds copied = skb->len; 6111da177e4SLinus Torvalds if (len < copied) { 6121da177e4SLinus Torvalds msg->msg_flags |= MSG_TRUNC; 6131da177e4SLinus Torvalds copied = len; 6141da177e4SLinus Torvalds } 6151da177e4SLinus Torvalds 6161da177e4SLinus Torvalds err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 6171da177e4SLinus Torvalds if (err) 6181da177e4SLinus Torvalds goto done; 6191da177e4SLinus Torvalds 6201da177e4SLinus Torvalds sock_recv_timestamp(msg, sk, skb); 6211da177e4SLinus Torvalds 6221da177e4SLinus Torvalds /* Copy the address. */ 6231da177e4SLinus Torvalds if (sin) { 6241da177e4SLinus Torvalds sin->sin_family = AF_INET; 625eddc9ec5SArnaldo Carvalho de Melo sin->sin_addr.s_addr = ip_hdr(skb)->saddr; 626f59fc7f3STetsuo Handa sin->sin_port = 0; 6271da177e4SLinus Torvalds memset(&sin->sin_zero, 0, sizeof(sin->sin_zero)); 6281da177e4SLinus Torvalds } 6291da177e4SLinus Torvalds if (inet->cmsg_flags) 6301da177e4SLinus Torvalds ip_cmsg_recv(msg, skb); 6311da177e4SLinus Torvalds if (flags & MSG_TRUNC) 6321da177e4SLinus Torvalds copied = skb->len; 6331da177e4SLinus Torvalds done: 6341da177e4SLinus Torvalds skb_free_datagram(sk, skb); 6355418c692SJesper Juhl out: 6365418c692SJesper Juhl if (err) 6375418c692SJesper Juhl return err; 6385418c692SJesper Juhl return copied; 6391da177e4SLinus Torvalds } 6401da177e4SLinus Torvalds 6411da177e4SLinus Torvalds static int raw_init(struct sock *sk) 6421da177e4SLinus Torvalds { 6431da177e4SLinus Torvalds struct raw_sock *rp = raw_sk(sk); 6441da177e4SLinus Torvalds 6451da177e4SLinus Torvalds if (inet_sk(sk)->num == IPPROTO_ICMP) 6461da177e4SLinus Torvalds memset(&rp->filter, 0, sizeof(rp->filter)); 6471da177e4SLinus Torvalds return 0; 6481da177e4SLinus Torvalds } 6491da177e4SLinus Torvalds 6501da177e4SLinus Torvalds static int raw_seticmpfilter(struct sock *sk, char __user *optval, int optlen) 6511da177e4SLinus Torvalds { 6521da177e4SLinus Torvalds if (optlen > sizeof(struct icmp_filter)) 6531da177e4SLinus Torvalds optlen = sizeof(struct icmp_filter); 6541da177e4SLinus Torvalds if (copy_from_user(&raw_sk(sk)->filter, optval, optlen)) 6551da177e4SLinus Torvalds return -EFAULT; 6561da177e4SLinus Torvalds return 0; 6571da177e4SLinus Torvalds } 6581da177e4SLinus Torvalds 6591da177e4SLinus Torvalds static int raw_geticmpfilter(struct sock *sk, char __user *optval, int __user *optlen) 6601da177e4SLinus Torvalds { 6611da177e4SLinus Torvalds int len, ret = -EFAULT; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds if (get_user(len, optlen)) 6641da177e4SLinus Torvalds goto out; 6651da177e4SLinus Torvalds ret = -EINVAL; 6661da177e4SLinus Torvalds if (len < 0) 6671da177e4SLinus Torvalds goto out; 6681da177e4SLinus Torvalds if (len > sizeof(struct icmp_filter)) 6691da177e4SLinus Torvalds len = sizeof(struct icmp_filter); 6701da177e4SLinus Torvalds ret = -EFAULT; 6711da177e4SLinus Torvalds if (put_user(len, optlen) || 6721da177e4SLinus Torvalds copy_to_user(optval, &raw_sk(sk)->filter, len)) 6731da177e4SLinus Torvalds goto out; 6741da177e4SLinus Torvalds ret = 0; 6751da177e4SLinus Torvalds out: return ret; 6761da177e4SLinus Torvalds } 6771da177e4SLinus Torvalds 6783fdadf7dSDmitry Mishin static int do_raw_setsockopt(struct sock *sk, int level, int optname, 6791da177e4SLinus Torvalds char __user *optval, int optlen) 6801da177e4SLinus Torvalds { 6811da177e4SLinus Torvalds if (optname == ICMP_FILTER) { 6821da177e4SLinus Torvalds if (inet_sk(sk)->num != IPPROTO_ICMP) 6831da177e4SLinus Torvalds return -EOPNOTSUPP; 6841da177e4SLinus Torvalds else 6851da177e4SLinus Torvalds return raw_seticmpfilter(sk, optval, optlen); 6861da177e4SLinus Torvalds } 6871da177e4SLinus Torvalds return -ENOPROTOOPT; 6881da177e4SLinus Torvalds } 6891da177e4SLinus Torvalds 6903fdadf7dSDmitry Mishin static int raw_setsockopt(struct sock *sk, int level, int optname, 6913fdadf7dSDmitry Mishin char __user *optval, int optlen) 6921da177e4SLinus Torvalds { 6931da177e4SLinus Torvalds if (level != SOL_RAW) 6943fdadf7dSDmitry Mishin return ip_setsockopt(sk, level, optname, optval, optlen); 6953fdadf7dSDmitry Mishin return do_raw_setsockopt(sk, level, optname, optval, optlen); 6963fdadf7dSDmitry Mishin } 6971da177e4SLinus Torvalds 6983fdadf7dSDmitry Mishin #ifdef CONFIG_COMPAT 6993fdadf7dSDmitry Mishin static int compat_raw_setsockopt(struct sock *sk, int level, int optname, 7003fdadf7dSDmitry Mishin char __user *optval, int optlen) 7013fdadf7dSDmitry Mishin { 7023fdadf7dSDmitry Mishin if (level != SOL_RAW) 703543d9cfeSArnaldo Carvalho de Melo return compat_ip_setsockopt(sk, level, optname, optval, optlen); 7043fdadf7dSDmitry Mishin return do_raw_setsockopt(sk, level, optname, optval, optlen); 7053fdadf7dSDmitry Mishin } 7063fdadf7dSDmitry Mishin #endif 7073fdadf7dSDmitry Mishin 7083fdadf7dSDmitry Mishin static int do_raw_getsockopt(struct sock *sk, int level, int optname, 7093fdadf7dSDmitry Mishin char __user *optval, int __user *optlen) 7103fdadf7dSDmitry Mishin { 7111da177e4SLinus Torvalds if (optname == ICMP_FILTER) { 7121da177e4SLinus Torvalds if (inet_sk(sk)->num != IPPROTO_ICMP) 7131da177e4SLinus Torvalds return -EOPNOTSUPP; 7141da177e4SLinus Torvalds else 7151da177e4SLinus Torvalds return raw_geticmpfilter(sk, optval, optlen); 7161da177e4SLinus Torvalds } 7171da177e4SLinus Torvalds return -ENOPROTOOPT; 7181da177e4SLinus Torvalds } 7191da177e4SLinus Torvalds 7203fdadf7dSDmitry Mishin static int raw_getsockopt(struct sock *sk, int level, int optname, 7213fdadf7dSDmitry Mishin char __user *optval, int __user *optlen) 7223fdadf7dSDmitry Mishin { 7233fdadf7dSDmitry Mishin if (level != SOL_RAW) 7243fdadf7dSDmitry Mishin return ip_getsockopt(sk, level, optname, optval, optlen); 7253fdadf7dSDmitry Mishin return do_raw_getsockopt(sk, level, optname, optval, optlen); 7263fdadf7dSDmitry Mishin } 7273fdadf7dSDmitry Mishin 7283fdadf7dSDmitry Mishin #ifdef CONFIG_COMPAT 7293fdadf7dSDmitry Mishin static int compat_raw_getsockopt(struct sock *sk, int level, int optname, 7303fdadf7dSDmitry Mishin char __user *optval, int __user *optlen) 7313fdadf7dSDmitry Mishin { 7323fdadf7dSDmitry Mishin if (level != SOL_RAW) 733543d9cfeSArnaldo Carvalho de Melo return compat_ip_getsockopt(sk, level, optname, optval, optlen); 7343fdadf7dSDmitry Mishin return do_raw_getsockopt(sk, level, optname, optval, optlen); 7353fdadf7dSDmitry Mishin } 7363fdadf7dSDmitry Mishin #endif 7373fdadf7dSDmitry Mishin 7381da177e4SLinus Torvalds static int raw_ioctl(struct sock *sk, int cmd, unsigned long arg) 7391da177e4SLinus Torvalds { 7401da177e4SLinus Torvalds switch (cmd) { 7411da177e4SLinus Torvalds case SIOCOUTQ: { 7421da177e4SLinus Torvalds int amount = atomic_read(&sk->sk_wmem_alloc); 7431da177e4SLinus Torvalds return put_user(amount, (int __user *)arg); 7441da177e4SLinus Torvalds } 7451da177e4SLinus Torvalds case SIOCINQ: { 7461da177e4SLinus Torvalds struct sk_buff *skb; 7471da177e4SLinus Torvalds int amount = 0; 7481da177e4SLinus Torvalds 749e0f9f858SHerbert Xu spin_lock_bh(&sk->sk_receive_queue.lock); 7501da177e4SLinus Torvalds skb = skb_peek(&sk->sk_receive_queue); 7511da177e4SLinus Torvalds if (skb != NULL) 7521da177e4SLinus Torvalds amount = skb->len; 753e0f9f858SHerbert Xu spin_unlock_bh(&sk->sk_receive_queue.lock); 7541da177e4SLinus Torvalds return put_user(amount, (int __user *)arg); 7551da177e4SLinus Torvalds } 7561da177e4SLinus Torvalds 7571da177e4SLinus Torvalds default: 7581da177e4SLinus Torvalds #ifdef CONFIG_IP_MROUTE 7591da177e4SLinus Torvalds return ipmr_ioctl(sk, cmd, (void __user *)arg); 7601da177e4SLinus Torvalds #else 7611da177e4SLinus Torvalds return -ENOIOCTLCMD; 7621da177e4SLinus Torvalds #endif 7631da177e4SLinus Torvalds } 7641da177e4SLinus Torvalds } 7651da177e4SLinus Torvalds 76647a31a6fSEric Dumazet DEFINE_PROTO_INUSE(raw) 76747a31a6fSEric Dumazet 7681da177e4SLinus Torvalds struct proto raw_prot = { 7691da177e4SLinus Torvalds .name = "RAW", 7701da177e4SLinus Torvalds .owner = THIS_MODULE, 7711da177e4SLinus Torvalds .close = raw_close, 7721da177e4SLinus Torvalds .connect = ip4_datagram_connect, 7731da177e4SLinus Torvalds .disconnect = udp_disconnect, 7741da177e4SLinus Torvalds .ioctl = raw_ioctl, 7751da177e4SLinus Torvalds .init = raw_init, 7761da177e4SLinus Torvalds .setsockopt = raw_setsockopt, 7771da177e4SLinus Torvalds .getsockopt = raw_getsockopt, 7781da177e4SLinus Torvalds .sendmsg = raw_sendmsg, 7791da177e4SLinus Torvalds .recvmsg = raw_recvmsg, 7801da177e4SLinus Torvalds .bind = raw_bind, 7811da177e4SLinus Torvalds .backlog_rcv = raw_rcv_skb, 7821da177e4SLinus Torvalds .hash = raw_v4_hash, 7831da177e4SLinus Torvalds .unhash = raw_v4_unhash, 7841da177e4SLinus Torvalds .obj_size = sizeof(struct raw_sock), 785543d9cfeSArnaldo Carvalho de Melo #ifdef CONFIG_COMPAT 786543d9cfeSArnaldo Carvalho de Melo .compat_setsockopt = compat_raw_setsockopt, 787543d9cfeSArnaldo Carvalho de Melo .compat_getsockopt = compat_raw_getsockopt, 788543d9cfeSArnaldo Carvalho de Melo #endif 78947a31a6fSEric Dumazet REF_PROTO_INUSE(raw) 7901da177e4SLinus Torvalds }; 7911da177e4SLinus Torvalds 7921da177e4SLinus Torvalds #ifdef CONFIG_PROC_FS 7931da177e4SLinus Torvalds struct raw_iter_state { 7941da177e4SLinus Torvalds int bucket; 7951da177e4SLinus Torvalds }; 7961da177e4SLinus Torvalds 7971da177e4SLinus Torvalds #define raw_seq_private(seq) ((struct raw_iter_state *)(seq)->private) 7981da177e4SLinus Torvalds 7991da177e4SLinus Torvalds static struct sock *raw_get_first(struct seq_file *seq) 8001da177e4SLinus Torvalds { 8011da177e4SLinus Torvalds struct sock *sk; 8021da177e4SLinus Torvalds struct raw_iter_state* state = raw_seq_private(seq); 8031da177e4SLinus Torvalds 8041da177e4SLinus Torvalds for (state->bucket = 0; state->bucket < RAWV4_HTABLE_SIZE; ++state->bucket) { 8051da177e4SLinus Torvalds struct hlist_node *node; 8061da177e4SLinus Torvalds 8071da177e4SLinus Torvalds sk_for_each(sk, node, &raw_v4_htable[state->bucket]) 8081da177e4SLinus Torvalds if (sk->sk_family == PF_INET) 8091da177e4SLinus Torvalds goto found; 8101da177e4SLinus Torvalds } 8111da177e4SLinus Torvalds sk = NULL; 8121da177e4SLinus Torvalds found: 8131da177e4SLinus Torvalds return sk; 8141da177e4SLinus Torvalds } 8151da177e4SLinus Torvalds 8161da177e4SLinus Torvalds static struct sock *raw_get_next(struct seq_file *seq, struct sock *sk) 8171da177e4SLinus Torvalds { 8181da177e4SLinus Torvalds struct raw_iter_state* state = raw_seq_private(seq); 8191da177e4SLinus Torvalds 8201da177e4SLinus Torvalds do { 8211da177e4SLinus Torvalds sk = sk_next(sk); 8221da177e4SLinus Torvalds try_again: 8231da177e4SLinus Torvalds ; 8241da177e4SLinus Torvalds } while (sk && sk->sk_family != PF_INET); 8251da177e4SLinus Torvalds 8261da177e4SLinus Torvalds if (!sk && ++state->bucket < RAWV4_HTABLE_SIZE) { 8271da177e4SLinus Torvalds sk = sk_head(&raw_v4_htable[state->bucket]); 8281da177e4SLinus Torvalds goto try_again; 8291da177e4SLinus Torvalds } 8301da177e4SLinus Torvalds return sk; 8311da177e4SLinus Torvalds } 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds static struct sock *raw_get_idx(struct seq_file *seq, loff_t pos) 8341da177e4SLinus Torvalds { 8351da177e4SLinus Torvalds struct sock *sk = raw_get_first(seq); 8361da177e4SLinus Torvalds 8371da177e4SLinus Torvalds if (sk) 8381da177e4SLinus Torvalds while (pos && (sk = raw_get_next(seq, sk)) != NULL) 8391da177e4SLinus Torvalds --pos; 8401da177e4SLinus Torvalds return pos ? NULL : sk; 8411da177e4SLinus Torvalds } 8421da177e4SLinus Torvalds 8431da177e4SLinus Torvalds static void *raw_seq_start(struct seq_file *seq, loff_t *pos) 8441da177e4SLinus Torvalds { 8451da177e4SLinus Torvalds read_lock(&raw_v4_lock); 8461da177e4SLinus Torvalds return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN; 8471da177e4SLinus Torvalds } 8481da177e4SLinus Torvalds 8491da177e4SLinus Torvalds static void *raw_seq_next(struct seq_file *seq, void *v, loff_t *pos) 8501da177e4SLinus Torvalds { 8511da177e4SLinus Torvalds struct sock *sk; 8521da177e4SLinus Torvalds 8531da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 8541da177e4SLinus Torvalds sk = raw_get_first(seq); 8551da177e4SLinus Torvalds else 8561da177e4SLinus Torvalds sk = raw_get_next(seq, v); 8571da177e4SLinus Torvalds ++*pos; 8581da177e4SLinus Torvalds return sk; 8591da177e4SLinus Torvalds } 8601da177e4SLinus Torvalds 8611da177e4SLinus Torvalds static void raw_seq_stop(struct seq_file *seq, void *v) 8621da177e4SLinus Torvalds { 8631da177e4SLinus Torvalds read_unlock(&raw_v4_lock); 8641da177e4SLinus Torvalds } 8651da177e4SLinus Torvalds 8661da177e4SLinus Torvalds static __inline__ char *get_raw_sock(struct sock *sp, char *tmpbuf, int i) 8671da177e4SLinus Torvalds { 8681da177e4SLinus Torvalds struct inet_sock *inet = inet_sk(sp); 869714e85beSAl Viro __be32 dest = inet->daddr, 8701da177e4SLinus Torvalds src = inet->rcv_saddr; 8711da177e4SLinus Torvalds __u16 destp = 0, 8721da177e4SLinus Torvalds srcp = inet->num; 8731da177e4SLinus Torvalds 8741da177e4SLinus Torvalds sprintf(tmpbuf, "%4d: %08X:%04X %08X:%04X" 875*33c732c3SWang Chen " %02X %08X:%08X %02X:%08lX %08X %5d %8d %lu %d %p %d", 8761da177e4SLinus Torvalds i, src, srcp, dest, destp, sp->sk_state, 8771da177e4SLinus Torvalds atomic_read(&sp->sk_wmem_alloc), 8781da177e4SLinus Torvalds atomic_read(&sp->sk_rmem_alloc), 8791da177e4SLinus Torvalds 0, 0L, 0, sock_i_uid(sp), 0, sock_i_ino(sp), 880*33c732c3SWang Chen atomic_read(&sp->sk_refcnt), sp, atomic_read(&sp->sk_drops)); 8811da177e4SLinus Torvalds return tmpbuf; 8821da177e4SLinus Torvalds } 8831da177e4SLinus Torvalds 884*33c732c3SWang Chen #define TMPSZ 128 885*33c732c3SWang Chen 8861da177e4SLinus Torvalds static int raw_seq_show(struct seq_file *seq, void *v) 8871da177e4SLinus Torvalds { 888*33c732c3SWang Chen char tmpbuf[TMPSZ+1]; 8891da177e4SLinus Torvalds 8901da177e4SLinus Torvalds if (v == SEQ_START_TOKEN) 891*33c732c3SWang Chen seq_printf(seq, "%-*s\n", TMPSZ-1, 8921da177e4SLinus Torvalds " sl local_address rem_address st tx_queue " 8931da177e4SLinus Torvalds "rx_queue tr tm->when retrnsmt uid timeout " 894*33c732c3SWang Chen "inode drops"); 8951da177e4SLinus Torvalds else { 8961da177e4SLinus Torvalds struct raw_iter_state *state = raw_seq_private(seq); 8971da177e4SLinus Torvalds 898*33c732c3SWang Chen seq_printf(seq, "%-*s\n", TMPSZ-1, 8991da177e4SLinus Torvalds get_raw_sock(v, tmpbuf, state->bucket)); 9001da177e4SLinus Torvalds } 9011da177e4SLinus Torvalds return 0; 9021da177e4SLinus Torvalds } 9031da177e4SLinus Torvalds 904f690808eSStephen Hemminger static const struct seq_operations raw_seq_ops = { 9051da177e4SLinus Torvalds .start = raw_seq_start, 9061da177e4SLinus Torvalds .next = raw_seq_next, 9071da177e4SLinus Torvalds .stop = raw_seq_stop, 9081da177e4SLinus Torvalds .show = raw_seq_show, 9091da177e4SLinus Torvalds }; 9101da177e4SLinus Torvalds 9111da177e4SLinus Torvalds static int raw_seq_open(struct inode *inode, struct file *file) 9121da177e4SLinus Torvalds { 913cf7732e4SPavel Emelyanov return seq_open_private(file, &raw_seq_ops, 914cf7732e4SPavel Emelyanov sizeof(struct raw_iter_state)); 9151da177e4SLinus Torvalds } 9161da177e4SLinus Torvalds 9179a32144eSArjan van de Ven static const struct file_operations raw_seq_fops = { 9181da177e4SLinus Torvalds .owner = THIS_MODULE, 9191da177e4SLinus Torvalds .open = raw_seq_open, 9201da177e4SLinus Torvalds .read = seq_read, 9211da177e4SLinus Torvalds .llseek = seq_lseek, 9221da177e4SLinus Torvalds .release = seq_release_private, 9231da177e4SLinus Torvalds }; 9241da177e4SLinus Torvalds 9251da177e4SLinus Torvalds int __init raw_proc_init(void) 9261da177e4SLinus Torvalds { 927457c4cbcSEric W. Biederman if (!proc_net_fops_create(&init_net, "raw", S_IRUGO, &raw_seq_fops)) 9281da177e4SLinus Torvalds return -ENOMEM; 9291da177e4SLinus Torvalds return 0; 9301da177e4SLinus Torvalds } 9311da177e4SLinus Torvalds 9321da177e4SLinus Torvalds void __init raw_proc_exit(void) 9331da177e4SLinus Torvalds { 934457c4cbcSEric W. Biederman proc_net_remove(&init_net, "raw"); 9351da177e4SLinus Torvalds } 9361da177e4SLinus Torvalds #endif /* CONFIG_PROC_FS */ 937