LCOV - code coverage report
Current view: top level - net/ipv6 - datagram.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 117 387 30.2 %
Date: 2020-09-30 20:25:40 Functions: 8 16 50.0 %
Branches: 62 299 20.7 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-or-later
       2                 :            : /*
       3                 :            :  *      common UDP/RAW code
       4                 :            :  *      Linux INET6 implementation
       5                 :            :  *
       6                 :            :  *      Authors:
       7                 :            :  *      Pedro Roque             <roque@di.fc.ul.pt>
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <linux/capability.h>
      11                 :            : #include <linux/errno.h>
      12                 :            : #include <linux/types.h>
      13                 :            : #include <linux/kernel.h>
      14                 :            : #include <linux/interrupt.h>
      15                 :            : #include <linux/socket.h>
      16                 :            : #include <linux/sockios.h>
      17                 :            : #include <linux/in6.h>
      18                 :            : #include <linux/ipv6.h>
      19                 :            : #include <linux/route.h>
      20                 :            : #include <linux/slab.h>
      21                 :            : #include <linux/export.h>
      22                 :            : 
      23                 :            : #include <net/ipv6.h>
      24                 :            : #include <net/ndisc.h>
      25                 :            : #include <net/addrconf.h>
      26                 :            : #include <net/transp_v6.h>
      27                 :            : #include <net/ip6_route.h>
      28                 :            : #include <net/tcp_states.h>
      29                 :            : #include <net/dsfield.h>
      30                 :            : #include <net/sock_reuseport.h>
      31                 :            : 
      32                 :            : #include <linux/errqueue.h>
      33                 :            : #include <linux/uaccess.h>
      34                 :            : 
      35                 :            : static bool ipv6_mapped_addr_any(const struct in6_addr *a)
      36                 :            : {
      37   [ #  #  #  #  :          0 :         return ipv6_addr_v4mapped(a) && (a->s6_addr32[3] == 0);
             #  #  #  # ]
      38                 :            : }
      39                 :            : 
      40                 :        828 : static void ip6_datagram_flow_key_init(struct flowi6 *fl6, struct sock *sk)
      41                 :            : {
      42                 :            :         struct inet_sock *inet = inet_sk(sk);
      43                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
      44                 :            : 
      45                 :        828 :         memset(fl6, 0, sizeof(*fl6));
      46                 :        828 :         fl6->flowi6_proto = sk->sk_protocol;
      47                 :        828 :         fl6->daddr = sk->sk_v6_daddr;
      48                 :        828 :         fl6->saddr = np->saddr;
      49                 :        828 :         fl6->flowi6_oif = sk->sk_bound_dev_if;
      50                 :        828 :         fl6->flowi6_mark = sk->sk_mark;
      51                 :        828 :         fl6->fl6_dport = inet->inet_dport;
      52                 :        828 :         fl6->fl6_sport = inet->inet_sport;
      53                 :        828 :         fl6->flowlabel = np->flow_label;
      54                 :        828 :         fl6->flowi6_uid = sk->sk_uid;
      55                 :            : 
      56         [ +  - ]:        828 :         if (!fl6->flowi6_oif)
      57                 :        828 :                 fl6->flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
      58                 :            : 
      59   [ +  -  -  + ]:       1656 :         if (!fl6->flowi6_oif && ipv6_addr_is_multicast(&fl6->daddr))
      60                 :          0 :                 fl6->flowi6_oif = np->mcast_oif;
      61                 :            : 
      62                 :        828 :         security_sk_classify_flow(sk, flowi6_to_flowi(fl6));
      63                 :        828 : }
      64                 :            : 
      65                 :        828 : int ip6_datagram_dst_update(struct sock *sk, bool fix_sk_saddr)
      66                 :            : {
      67                 :            :         struct ip6_flowlabel *flowlabel = NULL;
      68                 :            :         struct in6_addr *final_p, final;
      69                 :            :         struct ipv6_txoptions *opt;
      70                 :            :         struct dst_entry *dst;
      71                 :            :         struct inet_sock *inet = inet_sk(sk);
      72                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
      73                 :            :         struct flowi6 fl6;
      74                 :            :         int err = 0;
      75                 :            : 
      76   [ -  +  #  # ]:        828 :         if (np->sndflow && (np->flow_label & IPV6_FLOWLABEL_MASK)) {
      77                 :          0 :                 flowlabel = fl6_sock_lookup(sk, np->flow_label);
      78         [ #  # ]:          0 :                 if (IS_ERR(flowlabel))
      79                 :            :                         return -EINVAL;
      80                 :            :         }
      81                 :        828 :         ip6_datagram_flow_key_init(&fl6, sk);
      82                 :            : 
      83                 :            :         rcu_read_lock();
      84         [ -  + ]:       1656 :         opt = flowlabel ? flowlabel->opt : rcu_dereference(np->opt);
      85                 :        828 :         final_p = fl6_update_dst(&fl6, opt, &final);
      86                 :            :         rcu_read_unlock();
      87                 :            : 
      88                 :        828 :         dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
      89         [ +  - ]:        828 :         if (IS_ERR(dst)) {
      90                 :            :                 err = PTR_ERR(dst);
      91                 :        828 :                 goto out;
      92                 :            :         }
      93                 :            : 
      94         [ #  # ]:          0 :         if (fix_sk_saddr) {
      95         [ #  # ]:          0 :                 if (ipv6_addr_any(&np->saddr))
      96                 :          0 :                         np->saddr = fl6.saddr;
      97                 :            : 
      98         [ #  # ]:          0 :                 if (ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
      99                 :          0 :                         sk->sk_v6_rcv_saddr = fl6.saddr;
     100                 :          0 :                         inet->inet_rcv_saddr = LOOPBACK4_IPV6;
     101         [ #  # ]:          0 :                         if (sk->sk_prot->rehash)
     102                 :          0 :                                 sk->sk_prot->rehash(sk);
     103                 :            :                 }
     104                 :            :         }
     105                 :            : 
     106                 :          0 :         ip6_sk_dst_store_flow(sk, dst, &fl6);
     107                 :            : 
     108                 :            : out:
     109                 :        828 :         fl6_sock_release(flowlabel);
     110                 :        828 :         return err;
     111                 :            : }
     112                 :            : 
     113                 :       8997 : void ip6_datagram_release_cb(struct sock *sk)
     114                 :            : {
     115                 :            :         struct dst_entry *dst;
     116                 :            : 
     117         [ +  + ]:       8997 :         if (ipv6_addr_v4mapped(&sk->sk_v6_daddr))
     118                 :            :                 return;
     119                 :            : 
     120                 :            :         rcu_read_lock();
     121                 :            :         dst = __sk_dst_get(sk);
     122   [ -  +  #  #  :       8451 :         if (!dst || !dst->obsolete ||
                   #  # ]
     123                 :          0 :             dst->ops->check(dst, inet6_sk(sk)->dst_cookie)) {
     124                 :            :                 rcu_read_unlock();
     125                 :            :                 return;
     126                 :            :         }
     127                 :            :         rcu_read_unlock();
     128                 :            : 
     129                 :          0 :         ip6_datagram_dst_update(sk, false);
     130                 :            : }
     131                 :            : EXPORT_SYMBOL_GPL(ip6_datagram_release_cb);
     132                 :            : 
     133                 :        984 : int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr,
     134                 :            :                            int addr_len)
     135                 :            : {
     136                 :            :         struct sockaddr_in6     *usin = (struct sockaddr_in6 *) uaddr;
     137                 :            :         struct inet_sock        *inet = inet_sk(sk);
     138                 :            :         struct ipv6_pinfo       *np = inet6_sk(sk);
     139                 :            :         struct in6_addr         *daddr, old_daddr;
     140                 :            :         __be32                  fl6_flowlabel = 0;
     141                 :            :         __be32                  old_fl6_flowlabel;
     142                 :            :         __be16                  old_dport;
     143                 :            :         int                     addr_type;
     144                 :            :         int                     err;
     145                 :            : 
     146         [ +  + ]:        984 :         if (usin->sin6_family == AF_INET) {
     147         [ +  - ]:        156 :                 if (__ipv6_only_sock(sk))
     148                 :            :                         return -EAFNOSUPPORT;
     149                 :        156 :                 err = __ip4_datagram_connect(sk, uaddr, addr_len);
     150                 :        156 :                 goto ipv4_connected;
     151                 :            :         }
     152                 :            : 
     153         [ +  - ]:        828 :         if (addr_len < SIN6_LEN_RFC2133)
     154                 :            :                 return -EINVAL;
     155                 :            : 
     156         [ +  - ]:        828 :         if (usin->sin6_family != AF_INET6)
     157                 :            :                 return -EAFNOSUPPORT;
     158                 :            : 
     159         [ -  + ]:        828 :         if (np->sndflow)
     160                 :          0 :                 fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
     161                 :            : 
     162         [ -  + ]:        828 :         if (ipv6_addr_any(&usin->sin6_addr)) {
     163                 :            :                 /*
     164                 :            :                  *      connect to self
     165                 :            :                  */
     166         [ #  # ]:          0 :                 if (ipv6_addr_v4mapped(&sk->sk_v6_rcv_saddr))
     167                 :            :                         ipv6_addr_set_v4mapped(htonl(INADDR_LOOPBACK),
     168                 :            :                                                &usin->sin6_addr);
     169                 :            :                 else
     170                 :          0 :                         usin->sin6_addr = in6addr_loopback;
     171                 :            :         }
     172                 :            : 
     173                 :        828 :         addr_type = ipv6_addr_type(&usin->sin6_addr);
     174                 :            : 
     175                 :            :         daddr = &usin->sin6_addr;
     176                 :            : 
     177         [ -  + ]:        828 :         if (addr_type & IPV6_ADDR_MAPPED) {
     178                 :            :                 struct sockaddr_in sin;
     179                 :            : 
     180         [ #  # ]:          0 :                 if (__ipv6_only_sock(sk)) {
     181                 :            :                         err = -ENETUNREACH;
     182                 :            :                         goto out;
     183                 :            :                 }
     184                 :          0 :                 sin.sin_family = AF_INET;
     185                 :          0 :                 sin.sin_addr.s_addr = daddr->s6_addr32[3];
     186                 :          0 :                 sin.sin_port = usin->sin6_port;
     187                 :            : 
     188                 :          0 :                 err = __ip4_datagram_connect(sk,
     189                 :            :                                              (struct sockaddr *) &sin,
     190                 :            :                                              sizeof(sin));
     191                 :            : 
     192                 :            : ipv4_connected:
     193         [ +  - ]:        156 :                 if (err)
     194                 :            :                         goto out;
     195                 :            : 
     196                 :        156 :                 ipv6_addr_set_v4mapped(inet->inet_daddr, &sk->sk_v6_daddr);
     197                 :            : 
     198   [ -  +  #  # ]:        156 :                 if (ipv6_addr_any(&np->saddr) ||
     199                 :            :                     ipv6_mapped_addr_any(&np->saddr))
     200                 :        156 :                         ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
     201                 :            : 
     202   [ -  +  #  # ]:        156 :                 if (ipv6_addr_any(&sk->sk_v6_rcv_saddr) ||
     203                 :            :                     ipv6_mapped_addr_any(&sk->sk_v6_rcv_saddr)) {
     204                 :        156 :                         ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
     205                 :            :                                                &sk->sk_v6_rcv_saddr);
     206         [ +  - ]:        156 :                         if (sk->sk_prot->rehash)
     207                 :        156 :                                 sk->sk_prot->rehash(sk);
     208                 :            :                 }
     209                 :            : 
     210                 :            :                 goto out;
     211                 :            :         }
     212                 :            : 
     213         [ -  + ]:        828 :         if (__ipv6_addr_needs_scope_id(addr_type)) {
     214   [ #  #  #  # ]:          0 :                 if (addr_len >= sizeof(struct sockaddr_in6) &&
     215                 :          0 :                     usin->sin6_scope_id) {
     216         [ #  # ]:          0 :                         if (!sk_dev_equal_l3scope(sk, usin->sin6_scope_id)) {
     217                 :            :                                 err = -EINVAL;
     218                 :            :                                 goto out;
     219                 :            :                         }
     220                 :          0 :                         sk->sk_bound_dev_if = usin->sin6_scope_id;
     221                 :            :                 }
     222                 :            : 
     223   [ #  #  #  # ]:          0 :                 if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
     224                 :          0 :                         sk->sk_bound_dev_if = np->mcast_oif;
     225                 :            : 
     226                 :            :                 /* Connect to link-local address requires an interface */
     227         [ #  # ]:          0 :                 if (!sk->sk_bound_dev_if) {
     228                 :            :                         err = -EINVAL;
     229                 :            :                         goto out;
     230                 :            :                 }
     231                 :            :         }
     232                 :            : 
     233                 :            :         /* save the current peer information before updating it */
     234                 :        828 :         old_daddr = sk->sk_v6_daddr;
     235                 :        828 :         old_fl6_flowlabel = np->flow_label;
     236                 :        828 :         old_dport = inet->inet_dport;
     237                 :            : 
     238                 :        828 :         sk->sk_v6_daddr = *daddr;
     239                 :        828 :         np->flow_label = fl6_flowlabel;
     240                 :        828 :         inet->inet_dport = usin->sin6_port;
     241                 :            : 
     242                 :            :         /*
     243                 :            :          *      Check for a route to destination an obtain the
     244                 :            :          *      destination cache for it.
     245                 :            :          */
     246                 :            : 
     247                 :        828 :         err = ip6_datagram_dst_update(sk, true);
     248         [ +  - ]:        828 :         if (err) {
     249                 :            :                 /* Restore the socket peer info, to keep it consistent with
     250                 :            :                  * the old socket state
     251                 :            :                  */
     252                 :        828 :                 sk->sk_v6_daddr = old_daddr;
     253                 :        828 :                 np->flow_label = old_fl6_flowlabel;
     254                 :        828 :                 inet->inet_dport = old_dport;
     255                 :        828 :                 goto out;
     256                 :            :         }
     257                 :            : 
     258                 :            :         reuseport_has_conns(sk, true);
     259                 :          0 :         sk->sk_state = TCP_ESTABLISHED;
     260                 :            :         sk_set_txhash(sk);
     261                 :            : out:
     262                 :        984 :         return err;
     263                 :            : }
     264                 :            : EXPORT_SYMBOL_GPL(__ip6_datagram_connect);
     265                 :            : 
     266                 :        984 : int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
     267                 :            : {
     268                 :            :         int res;
     269                 :            : 
     270                 :            :         lock_sock(sk);
     271                 :        984 :         res = __ip6_datagram_connect(sk, uaddr, addr_len);
     272                 :        984 :         release_sock(sk);
     273                 :        984 :         return res;
     274                 :            : }
     275                 :            : EXPORT_SYMBOL_GPL(ip6_datagram_connect);
     276                 :            : 
     277                 :          0 : int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,
     278                 :            :                                  int addr_len)
     279                 :            : {
     280                 :            :         DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, uaddr);
     281         [ #  # ]:          0 :         if (sin6->sin6_family != AF_INET6)
     282                 :            :                 return -EAFNOSUPPORT;
     283                 :          0 :         return ip6_datagram_connect(sk, uaddr, addr_len);
     284                 :            : }
     285                 :            : EXPORT_SYMBOL_GPL(ip6_datagram_connect_v6_only);
     286                 :            : 
     287                 :          0 : void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
     288                 :            :                      __be16 port, u32 info, u8 *payload)
     289                 :            : {
     290                 :            :         struct ipv6_pinfo *np  = inet6_sk(sk);
     291                 :            :         struct icmp6hdr *icmph = icmp6_hdr(skb);
     292                 :            :         struct sock_exterr_skb *serr;
     293                 :            : 
     294         [ #  # ]:          0 :         if (!np->recverr)
     295                 :            :                 return;
     296                 :            : 
     297                 :          0 :         skb = skb_clone(skb, GFP_ATOMIC);
     298         [ #  # ]:          0 :         if (!skb)
     299                 :            :                 return;
     300                 :            : 
     301                 :          0 :         skb->protocol = htons(ETH_P_IPV6);
     302                 :            : 
     303                 :            :         serr = SKB_EXT_ERR(skb);
     304                 :          0 :         serr->ee.ee_errno = err;
     305                 :          0 :         serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
     306                 :          0 :         serr->ee.ee_type = icmph->icmp6_type;
     307                 :          0 :         serr->ee.ee_code = icmph->icmp6_code;
     308                 :          0 :         serr->ee.ee_pad = 0;
     309                 :          0 :         serr->ee.ee_info = info;
     310                 :          0 :         serr->ee.ee_data = 0;
     311                 :          0 :         serr->addr_offset = (u8 *)&(((struct ipv6hdr *)(icmph + 1))->daddr) -
     312                 :            :                                   skb_network_header(skb);
     313                 :          0 :         serr->port = port;
     314                 :            : 
     315                 :          0 :         __skb_pull(skb, payload - skb->data);
     316                 :            :         skb_reset_transport_header(skb);
     317                 :            : 
     318         [ #  # ]:          0 :         if (sock_queue_err_skb(sk, skb))
     319                 :          0 :                 kfree_skb(skb);
     320                 :            : }
     321                 :            : 
     322                 :          0 : void ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info)
     323                 :            : {
     324                 :            :         const struct ipv6_pinfo *np = inet6_sk(sk);
     325                 :            :         struct sock_exterr_skb *serr;
     326                 :            :         struct ipv6hdr *iph;
     327                 :            :         struct sk_buff *skb;
     328                 :            : 
     329         [ #  # ]:          0 :         if (!np->recverr)
     330                 :            :                 return;
     331                 :            : 
     332                 :            :         skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
     333         [ #  # ]:          0 :         if (!skb)
     334                 :            :                 return;
     335                 :            : 
     336                 :          0 :         skb->protocol = htons(ETH_P_IPV6);
     337                 :            : 
     338                 :          0 :         skb_put(skb, sizeof(struct ipv6hdr));
     339                 :            :         skb_reset_network_header(skb);
     340                 :            :         iph = ipv6_hdr(skb);
     341                 :          0 :         iph->daddr = fl6->daddr;
     342                 :            :         ip6_flow_hdr(iph, 0, 0);
     343                 :            : 
     344                 :            :         serr = SKB_EXT_ERR(skb);
     345                 :          0 :         serr->ee.ee_errno = err;
     346                 :          0 :         serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
     347                 :          0 :         serr->ee.ee_type = 0;
     348                 :          0 :         serr->ee.ee_code = 0;
     349                 :          0 :         serr->ee.ee_pad = 0;
     350                 :          0 :         serr->ee.ee_info = info;
     351                 :          0 :         serr->ee.ee_data = 0;
     352                 :          0 :         serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
     353                 :          0 :         serr->port = fl6->fl6_dport;
     354                 :            : 
     355                 :          0 :         __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
     356                 :            :         skb_reset_transport_header(skb);
     357                 :            : 
     358         [ #  # ]:          0 :         if (sock_queue_err_skb(sk, skb))
     359                 :          0 :                 kfree_skb(skb);
     360                 :            : }
     361                 :            : 
     362                 :          0 : void ipv6_local_rxpmtu(struct sock *sk, struct flowi6 *fl6, u32 mtu)
     363                 :            : {
     364                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
     365                 :            :         struct ipv6hdr *iph;
     366                 :            :         struct sk_buff *skb;
     367                 :            :         struct ip6_mtuinfo *mtu_info;
     368                 :            : 
     369         [ #  # ]:          0 :         if (!np->rxopt.bits.rxpmtu)
     370                 :            :                 return;
     371                 :            : 
     372                 :            :         skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
     373         [ #  # ]:          0 :         if (!skb)
     374                 :            :                 return;
     375                 :            : 
     376                 :          0 :         skb_put(skb, sizeof(struct ipv6hdr));
     377                 :            :         skb_reset_network_header(skb);
     378                 :            :         iph = ipv6_hdr(skb);
     379                 :          0 :         iph->daddr = fl6->daddr;
     380                 :            : 
     381                 :            :         mtu_info = IP6CBMTU(skb);
     382                 :            : 
     383                 :          0 :         mtu_info->ip6m_mtu = mtu;
     384                 :          0 :         mtu_info->ip6m_addr.sin6_family = AF_INET6;
     385                 :          0 :         mtu_info->ip6m_addr.sin6_port = 0;
     386                 :          0 :         mtu_info->ip6m_addr.sin6_flowinfo = 0;
     387                 :          0 :         mtu_info->ip6m_addr.sin6_scope_id = fl6->flowi6_oif;
     388                 :          0 :         mtu_info->ip6m_addr.sin6_addr = ipv6_hdr(skb)->daddr;
     389                 :            : 
     390                 :          0 :         __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
     391                 :            :         skb_reset_transport_header(skb);
     392                 :            : 
     393                 :          0 :         skb = xchg(&np->rxpmtu, skb);
     394                 :          0 :         kfree_skb(skb);
     395                 :            : }
     396                 :            : 
     397                 :            : /* For some errors we have valid addr_offset even with zero payload and
     398                 :            :  * zero port. Also, addr_offset should be supported if port is set.
     399                 :            :  */
     400                 :            : static inline bool ipv6_datagram_support_addr(struct sock_exterr_skb *serr)
     401                 :            : {
     402                 :          0 :         return serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6 ||
     403                 :          0 :                serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
     404   [ #  #  #  # ]:          0 :                serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL || serr->port;
     405                 :            : }
     406                 :            : 
     407                 :            : /* IPv6 supports cmsg on all origins aside from SO_EE_ORIGIN_LOCAL.
     408                 :            :  *
     409                 :            :  * At one point, excluding local errors was a quick test to identify icmp/icmp6
     410                 :            :  * errors. This is no longer true, but the test remained, so the v6 stack,
     411                 :            :  * unlike v4, also honors cmsg requests on all wifi and timestamp errors.
     412                 :            :  */
     413                 :            : static bool ip6_datagram_support_cmsg(struct sk_buff *skb,
     414                 :            :                                       struct sock_exterr_skb *serr)
     415                 :            : {
     416         [ #  # ]:          0 :         if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
     417                 :            :             serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6)
     418                 :            :                 return true;
     419                 :            : 
     420         [ #  # ]:          0 :         if (serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL)
     421                 :            :                 return false;
     422                 :            : 
     423         [ #  # ]:          0 :         if (!IP6CB(skb)->iif)
     424                 :            :                 return false;
     425                 :            : 
     426                 :            :         return true;
     427                 :            : }
     428                 :            : 
     429                 :            : /*
     430                 :            :  *      Handle MSG_ERRQUEUE
     431                 :            :  */
     432                 :          0 : int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
     433                 :            : {
     434                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
     435                 :            :         struct sock_exterr_skb *serr;
     436                 :            :         struct sk_buff *skb;
     437                 :          0 :         DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
     438                 :            :         struct {
     439                 :            :                 struct sock_extended_err ee;
     440                 :            :                 struct sockaddr_in6      offender;
     441                 :            :         } errhdr;
     442                 :            :         int err;
     443                 :            :         int copied;
     444                 :            : 
     445                 :            :         err = -EAGAIN;
     446                 :          0 :         skb = sock_dequeue_err_skb(sk);
     447         [ #  # ]:          0 :         if (!skb)
     448                 :            :                 goto out;
     449                 :            : 
     450                 :          0 :         copied = skb->len;
     451         [ #  # ]:          0 :         if (copied > len) {
     452                 :          0 :                 msg->msg_flags |= MSG_TRUNC;
     453                 :            :                 copied = len;
     454                 :            :         }
     455                 :            :         err = skb_copy_datagram_msg(skb, 0, msg, copied);
     456         [ #  # ]:          0 :         if (unlikely(err)) {
     457                 :          0 :                 kfree_skb(skb);
     458                 :          0 :                 return err;
     459                 :            :         }
     460                 :          0 :         sock_recv_timestamp(msg, sk, skb);
     461                 :            : 
     462                 :            :         serr = SKB_EXT_ERR(skb);
     463                 :            : 
     464   [ #  #  #  # ]:          0 :         if (sin && ipv6_datagram_support_addr(serr)) {
     465                 :            :                 const unsigned char *nh = skb_network_header(skb);
     466                 :          0 :                 sin->sin6_family = AF_INET6;
     467                 :          0 :                 sin->sin6_flowinfo = 0;
     468                 :          0 :                 sin->sin6_port = serr->port;
     469         [ #  # ]:          0 :                 if (skb->protocol == htons(ETH_P_IPV6)) {
     470                 :          0 :                         const struct ipv6hdr *ip6h = container_of((struct in6_addr *)(nh + serr->addr_offset),
     471                 :            :                                                                   struct ipv6hdr, daddr);
     472                 :          0 :                         sin->sin6_addr = ip6h->daddr;
     473         [ #  # ]:          0 :                         if (np->sndflow)
     474                 :          0 :                                 sin->sin6_flowinfo = ip6_flowinfo(ip6h);
     475                 :          0 :                         sin->sin6_scope_id =
     476                 :          0 :                                 ipv6_iface_scope_id(&sin->sin6_addr,
     477                 :            :                                                     IP6CB(skb)->iif);
     478                 :            :                 } else {
     479                 :          0 :                         ipv6_addr_set_v4mapped(*(__be32 *)(nh + serr->addr_offset),
     480                 :            :                                                &sin->sin6_addr);
     481                 :          0 :                         sin->sin6_scope_id = 0;
     482                 :            :                 }
     483                 :          0 :                 *addr_len = sizeof(*sin);
     484                 :            :         }
     485                 :            : 
     486                 :          0 :         memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
     487                 :            :         sin = &errhdr.offender;
     488                 :          0 :         memset(sin, 0, sizeof(*sin));
     489                 :            : 
     490         [ #  # ]:          0 :         if (ip6_datagram_support_cmsg(skb, serr)) {
     491                 :          0 :                 sin->sin6_family = AF_INET6;
     492         [ #  # ]:          0 :                 if (np->rxopt.all)
     493                 :          0 :                         ip6_datagram_recv_common_ctl(sk, msg, skb);
     494         [ #  # ]:          0 :                 if (skb->protocol == htons(ETH_P_IPV6)) {
     495                 :          0 :                         sin->sin6_addr = ipv6_hdr(skb)->saddr;
     496         [ #  # ]:          0 :                         if (np->rxopt.all)
     497                 :          0 :                                 ip6_datagram_recv_specific_ctl(sk, msg, skb);
     498                 :          0 :                         sin->sin6_scope_id =
     499                 :          0 :                                 ipv6_iface_scope_id(&sin->sin6_addr,
     500                 :            :                                                     IP6CB(skb)->iif);
     501                 :            :                 } else {
     502                 :          0 :                         ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
     503                 :            :                                                &sin->sin6_addr);
     504         [ #  # ]:          0 :                         if (inet_sk(sk)->cmsg_flags)
     505                 :            :                                 ip_cmsg_recv(msg, skb);
     506                 :            :                 }
     507                 :            :         }
     508                 :            : 
     509                 :          0 :         put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
     510                 :            : 
     511                 :            :         /* Now we could try to dump offended packet options */
     512                 :            : 
     513                 :          0 :         msg->msg_flags |= MSG_ERRQUEUE;
     514                 :            :         err = copied;
     515                 :            : 
     516                 :          0 :         consume_skb(skb);
     517                 :            : out:
     518                 :          0 :         return err;
     519                 :            : }
     520                 :            : EXPORT_SYMBOL_GPL(ipv6_recv_error);
     521                 :            : 
     522                 :            : /*
     523                 :            :  *      Handle IPV6_RECVPATHMTU
     524                 :            :  */
     525                 :          0 : int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len,
     526                 :            :                      int *addr_len)
     527                 :            : {
     528                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
     529                 :            :         struct sk_buff *skb;
     530                 :            :         struct ip6_mtuinfo mtu_info;
     531                 :          0 :         DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
     532                 :            :         int err;
     533                 :            :         int copied;
     534                 :            : 
     535                 :            :         err = -EAGAIN;
     536                 :          0 :         skb = xchg(&np->rxpmtu, NULL);
     537         [ #  # ]:          0 :         if (!skb)
     538                 :            :                 goto out;
     539                 :            : 
     540                 :          0 :         copied = skb->len;
     541         [ #  # ]:          0 :         if (copied > len) {
     542                 :          0 :                 msg->msg_flags |= MSG_TRUNC;
     543                 :            :                 copied = len;
     544                 :            :         }
     545                 :            :         err = skb_copy_datagram_msg(skb, 0, msg, copied);
     546         [ #  # ]:          0 :         if (err)
     547                 :            :                 goto out_free_skb;
     548                 :            : 
     549                 :          0 :         sock_recv_timestamp(msg, sk, skb);
     550                 :            : 
     551                 :          0 :         memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
     552                 :            : 
     553         [ #  # ]:          0 :         if (sin) {
     554                 :          0 :                 sin->sin6_family = AF_INET6;
     555                 :          0 :                 sin->sin6_flowinfo = 0;
     556                 :          0 :                 sin->sin6_port = 0;
     557                 :          0 :                 sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
     558                 :          0 :                 sin->sin6_addr = mtu_info.ip6m_addr.sin6_addr;
     559                 :          0 :                 *addr_len = sizeof(*sin);
     560                 :            :         }
     561                 :            : 
     562                 :          0 :         put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
     563                 :            : 
     564                 :            :         err = copied;
     565                 :            : 
     566                 :            : out_free_skb:
     567                 :          0 :         kfree_skb(skb);
     568                 :            : out:
     569                 :          0 :         return err;
     570                 :            : }
     571                 :            : 
     572                 :            : 
     573                 :        947 : void ip6_datagram_recv_common_ctl(struct sock *sk, struct msghdr *msg,
     574                 :            :                                  struct sk_buff *skb)
     575                 :            : {
     576                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
     577                 :        947 :         bool is_ipv6 = skb->protocol == htons(ETH_P_IPV6);
     578                 :            : 
     579         [ +  - ]:        947 :         if (np->rxopt.bits.rxinfo) {
     580                 :            :                 struct in6_pktinfo src_info;
     581                 :            : 
     582         [ +  - ]:        947 :                 if (is_ipv6) {
     583                 :        947 :                         src_info.ipi6_ifindex = IP6CB(skb)->iif;
     584                 :        947 :                         src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
     585                 :            :                 } else {
     586                 :          0 :                         src_info.ipi6_ifindex =
     587                 :          0 :                                 PKTINFO_SKB_CB(skb)->ipi_ifindex;
     588                 :          0 :                         ipv6_addr_set_v4mapped(ip_hdr(skb)->daddr,
     589                 :            :                                                &src_info.ipi6_addr);
     590                 :            :                 }
     591                 :            : 
     592         [ +  - ]:        947 :                 if (src_info.ipi6_ifindex >= 0)
     593                 :        947 :                         put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO,
     594                 :            :                                  sizeof(src_info), &src_info);
     595                 :            :         }
     596                 :        947 : }
     597                 :            : 
     598                 :        947 : void ip6_datagram_recv_specific_ctl(struct sock *sk, struct msghdr *msg,
     599                 :            :                                     struct sk_buff *skb)
     600                 :            : {
     601                 :            :         struct ipv6_pinfo *np = inet6_sk(sk);
     602                 :            :         struct inet6_skb_parm *opt = IP6CB(skb);
     603                 :            :         unsigned char *nh = skb_network_header(skb);
     604                 :            : 
     605         [ +  - ]:        947 :         if (np->rxopt.bits.rxhlim) {
     606                 :        947 :                 int hlim = ipv6_hdr(skb)->hop_limit;
     607                 :        947 :                 put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
     608                 :            :         }
     609                 :            : 
     610         [ -  + ]:        947 :         if (np->rxopt.bits.rxtclass) {
     611                 :          0 :                 int tclass = ipv6_get_dsfield(ipv6_hdr(skb));
     612                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
     613                 :            :         }
     614                 :            : 
     615         [ -  + ]:        947 :         if (np->rxopt.bits.rxflow) {
     616                 :          0 :                 __be32 flowinfo = ip6_flowinfo((struct ipv6hdr *)nh);
     617         [ #  # ]:          0 :                 if (flowinfo)
     618                 :          0 :                         put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
     619                 :            :         }
     620                 :            : 
     621                 :            :         /* HbH is allowed only once */
     622   [ -  +  #  # ]:        947 :         if (np->rxopt.bits.hopopts && (opt->flags & IP6SKB_HOPBYHOP)) {
     623                 :          0 :                 u8 *ptr = nh + sizeof(struct ipv6hdr);
     624                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
     625                 :            :         }
     626                 :            : 
     627   [ -  +  #  # ]:        947 :         if (opt->lastopt &&
     628                 :          0 :             (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {
     629                 :            :                 /*
     630                 :            :                  * Silly enough, but we need to reparse in order to
     631                 :            :                  * report extension headers (except for HbH)
     632                 :            :                  * in order.
     633                 :            :                  *
     634                 :            :                  * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
     635                 :            :                  * (and WILL NOT be) defined because
     636                 :            :                  * IPV6_RECVDSTOPTS is more generic. --yoshfuji
     637                 :            :                  */
     638                 :            :                 unsigned int off = sizeof(struct ipv6hdr);
     639                 :          0 :                 u8 nexthdr = ipv6_hdr(skb)->nexthdr;
     640                 :            : 
     641         [ #  # ]:          0 :                 while (off <= opt->lastopt) {
     642                 :            :                         unsigned int len;
     643                 :          0 :                         u8 *ptr = nh + off;
     644                 :            : 
     645   [ #  #  #  # ]:          0 :                         switch (nexthdr) {
     646                 :            :                         case IPPROTO_DSTOPTS:
     647                 :          0 :                                 nexthdr = ptr[0];
     648                 :          0 :                                 len = (ptr[1] + 1) << 3;
     649         [ #  # ]:          0 :                                 if (np->rxopt.bits.dstopts)
     650                 :          0 :                                         put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, len, ptr);
     651                 :            :                                 break;
     652                 :            :                         case IPPROTO_ROUTING:
     653                 :          0 :                                 nexthdr = ptr[0];
     654                 :          0 :                                 len = (ptr[1] + 1) << 3;
     655         [ #  # ]:          0 :                                 if (np->rxopt.bits.srcrt)
     656                 :          0 :                                         put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, len, ptr);
     657                 :            :                                 break;
     658                 :            :                         case IPPROTO_AH:
     659                 :          0 :                                 nexthdr = ptr[0];
     660                 :          0 :                                 len = (ptr[1] + 2) << 2;
     661                 :          0 :                                 break;
     662                 :            :                         default:
     663                 :          0 :                                 nexthdr = ptr[0];
     664                 :          0 :                                 len = (ptr[1] + 1) << 3;
     665                 :          0 :                                 break;
     666                 :            :                         }
     667                 :            : 
     668                 :          0 :                         off += len;
     669                 :            :                 }
     670                 :            :         }
     671                 :            : 
     672                 :            :         /* socket options in old style */
     673         [ -  + ]:        947 :         if (np->rxopt.bits.rxoinfo) {
     674                 :            :                 struct in6_pktinfo src_info;
     675                 :            : 
     676                 :          0 :                 src_info.ipi6_ifindex = opt->iif;
     677                 :          0 :                 src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
     678                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
     679                 :            :         }
     680         [ -  + ]:        947 :         if (np->rxopt.bits.rxohlim) {
     681                 :          0 :                 int hlim = ipv6_hdr(skb)->hop_limit;
     682                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
     683                 :            :         }
     684   [ -  +  #  # ]:        947 :         if (np->rxopt.bits.ohopopts && (opt->flags & IP6SKB_HOPBYHOP)) {
     685                 :          0 :                 u8 *ptr = nh + sizeof(struct ipv6hdr);
     686                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_2292HOPOPTS, (ptr[1]+1)<<3, ptr);
     687                 :            :         }
     688   [ -  +  #  # ]:        947 :         if (np->rxopt.bits.odstopts && opt->dst0) {
     689                 :          0 :                 u8 *ptr = nh + opt->dst0;
     690                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
     691                 :            :         }
     692   [ -  +  #  # ]:        947 :         if (np->rxopt.bits.osrcrt && opt->srcrt) {
     693                 :          0 :                 struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(nh + opt->srcrt);
     694                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_2292RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
     695                 :            :         }
     696   [ -  +  #  # ]:        947 :         if (np->rxopt.bits.odstopts && opt->dst1) {
     697                 :          0 :                 u8 *ptr = nh + opt->dst1;
     698                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
     699                 :            :         }
     700         [ -  + ]:        947 :         if (np->rxopt.bits.rxorigdstaddr) {
     701                 :            :                 struct sockaddr_in6 sin6;
     702                 :            :                 __be16 _ports[2], *ports;
     703                 :            : 
     704                 :            :                 ports = skb_header_pointer(skb, skb_transport_offset(skb),
     705                 :            :                                            sizeof(_ports), &_ports);
     706         [ #  # ]:          0 :                 if (ports) {
     707                 :            :                         /* All current transport protocols have the port numbers in the
     708                 :            :                          * first four bytes of the transport header and this function is
     709                 :            :                          * written with this assumption in mind.
     710                 :            :                          */
     711                 :          0 :                         sin6.sin6_family = AF_INET6;
     712                 :          0 :                         sin6.sin6_addr = ipv6_hdr(skb)->daddr;
     713                 :          0 :                         sin6.sin6_port = ports[1];
     714                 :          0 :                         sin6.sin6_flowinfo = 0;
     715                 :          0 :                         sin6.sin6_scope_id =
     716                 :          0 :                                 ipv6_iface_scope_id(&ipv6_hdr(skb)->daddr,
     717                 :            :                                                     opt->iif);
     718                 :            : 
     719                 :          0 :                         put_cmsg(msg, SOL_IPV6, IPV6_ORIGDSTADDR, sizeof(sin6), &sin6);
     720                 :            :                 }
     721                 :            :         }
     722   [ -  +  #  # ]:        947 :         if (np->rxopt.bits.recvfragsize && opt->frag_max_size) {
     723                 :          0 :                 int val = opt->frag_max_size;
     724                 :            : 
     725                 :          0 :                 put_cmsg(msg, SOL_IPV6, IPV6_RECVFRAGSIZE, sizeof(val), &val);
     726                 :            :         }
     727                 :        947 : }
     728                 :            : 
     729                 :          0 : void ip6_datagram_recv_ctl(struct sock *sk, struct msghdr *msg,
     730                 :            :                           struct sk_buff *skb)
     731                 :            : {
     732                 :          0 :         ip6_datagram_recv_common_ctl(sk, msg, skb);
     733                 :          0 :         ip6_datagram_recv_specific_ctl(sk, msg, skb);
     734                 :          0 : }
     735                 :            : EXPORT_SYMBOL_GPL(ip6_datagram_recv_ctl);
     736                 :            : 
     737                 :       2812 : int ip6_datagram_send_ctl(struct net *net, struct sock *sk,
     738                 :            :                           struct msghdr *msg, struct flowi6 *fl6,
     739                 :            :                           struct ipcm6_cookie *ipc6)
     740                 :            : {
     741                 :            :         struct in6_pktinfo *src_info;
     742                 :            :         struct cmsghdr *cmsg;
     743                 :            :         struct ipv6_rt_hdr *rthdr;
     744                 :            :         struct ipv6_opt_hdr *hdr;
     745                 :       2812 :         struct ipv6_txoptions *opt = ipc6->opt;
     746                 :            :         int len;
     747                 :            :         int err = 0;
     748                 :            : 
     749   [ +  -  +  + ]:       6843 :         for_each_cmsghdr(cmsg, msg) {
     750                 :            :                 int addr_type;
     751                 :            : 
     752   [ +  -  +  - ]:       2812 :                 if (!CMSG_OK(msg, cmsg)) {
     753                 :            :                         err = -EINVAL;
     754                 :            :                         goto exit_f;
     755                 :            :                 }
     756                 :            : 
     757         [ -  + ]:       2812 :                 if (cmsg->cmsg_level == SOL_SOCKET) {
     758                 :          0 :                         err = __sock_cmsg_send(sk, msg, cmsg, &ipc6->sockc);
     759         [ #  # ]:          0 :                         if (err)
     760                 :          0 :                                 return err;
     761                 :          0 :                         continue;
     762                 :            :                 }
     763                 :            : 
     764         [ -  + ]:       2812 :                 if (cmsg->cmsg_level != SOL_IPV6)
     765                 :          0 :                         continue;
     766                 :            : 
     767   [ +  -  -  -  :       2812 :                 switch (cmsg->cmsg_type) {
             -  -  -  -  
                      - ]
     768                 :            :                 case IPV6_PKTINFO:
     769                 :            :                 case IPV6_2292PKTINFO:
     770                 :            :                     {
     771                 :            :                         struct net_device *dev = NULL;
     772                 :            :                         int src_idx;
     773                 :            : 
     774         [ +  - ]:       2812 :                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
     775                 :            :                                 err = -EINVAL;
     776                 :            :                                 goto exit_f;
     777                 :            :                         }
     778                 :            : 
     779                 :            :                         src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
     780                 :       2812 :                         src_idx = src_info->ipi6_ifindex;
     781                 :            : 
     782         [ +  - ]:       2812 :                         if (src_idx) {
     783   [ +  +  -  + ]:       2812 :                                 if (fl6->flowi6_oif &&
     784         [ #  # ]:          0 :                                     src_idx != fl6->flowi6_oif &&
     785         [ #  # ]:          0 :                                     (sk->sk_bound_dev_if != fl6->flowi6_oif ||
     786                 :          0 :                                      !sk_dev_equal_l3scope(sk, src_idx)))
     787                 :            :                                         return -EINVAL;
     788                 :       2812 :                                 fl6->flowi6_oif = src_idx;
     789                 :            :                         }
     790                 :            : 
     791                 :       2812 :                         addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
     792                 :            : 
     793                 :            :                         rcu_read_lock();
     794         [ +  - ]:       2812 :                         if (fl6->flowi6_oif) {
     795                 :       2812 :                                 dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
     796         [ -  + ]:       2812 :                                 if (!dev) {
     797                 :            :                                         rcu_read_unlock();
     798                 :          0 :                                         return -ENODEV;
     799                 :            :                                 }
     800         [ #  # ]:          0 :                         } else if (addr_type & IPV6_ADDR_LINKLOCAL) {
     801                 :            :                                 rcu_read_unlock();
     802                 :          0 :                                 return -EINVAL;
     803                 :            :                         }
     804                 :            : 
     805         [ +  + ]:       2812 :                         if (addr_type != IPV6_ADDR_ANY) {
     806                 :       1981 :                                 int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
     807   [ +  -  +  + ]:       3962 :                                 if (!ipv6_can_nonlocal_bind(net, inet_sk(sk)) &&
     808                 :       1981 :                                     !ipv6_chk_addr_and_flags(net, &src_info->ipi6_addr,
     809                 :            :                                                              dev, !strict, 0,
     810         [ -  + ]:       1593 :                                                              IFA_F_TENTATIVE) &&
     811                 :       1593 :                                     !ipv6_chk_acast_addr_src(net, dev,
     812                 :            :                                                              &src_info->ipi6_addr))
     813                 :            :                                         err = -EINVAL;
     814                 :            :                                 else
     815                 :        388 :                                         fl6->saddr = src_info->ipi6_addr;
     816                 :            :                         }
     817                 :            : 
     818                 :            :                         rcu_read_unlock();
     819                 :            : 
     820         [ +  + ]:       2812 :                         if (err)
     821                 :            :                                 goto exit_f;
     822                 :            : 
     823                 :            :                         break;
     824                 :            :                     }
     825                 :            : 
     826                 :            :                 case IPV6_FLOWINFO:
     827         [ #  # ]:          0 :                         if (cmsg->cmsg_len < CMSG_LEN(4)) {
     828                 :            :                                 err = -EINVAL;
     829                 :            :                                 goto exit_f;
     830                 :            :                         }
     831                 :            : 
     832         [ #  # ]:          0 :                         if (fl6->flowlabel&IPV6_FLOWINFO_MASK) {
     833         [ #  # ]:          0 :                                 if ((fl6->flowlabel^*(__be32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
     834                 :            :                                         err = -EINVAL;
     835                 :            :                                         goto exit_f;
     836                 :            :                                 }
     837                 :            :                         }
     838                 :          0 :                         fl6->flowlabel = IPV6_FLOWINFO_MASK & *(__be32 *)CMSG_DATA(cmsg);
     839                 :          0 :                         break;
     840                 :            : 
     841                 :            :                 case IPV6_2292HOPOPTS:
     842                 :            :                 case IPV6_HOPOPTS:
     843   [ #  #  #  # ]:          0 :                         if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
     844                 :            :                                 err = -EINVAL;
     845                 :            :                                 goto exit_f;
     846                 :            :                         }
     847                 :            : 
     848                 :          0 :                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
     849                 :          0 :                         len = ((hdr->hdrlen + 1) << 3);
     850         [ #  # ]:          0 :                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
     851                 :            :                                 err = -EINVAL;
     852                 :            :                                 goto exit_f;
     853                 :            :                         }
     854         [ #  # ]:          0 :                         if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
     855                 :            :                                 err = -EPERM;
     856                 :            :                                 goto exit_f;
     857                 :            :                         }
     858                 :          0 :                         opt->opt_nflen += len;
     859                 :          0 :                         opt->hopopt = hdr;
     860                 :          0 :                         break;
     861                 :            : 
     862                 :            :                 case IPV6_2292DSTOPTS:
     863         [ #  # ]:          0 :                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
     864                 :            :                                 err = -EINVAL;
     865                 :            :                                 goto exit_f;
     866                 :            :                         }
     867                 :            : 
     868                 :          0 :                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
     869                 :          0 :                         len = ((hdr->hdrlen + 1) << 3);
     870         [ #  # ]:          0 :                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
     871                 :            :                                 err = -EINVAL;
     872                 :            :                                 goto exit_f;
     873                 :            :                         }
     874         [ #  # ]:          0 :                         if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
     875                 :            :                                 err = -EPERM;
     876                 :            :                                 goto exit_f;
     877                 :            :                         }
     878         [ #  # ]:          0 :                         if (opt->dst1opt) {
     879                 :            :                                 err = -EINVAL;
     880                 :            :                                 goto exit_f;
     881                 :            :                         }
     882                 :          0 :                         opt->opt_flen += len;
     883                 :          0 :                         opt->dst1opt = hdr;
     884                 :          0 :                         break;
     885                 :            : 
     886                 :            :                 case IPV6_DSTOPTS:
     887                 :            :                 case IPV6_RTHDRDSTOPTS:
     888         [ #  # ]:          0 :                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
     889                 :            :                                 err = -EINVAL;
     890                 :            :                                 goto exit_f;
     891                 :            :                         }
     892                 :            : 
     893                 :          0 :                         hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
     894                 :          0 :                         len = ((hdr->hdrlen + 1) << 3);
     895         [ #  # ]:          0 :                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
     896                 :            :                                 err = -EINVAL;
     897                 :            :                                 goto exit_f;
     898                 :            :                         }
     899         [ #  # ]:          0 :                         if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
     900                 :            :                                 err = -EPERM;
     901                 :            :                                 goto exit_f;
     902                 :            :                         }
     903         [ #  # ]:          0 :                         if (cmsg->cmsg_type == IPV6_DSTOPTS) {
     904                 :          0 :                                 opt->opt_flen += len;
     905                 :          0 :                                 opt->dst1opt = hdr;
     906                 :            :                         } else {
     907                 :          0 :                                 opt->opt_nflen += len;
     908                 :          0 :                                 opt->dst0opt = hdr;
     909                 :            :                         }
     910                 :            :                         break;
     911                 :            : 
     912                 :            :                 case IPV6_2292RTHDR:
     913                 :            :                 case IPV6_RTHDR:
     914                 :            :                         if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
     915                 :            :                                 err = -EINVAL;
     916                 :            :                                 goto exit_f;
     917                 :            :                         }
     918                 :            : 
     919                 :            :                         rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
     920                 :            : 
     921                 :            :                         switch (rthdr->type) {
     922                 :            : #if IS_ENABLED(CONFIG_IPV6_MIP6)
     923                 :            :                         case IPV6_SRCRT_TYPE_2:
     924                 :            :                                 if (rthdr->hdrlen != 2 ||
     925                 :            :                                     rthdr->segments_left != 1) {
     926                 :            :                                         err = -EINVAL;
     927                 :            :                                         goto exit_f;
     928                 :            :                                 }
     929                 :            :                                 break;
     930                 :            : #endif
     931                 :            :                         default:
     932                 :            :                                 err = -EINVAL;
     933                 :            :                                 goto exit_f;
     934                 :            :                         }
     935                 :            : 
     936                 :            :                         len = ((rthdr->hdrlen + 1) << 3);
     937                 :            : 
     938                 :            :                         if (cmsg->cmsg_len < CMSG_LEN(len)) {
     939                 :            :                                 err = -EINVAL;
     940                 :            :                                 goto exit_f;
     941                 :            :                         }
     942                 :            : 
     943                 :            :                         /* segments left must also match */
     944                 :            :                         if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
     945                 :            :                                 err = -EINVAL;
     946                 :            :                                 goto exit_f;
     947                 :            :                         }
     948                 :            : 
     949                 :            :                         opt->opt_nflen += len;
     950                 :            :                         opt->srcrt = rthdr;
     951                 :            : 
     952                 :            :                         if (cmsg->cmsg_type == IPV6_2292RTHDR && opt->dst1opt) {
     953                 :            :                                 int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
     954                 :            : 
     955                 :            :                                 opt->opt_nflen += dsthdrlen;
     956                 :            :                                 opt->dst0opt = opt->dst1opt;
     957                 :            :                                 opt->dst1opt = NULL;
     958                 :            :                                 opt->opt_flen -= dsthdrlen;
     959                 :            :                         }
     960                 :            : 
     961                 :            :                         break;
     962                 :            : 
     963                 :            :                 case IPV6_2292HOPLIMIT:
     964                 :            :                 case IPV6_HOPLIMIT:
     965         [ #  # ]:          0 :                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
     966                 :            :                                 err = -EINVAL;
     967                 :            :                                 goto exit_f;
     968                 :            :                         }
     969                 :            : 
     970                 :          0 :                         ipc6->hlimit = *(int *)CMSG_DATA(cmsg);
     971         [ #  # ]:          0 :                         if (ipc6->hlimit < -1 || ipc6->hlimit > 0xff) {
     972                 :            :                                 err = -EINVAL;
     973                 :            :                                 goto exit_f;
     974                 :            :                         }
     975                 :            : 
     976                 :            :                         break;
     977                 :            : 
     978                 :            :                 case IPV6_TCLASS:
     979                 :            :                     {
     980                 :            :                         int tc;
     981                 :            : 
     982                 :            :                         err = -EINVAL;
     983         [ #  # ]:          0 :                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
     984                 :            :                                 goto exit_f;
     985                 :            : 
     986                 :          0 :                         tc = *(int *)CMSG_DATA(cmsg);
     987         [ #  # ]:          0 :                         if (tc < -1 || tc > 0xff)
     988                 :            :                                 goto exit_f;
     989                 :            : 
     990                 :            :                         err = 0;
     991                 :          0 :                         ipc6->tclass = tc;
     992                 :            : 
     993                 :          0 :                         break;
     994                 :            :                     }
     995                 :            : 
     996                 :            :                 case IPV6_DONTFRAG:
     997                 :            :                     {
     998                 :            :                         int df;
     999                 :            : 
    1000                 :            :                         err = -EINVAL;
    1001         [ #  # ]:          0 :                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
    1002                 :            :                                 goto exit_f;
    1003                 :            : 
    1004                 :          0 :                         df = *(int *)CMSG_DATA(cmsg);
    1005         [ #  # ]:          0 :                         if (df < 0 || df > 1)
    1006                 :            :                                 goto exit_f;
    1007                 :            : 
    1008                 :            :                         err = 0;
    1009                 :          0 :                         ipc6->dontfrag = df;
    1010                 :            : 
    1011                 :          0 :                         break;
    1012                 :            :                     }
    1013                 :            :                 default:
    1014                 :            :                         net_dbg_ratelimited("invalid cmsg type: %d\n",
    1015                 :            :                                             cmsg->cmsg_type);
    1016                 :            :                         err = -EINVAL;
    1017                 :            :                         goto exit_f;
    1018                 :            :                 }
    1019                 :            :         }
    1020                 :            : 
    1021                 :            : exit_f:
    1022                 :       2812 :         return err;
    1023                 :            : }
    1024                 :            : EXPORT_SYMBOL_GPL(ip6_datagram_send_ctl);
    1025                 :            : 
    1026                 :          0 : void __ip6_dgram_sock_seq_show(struct seq_file *seq, struct sock *sp,
    1027                 :            :                                __u16 srcp, __u16 destp, int rqueue, int bucket)
    1028                 :            : {
    1029                 :            :         const struct in6_addr *dest, *src;
    1030                 :            : 
    1031                 :            :         dest  = &sp->sk_v6_daddr;
    1032                 :            :         src   = &sp->sk_v6_rcv_saddr;
    1033                 :          0 :         seq_printf(seq,
    1034                 :            :                    "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
    1035                 :            :                    "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
    1036                 :            :                    bucket,
    1037                 :            :                    src->s6_addr32[0], src->s6_addr32[1],
    1038                 :            :                    src->s6_addr32[2], src->s6_addr32[3], srcp,
    1039                 :            :                    dest->s6_addr32[0], dest->s6_addr32[1],
    1040                 :            :                    dest->s6_addr32[2], dest->s6_addr32[3], destp,
    1041                 :          0 :                    sp->sk_state,
    1042                 :            :                    sk_wmem_alloc_get(sp),
    1043                 :            :                    rqueue,
    1044                 :            :                    0, 0L, 0,
    1045                 :            :                    from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
    1046                 :            :                    0,
    1047                 :            :                    sock_i_ino(sp),
    1048                 :            :                    refcount_read(&sp->sk_refcnt), sp,
    1049                 :          0 :                    atomic_read(&sp->sk_drops));
    1050                 :          0 : }

Generated by: LCOV version 1.14