Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  common UDP/RAW code
0004  *  Linux INET6 implementation
0005  *
0006  *  Authors:
0007  *  Pedro Roque     <roque@di.fc.ul.pt>
0008  */
0009 
0010 #include <linux/capability.h>
0011 #include <linux/errno.h>
0012 #include <linux/types.h>
0013 #include <linux/kernel.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/socket.h>
0016 #include <linux/sockios.h>
0017 #include <linux/in6.h>
0018 #include <linux/ipv6.h>
0019 #include <linux/route.h>
0020 #include <linux/slab.h>
0021 #include <linux/export.h>
0022 #include <linux/icmp.h>
0023 
0024 #include <net/ipv6.h>
0025 #include <net/ndisc.h>
0026 #include <net/addrconf.h>
0027 #include <net/transp_v6.h>
0028 #include <net/ip6_route.h>
0029 #include <net/tcp_states.h>
0030 #include <net/dsfield.h>
0031 #include <net/sock_reuseport.h>
0032 
0033 #include <linux/errqueue.h>
0034 #include <linux/uaccess.h>
0035 
0036 static bool ipv6_mapped_addr_any(const struct in6_addr *a)
0037 {
0038     return ipv6_addr_v4mapped(a) && (a->s6_addr32[3] == 0);
0039 }
0040 
0041 static void ip6_datagram_flow_key_init(struct flowi6 *fl6, struct sock *sk)
0042 {
0043     struct inet_sock *inet = inet_sk(sk);
0044     struct ipv6_pinfo *np = inet6_sk(sk);
0045 
0046     memset(fl6, 0, sizeof(*fl6));
0047     fl6->flowi6_proto = sk->sk_protocol;
0048     fl6->daddr = sk->sk_v6_daddr;
0049     fl6->saddr = np->saddr;
0050     fl6->flowi6_oif = sk->sk_bound_dev_if;
0051     fl6->flowi6_mark = sk->sk_mark;
0052     fl6->fl6_dport = inet->inet_dport;
0053     fl6->fl6_sport = inet->inet_sport;
0054     fl6->flowlabel = np->flow_label;
0055     fl6->flowi6_uid = sk->sk_uid;
0056 
0057     if (!fl6->flowi6_oif)
0058         fl6->flowi6_oif = np->sticky_pktinfo.ipi6_ifindex;
0059 
0060     if (!fl6->flowi6_oif && ipv6_addr_is_multicast(&fl6->daddr))
0061         fl6->flowi6_oif = np->mcast_oif;
0062 
0063     security_sk_classify_flow(sk, flowi6_to_flowi_common(fl6));
0064 }
0065 
0066 int ip6_datagram_dst_update(struct sock *sk, bool fix_sk_saddr)
0067 {
0068     struct ip6_flowlabel *flowlabel = NULL;
0069     struct in6_addr *final_p, final;
0070     struct ipv6_txoptions *opt;
0071     struct dst_entry *dst;
0072     struct inet_sock *inet = inet_sk(sk);
0073     struct ipv6_pinfo *np = inet6_sk(sk);
0074     struct flowi6 fl6;
0075     int err = 0;
0076 
0077     if (np->sndflow && (np->flow_label & IPV6_FLOWLABEL_MASK)) {
0078         flowlabel = fl6_sock_lookup(sk, np->flow_label);
0079         if (IS_ERR(flowlabel))
0080             return -EINVAL;
0081     }
0082     ip6_datagram_flow_key_init(&fl6, sk);
0083 
0084     rcu_read_lock();
0085     opt = flowlabel ? flowlabel->opt : rcu_dereference(np->opt);
0086     final_p = fl6_update_dst(&fl6, opt, &final);
0087     rcu_read_unlock();
0088 
0089     dst = ip6_dst_lookup_flow(sock_net(sk), sk, &fl6, final_p);
0090     if (IS_ERR(dst)) {
0091         err = PTR_ERR(dst);
0092         goto out;
0093     }
0094 
0095     if (fix_sk_saddr) {
0096         if (ipv6_addr_any(&np->saddr))
0097             np->saddr = fl6.saddr;
0098 
0099         if (ipv6_addr_any(&sk->sk_v6_rcv_saddr)) {
0100             sk->sk_v6_rcv_saddr = fl6.saddr;
0101             inet->inet_rcv_saddr = LOOPBACK4_IPV6;
0102             if (sk->sk_prot->rehash)
0103                 sk->sk_prot->rehash(sk);
0104         }
0105     }
0106 
0107     ip6_sk_dst_store_flow(sk, dst, &fl6);
0108 
0109 out:
0110     fl6_sock_release(flowlabel);
0111     return err;
0112 }
0113 
0114 void ip6_datagram_release_cb(struct sock *sk)
0115 {
0116     struct dst_entry *dst;
0117 
0118     if (ipv6_addr_v4mapped(&sk->sk_v6_daddr))
0119         return;
0120 
0121     rcu_read_lock();
0122     dst = __sk_dst_get(sk);
0123     if (!dst || !dst->obsolete ||
0124         dst->ops->check(dst, inet6_sk(sk)->dst_cookie)) {
0125         rcu_read_unlock();
0126         return;
0127     }
0128     rcu_read_unlock();
0129 
0130     ip6_datagram_dst_update(sk, false);
0131 }
0132 EXPORT_SYMBOL_GPL(ip6_datagram_release_cb);
0133 
0134 int __ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr,
0135                int addr_len)
0136 {
0137     struct sockaddr_in6 *usin = (struct sockaddr_in6 *) uaddr;
0138     struct inet_sock    *inet = inet_sk(sk);
0139     struct ipv6_pinfo   *np = inet6_sk(sk);
0140     struct in6_addr     *daddr, old_daddr;
0141     __be32          fl6_flowlabel = 0;
0142     __be32          old_fl6_flowlabel;
0143     __be16          old_dport;
0144     int         addr_type;
0145     int         err;
0146 
0147     if (usin->sin6_family == AF_INET) {
0148         if (ipv6_only_sock(sk))
0149             return -EAFNOSUPPORT;
0150         err = __ip4_datagram_connect(sk, uaddr, addr_len);
0151         goto ipv4_connected;
0152     }
0153 
0154     if (addr_len < SIN6_LEN_RFC2133)
0155         return -EINVAL;
0156 
0157     if (usin->sin6_family != AF_INET6)
0158         return -EAFNOSUPPORT;
0159 
0160     if (np->sndflow)
0161         fl6_flowlabel = usin->sin6_flowinfo & IPV6_FLOWINFO_MASK;
0162 
0163     if (ipv6_addr_any(&usin->sin6_addr)) {
0164         /*
0165          *  connect to self
0166          */
0167         if (ipv6_addr_v4mapped(&sk->sk_v6_rcv_saddr))
0168             ipv6_addr_set_v4mapped(htonl(INADDR_LOOPBACK),
0169                            &usin->sin6_addr);
0170         else
0171             usin->sin6_addr = in6addr_loopback;
0172     }
0173 
0174     addr_type = ipv6_addr_type(&usin->sin6_addr);
0175 
0176     daddr = &usin->sin6_addr;
0177 
0178     if (addr_type & IPV6_ADDR_MAPPED) {
0179         struct sockaddr_in sin;
0180 
0181         if (ipv6_only_sock(sk)) {
0182             err = -ENETUNREACH;
0183             goto out;
0184         }
0185         sin.sin_family = AF_INET;
0186         sin.sin_addr.s_addr = daddr->s6_addr32[3];
0187         sin.sin_port = usin->sin6_port;
0188 
0189         err = __ip4_datagram_connect(sk,
0190                          (struct sockaddr *) &sin,
0191                          sizeof(sin));
0192 
0193 ipv4_connected:
0194         if (err)
0195             goto out;
0196 
0197         ipv6_addr_set_v4mapped(inet->inet_daddr, &sk->sk_v6_daddr);
0198 
0199         if (ipv6_addr_any(&np->saddr) ||
0200             ipv6_mapped_addr_any(&np->saddr))
0201             ipv6_addr_set_v4mapped(inet->inet_saddr, &np->saddr);
0202 
0203         if (ipv6_addr_any(&sk->sk_v6_rcv_saddr) ||
0204             ipv6_mapped_addr_any(&sk->sk_v6_rcv_saddr)) {
0205             ipv6_addr_set_v4mapped(inet->inet_rcv_saddr,
0206                            &sk->sk_v6_rcv_saddr);
0207             if (sk->sk_prot->rehash)
0208                 sk->sk_prot->rehash(sk);
0209         }
0210 
0211         goto out;
0212     }
0213 
0214     if (__ipv6_addr_needs_scope_id(addr_type)) {
0215         if (addr_len >= sizeof(struct sockaddr_in6) &&
0216             usin->sin6_scope_id) {
0217             if (!sk_dev_equal_l3scope(sk, usin->sin6_scope_id)) {
0218                 err = -EINVAL;
0219                 goto out;
0220             }
0221             WRITE_ONCE(sk->sk_bound_dev_if, usin->sin6_scope_id);
0222         }
0223 
0224         if (!sk->sk_bound_dev_if && (addr_type & IPV6_ADDR_MULTICAST))
0225             WRITE_ONCE(sk->sk_bound_dev_if, np->mcast_oif);
0226 
0227         /* Connect to link-local address requires an interface */
0228         if (!sk->sk_bound_dev_if) {
0229             err = -EINVAL;
0230             goto out;
0231         }
0232     }
0233 
0234     /* save the current peer information before updating it */
0235     old_daddr = sk->sk_v6_daddr;
0236     old_fl6_flowlabel = np->flow_label;
0237     old_dport = inet->inet_dport;
0238 
0239     sk->sk_v6_daddr = *daddr;
0240     np->flow_label = fl6_flowlabel;
0241     inet->inet_dport = usin->sin6_port;
0242 
0243     /*
0244      *  Check for a route to destination an obtain the
0245      *  destination cache for it.
0246      */
0247 
0248     err = ip6_datagram_dst_update(sk, true);
0249     if (err) {
0250         /* Restore the socket peer info, to keep it consistent with
0251          * the old socket state
0252          */
0253         sk->sk_v6_daddr = old_daddr;
0254         np->flow_label = old_fl6_flowlabel;
0255         inet->inet_dport = old_dport;
0256         goto out;
0257     }
0258 
0259     reuseport_has_conns(sk, true);
0260     sk->sk_state = TCP_ESTABLISHED;
0261     sk_set_txhash(sk);
0262 out:
0263     return err;
0264 }
0265 EXPORT_SYMBOL_GPL(__ip6_datagram_connect);
0266 
0267 int ip6_datagram_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len)
0268 {
0269     int res;
0270 
0271     lock_sock(sk);
0272     res = __ip6_datagram_connect(sk, uaddr, addr_len);
0273     release_sock(sk);
0274     return res;
0275 }
0276 EXPORT_SYMBOL_GPL(ip6_datagram_connect);
0277 
0278 int ip6_datagram_connect_v6_only(struct sock *sk, struct sockaddr *uaddr,
0279                  int addr_len)
0280 {
0281     DECLARE_SOCKADDR(struct sockaddr_in6 *, sin6, uaddr);
0282     if (sin6->sin6_family != AF_INET6)
0283         return -EAFNOSUPPORT;
0284     return ip6_datagram_connect(sk, uaddr, addr_len);
0285 }
0286 EXPORT_SYMBOL_GPL(ip6_datagram_connect_v6_only);
0287 
0288 static void ipv6_icmp_error_rfc4884(const struct sk_buff *skb,
0289                     struct sock_ee_data_rfc4884 *out)
0290 {
0291     switch (icmp6_hdr(skb)->icmp6_type) {
0292     case ICMPV6_TIME_EXCEED:
0293     case ICMPV6_DEST_UNREACH:
0294         ip_icmp_error_rfc4884(skb, out, sizeof(struct icmp6hdr),
0295                       icmp6_hdr(skb)->icmp6_datagram_len * 8);
0296     }
0297 }
0298 
0299 void ipv6_icmp_error(struct sock *sk, struct sk_buff *skb, int err,
0300              __be16 port, u32 info, u8 *payload)
0301 {
0302     struct ipv6_pinfo *np  = inet6_sk(sk);
0303     struct icmp6hdr *icmph = icmp6_hdr(skb);
0304     struct sock_exterr_skb *serr;
0305 
0306     if (!np->recverr)
0307         return;
0308 
0309     skb = skb_clone(skb, GFP_ATOMIC);
0310     if (!skb)
0311         return;
0312 
0313     skb->protocol = htons(ETH_P_IPV6);
0314 
0315     serr = SKB_EXT_ERR(skb);
0316     serr->ee.ee_errno = err;
0317     serr->ee.ee_origin = SO_EE_ORIGIN_ICMP6;
0318     serr->ee.ee_type = icmph->icmp6_type;
0319     serr->ee.ee_code = icmph->icmp6_code;
0320     serr->ee.ee_pad = 0;
0321     serr->ee.ee_info = info;
0322     serr->ee.ee_data = 0;
0323     serr->addr_offset = (u8 *)&(((struct ipv6hdr *)(icmph + 1))->daddr) -
0324                   skb_network_header(skb);
0325     serr->port = port;
0326 
0327     __skb_pull(skb, payload - skb->data);
0328 
0329     if (inet6_sk(sk)->recverr_rfc4884)
0330         ipv6_icmp_error_rfc4884(skb, &serr->ee.ee_rfc4884);
0331 
0332     skb_reset_transport_header(skb);
0333 
0334     if (sock_queue_err_skb(sk, skb))
0335         kfree_skb(skb);
0336 }
0337 
0338 void ipv6_local_error(struct sock *sk, int err, struct flowi6 *fl6, u32 info)
0339 {
0340     const struct ipv6_pinfo *np = inet6_sk(sk);
0341     struct sock_exterr_skb *serr;
0342     struct ipv6hdr *iph;
0343     struct sk_buff *skb;
0344 
0345     if (!np->recverr)
0346         return;
0347 
0348     skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
0349     if (!skb)
0350         return;
0351 
0352     skb->protocol = htons(ETH_P_IPV6);
0353 
0354     skb_put(skb, sizeof(struct ipv6hdr));
0355     skb_reset_network_header(skb);
0356     iph = ipv6_hdr(skb);
0357     iph->daddr = fl6->daddr;
0358     ip6_flow_hdr(iph, 0, 0);
0359 
0360     serr = SKB_EXT_ERR(skb);
0361     serr->ee.ee_errno = err;
0362     serr->ee.ee_origin = SO_EE_ORIGIN_LOCAL;
0363     serr->ee.ee_type = 0;
0364     serr->ee.ee_code = 0;
0365     serr->ee.ee_pad = 0;
0366     serr->ee.ee_info = info;
0367     serr->ee.ee_data = 0;
0368     serr->addr_offset = (u8 *)&iph->daddr - skb_network_header(skb);
0369     serr->port = fl6->fl6_dport;
0370 
0371     __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
0372     skb_reset_transport_header(skb);
0373 
0374     if (sock_queue_err_skb(sk, skb))
0375         kfree_skb(skb);
0376 }
0377 
0378 void ipv6_local_rxpmtu(struct sock *sk, struct flowi6 *fl6, u32 mtu)
0379 {
0380     struct ipv6_pinfo *np = inet6_sk(sk);
0381     struct ipv6hdr *iph;
0382     struct sk_buff *skb;
0383     struct ip6_mtuinfo *mtu_info;
0384 
0385     if (!np->rxopt.bits.rxpmtu)
0386         return;
0387 
0388     skb = alloc_skb(sizeof(struct ipv6hdr), GFP_ATOMIC);
0389     if (!skb)
0390         return;
0391 
0392     skb_put(skb, sizeof(struct ipv6hdr));
0393     skb_reset_network_header(skb);
0394     iph = ipv6_hdr(skb);
0395     iph->daddr = fl6->daddr;
0396 
0397     mtu_info = IP6CBMTU(skb);
0398 
0399     mtu_info->ip6m_mtu = mtu;
0400     mtu_info->ip6m_addr.sin6_family = AF_INET6;
0401     mtu_info->ip6m_addr.sin6_port = 0;
0402     mtu_info->ip6m_addr.sin6_flowinfo = 0;
0403     mtu_info->ip6m_addr.sin6_scope_id = fl6->flowi6_oif;
0404     mtu_info->ip6m_addr.sin6_addr = ipv6_hdr(skb)->daddr;
0405 
0406     __skb_pull(skb, skb_tail_pointer(skb) - skb->data);
0407     skb_reset_transport_header(skb);
0408 
0409     skb = xchg(&np->rxpmtu, skb);
0410     kfree_skb(skb);
0411 }
0412 
0413 /* For some errors we have valid addr_offset even with zero payload and
0414  * zero port. Also, addr_offset should be supported if port is set.
0415  */
0416 static inline bool ipv6_datagram_support_addr(struct sock_exterr_skb *serr)
0417 {
0418     return serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6 ||
0419            serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
0420            serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL || serr->port;
0421 }
0422 
0423 /* IPv6 supports cmsg on all origins aside from SO_EE_ORIGIN_LOCAL.
0424  *
0425  * At one point, excluding local errors was a quick test to identify icmp/icmp6
0426  * errors. This is no longer true, but the test remained, so the v6 stack,
0427  * unlike v4, also honors cmsg requests on all wifi and timestamp errors.
0428  */
0429 static bool ip6_datagram_support_cmsg(struct sk_buff *skb,
0430                       struct sock_exterr_skb *serr)
0431 {
0432     if (serr->ee.ee_origin == SO_EE_ORIGIN_ICMP ||
0433         serr->ee.ee_origin == SO_EE_ORIGIN_ICMP6)
0434         return true;
0435 
0436     if (serr->ee.ee_origin == SO_EE_ORIGIN_LOCAL)
0437         return false;
0438 
0439     if (!IP6CB(skb)->iif)
0440         return false;
0441 
0442     return true;
0443 }
0444 
0445 /*
0446  *  Handle MSG_ERRQUEUE
0447  */
0448 int ipv6_recv_error(struct sock *sk, struct msghdr *msg, int len, int *addr_len)
0449 {
0450     struct ipv6_pinfo *np = inet6_sk(sk);
0451     struct sock_exterr_skb *serr;
0452     struct sk_buff *skb;
0453     DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
0454     struct {
0455         struct sock_extended_err ee;
0456         struct sockaddr_in6  offender;
0457     } errhdr;
0458     int err;
0459     int copied;
0460 
0461     err = -EAGAIN;
0462     skb = sock_dequeue_err_skb(sk);
0463     if (!skb)
0464         goto out;
0465 
0466     copied = skb->len;
0467     if (copied > len) {
0468         msg->msg_flags |= MSG_TRUNC;
0469         copied = len;
0470     }
0471     err = skb_copy_datagram_msg(skb, 0, msg, copied);
0472     if (unlikely(err)) {
0473         kfree_skb(skb);
0474         return err;
0475     }
0476     sock_recv_timestamp(msg, sk, skb);
0477 
0478     serr = SKB_EXT_ERR(skb);
0479 
0480     if (sin && ipv6_datagram_support_addr(serr)) {
0481         const unsigned char *nh = skb_network_header(skb);
0482         sin->sin6_family = AF_INET6;
0483         sin->sin6_flowinfo = 0;
0484         sin->sin6_port = serr->port;
0485         if (skb->protocol == htons(ETH_P_IPV6)) {
0486             const struct ipv6hdr *ip6h = container_of((struct in6_addr *)(nh + serr->addr_offset),
0487                                   struct ipv6hdr, daddr);
0488             sin->sin6_addr = ip6h->daddr;
0489             if (np->sndflow)
0490                 sin->sin6_flowinfo = ip6_flowinfo(ip6h);
0491             sin->sin6_scope_id =
0492                 ipv6_iface_scope_id(&sin->sin6_addr,
0493                             IP6CB(skb)->iif);
0494         } else {
0495             ipv6_addr_set_v4mapped(*(__be32 *)(nh + serr->addr_offset),
0496                            &sin->sin6_addr);
0497             sin->sin6_scope_id = 0;
0498         }
0499         *addr_len = sizeof(*sin);
0500     }
0501 
0502     memcpy(&errhdr.ee, &serr->ee, sizeof(struct sock_extended_err));
0503     sin = &errhdr.offender;
0504     memset(sin, 0, sizeof(*sin));
0505 
0506     if (ip6_datagram_support_cmsg(skb, serr)) {
0507         sin->sin6_family = AF_INET6;
0508         if (np->rxopt.all)
0509             ip6_datagram_recv_common_ctl(sk, msg, skb);
0510         if (skb->protocol == htons(ETH_P_IPV6)) {
0511             sin->sin6_addr = ipv6_hdr(skb)->saddr;
0512             if (np->rxopt.all)
0513                 ip6_datagram_recv_specific_ctl(sk, msg, skb);
0514             sin->sin6_scope_id =
0515                 ipv6_iface_scope_id(&sin->sin6_addr,
0516                             IP6CB(skb)->iif);
0517         } else {
0518             ipv6_addr_set_v4mapped(ip_hdr(skb)->saddr,
0519                            &sin->sin6_addr);
0520             if (inet_sk(sk)->cmsg_flags)
0521                 ip_cmsg_recv(msg, skb);
0522         }
0523     }
0524 
0525     put_cmsg(msg, SOL_IPV6, IPV6_RECVERR, sizeof(errhdr), &errhdr);
0526 
0527     /* Now we could try to dump offended packet options */
0528 
0529     msg->msg_flags |= MSG_ERRQUEUE;
0530     err = copied;
0531 
0532     consume_skb(skb);
0533 out:
0534     return err;
0535 }
0536 EXPORT_SYMBOL_GPL(ipv6_recv_error);
0537 
0538 /*
0539  *  Handle IPV6_RECVPATHMTU
0540  */
0541 int ipv6_recv_rxpmtu(struct sock *sk, struct msghdr *msg, int len,
0542              int *addr_len)
0543 {
0544     struct ipv6_pinfo *np = inet6_sk(sk);
0545     struct sk_buff *skb;
0546     struct ip6_mtuinfo mtu_info;
0547     DECLARE_SOCKADDR(struct sockaddr_in6 *, sin, msg->msg_name);
0548     int err;
0549     int copied;
0550 
0551     err = -EAGAIN;
0552     skb = xchg(&np->rxpmtu, NULL);
0553     if (!skb)
0554         goto out;
0555 
0556     copied = skb->len;
0557     if (copied > len) {
0558         msg->msg_flags |= MSG_TRUNC;
0559         copied = len;
0560     }
0561     err = skb_copy_datagram_msg(skb, 0, msg, copied);
0562     if (err)
0563         goto out_free_skb;
0564 
0565     sock_recv_timestamp(msg, sk, skb);
0566 
0567     memcpy(&mtu_info, IP6CBMTU(skb), sizeof(mtu_info));
0568 
0569     if (sin) {
0570         sin->sin6_family = AF_INET6;
0571         sin->sin6_flowinfo = 0;
0572         sin->sin6_port = 0;
0573         sin->sin6_scope_id = mtu_info.ip6m_addr.sin6_scope_id;
0574         sin->sin6_addr = mtu_info.ip6m_addr.sin6_addr;
0575         *addr_len = sizeof(*sin);
0576     }
0577 
0578     put_cmsg(msg, SOL_IPV6, IPV6_PATHMTU, sizeof(mtu_info), &mtu_info);
0579 
0580     err = copied;
0581 
0582 out_free_skb:
0583     kfree_skb(skb);
0584 out:
0585     return err;
0586 }
0587 
0588 
0589 void ip6_datagram_recv_common_ctl(struct sock *sk, struct msghdr *msg,
0590                  struct sk_buff *skb)
0591 {
0592     struct ipv6_pinfo *np = inet6_sk(sk);
0593     bool is_ipv6 = skb->protocol == htons(ETH_P_IPV6);
0594 
0595     if (np->rxopt.bits.rxinfo) {
0596         struct in6_pktinfo src_info;
0597 
0598         if (is_ipv6) {
0599             src_info.ipi6_ifindex = IP6CB(skb)->iif;
0600             src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
0601         } else {
0602             src_info.ipi6_ifindex =
0603                 PKTINFO_SKB_CB(skb)->ipi_ifindex;
0604             ipv6_addr_set_v4mapped(ip_hdr(skb)->daddr,
0605                            &src_info.ipi6_addr);
0606         }
0607 
0608         if (src_info.ipi6_ifindex >= 0)
0609             put_cmsg(msg, SOL_IPV6, IPV6_PKTINFO,
0610                  sizeof(src_info), &src_info);
0611     }
0612 }
0613 
0614 void ip6_datagram_recv_specific_ctl(struct sock *sk, struct msghdr *msg,
0615                     struct sk_buff *skb)
0616 {
0617     struct ipv6_pinfo *np = inet6_sk(sk);
0618     struct inet6_skb_parm *opt = IP6CB(skb);
0619     unsigned char *nh = skb_network_header(skb);
0620 
0621     if (np->rxopt.bits.rxhlim) {
0622         int hlim = ipv6_hdr(skb)->hop_limit;
0623         put_cmsg(msg, SOL_IPV6, IPV6_HOPLIMIT, sizeof(hlim), &hlim);
0624     }
0625 
0626     if (np->rxopt.bits.rxtclass) {
0627         int tclass = ipv6_get_dsfield(ipv6_hdr(skb));
0628         put_cmsg(msg, SOL_IPV6, IPV6_TCLASS, sizeof(tclass), &tclass);
0629     }
0630 
0631     if (np->rxopt.bits.rxflow) {
0632         __be32 flowinfo = ip6_flowinfo((struct ipv6hdr *)nh);
0633         if (flowinfo)
0634             put_cmsg(msg, SOL_IPV6, IPV6_FLOWINFO, sizeof(flowinfo), &flowinfo);
0635     }
0636 
0637     /* HbH is allowed only once */
0638     if (np->rxopt.bits.hopopts && (opt->flags & IP6SKB_HOPBYHOP)) {
0639         u8 *ptr = nh + sizeof(struct ipv6hdr);
0640         put_cmsg(msg, SOL_IPV6, IPV6_HOPOPTS, (ptr[1]+1)<<3, ptr);
0641     }
0642 
0643     if (opt->lastopt &&
0644         (np->rxopt.bits.dstopts || np->rxopt.bits.srcrt)) {
0645         /*
0646          * Silly enough, but we need to reparse in order to
0647          * report extension headers (except for HbH)
0648          * in order.
0649          *
0650          * Also note that IPV6_RECVRTHDRDSTOPTS is NOT
0651          * (and WILL NOT be) defined because
0652          * IPV6_RECVDSTOPTS is more generic. --yoshfuji
0653          */
0654         unsigned int off = sizeof(struct ipv6hdr);
0655         u8 nexthdr = ipv6_hdr(skb)->nexthdr;
0656 
0657         while (off <= opt->lastopt) {
0658             unsigned int len;
0659             u8 *ptr = nh + off;
0660 
0661             switch (nexthdr) {
0662             case IPPROTO_DSTOPTS:
0663                 nexthdr = ptr[0];
0664                 len = (ptr[1] + 1) << 3;
0665                 if (np->rxopt.bits.dstopts)
0666                     put_cmsg(msg, SOL_IPV6, IPV6_DSTOPTS, len, ptr);
0667                 break;
0668             case IPPROTO_ROUTING:
0669                 nexthdr = ptr[0];
0670                 len = (ptr[1] + 1) << 3;
0671                 if (np->rxopt.bits.srcrt)
0672                     put_cmsg(msg, SOL_IPV6, IPV6_RTHDR, len, ptr);
0673                 break;
0674             case IPPROTO_AH:
0675                 nexthdr = ptr[0];
0676                 len = (ptr[1] + 2) << 2;
0677                 break;
0678             default:
0679                 nexthdr = ptr[0];
0680                 len = (ptr[1] + 1) << 3;
0681                 break;
0682             }
0683 
0684             off += len;
0685         }
0686     }
0687 
0688     /* socket options in old style */
0689     if (np->rxopt.bits.rxoinfo) {
0690         struct in6_pktinfo src_info;
0691 
0692         src_info.ipi6_ifindex = opt->iif;
0693         src_info.ipi6_addr = ipv6_hdr(skb)->daddr;
0694         put_cmsg(msg, SOL_IPV6, IPV6_2292PKTINFO, sizeof(src_info), &src_info);
0695     }
0696     if (np->rxopt.bits.rxohlim) {
0697         int hlim = ipv6_hdr(skb)->hop_limit;
0698         put_cmsg(msg, SOL_IPV6, IPV6_2292HOPLIMIT, sizeof(hlim), &hlim);
0699     }
0700     if (np->rxopt.bits.ohopopts && (opt->flags & IP6SKB_HOPBYHOP)) {
0701         u8 *ptr = nh + sizeof(struct ipv6hdr);
0702         put_cmsg(msg, SOL_IPV6, IPV6_2292HOPOPTS, (ptr[1]+1)<<3, ptr);
0703     }
0704     if (np->rxopt.bits.odstopts && opt->dst0) {
0705         u8 *ptr = nh + opt->dst0;
0706         put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
0707     }
0708     if (np->rxopt.bits.osrcrt && opt->srcrt) {
0709         struct ipv6_rt_hdr *rthdr = (struct ipv6_rt_hdr *)(nh + opt->srcrt);
0710         put_cmsg(msg, SOL_IPV6, IPV6_2292RTHDR, (rthdr->hdrlen+1) << 3, rthdr);
0711     }
0712     if (np->rxopt.bits.odstopts && opt->dst1) {
0713         u8 *ptr = nh + opt->dst1;
0714         put_cmsg(msg, SOL_IPV6, IPV6_2292DSTOPTS, (ptr[1]+1)<<3, ptr);
0715     }
0716     if (np->rxopt.bits.rxorigdstaddr) {
0717         struct sockaddr_in6 sin6;
0718         __be16 _ports[2], *ports;
0719 
0720         ports = skb_header_pointer(skb, skb_transport_offset(skb),
0721                        sizeof(_ports), &_ports);
0722         if (ports) {
0723             /* All current transport protocols have the port numbers in the
0724              * first four bytes of the transport header and this function is
0725              * written with this assumption in mind.
0726              */
0727             sin6.sin6_family = AF_INET6;
0728             sin6.sin6_addr = ipv6_hdr(skb)->daddr;
0729             sin6.sin6_port = ports[1];
0730             sin6.sin6_flowinfo = 0;
0731             sin6.sin6_scope_id =
0732                 ipv6_iface_scope_id(&ipv6_hdr(skb)->daddr,
0733                             opt->iif);
0734 
0735             put_cmsg(msg, SOL_IPV6, IPV6_ORIGDSTADDR, sizeof(sin6), &sin6);
0736         }
0737     }
0738     if (np->rxopt.bits.recvfragsize && opt->frag_max_size) {
0739         int val = opt->frag_max_size;
0740 
0741         put_cmsg(msg, SOL_IPV6, IPV6_RECVFRAGSIZE, sizeof(val), &val);
0742     }
0743 }
0744 
0745 void ip6_datagram_recv_ctl(struct sock *sk, struct msghdr *msg,
0746               struct sk_buff *skb)
0747 {
0748     ip6_datagram_recv_common_ctl(sk, msg, skb);
0749     ip6_datagram_recv_specific_ctl(sk, msg, skb);
0750 }
0751 EXPORT_SYMBOL_GPL(ip6_datagram_recv_ctl);
0752 
0753 int ip6_datagram_send_ctl(struct net *net, struct sock *sk,
0754               struct msghdr *msg, struct flowi6 *fl6,
0755               struct ipcm6_cookie *ipc6)
0756 {
0757     struct in6_pktinfo *src_info;
0758     struct cmsghdr *cmsg;
0759     struct ipv6_rt_hdr *rthdr;
0760     struct ipv6_opt_hdr *hdr;
0761     struct ipv6_txoptions *opt = ipc6->opt;
0762     int len;
0763     int err = 0;
0764 
0765     for_each_cmsghdr(cmsg, msg) {
0766         int addr_type;
0767 
0768         if (!CMSG_OK(msg, cmsg)) {
0769             err = -EINVAL;
0770             goto exit_f;
0771         }
0772 
0773         if (cmsg->cmsg_level == SOL_SOCKET) {
0774             err = __sock_cmsg_send(sk, msg, cmsg, &ipc6->sockc);
0775             if (err)
0776                 return err;
0777             continue;
0778         }
0779 
0780         if (cmsg->cmsg_level != SOL_IPV6)
0781             continue;
0782 
0783         switch (cmsg->cmsg_type) {
0784         case IPV6_PKTINFO:
0785         case IPV6_2292PKTINFO:
0786             {
0787             struct net_device *dev = NULL;
0788             int src_idx;
0789 
0790             if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct in6_pktinfo))) {
0791                 err = -EINVAL;
0792                 goto exit_f;
0793             }
0794 
0795             src_info = (struct in6_pktinfo *)CMSG_DATA(cmsg);
0796             src_idx = src_info->ipi6_ifindex;
0797 
0798             if (src_idx) {
0799                 if (fl6->flowi6_oif &&
0800                     src_idx != fl6->flowi6_oif &&
0801                     (READ_ONCE(sk->sk_bound_dev_if) != fl6->flowi6_oif ||
0802                      !sk_dev_equal_l3scope(sk, src_idx)))
0803                     return -EINVAL;
0804                 fl6->flowi6_oif = src_idx;
0805             }
0806 
0807             addr_type = __ipv6_addr_type(&src_info->ipi6_addr);
0808 
0809             rcu_read_lock();
0810             if (fl6->flowi6_oif) {
0811                 dev = dev_get_by_index_rcu(net, fl6->flowi6_oif);
0812                 if (!dev) {
0813                     rcu_read_unlock();
0814                     return -ENODEV;
0815                 }
0816             } else if (addr_type & IPV6_ADDR_LINKLOCAL) {
0817                 rcu_read_unlock();
0818                 return -EINVAL;
0819             }
0820 
0821             if (addr_type != IPV6_ADDR_ANY) {
0822                 int strict = __ipv6_addr_src_scope(addr_type) <= IPV6_ADDR_SCOPE_LINKLOCAL;
0823                 if (!ipv6_can_nonlocal_bind(net, inet_sk(sk)) &&
0824                     !ipv6_chk_addr_and_flags(net, &src_info->ipi6_addr,
0825                                  dev, !strict, 0,
0826                                  IFA_F_TENTATIVE) &&
0827                     !ipv6_chk_acast_addr_src(net, dev,
0828                                  &src_info->ipi6_addr))
0829                     err = -EINVAL;
0830                 else
0831                     fl6->saddr = src_info->ipi6_addr;
0832             }
0833 
0834             rcu_read_unlock();
0835 
0836             if (err)
0837                 goto exit_f;
0838 
0839             break;
0840             }
0841 
0842         case IPV6_FLOWINFO:
0843             if (cmsg->cmsg_len < CMSG_LEN(4)) {
0844                 err = -EINVAL;
0845                 goto exit_f;
0846             }
0847 
0848             if (fl6->flowlabel&IPV6_FLOWINFO_MASK) {
0849                 if ((fl6->flowlabel^*(__be32 *)CMSG_DATA(cmsg))&~IPV6_FLOWINFO_MASK) {
0850                     err = -EINVAL;
0851                     goto exit_f;
0852                 }
0853             }
0854             fl6->flowlabel = IPV6_FLOWINFO_MASK & *(__be32 *)CMSG_DATA(cmsg);
0855             break;
0856 
0857         case IPV6_2292HOPOPTS:
0858         case IPV6_HOPOPTS:
0859             if (opt->hopopt || cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
0860                 err = -EINVAL;
0861                 goto exit_f;
0862             }
0863 
0864             hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
0865             len = ((hdr->hdrlen + 1) << 3);
0866             if (cmsg->cmsg_len < CMSG_LEN(len)) {
0867                 err = -EINVAL;
0868                 goto exit_f;
0869             }
0870             if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
0871                 err = -EPERM;
0872                 goto exit_f;
0873             }
0874             opt->opt_nflen += len;
0875             opt->hopopt = hdr;
0876             break;
0877 
0878         case IPV6_2292DSTOPTS:
0879             if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
0880                 err = -EINVAL;
0881                 goto exit_f;
0882             }
0883 
0884             hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
0885             len = ((hdr->hdrlen + 1) << 3);
0886             if (cmsg->cmsg_len < CMSG_LEN(len)) {
0887                 err = -EINVAL;
0888                 goto exit_f;
0889             }
0890             if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
0891                 err = -EPERM;
0892                 goto exit_f;
0893             }
0894             if (opt->dst1opt) {
0895                 err = -EINVAL;
0896                 goto exit_f;
0897             }
0898             opt->opt_flen += len;
0899             opt->dst1opt = hdr;
0900             break;
0901 
0902         case IPV6_DSTOPTS:
0903         case IPV6_RTHDRDSTOPTS:
0904             if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_opt_hdr))) {
0905                 err = -EINVAL;
0906                 goto exit_f;
0907             }
0908 
0909             hdr = (struct ipv6_opt_hdr *)CMSG_DATA(cmsg);
0910             len = ((hdr->hdrlen + 1) << 3);
0911             if (cmsg->cmsg_len < CMSG_LEN(len)) {
0912                 err = -EINVAL;
0913                 goto exit_f;
0914             }
0915             if (!ns_capable(net->user_ns, CAP_NET_RAW)) {
0916                 err = -EPERM;
0917                 goto exit_f;
0918             }
0919             if (cmsg->cmsg_type == IPV6_DSTOPTS) {
0920                 opt->opt_flen += len;
0921                 opt->dst1opt = hdr;
0922             } else {
0923                 opt->opt_nflen += len;
0924                 opt->dst0opt = hdr;
0925             }
0926             break;
0927 
0928         case IPV6_2292RTHDR:
0929         case IPV6_RTHDR:
0930             if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct ipv6_rt_hdr))) {
0931                 err = -EINVAL;
0932                 goto exit_f;
0933             }
0934 
0935             rthdr = (struct ipv6_rt_hdr *)CMSG_DATA(cmsg);
0936 
0937             switch (rthdr->type) {
0938 #if IS_ENABLED(CONFIG_IPV6_MIP6)
0939             case IPV6_SRCRT_TYPE_2:
0940                 if (rthdr->hdrlen != 2 ||
0941                     rthdr->segments_left != 1) {
0942                     err = -EINVAL;
0943                     goto exit_f;
0944                 }
0945                 break;
0946 #endif
0947             default:
0948                 err = -EINVAL;
0949                 goto exit_f;
0950             }
0951 
0952             len = ((rthdr->hdrlen + 1) << 3);
0953 
0954             if (cmsg->cmsg_len < CMSG_LEN(len)) {
0955                 err = -EINVAL;
0956                 goto exit_f;
0957             }
0958 
0959             /* segments left must also match */
0960             if ((rthdr->hdrlen >> 1) != rthdr->segments_left) {
0961                 err = -EINVAL;
0962                 goto exit_f;
0963             }
0964 
0965             opt->opt_nflen += len;
0966             opt->srcrt = rthdr;
0967 
0968             if (cmsg->cmsg_type == IPV6_2292RTHDR && opt->dst1opt) {
0969                 int dsthdrlen = ((opt->dst1opt->hdrlen+1)<<3);
0970 
0971                 opt->opt_nflen += dsthdrlen;
0972                 opt->dst0opt = opt->dst1opt;
0973                 opt->dst1opt = NULL;
0974                 opt->opt_flen -= dsthdrlen;
0975             }
0976 
0977             break;
0978 
0979         case IPV6_2292HOPLIMIT:
0980         case IPV6_HOPLIMIT:
0981             if (cmsg->cmsg_len != CMSG_LEN(sizeof(int))) {
0982                 err = -EINVAL;
0983                 goto exit_f;
0984             }
0985 
0986             ipc6->hlimit = *(int *)CMSG_DATA(cmsg);
0987             if (ipc6->hlimit < -1 || ipc6->hlimit > 0xff) {
0988                 err = -EINVAL;
0989                 goto exit_f;
0990             }
0991 
0992             break;
0993 
0994         case IPV6_TCLASS:
0995             {
0996             int tc;
0997 
0998             err = -EINVAL;
0999             if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
1000                 goto exit_f;
1001 
1002             tc = *(int *)CMSG_DATA(cmsg);
1003             if (tc < -1 || tc > 0xff)
1004                 goto exit_f;
1005 
1006             err = 0;
1007             ipc6->tclass = tc;
1008 
1009             break;
1010             }
1011 
1012         case IPV6_DONTFRAG:
1013             {
1014             int df;
1015 
1016             err = -EINVAL;
1017             if (cmsg->cmsg_len != CMSG_LEN(sizeof(int)))
1018                 goto exit_f;
1019 
1020             df = *(int *)CMSG_DATA(cmsg);
1021             if (df < 0 || df > 1)
1022                 goto exit_f;
1023 
1024             err = 0;
1025             ipc6->dontfrag = df;
1026 
1027             break;
1028             }
1029         default:
1030             net_dbg_ratelimited("invalid cmsg type: %d\n",
1031                         cmsg->cmsg_type);
1032             err = -EINVAL;
1033             goto exit_f;
1034         }
1035     }
1036 
1037 exit_f:
1038     return err;
1039 }
1040 EXPORT_SYMBOL_GPL(ip6_datagram_send_ctl);
1041 
1042 void __ip6_dgram_sock_seq_show(struct seq_file *seq, struct sock *sp,
1043                    __u16 srcp, __u16 destp, int rqueue, int bucket)
1044 {
1045     const struct in6_addr *dest, *src;
1046 
1047     dest  = &sp->sk_v6_daddr;
1048     src   = &sp->sk_v6_rcv_saddr;
1049     seq_printf(seq,
1050            "%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1051            "%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
1052            bucket,
1053            src->s6_addr32[0], src->s6_addr32[1],
1054            src->s6_addr32[2], src->s6_addr32[3], srcp,
1055            dest->s6_addr32[0], dest->s6_addr32[1],
1056            dest->s6_addr32[2], dest->s6_addr32[3], destp,
1057            sp->sk_state,
1058            sk_wmem_alloc_get(sp),
1059            rqueue,
1060            0, 0L, 0,
1061            from_kuid_munged(seq_user_ns(seq), sock_i_uid(sp)),
1062            0,
1063            sock_i_ino(sp),
1064            refcount_read(&sp->sk_refcnt), sp,
1065            atomic_read(&sp->sk_drops));
1066 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!