LCOV - code coverage report
Current view: top level - net/ipv4 - raw.c (source / functions) Hit Total Coverage
Test: Real Lines: 51 395 12.9 %
Date: 2020-10-17 15:46:16 Functions: 0 39 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  * INET         An implementation of the TCP/IP protocol suite for the LINUX
       4                 :            :  *              operating system.  INET is implemented using the  BSD Socket
       5                 :            :  *              interface as the means of communication with the user level.
       6                 :            :  *
       7                 :            :  *              RAW - implementation of IP "raw" sockets.
       8                 :            :  *
       9                 :            :  * Authors:     Ross Biro
      10                 :            :  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
      11                 :            :  *
      12                 :            :  * Fixes:
      13                 :            :  *              Alan Cox        :       verify_area() fixed up
      14                 :            :  *              Alan Cox        :       ICMP error handling
      15                 :            :  *              Alan Cox        :       EMSGSIZE if you send too big a packet
      16                 :            :  *              Alan Cox        :       Now uses generic datagrams and shared
      17                 :            :  *                                      skbuff library. No more peek crashes,
      18                 :            :  *                                      no more backlogs
      19                 :            :  *              Alan Cox        :       Checks sk->broadcast.
      20                 :            :  *              Alan Cox        :       Uses skb_free_datagram/skb_copy_datagram
      21                 :            :  *              Alan Cox        :       Raw passes ip options too
      22                 :            :  *              Alan Cox        :       Setsocketopt added
      23                 :            :  *              Alan Cox        :       Fixed error return for broadcasts
      24                 :            :  *              Alan Cox        :       Removed wake_up calls
      25                 :            :  *              Alan Cox        :       Use ttl/tos
      26                 :            :  *              Alan Cox        :       Cleaned up old debugging
      27                 :            :  *              Alan Cox        :       Use new kernel side addresses
      28                 :            :  *      Arnt Gulbrandsen        :       Fixed MSG_DONTROUTE in raw sockets.
      29                 :            :  *              Alan Cox        :       BSD style RAW socket demultiplexing.
      30                 :            :  *              Alan Cox        :       Beginnings of mrouted support.
      31                 :            :  *              Alan Cox        :       Added IP_HDRINCL option.
      32                 :            :  *              Alan Cox        :       Skip broadcast check if BSDism set.
      33                 :            :  *              David S. Miller :       New socket lookup architecture.
      34                 :            :  */
      35                 :            : 
      36                 :            : #include <linux/types.h>
      37                 :            : #include <linux/atomic.h>
      38                 :            : #include <asm/byteorder.h>
      39                 :            : #include <asm/current.h>
      40                 :            : #include <linux/uaccess.h>
      41                 :            : #include <asm/ioctls.h>
      42                 :            : #include <linux/stddef.h>
      43                 :            : #include <linux/slab.h>
      44                 :            : #include <linux/errno.h>
      45                 :            : #include <linux/kernel.h>
      46                 :            : #include <linux/export.h>
      47                 :            : #include <linux/spinlock.h>
      48                 :            : #include <linux/sockios.h>
      49                 :            : #include <linux/socket.h>
      50                 :            : #include <linux/in.h>
      51                 :            : #include <linux/mroute.h>
      52                 :            : #include <linux/netdevice.h>
      53                 :            : #include <linux/in_route.h>
      54                 :            : #include <linux/route.h>
      55                 :            : #include <linux/skbuff.h>
      56                 :            : #include <linux/igmp.h>
      57                 :            : #include <net/net_namespace.h>
      58                 :            : #include <net/dst.h>
      59                 :            : #include <net/sock.h>
      60                 :            : #include <linux/ip.h>
      61                 :            : #include <linux/net.h>
      62                 :            : #include <net/ip.h>
      63                 :            : #include <net/icmp.h>
      64                 :            : #include <net/udp.h>
      65                 :            : #include <net/raw.h>
      66                 :            : #include <net/snmp.h>
      67                 :            : #include <net/tcp_states.h>
      68                 :            : #include <net/inet_common.h>
      69                 :            : #include <net/checksum.h>
      70                 :            : #include <net/xfrm.h>
      71                 :            : #include <linux/rtnetlink.h>
      72                 :            : #include <linux/proc_fs.h>
      73                 :            : #include <linux/seq_file.h>
      74                 :            : #include <linux/netfilter.h>
      75                 :            : #include <linux/netfilter_ipv4.h>
      76                 :            : #include <linux/compat.h>
      77                 :            : #include <linux/uio.h>
      78                 :            : 
      79                 :            : struct raw_frag_vec {
      80                 :            :         struct msghdr *msg;
      81                 :            :         union {
      82                 :            :                 struct icmphdr icmph;
      83                 :            :                 char c[1];
      84                 :            :         } hdr;
      85                 :            :         int hlen;
      86                 :            : };
      87                 :            : 
      88                 :            : struct raw_hashinfo raw_v4_hashinfo = {
      89                 :            :         .lock = __RW_LOCK_UNLOCKED(raw_v4_hashinfo.lock),
      90                 :            : };
      91                 :            : EXPORT_SYMBOL_GPL(raw_v4_hashinfo);
      92                 :            : 
      93                 :          3 : int raw_hash_sk(struct sock *sk)
      94                 :            : {
      95                 :          3 :         struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
      96                 :            :         struct hlist_head *head;
      97                 :            : 
      98                 :          3 :         head = &h->ht[inet_sk(sk)->inet_num & (RAW_HTABLE_SIZE - 1)];
      99                 :            : 
     100                 :          3 :         write_lock_bh(&h->lock);
     101                 :            :         sk_add_node(sk, head);
     102                 :          3 :         sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1);
     103                 :          3 :         write_unlock_bh(&h->lock);
     104                 :            : 
     105                 :          3 :         return 0;
     106                 :            : }
     107                 :            : EXPORT_SYMBOL_GPL(raw_hash_sk);
     108                 :            : 
     109                 :          3 : void raw_unhash_sk(struct sock *sk)
     110                 :            : {
     111                 :          3 :         struct raw_hashinfo *h = sk->sk_prot->h.raw_hash;
     112                 :            : 
     113                 :          3 :         write_lock_bh(&h->lock);
     114                 :          3 :         if (sk_del_node_init(sk))
     115                 :          3 :                 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1);
     116                 :          3 :         write_unlock_bh(&h->lock);
     117                 :          3 : }
     118                 :            : EXPORT_SYMBOL_GPL(raw_unhash_sk);
     119                 :            : 
     120                 :          0 : struct sock *__raw_v4_lookup(struct net *net, struct sock *sk,
     121                 :            :                              unsigned short num, __be32 raddr, __be32 laddr,
     122                 :            :                              int dif, int sdif)
     123                 :            : {
     124                 :          0 :         sk_for_each_from(sk) {
     125                 :            :                 struct inet_sock *inet = inet_sk(sk);
     126                 :            : 
     127                 :          0 :                 if (net_eq(sock_net(sk), net) && inet->inet_num == num       &&
     128                 :          0 :                     !(inet->inet_daddr && inet->inet_daddr != raddr)      &&
     129                 :          0 :                     !(inet->inet_rcv_saddr && inet->inet_rcv_saddr != laddr) &&
     130                 :          0 :                     raw_sk_bound_dev_eq(net, sk->sk_bound_dev_if, dif, sdif))
     131                 :            :                         goto found; /* gotcha */
     132                 :            :         }
     133                 :            :         sk = NULL;
     134                 :            : found:
     135                 :          0 :         return sk;
     136                 :            : }
     137                 :            : EXPORT_SYMBOL_GPL(__raw_v4_lookup);
     138                 :            : 
     139                 :            : /*
     140                 :            :  *      0 - deliver
     141                 :            :  *      1 - block
     142                 :            :  */
     143                 :          0 : static int icmp_filter(const struct sock *sk, const struct sk_buff *skb)
     144                 :            : {
     145                 :            :         struct icmphdr _hdr;
     146                 :            :         const struct icmphdr *hdr;
     147                 :            : 
     148                 :            :         hdr = skb_header_pointer(skb, skb_transport_offset(skb),
     149                 :            :                                  sizeof(_hdr), &_hdr);
     150                 :          0 :         if (!hdr)
     151                 :            :                 return 1;
     152                 :            : 
     153                 :          0 :         if (hdr->type < 32) {
     154                 :          0 :                 __u32 data = raw_sk(sk)->filter.data;
     155                 :            : 
     156                 :          0 :                 return ((1U << hdr->type) & data) != 0;
     157                 :            :         }
     158                 :            : 
     159                 :            :         /* Do not block unknown ICMP types */
     160                 :            :         return 0;
     161                 :            : }
     162                 :            : 
     163                 :            : /* IP input processing comes here for RAW socket delivery.
     164                 :            :  * Caller owns SKB, so we must make clones.
     165                 :            :  *
     166                 :            :  * RFC 1122: SHOULD pass TOS value up to the transport layer.
     167                 :            :  * -> It does. And not only TOS, but all IP header.
     168                 :            :  */
     169                 :          0 : static int raw_v4_input(struct sk_buff *skb, const struct iphdr *iph, int hash)
     170                 :            : {
     171                 :            :         int sdif = inet_sdif(skb);
     172                 :            :         int dif = inet_iif(skb);
     173                 :            :         struct sock *sk;
     174                 :            :         struct hlist_head *head;
     175                 :            :         int delivered = 0;
     176                 :            :         struct net *net;
     177                 :            : 
     178                 :          0 :         read_lock(&raw_v4_hashinfo.lock);
     179                 :          0 :         head = &raw_v4_hashinfo.ht[hash];
     180                 :          0 :         if (hlist_empty(head))
     181                 :            :                 goto out;
     182                 :            : 
     183                 :          0 :         net = dev_net(skb->dev);
     184                 :          0 :         sk = __raw_v4_lookup(net, __sk_head(head), iph->protocol,
     185                 :            :                              iph->saddr, iph->daddr, dif, sdif);
     186                 :            : 
     187                 :          0 :         while (sk) {
     188                 :            :                 delivered = 1;
     189                 :          0 :                 if ((iph->protocol != IPPROTO_ICMP || !icmp_filter(sk, skb)) &&
     190                 :          0 :                     ip_mc_sf_allow(sk, iph->daddr, iph->saddr,
     191                 :          0 :                                    skb->dev->ifindex, sdif)) {
     192                 :          0 :                         struct sk_buff *clone = skb_clone(skb, GFP_ATOMIC);
     193                 :            : 
     194                 :            :                         /* Not releasing hash table! */
     195                 :          0 :                         if (clone)
     196                 :          0 :                                 raw_rcv(sk, clone);
     197                 :            :                 }
     198                 :          0 :                 sk = __raw_v4_lookup(net, sk_next(sk), iph->protocol,
     199                 :            :                                      iph->saddr, iph->daddr,
     200                 :            :                                      dif, sdif);
     201                 :            :         }
     202                 :            : out:
     203                 :            :         read_unlock(&raw_v4_hashinfo.lock);
     204                 :          0 :         return delivered;
     205                 :            : }
     206                 :            : 
     207                 :          3 : int raw_local_deliver(struct sk_buff *skb, int protocol)
     208                 :            : {
     209                 :            :         int hash;
     210                 :            :         struct sock *raw_sk;
     211                 :            : 
     212                 :          3 :         hash = protocol & (RAW_HTABLE_SIZE - 1);
     213                 :          3 :         raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
     214                 :            : 
     215                 :            :         /* If there maybe a raw socket we must check - if not we
     216                 :            :          * don't care less
     217                 :            :          */
     218                 :          3 :         if (raw_sk && !raw_v4_input(skb, ip_hdr(skb), hash))
     219                 :            :                 raw_sk = NULL;
     220                 :            : 
     221                 :          3 :         return raw_sk != NULL;
     222                 :            : 
     223                 :            : }
     224                 :            : 
     225                 :          0 : static void raw_err(struct sock *sk, struct sk_buff *skb, u32 info)
     226                 :            : {
     227                 :            :         struct inet_sock *inet = inet_sk(sk);
     228                 :          0 :         const int type = icmp_hdr(skb)->type;
     229                 :          0 :         const int code = icmp_hdr(skb)->code;
     230                 :            :         int err = 0;
     231                 :            :         int harderr = 0;
     232                 :            : 
     233                 :          0 :         if (type == ICMP_DEST_UNREACH && code == ICMP_FRAG_NEEDED)
     234                 :          0 :                 ipv4_sk_update_pmtu(skb, sk, info);
     235                 :          0 :         else if (type == ICMP_REDIRECT) {
     236                 :          0 :                 ipv4_sk_redirect(skb, sk);
     237                 :          0 :                 return;
     238                 :            :         }
     239                 :            : 
     240                 :            :         /* Report error on raw socket, if:
     241                 :            :            1. User requested ip_recverr.
     242                 :            :            2. Socket is connected (otherwise the error indication
     243                 :            :               is useless without ip_recverr and error is hard.
     244                 :            :          */
     245                 :          0 :         if (!inet->recverr && sk->sk_state != TCP_ESTABLISHED)
     246                 :            :                 return;
     247                 :            : 
     248                 :          0 :         switch (type) {
     249                 :            :         default:
     250                 :            :         case ICMP_TIME_EXCEEDED:
     251                 :            :                 err = EHOSTUNREACH;
     252                 :            :                 break;
     253                 :            :         case ICMP_SOURCE_QUENCH:
     254                 :            :                 return;
     255                 :            :         case ICMP_PARAMETERPROB:
     256                 :            :                 err = EPROTO;
     257                 :            :                 harderr = 1;
     258                 :          0 :                 break;
     259                 :            :         case ICMP_DEST_UNREACH:
     260                 :            :                 err = EHOSTUNREACH;
     261                 :          0 :                 if (code > NR_ICMP_UNREACH)
     262                 :            :                         break;
     263                 :          0 :                 err = icmp_err_convert[code].errno;
     264                 :          0 :                 harderr = icmp_err_convert[code].fatal;
     265                 :          0 :                 if (code == ICMP_FRAG_NEEDED) {
     266                 :          0 :                         harderr = inet->pmtudisc != IP_PMTUDISC_DONT;
     267                 :            :                         err = EMSGSIZE;
     268                 :            :                 }
     269                 :            :         }
     270                 :            : 
     271                 :          0 :         if (inet->recverr) {
     272                 :          0 :                 const struct iphdr *iph = (const struct iphdr *)skb->data;
     273                 :          0 :                 u8 *payload = skb->data + (iph->ihl << 2);
     274                 :            : 
     275                 :          0 :                 if (inet->hdrincl)
     276                 :            :                         payload = skb->data;
     277                 :          0 :                 ip_icmp_error(sk, skb, err, 0, info, payload);
     278                 :            :         }
     279                 :            : 
     280                 :          0 :         if (inet->recverr || harderr) {
     281                 :          0 :                 sk->sk_err = err;
     282                 :          0 :                 sk->sk_error_report(sk);
     283                 :            :         }
     284                 :            : }
     285                 :            : 
     286                 :          1 : void raw_icmp_error(struct sk_buff *skb, int protocol, u32 info)
     287                 :            : {
     288                 :            :         int hash;
     289                 :            :         struct sock *raw_sk;
     290                 :            :         const struct iphdr *iph;
     291                 :            :         struct net *net;
     292                 :            : 
     293                 :          1 :         hash = protocol & (RAW_HTABLE_SIZE - 1);
     294                 :            : 
     295                 :          1 :         read_lock(&raw_v4_hashinfo.lock);
     296                 :          1 :         raw_sk = sk_head(&raw_v4_hashinfo.ht[hash]);
     297                 :          1 :         if (raw_sk) {
     298                 :          0 :                 int dif = skb->dev->ifindex;
     299                 :            :                 int sdif = inet_sdif(skb);
     300                 :            : 
     301                 :          0 :                 iph = (const struct iphdr *)skb->data;
     302                 :            :                 net = dev_net(skb->dev);
     303                 :            : 
     304                 :          0 :                 while ((raw_sk = __raw_v4_lookup(net, raw_sk, protocol,
     305                 :            :                                                 iph->daddr, iph->saddr,
     306                 :            :                                                 dif, sdif)) != NULL) {
     307                 :          0 :                         raw_err(raw_sk, skb, info);
     308                 :            :                         raw_sk = sk_next(raw_sk);
     309                 :          0 :                         iph = (const struct iphdr *)skb->data;
     310                 :            :                 }
     311                 :            :         }
     312                 :            :         read_unlock(&raw_v4_hashinfo.lock);
     313                 :          1 : }
     314                 :            : 
     315                 :          0 : static int raw_rcv_skb(struct sock *sk, struct sk_buff *skb)
     316                 :            : {
     317                 :            :         /* Charge it to the socket. */
     318                 :            : 
     319                 :          0 :         ipv4_pktinfo_prepare(sk, skb);
     320                 :          0 :         if (sock_queue_rcv_skb(sk, skb) < 0) {
     321                 :          0 :                 kfree_skb(skb);
     322                 :          0 :                 return NET_RX_DROP;
     323                 :            :         }
     324                 :            : 
     325                 :            :         return NET_RX_SUCCESS;
     326                 :            : }
     327                 :            : 
     328                 :          0 : int raw_rcv(struct sock *sk, struct sk_buff *skb)
     329                 :            : {
     330                 :          0 :         if (!xfrm4_policy_check(sk, XFRM_POLICY_IN, skb)) {
     331                 :          0 :                 atomic_inc(&sk->sk_drops);
     332                 :          0 :                 kfree_skb(skb);
     333                 :          0 :                 return NET_RX_DROP;
     334                 :            :         }
     335                 :            :         nf_reset_ct(skb);
     336                 :            : 
     337                 :          0 :         skb_push(skb, skb->data - skb_network_header(skb));
     338                 :            : 
     339                 :          0 :         raw_rcv_skb(sk, skb);
     340                 :          0 :         return 0;
     341                 :            : }
     342                 :            : 
     343                 :          0 : static int raw_send_hdrinc(struct sock *sk, struct flowi4 *fl4,
     344                 :            :                            struct msghdr *msg, size_t length,
     345                 :            :                            struct rtable **rtp, unsigned int flags,
     346                 :            :                            const struct sockcm_cookie *sockc)
     347                 :            : {
     348                 :            :         struct inet_sock *inet = inet_sk(sk);
     349                 :            :         struct net *net = sock_net(sk);
     350                 :            :         struct iphdr *iph;
     351                 :            :         struct sk_buff *skb;
     352                 :            :         unsigned int iphlen;
     353                 :            :         int err;
     354                 :          0 :         struct rtable *rt = *rtp;
     355                 :            :         int hlen, tlen;
     356                 :            : 
     357                 :          0 :         if (length > rt->dst.dev->mtu) {
     358                 :          0 :                 ip_local_error(sk, EMSGSIZE, fl4->daddr, inet->inet_dport,
     359                 :            :                                rt->dst.dev->mtu);
     360                 :          0 :                 return -EMSGSIZE;
     361                 :            :         }
     362                 :          0 :         if (length < sizeof(struct iphdr))
     363                 :            :                 return -EINVAL;
     364                 :            : 
     365                 :          0 :         if (flags&MSG_PROBE)
     366                 :            :                 goto out;
     367                 :            : 
     368                 :          0 :         hlen = LL_RESERVED_SPACE(rt->dst.dev);
     369                 :          0 :         tlen = rt->dst.dev->needed_tailroom;
     370                 :          0 :         skb = sock_alloc_send_skb(sk,
     371                 :          0 :                                   length + hlen + tlen + 15,
     372                 :            :                                   flags & MSG_DONTWAIT, &err);
     373                 :          0 :         if (!skb)
     374                 :            :                 goto error;
     375                 :            :         skb_reserve(skb, hlen);
     376                 :            : 
     377                 :          0 :         skb->priority = sk->sk_priority;
     378                 :          0 :         skb->mark = sockc->mark;
     379                 :          0 :         skb->tstamp = sockc->transmit_time;
     380                 :          0 :         skb_dst_set(skb, &rt->dst);
     381                 :          0 :         *rtp = NULL;
     382                 :            : 
     383                 :            :         skb_reset_network_header(skb);
     384                 :            :         iph = ip_hdr(skb);
     385                 :          0 :         skb_put(skb, length);
     386                 :            : 
     387                 :          0 :         skb->ip_summed = CHECKSUM_NONE;
     388                 :            : 
     389                 :          0 :         skb_setup_tx_timestamp(skb, sockc->tsflags);
     390                 :            : 
     391                 :          0 :         if (flags & MSG_CONFIRM)
     392                 :            :                 skb_set_dst_pending_confirm(skb, 1);
     393                 :            : 
     394                 :          0 :         skb->transport_header = skb->network_header;
     395                 :          0 :         err = -EFAULT;
     396                 :          0 :         if (memcpy_from_msg(iph, msg, length))
     397                 :            :                 goto error_free;
     398                 :            : 
     399                 :          0 :         iphlen = iph->ihl * 4;
     400                 :            : 
     401                 :            :         /*
     402                 :            :          * We don't want to modify the ip header, but we do need to
     403                 :            :          * be sure that it won't cause problems later along the network
     404                 :            :          * stack.  Specifically we want to make sure that iph->ihl is a
     405                 :            :          * sane value.  If ihl points beyond the length of the buffer passed
     406                 :            :          * in, reject the frame as invalid
     407                 :            :          */
     408                 :          0 :         err = -EINVAL;
     409                 :          0 :         if (iphlen > length)
     410                 :            :                 goto error_free;
     411                 :            : 
     412                 :          0 :         if (iphlen >= sizeof(*iph)) {
     413                 :          0 :                 if (!iph->saddr)
     414                 :          0 :                         iph->saddr = fl4->saddr;
     415                 :          0 :                 iph->check   = 0;
     416                 :          0 :                 iph->tot_len = htons(length);
     417                 :          0 :                 if (!iph->id)
     418                 :            :                         ip_select_ident(net, skb, NULL);
     419                 :            : 
     420                 :          0 :                 iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
     421                 :          0 :                 skb->transport_header += iphlen;
     422                 :          0 :                 if (iph->protocol == IPPROTO_ICMP &&
     423                 :          0 :                     length >= iphlen + sizeof(struct icmphdr))
     424                 :          0 :                         icmp_out_count(net, ((struct icmphdr *)
     425                 :            :                                 skb_transport_header(skb))->type);
     426                 :            :         }
     427                 :            : 
     428                 :          0 :         err = NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_OUT,
     429                 :            :                       net, sk, skb, NULL, rt->dst.dev,
     430                 :            :                       dst_output);
     431                 :          0 :         if (err > 0)
     432                 :          0 :                 err = net_xmit_errno(err);
     433                 :          0 :         if (err)
     434                 :            :                 goto error;
     435                 :            : out:
     436                 :            :         return 0;
     437                 :            : 
     438                 :            : error_free:
     439                 :          0 :         kfree_skb(skb);
     440                 :            : error:
     441                 :          0 :         IP_INC_STATS(net, IPSTATS_MIB_OUTDISCARDS);
     442                 :          0 :         if (err == -ENOBUFS && !inet->recverr)
     443                 :          0 :                 err = 0;
     444                 :          0 :         return err;
     445                 :            : }
     446                 :            : 
     447                 :          0 : static int raw_probe_proto_opt(struct raw_frag_vec *rfv, struct flowi4 *fl4)
     448                 :            : {
     449                 :            :         int err;
     450                 :            : 
     451                 :          0 :         if (fl4->flowi4_proto != IPPROTO_ICMP)
     452                 :            :                 return 0;
     453                 :            : 
     454                 :            :         /* We only need the first two bytes. */
     455                 :          0 :         rfv->hlen = 2;
     456                 :            : 
     457                 :          0 :         err = memcpy_from_msg(rfv->hdr.c, rfv->msg, rfv->hlen);
     458                 :          0 :         if (err)
     459                 :            :                 return err;
     460                 :            : 
     461                 :          0 :         fl4->fl4_icmp_type = rfv->hdr.icmph.type;
     462                 :          0 :         fl4->fl4_icmp_code = rfv->hdr.icmph.code;
     463                 :            : 
     464                 :          0 :         return 0;
     465                 :            : }
     466                 :            : 
     467                 :          0 : static int raw_getfrag(void *from, char *to, int offset, int len, int odd,
     468                 :            :                        struct sk_buff *skb)
     469                 :            : {
     470                 :            :         struct raw_frag_vec *rfv = from;
     471                 :            : 
     472                 :          0 :         if (offset < rfv->hlen) {
     473                 :          0 :                 int copy = min(rfv->hlen - offset, len);
     474                 :            : 
     475                 :          0 :                 if (skb->ip_summed == CHECKSUM_PARTIAL)
     476                 :          0 :                         memcpy(to, rfv->hdr.c + offset, copy);
     477                 :            :                 else
     478                 :          0 :                         skb->csum = csum_block_add(
     479                 :            :                                 skb->csum,
     480                 :          0 :                                 csum_partial_copy_nocheck(rfv->hdr.c + offset,
     481                 :            :                                                           to, copy, 0),
     482                 :            :                                 odd);
     483                 :            : 
     484                 :            :                 odd = 0;
     485                 :          0 :                 offset += copy;
     486                 :          0 :                 to += copy;
     487                 :          0 :                 len -= copy;
     488                 :            : 
     489                 :          0 :                 if (!len)
     490                 :            :                         return 0;
     491                 :            :         }
     492                 :            : 
     493                 :          0 :         offset -= rfv->hlen;
     494                 :            : 
     495                 :          0 :         return ip_generic_getfrag(rfv->msg, to, offset, len, odd, skb);
     496                 :            : }
     497                 :            : 
     498                 :          0 : static int raw_sendmsg(struct sock *sk, struct msghdr *msg, size_t len)
     499                 :            : {
     500                 :            :         struct inet_sock *inet = inet_sk(sk);
     501                 :            :         struct net *net = sock_net(sk);
     502                 :            :         struct ipcm_cookie ipc;
     503                 :          0 :         struct rtable *rt = NULL;
     504                 :            :         struct flowi4 fl4;
     505                 :            :         int free = 0;
     506                 :            :         __be32 daddr;
     507                 :            :         __be32 saddr;
     508                 :            :         u8  tos;
     509                 :            :         int err;
     510                 :            :         struct ip_options_data opt_copy;
     511                 :            :         struct raw_frag_vec rfv;
     512                 :            :         int hdrincl;
     513                 :            : 
     514                 :            :         err = -EMSGSIZE;
     515                 :          0 :         if (len > 0xFFFF)
     516                 :            :                 goto out;
     517                 :            : 
     518                 :            :         /* hdrincl should be READ_ONCE(inet->hdrincl)
     519                 :            :          * but READ_ONCE() doesn't work with bit fields.
     520                 :            :          * Doing this indirectly yields the same result.
     521                 :            :          */
     522                 :          0 :         hdrincl = inet->hdrincl;
     523                 :          0 :         hdrincl = READ_ONCE(hdrincl);
     524                 :            :         /*
     525                 :            :          *      Check the flags.
     526                 :            :          */
     527                 :            : 
     528                 :            :         err = -EOPNOTSUPP;
     529                 :          0 :         if (msg->msg_flags & MSG_OOB)    /* Mirror BSD error message */
     530                 :            :                 goto out;               /* compatibility */
     531                 :            : 
     532                 :            :         /*
     533                 :            :          *      Get and verify the address.
     534                 :            :          */
     535                 :            : 
     536                 :          0 :         if (msg->msg_namelen) {
     537                 :          0 :                 DECLARE_SOCKADDR(struct sockaddr_in *, usin, msg->msg_name);
     538                 :            :                 err = -EINVAL;
     539                 :          0 :                 if (msg->msg_namelen < sizeof(*usin))
     540                 :            :                         goto out;
     541                 :          0 :                 if (usin->sin_family != AF_INET) {
     542                 :          0 :                         pr_info_once("%s: %s forgot to set AF_INET. Fix it!\n",
     543                 :            :                                      __func__, current->comm);
     544                 :            :                         err = -EAFNOSUPPORT;
     545                 :          0 :                         if (usin->sin_family)
     546                 :            :                                 goto out;
     547                 :            :                 }
     548                 :          0 :                 daddr = usin->sin_addr.s_addr;
     549                 :            :                 /* ANK: I did not forget to get protocol from port field.
     550                 :            :                  * I just do not know, who uses this weirdness.
     551                 :            :                  * IP_HDRINCL is much more convenient.
     552                 :            :                  */
     553                 :            :         } else {
     554                 :            :                 err = -EDESTADDRREQ;
     555                 :          0 :                 if (sk->sk_state != TCP_ESTABLISHED)
     556                 :            :                         goto out;
     557                 :          0 :                 daddr = inet->inet_daddr;
     558                 :            :         }
     559                 :            : 
     560                 :            :         ipcm_init_sk(&ipc, inet);
     561                 :            : 
     562                 :          0 :         if (msg->msg_controllen) {
     563                 :          0 :                 err = ip_cmsg_send(sk, msg, &ipc, false);
     564                 :          0 :                 if (unlikely(err)) {
     565                 :          0 :                         kfree(ipc.opt);
     566                 :          0 :                         goto out;
     567                 :            :                 }
     568                 :          0 :                 if (ipc.opt)
     569                 :            :                         free = 1;
     570                 :            :         }
     571                 :            : 
     572                 :          0 :         saddr = ipc.addr;
     573                 :          0 :         ipc.addr = daddr;
     574                 :            : 
     575                 :          0 :         if (!ipc.opt) {
     576                 :            :                 struct ip_options_rcu *inet_opt;
     577                 :            : 
     578                 :            :                 rcu_read_lock();
     579                 :          0 :                 inet_opt = rcu_dereference(inet->inet_opt);
     580                 :          0 :                 if (inet_opt) {
     581                 :          0 :                         memcpy(&opt_copy, inet_opt,
     582                 :          0 :                                sizeof(*inet_opt) + inet_opt->opt.optlen);
     583                 :          0 :                         ipc.opt = &opt_copy.opt;
     584                 :            :                 }
     585                 :            :                 rcu_read_unlock();
     586                 :            :         }
     587                 :            : 
     588                 :          0 :         if (ipc.opt) {
     589                 :            :                 err = -EINVAL;
     590                 :            :                 /* Linux does not mangle headers on raw sockets,
     591                 :            :                  * so that IP options + IP_HDRINCL is non-sense.
     592                 :            :                  */
     593                 :          0 :                 if (hdrincl)
     594                 :            :                         goto done;
     595                 :          0 :                 if (ipc.opt->opt.srr) {
     596                 :          0 :                         if (!daddr)
     597                 :            :                                 goto done;
     598                 :          0 :                         daddr = ipc.opt->opt.faddr;
     599                 :            :                 }
     600                 :            :         }
     601                 :            :         tos = get_rtconn_flags(&ipc, sk);
     602                 :          0 :         if (msg->msg_flags & MSG_DONTROUTE)
     603                 :          0 :                 tos |= RTO_ONLINK;
     604                 :            : 
     605                 :          0 :         if (ipv4_is_multicast(daddr)) {
     606                 :          0 :                 if (!ipc.oif || netif_index_is_l3_master(sock_net(sk), ipc.oif))
     607                 :          0 :                         ipc.oif = inet->mc_index;
     608                 :          0 :                 if (!saddr)
     609                 :          0 :                         saddr = inet->mc_addr;
     610                 :          0 :         } else if (!ipc.oif) {
     611                 :          0 :                 ipc.oif = inet->uc_index;
     612                 :          0 :         } else if (ipv4_is_lbcast(daddr) && inet->uc_index) {
     613                 :            :                 /* oif is set, packet is to local broadcast and
     614                 :            :                  * and uc_index is set. oif is most likely set
     615                 :            :                  * by sk_bound_dev_if. If uc_index != oif check if the
     616                 :            :                  * oif is an L3 master and uc_index is an L3 slave.
     617                 :            :                  * If so, we want to allow the send using the uc_index.
     618                 :            :                  */
     619                 :          0 :                 if (ipc.oif != inet->uc_index &&
     620                 :          0 :                     ipc.oif == l3mdev_master_ifindex_by_index(sock_net(sk),
     621                 :            :                                                               inet->uc_index)) {
     622                 :          0 :                         ipc.oif = inet->uc_index;
     623                 :            :                 }
     624                 :            :         }
     625                 :            : 
     626                 :          0 :         flowi4_init_output(&fl4, ipc.oif, ipc.sockc.mark, tos,
     627                 :            :                            RT_SCOPE_UNIVERSE,
     628                 :          0 :                            hdrincl ? IPPROTO_RAW : sk->sk_protocol,
     629                 :            :                            inet_sk_flowi_flags(sk) |
     630                 :            :                             (hdrincl ? FLOWI_FLAG_KNOWN_NH : 0),
     631                 :            :                            daddr, saddr, 0, 0, sk->sk_uid);
     632                 :            : 
     633                 :          0 :         if (!hdrincl) {
     634                 :          0 :                 rfv.msg = msg;
     635                 :          0 :                 rfv.hlen = 0;
     636                 :            : 
     637                 :          0 :                 err = raw_probe_proto_opt(&rfv, &fl4);
     638                 :          0 :                 if (err)
     639                 :            :                         goto done;
     640                 :            :         }
     641                 :            : 
     642                 :          0 :         security_sk_classify_flow(sk, flowi4_to_flowi(&fl4));
     643                 :          0 :         rt = ip_route_output_flow(net, &fl4, sk);
     644                 :          0 :         if (IS_ERR(rt)) {
     645                 :            :                 err = PTR_ERR(rt);
     646                 :          0 :                 rt = NULL;
     647                 :          0 :                 goto done;
     648                 :            :         }
     649                 :            : 
     650                 :            :         err = -EACCES;
     651                 :          0 :         if (rt->rt_flags & RTCF_BROADCAST && !sock_flag(sk, SOCK_BROADCAST))
     652                 :            :                 goto done;
     653                 :            : 
     654                 :          0 :         if (msg->msg_flags & MSG_CONFIRM)
     655                 :            :                 goto do_confirm;
     656                 :            : back_from_confirm:
     657                 :            : 
     658                 :          0 :         if (hdrincl)
     659                 :          0 :                 err = raw_send_hdrinc(sk, &fl4, msg, len,
     660                 :            :                                       &rt, msg->msg_flags, &ipc.sockc);
     661                 :            : 
     662                 :            :          else {
     663                 :          0 :                 if (!ipc.addr)
     664                 :          0 :                         ipc.addr = fl4.daddr;
     665                 :            :                 lock_sock(sk);
     666                 :          0 :                 err = ip_append_data(sk, &fl4, raw_getfrag,
     667                 :            :                                      &rfv, len, 0,
     668                 :            :                                      &ipc, &rt, msg->msg_flags);
     669                 :          0 :                 if (err)
     670                 :          0 :                         ip_flush_pending_frames(sk);
     671                 :          0 :                 else if (!(msg->msg_flags & MSG_MORE)) {
     672                 :          0 :                         err = ip_push_pending_frames(sk, &fl4);
     673                 :          0 :                         if (err == -ENOBUFS && !inet->recverr)
     674                 :            :                                 err = 0;
     675                 :            :                 }
     676                 :          0 :                 release_sock(sk);
     677                 :            :         }
     678                 :            : done:
     679                 :          0 :         if (free)
     680                 :          0 :                 kfree(ipc.opt);
     681                 :          0 :         ip_rt_put(rt);
     682                 :            : 
     683                 :            : out:
     684                 :          0 :         if (err < 0)
     685                 :            :                 return err;
     686                 :          0 :         return len;
     687                 :            : 
     688                 :            : do_confirm:
     689                 :          0 :         if (msg->msg_flags & MSG_PROBE)
     690                 :          0 :                 dst_confirm_neigh(&rt->dst, &fl4.daddr);
     691                 :          0 :         if (!(msg->msg_flags & MSG_PROBE) || len)
     692                 :            :                 goto back_from_confirm;
     693                 :            :         err = 0;
     694                 :            :         goto done;
     695                 :            : }
     696                 :            : 
     697                 :          1 : static void raw_close(struct sock *sk, long timeout)
     698                 :            : {
     699                 :            :         /*
     700                 :            :          * Raw sockets may have direct kernel references. Kill them.
     701                 :            :          */
     702                 :          1 :         ip_ra_control(sk, 0, NULL);
     703                 :            : 
     704                 :          1 :         sk_common_release(sk);
     705                 :          1 : }
     706                 :            : 
     707                 :          1 : static void raw_destroy(struct sock *sk)
     708                 :            : {
     709                 :            :         lock_sock(sk);
     710                 :          1 :         ip_flush_pending_frames(sk);
     711                 :          1 :         release_sock(sk);
     712                 :          1 : }
     713                 :            : 
     714                 :            : /* This gets rid of all the nasties in af_inet. -DaveM */
     715                 :          0 : static int raw_bind(struct sock *sk, struct sockaddr *uaddr, int addr_len)
     716                 :            : {
     717                 :            :         struct inet_sock *inet = inet_sk(sk);
     718                 :            :         struct sockaddr_in *addr = (struct sockaddr_in *) uaddr;
     719                 :            :         u32 tb_id = RT_TABLE_LOCAL;
     720                 :            :         int ret = -EINVAL;
     721                 :            :         int chk_addr_ret;
     722                 :            : 
     723                 :          0 :         if (sk->sk_state != TCP_CLOSE || addr_len < sizeof(struct sockaddr_in))
     724                 :            :                 goto out;
     725                 :            : 
     726                 :          0 :         if (sk->sk_bound_dev_if)
     727                 :          0 :                 tb_id = l3mdev_fib_table_by_index(sock_net(sk),
     728                 :          0 :                                                  sk->sk_bound_dev_if) ? : tb_id;
     729                 :            : 
     730                 :          0 :         chk_addr_ret = inet_addr_type_table(sock_net(sk), addr->sin_addr.s_addr,
     731                 :            :                                             tb_id);
     732                 :            : 
     733                 :            :         ret = -EADDRNOTAVAIL;
     734                 :          0 :         if (addr->sin_addr.s_addr && chk_addr_ret != RTN_LOCAL &&
     735                 :          0 :             chk_addr_ret != RTN_MULTICAST && chk_addr_ret != RTN_BROADCAST)
     736                 :            :                 goto out;
     737                 :          0 :         inet->inet_rcv_saddr = inet->inet_saddr = addr->sin_addr.s_addr;
     738                 :          0 :         if (chk_addr_ret == RTN_MULTICAST || chk_addr_ret == RTN_BROADCAST)
     739                 :          0 :                 inet->inet_saddr = 0;  /* Use device */
     740                 :            :         sk_dst_reset(sk);
     741                 :            :         ret = 0;
     742                 :          0 : out:    return ret;
     743                 :            : }
     744                 :            : 
     745                 :            : /*
     746                 :            :  *      This should be easy, if there is something there
     747                 :            :  *      we return it, otherwise we block.
     748                 :            :  */
     749                 :            : 
     750                 :          0 : static int raw_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
     751                 :            :                        int noblock, int flags, int *addr_len)
     752                 :            : {
     753                 :            :         struct inet_sock *inet = inet_sk(sk);
     754                 :            :         size_t copied = 0;
     755                 :          0 :         int err = -EOPNOTSUPP;
     756                 :          0 :         DECLARE_SOCKADDR(struct sockaddr_in *, sin, msg->msg_name);
     757                 :            :         struct sk_buff *skb;
     758                 :            : 
     759                 :          0 :         if (flags & MSG_OOB)
     760                 :            :                 goto out;
     761                 :            : 
     762                 :          0 :         if (flags & MSG_ERRQUEUE) {
     763                 :          0 :                 err = ip_recv_error(sk, msg, len, addr_len);
     764                 :          0 :                 goto out;
     765                 :            :         }
     766                 :            : 
     767                 :          0 :         skb = skb_recv_datagram(sk, flags, noblock, &err);
     768                 :          0 :         if (!skb)
     769                 :            :                 goto out;
     770                 :            : 
     771                 :          0 :         copied = skb->len;
     772                 :          0 :         if (len < copied) {
     773                 :          0 :                 msg->msg_flags |= MSG_TRUNC;
     774                 :            :                 copied = len;
     775                 :            :         }
     776                 :            : 
     777                 :          0 :         err = skb_copy_datagram_msg(skb, 0, msg, copied);
     778                 :          0 :         if (err)
     779                 :            :                 goto done;
     780                 :            : 
     781                 :          0 :         sock_recv_ts_and_drops(msg, sk, skb);
     782                 :            : 
     783                 :            :         /* Copy the address. */
     784                 :          0 :         if (sin) {
     785                 :          0 :                 sin->sin_family = AF_INET;
     786                 :          0 :                 sin->sin_addr.s_addr = ip_hdr(skb)->saddr;
     787                 :          0 :                 sin->sin_port = 0;
     788                 :          0 :                 memset(&sin->sin_zero, 0, sizeof(sin->sin_zero));
     789                 :          0 :                 *addr_len = sizeof(*sin);
     790                 :            :         }
     791                 :          0 :         if (inet->cmsg_flags)
     792                 :            :                 ip_cmsg_recv(msg, skb);
     793                 :          0 :         if (flags & MSG_TRUNC)
     794                 :          0 :                 copied = skb->len;
     795                 :            : done:
     796                 :          0 :         skb_free_datagram(sk, skb);
     797                 :            : out:
     798                 :          0 :         if (err)
     799                 :            :                 return err;
     800                 :          0 :         return copied;
     801                 :            : }
     802                 :            : 
     803                 :          3 : static int raw_sk_init(struct sock *sk)
     804                 :            : {
     805                 :            :         struct raw_sock *rp = raw_sk(sk);
     806                 :            : 
     807                 :          3 :         if (inet_sk(sk)->inet_num == IPPROTO_ICMP)
     808                 :          3 :                 memset(&rp->filter, 0, sizeof(rp->filter));
     809                 :          3 :         return 0;
     810                 :            : }
     811                 :            : 
     812                 :          0 : static int raw_seticmpfilter(struct sock *sk, char __user *optval, int optlen)
     813                 :            : {
     814                 :          0 :         if (optlen > sizeof(struct icmp_filter))
     815                 :            :                 optlen = sizeof(struct icmp_filter);
     816                 :          0 :         if (copy_from_user(&raw_sk(sk)->filter, optval, optlen))
     817                 :            :                 return -EFAULT;
     818                 :          0 :         return 0;
     819                 :            : }
     820                 :            : 
     821                 :          0 : static int raw_geticmpfilter(struct sock *sk, char __user *optval, int __user *optlen)
     822                 :            : {
     823                 :            :         int len, ret = -EFAULT;
     824                 :            : 
     825                 :          0 :         if (get_user(len, optlen))
     826                 :            :                 goto out;
     827                 :            :         ret = -EINVAL;
     828                 :          0 :         if (len < 0)
     829                 :            :                 goto out;
     830                 :          0 :         if (len > sizeof(struct icmp_filter))
     831                 :            :                 len = sizeof(struct icmp_filter);
     832                 :            :         ret = -EFAULT;
     833                 :          0 :         if (put_user(len, optlen) ||
     834                 :          0 :             copy_to_user(optval, &raw_sk(sk)->filter, len))
     835                 :            :                 goto out;
     836                 :            :         ret = 0;
     837                 :          0 : out:    return ret;
     838                 :            : }
     839                 :            : 
     840                 :            : static int do_raw_setsockopt(struct sock *sk, int level, int optname,
     841                 :            :                           char __user *optval, unsigned int optlen)
     842                 :            : {
     843                 :          0 :         if (optname == ICMP_FILTER) {
     844                 :          0 :                 if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
     845                 :            :                         return -EOPNOTSUPP;
     846                 :            :                 else
     847                 :          0 :                         return raw_seticmpfilter(sk, optval, optlen);
     848                 :            :         }
     849                 :            :         return -ENOPROTOOPT;
     850                 :            : }
     851                 :            : 
     852                 :          0 : static int raw_setsockopt(struct sock *sk, int level, int optname,
     853                 :            :                           char __user *optval, unsigned int optlen)
     854                 :            : {
     855                 :          0 :         if (level != SOL_RAW)
     856                 :          0 :                 return ip_setsockopt(sk, level, optname, optval, optlen);
     857                 :          0 :         return do_raw_setsockopt(sk, level, optname, optval, optlen);
     858                 :            : }
     859                 :            : 
     860                 :            : #ifdef CONFIG_COMPAT
     861                 :            : static int compat_raw_setsockopt(struct sock *sk, int level, int optname,
     862                 :            :                                  char __user *optval, unsigned int optlen)
     863                 :            : {
     864                 :            :         if (level != SOL_RAW)
     865                 :            :                 return compat_ip_setsockopt(sk, level, optname, optval, optlen);
     866                 :            :         return do_raw_setsockopt(sk, level, optname, optval, optlen);
     867                 :            : }
     868                 :            : #endif
     869                 :            : 
     870                 :            : static int do_raw_getsockopt(struct sock *sk, int level, int optname,
     871                 :            :                           char __user *optval, int __user *optlen)
     872                 :            : {
     873                 :          0 :         if (optname == ICMP_FILTER) {
     874                 :          0 :                 if (inet_sk(sk)->inet_num != IPPROTO_ICMP)
     875                 :            :                         return -EOPNOTSUPP;
     876                 :            :                 else
     877                 :          0 :                         return raw_geticmpfilter(sk, optval, optlen);
     878                 :            :         }
     879                 :            :         return -ENOPROTOOPT;
     880                 :            : }
     881                 :            : 
     882                 :          0 : static int raw_getsockopt(struct sock *sk, int level, int optname,
     883                 :            :                           char __user *optval, int __user *optlen)
     884                 :            : {
     885                 :          0 :         if (level != SOL_RAW)
     886                 :          0 :                 return ip_getsockopt(sk, level, optname, optval, optlen);
     887                 :          0 :         return do_raw_getsockopt(sk, level, optname, optval, optlen);
     888                 :            : }
     889                 :            : 
     890                 :            : #ifdef CONFIG_COMPAT
     891                 :            : static int compat_raw_getsockopt(struct sock *sk, int level, int optname,
     892                 :            :                                  char __user *optval, int __user *optlen)
     893                 :            : {
     894                 :            :         if (level != SOL_RAW)
     895                 :            :                 return compat_ip_getsockopt(sk, level, optname, optval, optlen);
     896                 :            :         return do_raw_getsockopt(sk, level, optname, optval, optlen);
     897                 :            : }
     898                 :            : #endif
     899                 :            : 
     900                 :          0 : static int raw_ioctl(struct sock *sk, int cmd, unsigned long arg)
     901                 :            : {
     902                 :          0 :         switch (cmd) {
     903                 :            :         case SIOCOUTQ: {
     904                 :            :                 int amount = sk_wmem_alloc_get(sk);
     905                 :            : 
     906                 :          0 :                 return put_user(amount, (int __user *)arg);
     907                 :            :         }
     908                 :            :         case SIOCINQ: {
     909                 :            :                 struct sk_buff *skb;
     910                 :            :                 int amount = 0;
     911                 :            : 
     912                 :            :                 spin_lock_bh(&sk->sk_receive_queue.lock);
     913                 :          0 :                 skb = skb_peek(&sk->sk_receive_queue);
     914                 :          0 :                 if (skb)
     915                 :          0 :                         amount = skb->len;
     916                 :            :                 spin_unlock_bh(&sk->sk_receive_queue.lock);
     917                 :          0 :                 return put_user(amount, (int __user *)arg);
     918                 :            :         }
     919                 :            : 
     920                 :            :         default:
     921                 :            : #ifdef CONFIG_IP_MROUTE
     922                 :          0 :                 return ipmr_ioctl(sk, cmd, (void __user *)arg);
     923                 :            : #else
     924                 :            :                 return -ENOIOCTLCMD;
     925                 :            : #endif
     926                 :            :         }
     927                 :            : }
     928                 :            : 
     929                 :            : #ifdef CONFIG_COMPAT
     930                 :            : static int compat_raw_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
     931                 :            : {
     932                 :            :         switch (cmd) {
     933                 :            :         case SIOCOUTQ:
     934                 :            :         case SIOCINQ:
     935                 :            :                 return -ENOIOCTLCMD;
     936                 :            :         default:
     937                 :            : #ifdef CONFIG_IP_MROUTE
     938                 :            :                 return ipmr_compat_ioctl(sk, cmd, compat_ptr(arg));
     939                 :            : #else
     940                 :            :                 return -ENOIOCTLCMD;
     941                 :            : #endif
     942                 :            :         }
     943                 :            : }
     944                 :            : #endif
     945                 :            : 
     946                 :          0 : int raw_abort(struct sock *sk, int err)
     947                 :            : {
     948                 :            :         lock_sock(sk);
     949                 :            : 
     950                 :          0 :         sk->sk_err = err;
     951                 :          0 :         sk->sk_error_report(sk);
     952                 :          0 :         __udp_disconnect(sk, 0);
     953                 :            : 
     954                 :          0 :         release_sock(sk);
     955                 :            : 
     956                 :          0 :         return 0;
     957                 :            : }
     958                 :            : EXPORT_SYMBOL_GPL(raw_abort);
     959                 :            : 
     960                 :            : struct proto raw_prot = {
     961                 :            :         .name              = "RAW",
     962                 :            :         .owner             = THIS_MODULE,
     963                 :            :         .close             = raw_close,
     964                 :            :         .destroy           = raw_destroy,
     965                 :            :         .connect           = ip4_datagram_connect,
     966                 :            :         .disconnect        = __udp_disconnect,
     967                 :            :         .ioctl             = raw_ioctl,
     968                 :            :         .init              = raw_sk_init,
     969                 :            :         .setsockopt        = raw_setsockopt,
     970                 :            :         .getsockopt        = raw_getsockopt,
     971                 :            :         .sendmsg           = raw_sendmsg,
     972                 :            :         .recvmsg           = raw_recvmsg,
     973                 :            :         .bind              = raw_bind,
     974                 :            :         .backlog_rcv       = raw_rcv_skb,
     975                 :            :         .release_cb        = ip4_datagram_release_cb,
     976                 :            :         .hash              = raw_hash_sk,
     977                 :            :         .unhash            = raw_unhash_sk,
     978                 :            :         .obj_size          = sizeof(struct raw_sock),
     979                 :            :         .useroffset        = offsetof(struct raw_sock, filter),
     980                 :            :         .usersize          = sizeof_field(struct raw_sock, filter),
     981                 :            :         .h.raw_hash        = &raw_v4_hashinfo,
     982                 :            : #ifdef CONFIG_COMPAT
     983                 :            :         .compat_setsockopt = compat_raw_setsockopt,
     984                 :            :         .compat_getsockopt = compat_raw_getsockopt,
     985                 :            :         .compat_ioctl      = compat_raw_ioctl,
     986                 :            : #endif
     987                 :            :         .diag_destroy      = raw_abort,
     988                 :            : };
     989                 :            : 
     990                 :            : #ifdef CONFIG_PROC_FS
     991                 :          0 : static struct sock *raw_get_first(struct seq_file *seq)
     992                 :            : {
     993                 :            :         struct sock *sk;
     994                 :          0 :         struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
     995                 :            :         struct raw_iter_state *state = raw_seq_private(seq);
     996                 :            : 
     997                 :          0 :         for (state->bucket = 0; state->bucket < RAW_HTABLE_SIZE;
     998                 :          0 :                         ++state->bucket) {
     999                 :          0 :                 sk_for_each(sk, &h->ht[state->bucket])
    1000                 :          0 :                         if (sock_net(sk) == seq_file_net(seq))
    1001                 :            :                                 goto found;
    1002                 :            :         }
    1003                 :            :         sk = NULL;
    1004                 :            : found:
    1005                 :          0 :         return sk;
    1006                 :            : }
    1007                 :            : 
    1008                 :          0 : static struct sock *raw_get_next(struct seq_file *seq, struct sock *sk)
    1009                 :            : {
    1010                 :          0 :         struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
    1011                 :            :         struct raw_iter_state *state = raw_seq_private(seq);
    1012                 :            : 
    1013                 :            :         do {
    1014                 :            :                 sk = sk_next(sk);
    1015                 :            : try_again:
    1016                 :            :                 ;
    1017                 :          0 :         } while (sk && sock_net(sk) != seq_file_net(seq));
    1018                 :            : 
    1019                 :          0 :         if (!sk && ++state->bucket < RAW_HTABLE_SIZE) {
    1020                 :          0 :                 sk = sk_head(&h->ht[state->bucket]);
    1021                 :            :                 goto try_again;
    1022                 :            :         }
    1023                 :          0 :         return sk;
    1024                 :            : }
    1025                 :            : 
    1026                 :          0 : static struct sock *raw_get_idx(struct seq_file *seq, loff_t pos)
    1027                 :            : {
    1028                 :          0 :         struct sock *sk = raw_get_first(seq);
    1029                 :            : 
    1030                 :          0 :         if (sk)
    1031                 :          0 :                 while (pos && (sk = raw_get_next(seq, sk)) != NULL)
    1032                 :          0 :                         --pos;
    1033                 :          0 :         return pos ? NULL : sk;
    1034                 :            : }
    1035                 :            : 
    1036                 :          0 : void *raw_seq_start(struct seq_file *seq, loff_t *pos)
    1037                 :            : {
    1038                 :          0 :         struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
    1039                 :            : 
    1040                 :          0 :         read_lock(&h->lock);
    1041                 :          0 :         return *pos ? raw_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
    1042                 :            : }
    1043                 :            : EXPORT_SYMBOL_GPL(raw_seq_start);
    1044                 :            : 
    1045                 :          0 : void *raw_seq_next(struct seq_file *seq, void *v, loff_t *pos)
    1046                 :            : {
    1047                 :            :         struct sock *sk;
    1048                 :            : 
    1049                 :          0 :         if (v == SEQ_START_TOKEN)
    1050                 :          0 :                 sk = raw_get_first(seq);
    1051                 :            :         else
    1052                 :          0 :                 sk = raw_get_next(seq, v);
    1053                 :          0 :         ++*pos;
    1054                 :          0 :         return sk;
    1055                 :            : }
    1056                 :            : EXPORT_SYMBOL_GPL(raw_seq_next);
    1057                 :            : 
    1058                 :          0 : void raw_seq_stop(struct seq_file *seq, void *v)
    1059                 :            : {
    1060                 :          0 :         struct raw_hashinfo *h = PDE_DATA(file_inode(seq->file));
    1061                 :            : 
    1062                 :            :         read_unlock(&h->lock);
    1063                 :          0 : }
    1064                 :            : EXPORT_SYMBOL_GPL(raw_seq_stop);
    1065                 :            : 
    1066                 :          0 : static void raw_sock_seq_show(struct seq_file *seq, struct sock *sp, int i)
    1067                 :            : {
    1068                 :            :         struct inet_sock *inet = inet_sk(sp);
    1069                 :          0 :         __be32 dest = inet->inet_daddr,
    1070                 :          0 :                src = inet->inet_rcv_saddr;
    1071                 :            :         __u16 destp = 0,
    1072                 :          0 :               srcp  = inet->inet_num;
    1073                 :            : 
    1074                 :          0 :         seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
    1075                 :            :                 " %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
    1076                 :          0 :                 i, src, srcp, dest, destp, sp->sk_state,
    1077                 :            :                 sk_wmem_alloc_get(sp),
    1078                 :            :                 sk_rmem_alloc_get(sp),
    1079                 :            :                 0, 0L, 0,
    1080                 :            :                 from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
    1081                 :            :                 0, sock_i_ino(sp),
    1082                 :          0 :                 refcount_read(&sp->sk_refcnt), sp, atomic_read(&sp->sk_drops));
    1083                 :          0 : }
    1084                 :            : 
    1085                 :          0 : static int raw_seq_show(struct seq_file *seq, void *v)
    1086                 :            : {
    1087                 :          0 :         if (v == SEQ_START_TOKEN)
    1088                 :          0 :                 seq_printf(seq, "  sl  local_address rem_address   st tx_queue "
    1089                 :            :                                 "rx_queue tr tm->when retrnsmt   uid  timeout "
    1090                 :            :                                 "inode ref pointer drops\n");
    1091                 :            :         else
    1092                 :          0 :                 raw_sock_seq_show(seq, v, raw_seq_private(seq)->bucket);
    1093                 :          0 :         return 0;
    1094                 :            : }
    1095                 :            : 
    1096                 :            : static const struct seq_operations raw_seq_ops = {
    1097                 :            :         .start = raw_seq_start,
    1098                 :            :         .next  = raw_seq_next,
    1099                 :            :         .stop  = raw_seq_stop,
    1100                 :            :         .show  = raw_seq_show,
    1101                 :            : };
    1102                 :            : 
    1103                 :          3 : static __net_init int raw_init_net(struct net *net)
    1104                 :            : {
    1105                 :          3 :         if (!proc_create_net_data("raw", 0444, net->proc_net, &raw_seq_ops,
    1106                 :            :                         sizeof(struct raw_iter_state), &raw_v4_hashinfo))
    1107                 :            :                 return -ENOMEM;
    1108                 :            : 
    1109                 :          3 :         return 0;
    1110                 :            : }
    1111                 :            : 
    1112                 :          1 : static __net_exit void raw_exit_net(struct net *net)
    1113                 :            : {
    1114                 :          1 :         remove_proc_entry("raw", net->proc_net);
    1115                 :          1 : }
    1116                 :            : 
    1117                 :            : static __net_initdata struct pernet_operations raw_net_ops = {
    1118                 :            :         .init = raw_init_net,
    1119                 :            :         .exit = raw_exit_net,
    1120                 :            : };
    1121                 :            : 
    1122                 :          3 : int __init raw_proc_init(void)
    1123                 :            : {
    1124                 :          3 :         return register_pernet_subsys(&raw_net_ops);
    1125                 :            : }
    1126                 :            : 
    1127                 :          0 : void __init raw_proc_exit(void)
    1128                 :            : {
    1129                 :          0 :         unregister_pernet_subsys(&raw_net_ops);
    1130                 :          0 : }
    1131                 :            : #endif /* CONFIG_PROC_FS */
    1132                 :            : 
    1133                 :            : static void raw_sysctl_init_net(struct net *net)
    1134                 :            : {
    1135                 :            : #ifdef CONFIG_NET_L3_MASTER_DEV
    1136                 :          3 :         net->ipv4.sysctl_raw_l3mdev_accept = 1;
    1137                 :            : #endif
    1138                 :            : }
    1139                 :            : 
    1140                 :          3 : static int __net_init raw_sysctl_init(struct net *net)
    1141                 :            : {
    1142                 :            :         raw_sysctl_init_net(net);
    1143                 :          3 :         return 0;
    1144                 :            : }
    1145                 :            : 
    1146                 :            : static struct pernet_operations __net_initdata raw_sysctl_ops = {
    1147                 :            :         .init   = raw_sysctl_init,
    1148                 :            : };
    1149                 :            : 
    1150                 :          3 : void __init raw_init(void)
    1151                 :            : {
    1152                 :            :         raw_sysctl_init_net(&init_net);
    1153                 :          3 :         if (register_pernet_subsys(&raw_sysctl_ops))
    1154                 :          0 :                 panic("RAW: failed to init sysctl parameters.\n");
    1155                 :          3 : }
    

Generated by: LCOV version 1.14