Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0-or-later
       2             : /* QUIC kernel implementation
       3             :  * (C) Copyright Red Hat Corp. 2023
       4             :  *
       5             :  * This file is part of the QUIC kernel implementation
       6             :  *
       7             :  * Initialization/cleanup for QUIC protocol support.
       8             :  *
       9             :  * Written or modified by:
      10             :  *    Xin Long <lucien.xin@gmail.com>
      11             :  */
      12             : 
      13             : #include <net/inet_common.h>
      14             : #include <net/udp_tunnel.h>
      15             : #include <linux/icmp.h>
      16             : 
      17             : #include "common.h"
      18             : #include "family.h"
      19             : 
      20             : struct quic_addr_family_ops {
      21             :         u32     iph_len;                                /* Network layer header length */
      22             :         int     (*is_any_addr)(union quic_addr *addr);  /* Check if the addr is a wildcard (ANY) */
      23             : 
      24             :         /* Initialize UDP tunnel socket configuration */
      25             :         void    (*udp_conf_init)(struct sock *sk, struct udp_port_cfg *conf, union quic_addr *addr);
      26             :         /* Perform IP route lookup */
      27             :         int     (*flow_route)(struct sock *sk, union quic_addr *da, union quic_addr *sa,
      28             :                               struct flowi *fl);
      29             :         /* Transmit packet through UDP tunnel socket */
      30             :         void    (*lower_xmit)(struct sock *sk, struct sk_buff *skb, struct flowi *fl);
      31             : 
      32             :         /* Extract source and destination IP addresses from the packet */
      33             :         void    (*get_msg_addrs)(union quic_addr *da, union quic_addr *sa, struct sk_buff *skb);
      34             :         /* Dump the address into a seq_file (e.g., for /proc/net/quic/sks) */
      35             :         void    (*seq_dump_addr)(struct seq_file *seq, union quic_addr *addr);
      36             :          /* Extract MTU information from an ICMP packet */
      37             :         int     (*get_mtu_info)(struct sk_buff *skb, u32 *info);
      38             :         /* Extract ECN bits from the packet */
      39             :         u8      (*get_msg_ecn)(struct sk_buff *skb);
      40             : };
      41             : 
      42             : struct quic_proto_family_ops {
      43             :         /* Validate and convert user address from bind/connect/setsockopt */
      44             :         int     (*get_user_addr)(struct sock *sk, union quic_addr *a, struct sockaddr *addr,
      45             :                                  int addr_len);
      46             :         /* Get the 'preferred_address' from transport parameters (rfc9000#section-18.2) */
      47             :         void    (*get_pref_addr)(struct sock *sk, union quic_addr *addr, u8 **pp, u32 *plen);
      48             :         /* Set the 'preferred_address' into transport parameters (rfc9000#section-18.2) */
      49             :         void    (*set_pref_addr)(struct sock *sk, u8 *p, union quic_addr *addr);
      50             : 
      51             :         /* Compare two addresses considering socket family and wildcard (ANY) match */
      52             :         bool    (*cmp_sk_addr)(struct sock *sk, union quic_addr *a, union quic_addr *addr);
      53             :         /* Get socket's local or peer address (getsockname/getpeername) */
      54             :         int     (*get_sk_addr)(struct socket *sock, struct sockaddr *addr, int peer);
      55             :         /* Set socket's source or destination address */
      56             :         void    (*set_sk_addr)(struct sock *sk, union quic_addr *addr, bool src);
      57             :         /* Set ECN bits for the socket */
      58             :         void    (*set_sk_ecn)(struct sock *sk, u8 ecn);
      59             : 
      60             :         /* Handle getsockopt() for non-SOL_QUIC levels */
      61             :         int     (*getsockopt)(struct sock *sk, int level, int optname, char __user *optval,
      62             :                               int __user *optlen);
      63             :         /* Handle setsockopt() for non-SOL_QUIC levels */
      64             :         int     (*setsockopt)(struct sock *sk, int level, int optname, sockptr_t optval,
      65             :                               unsigned int optlen);
      66             : };
      67             : 
      68          66 : static int quic_v4_is_any_addr(union quic_addr *addr)
      69             : {
      70          66 :         return addr->v4.sin_addr.s_addr == htonl(INADDR_ANY);
      71             : }
      72             : 
      73         990 : static int quic_v6_is_any_addr(union quic_addr *addr)
      74             : {
      75         990 :         return ipv6_addr_any(&addr->v6.sin6_addr);
      76             : }
      77             : 
      78         618 : static void quic_v4_udp_conf_init(struct sock *sk, struct udp_port_cfg *conf, union quic_addr *a)
      79             : {
      80         618 :         conf->family = AF_INET;
      81         618 :         conf->local_ip.s_addr = a->v4.sin_addr.s_addr;
      82         618 :         conf->local_udp_port = a->v4.sin_port;
      83         618 :         conf->use_udp6_rx_checksums = true;
      84         618 : }
      85             : 
      86         143 : static void quic_v6_udp_conf_init(struct sock *sk, struct udp_port_cfg *conf, union quic_addr *a)
      87             : {
      88         143 :         conf->family = AF_INET6;
      89         143 :         conf->local_ip6 = a->v6.sin6_addr;
      90         143 :         conf->local_udp_port = a->v6.sin6_port;
      91         143 :         conf->use_udp6_rx_checksums = true;
      92         143 :         conf->ipv6_v6only = ipv6_only_sock(sk);
      93         143 : }
      94             : 
      95     3074381 : static int quic_v4_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa,
      96             :                               struct flowi *fl)
      97             : {
      98     3074381 :         struct flowi4 *fl4;
      99     3074381 :         struct rtable *rt;
     100     3074381 :         struct flowi _fl;
     101             : 
     102     3074381 :         if (__sk_dst_check(sk, 0))
     103             :                 return 1;
     104             : 
     105        2143 :         fl4 = &_fl.u.ip4;
     106        2143 :         memset(&_fl, 0x00, sizeof(_fl));
     107        2143 :         fl4->saddr = sa->v4.sin_addr.s_addr;
     108        2143 :         fl4->fl4_sport = sa->v4.sin_port;
     109        2143 :         fl4->daddr = da->v4.sin_addr.s_addr;
     110        2143 :         fl4->fl4_dport = da->v4.sin_port;
     111             : 
     112        2143 :         rt = ip_route_output_key(sock_net(sk), fl4);
     113        2143 :         if (IS_ERR(rt))
     114           0 :                 return PTR_ERR(rt);
     115             : 
     116        2143 :         if (!sa->v4.sin_family) {
     117         572 :                 sa->v4.sin_family = AF_INET;
     118         572 :                 sa->v4.sin_addr.s_addr = fl4->saddr;
     119             :         }
     120        2143 :         sk_setup_caps(sk, &rt->dst);
     121        4286 :         memcpy(fl, &_fl, sizeof(_fl));
     122        2143 :         return 0;
     123             : }
     124             : 
     125     7939726 : static int quic_v6_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa,
     126             :                               struct flowi *fl)
     127             : {
     128     7939726 :         struct ipv6_pinfo *np = inet6_sk(sk);
     129     7939726 :         struct ip6_flowlabel *flowlabel;
     130     7939726 :         struct dst_entry *dst;
     131     7939726 :         struct flowi6 *fl6;
     132     7939726 :         struct flowi _fl;
     133             : 
     134     7939726 :         if (__sk_dst_check(sk, np->dst_cookie))
     135             :                 return 1;
     136             : 
     137         201 :         fl6 = &_fl.u.ip6;
     138         201 :         memset(&_fl, 0x0, sizeof(_fl));
     139         201 :         fl6->saddr = sa->v6.sin6_addr;
     140         201 :         fl6->fl6_sport = sa->v6.sin6_port;
     141         201 :         fl6->daddr = da->v6.sin6_addr;
     142         201 :         fl6->fl6_dport = da->v6.sin6_port;
     143             : 
     144         201 :         if (inet6_test_bit(SNDFLOW, sk)) {
     145           0 :                 fl6->flowlabel = (da->v6.sin6_flowinfo & IPV6_FLOWINFO_MASK);
     146           0 :                 if (fl6->flowlabel & IPV6_FLOWLABEL_MASK) {
     147           0 :                         flowlabel = fl6_sock_lookup(sk, fl6->flowlabel);
     148           0 :                         if (IS_ERR(flowlabel))
     149             :                                 return -EINVAL;
     150           0 :                         fl6_sock_release(flowlabel);
     151             :                 }
     152             :         }
     153             : 
     154         201 :         dst = ip6_dst_lookup_flow(sock_net(sk), sk, fl6, NULL);
     155         201 :         if (IS_ERR(dst))
     156           0 :                 return PTR_ERR(dst);
     157             : 
     158         201 :         if (!sa->v6.sin6_family) {
     159          37 :                 sa->v6.sin6_family = AF_INET6;
     160          37 :                 sa->v6.sin6_addr = fl6->saddr;
     161             :         }
     162         201 :         ip6_dst_store(sk, dst, NULL, NULL);
     163         402 :         memcpy(fl, &_fl, sizeof(_fl));
     164         201 :         return 0;
     165             : }
     166             : 
     167     1770790 : static void quic_v4_lower_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
     168             : {
     169     1770790 :         struct quic_skb_cb *cb = QUIC_SKB_CB(skb);
     170     1770790 :         u8 tos = (inet_sk(sk)->tos | cb->ecn), ttl;
     171     1770790 :         struct flowi4 *fl4 = &fl->u.ip4;
     172     1770790 :         struct dst_entry *dst;
     173     1770790 :         __be16 df = 0;
     174             : 
     175     1770790 :         pr_debug("%s: skb: %p, len: %d, num: %llu, %pI4:%d -> %pI4:%d\n", __func__,
     176             :                  skb, skb->len, cb->number, &fl4->saddr, ntohs(fl4->fl4_sport),
     177             :                  &fl4->daddr, ntohs(fl4->fl4_dport));
     178             : 
     179     1770790 :         dst = sk_dst_get(sk);
     180     1770811 :         if (!dst) {
     181           0 :                 kfree_skb(skb);
     182           0 :                 return;
     183             :         }
     184     1770811 :         if (ip_dont_fragment(sk, dst) && !skb->ignore_df)
     185     1770811 :                 df = htons(IP_DF);
     186             : 
     187     1770805 :         ttl = (u8)ip4_dst_hoplimit(dst);
     188     1770802 :         udp_tunnel_xmit_skb((struct rtable *)dst, sk, skb, fl4->saddr, fl4->daddr,
     189     1770802 :                             tos, ttl, df, fl4->fl4_sport, fl4->fl4_dport, false, false, 0);
     190             : }
     191             : 
     192     4786544 : static void quic_v6_lower_xmit(struct sock *sk, struct sk_buff *skb, struct flowi *fl)
     193             : {
     194     4786544 :         struct quic_skb_cb *cb = QUIC_SKB_CB(skb);
     195     4786544 :         u8 tc = (inet6_sk(sk)->tclass | cb->ecn), ttl;
     196     4786544 :         struct flowi6 *fl6 = &fl->u.ip6;
     197     4786544 :         struct dst_entry *dst;
     198     4786544 :         __be32 label;
     199             : 
     200     4786544 :         pr_debug("%s: skb: %p, len: %d, num: %llu, %pI6c:%d -> %pI6c:%d\n", __func__,
     201             :                  skb, skb->len, cb->number, &fl6->saddr, ntohs(fl6->fl6_sport),
     202             :                  &fl6->daddr, ntohs(fl6->fl6_dport));
     203             : 
     204     4786572 :         dst = sk_dst_get(sk);
     205     4786596 :         if (!dst) {
     206           0 :                 kfree_skb(skb);
     207           0 :                 return;
     208             :         }
     209             : 
     210     4786596 :         ttl = (u8)ip6_dst_hoplimit(dst);
     211     4786581 :         label = ip6_make_flowlabel(sock_net(sk), skb, fl6->flowlabel, true, fl6);
     212     4786573 :         udp_tunnel6_xmit_skb(dst, sk, skb, NULL, &fl6->saddr, &fl6->daddr, tc,
     213     4786573 :                              ttl, label, fl6->fl6_sport, fl6->fl6_dport, false, 0);
     214             : }
     215             : 
     216          87 : static void quic_v4_seq_dump_addr(struct seq_file *seq, union quic_addr *addr)
     217             : {
     218          87 :         seq_printf(seq, "%pI4:%d\t", &addr->v4.sin_addr.s_addr, ntohs(addr->v4.sin_port));
     219          87 : }
     220             : 
     221          18 : static void quic_v6_seq_dump_addr(struct seq_file *seq, union quic_addr *addr)
     222             : {
     223          18 :         seq_printf(seq, "%pI6c:%d\t", &addr->v6.sin6_addr, ntohs(addr->v4.sin_port));
     224          18 : }
     225             : 
     226     1792555 : static void quic_v4_get_msg_addrs(union quic_addr *da, union quic_addr *sa, struct sk_buff *skb)
     227             : {
     228     1792555 :         struct udphdr *uh = quic_udphdr(skb);
     229             : 
     230     1792555 :         sa->v4.sin_family = AF_INET;
     231     1792555 :         sa->v4.sin_port = uh->source;
     232     1792555 :         sa->v4.sin_addr.s_addr = ip_hdr(skb)->saddr;
     233             : 
     234     1792555 :         da->v4.sin_family = AF_INET;
     235     1792555 :         da->v4.sin_port = uh->dest;
     236     1792555 :         da->v4.sin_addr.s_addr = ip_hdr(skb)->daddr;
     237     1792555 : }
     238             : 
     239     4784030 : static void quic_v6_get_msg_addrs(union quic_addr *da, union quic_addr *sa, struct sk_buff *skb)
     240             : {
     241     4784030 :         struct udphdr *uh = quic_udphdr(skb);
     242             : 
     243     4784030 :         sa->v6.sin6_family = AF_INET6;
     244     4784030 :         sa->v6.sin6_port = uh->source;
     245     4784030 :         sa->v6.sin6_addr = ipv6_hdr(skb)->saddr;
     246             : 
     247     4784030 :         da->v6.sin6_family = AF_INET6;
     248     4784030 :         da->v6.sin6_port = uh->dest;
     249     4784030 :         da->v6.sin6_addr = ipv6_hdr(skb)->daddr;
     250     4784030 : }
     251             : 
     252         349 : static int quic_v4_get_mtu_info(struct sk_buff *skb, u32 *info)
     253             : {
     254         349 :         struct icmphdr *hdr;
     255             : 
     256         349 :         hdr = (struct icmphdr *)(skb_network_header(skb) - sizeof(struct icmphdr));
     257         349 :         if (hdr->type == ICMP_DEST_UNREACH && hdr->code == ICMP_FRAG_NEEDED) {
     258           0 :                 *info = ntohs(hdr->un.frag.mtu);
     259           0 :                 return 0;
     260             :         }
     261             : 
     262             :         /* Defer other types' processing to UDP error handler. */
     263             :         return 1;
     264             : }
     265             : 
     266        2893 : static int quic_v6_get_mtu_info(struct sk_buff *skb, u32 *info)
     267             : {
     268        2893 :         struct icmp6hdr *hdr;
     269             : 
     270        2893 :         hdr = (struct icmp6hdr *)(skb_network_header(skb) - sizeof(struct icmp6hdr));
     271        2893 :         if (hdr->icmp6_type == ICMPV6_PKT_TOOBIG) {
     272        2893 :                 *info = ntohl(hdr->icmp6_mtu);
     273        2893 :                 return 0;
     274             :         }
     275             : 
     276             :         /* Defer other types' processing to UDP error handler. */
     277             :         return 1;
     278             : }
     279             : 
     280     1793532 : static u8 quic_v4_get_msg_ecn(struct sk_buff *skb)
     281             : {
     282     1793532 :         return (ip_hdr(skb)->tos & INET_ECN_MASK);
     283             : }
     284             : 
     285     4781581 : static u8 quic_v6_get_msg_ecn(struct sk_buff *skb)
     286             : {
     287     4781581 :         return (ipv6_get_dsfield(ipv6_hdr(skb)) & INET_ECN_MASK);
     288             : }
     289             : 
     290             : static struct quic_addr_family_ops quic_af_inet = {
     291             :         .iph_len                = sizeof(struct iphdr),
     292             :         .is_any_addr            = quic_v4_is_any_addr,
     293             :         .udp_conf_init          = quic_v4_udp_conf_init,
     294             :         .flow_route             = quic_v4_flow_route,
     295             :         .lower_xmit             = quic_v4_lower_xmit,
     296             :         .seq_dump_addr          = quic_v4_seq_dump_addr,
     297             :         .get_msg_addrs          = quic_v4_get_msg_addrs,
     298             :         .get_mtu_info           = quic_v4_get_mtu_info,
     299             :         .get_msg_ecn            = quic_v4_get_msg_ecn,
     300             : };
     301             : 
     302             : static struct quic_addr_family_ops quic_af_inet6 = {
     303             :         .iph_len                = sizeof(struct ipv6hdr),
     304             :         .is_any_addr            = quic_v6_is_any_addr,
     305             :         .udp_conf_init          = quic_v6_udp_conf_init,
     306             :         .flow_route             = quic_v6_flow_route,
     307             :         .lower_xmit             = quic_v6_lower_xmit,
     308             :         .seq_dump_addr          = quic_v6_seq_dump_addr,
     309             :         .get_msg_addrs          = quic_v6_get_msg_addrs,
     310             :         .get_mtu_info           = quic_v6_get_mtu_info,
     311             :         .get_msg_ecn            = quic_v6_get_msg_ecn,
     312             : };
     313             : 
     314             : static struct quic_addr_family_ops *quic_afs[] = {
     315             :         &quic_af_inet,
     316             :         &quic_af_inet6
     317             : };
     318             : 
     319             : #define quic_af(a)              quic_afs[(a)->sa.sa_family == AF_INET6]
     320             : #define quic_af_skb(skb)        quic_afs[ip_hdr(skb)->version == 6]
     321             : 
     322         131 : static int quic_v4_get_user_addr(struct sock *sk, union quic_addr *a, struct sockaddr *addr,
     323             :                                  int addr_len)
     324             : {
     325         131 :         u32 len = sizeof(struct sockaddr_in);
     326             : 
     327         131 :         if (addr_len < len || addr->sa_family != sk->sk_family)
     328             :                 return 1;
     329         262 :         memcpy(a, addr, len);
     330         131 :         return 0;
     331             : }
     332             : 
     333        1031 : static int quic_v6_get_user_addr(struct sock *sk, union quic_addr *a, struct sockaddr *addr,
     334             :                                  int addr_len)
     335             : {
     336        1031 :         u32 len = sizeof(struct sockaddr_in);
     337             : 
     338        1031 :         if (addr_len < len)
     339             :                 return 1;
     340             : 
     341        1031 :         if (addr->sa_family != sk->sk_family) {
     342         876 :                 if (ipv6_only_sock(sk))
     343             :                         return 1;
     344        1752 :                 memcpy(a, addr, len);
     345         876 :                 return 0;
     346             :         }
     347             : 
     348         155 :         len = sizeof(struct sockaddr_in6);
     349         155 :         if (addr_len < len)
     350             :                 return 1;
     351         310 :         memcpy(a, addr, len);
     352         155 :         return 0;
     353             : }
     354             : 
     355          15 : static void quic_v4_get_pref_addr(struct sock *sk, union quic_addr *addr, u8 **pp, u32 *plen)
     356             : {
     357          15 :         u8 *p = *pp;
     358             : 
     359          30 :         memcpy(&addr->v4.sin_addr, p, QUIC_ADDR4_LEN);
     360          15 :         p += QUIC_ADDR4_LEN;
     361          30 :         memcpy(&addr->v4.sin_port, p, QUIC_PORT_LEN);
     362          15 :         p += QUIC_PORT_LEN;
     363             :         /* Skip over IPv6 address and port,  not used for AF_INET sockets. */
     364          15 :         p += QUIC_ADDR6_LEN;
     365          15 :         p += QUIC_PORT_LEN;
     366             : 
     367          15 :         addr->v4.sin_family = AF_INET;
     368          15 :         *plen -= (p - *pp);
     369          15 :         *pp = p;
     370          15 : }
     371             : 
     372          26 : static void quic_v6_get_pref_addr(struct sock *sk, union quic_addr *addr, u8 **pp, u32 *plen)
     373             : {
     374          26 :         u8 *p = *pp;
     375             : 
     376             :         /* Skip over IPv4 address and port. */
     377          26 :         p += QUIC_ADDR4_LEN;
     378          26 :         p += QUIC_PORT_LEN;
     379             :         /* Try to use IPv6 address and port first. */
     380          52 :         memcpy(&addr->v6.sin6_addr, p, QUIC_ADDR6_LEN);
     381          26 :         p += QUIC_ADDR6_LEN;
     382          52 :         memcpy(&addr->v6.sin6_port, p, QUIC_PORT_LEN);
     383          26 :         p += QUIC_PORT_LEN;
     384             : 
     385          26 :         if (ipv6_only_sock(sk) ||
     386          13 :             addr->v6.sin6_port || !ipv6_addr_any(&addr->v6.sin6_addr)) {
     387          13 :                 addr->v4.sin_family = AF_INET6;
     388          13 :                 *plen -= (p - *pp);
     389          13 :                 *pp = p;
     390          13 :                 return;
     391             :         }
     392             : 
     393             :         /* Fallback to IPv4 if IPv6 address is not usable. */
     394          13 :         quic_v4_get_pref_addr(sk, addr, pp, plen);
     395             : }
     396             : 
     397          13 : static void quic_v4_set_pref_addr(struct sock *sk, u8 *p, union quic_addr *addr)
     398             : {
     399          26 :         memcpy(p, &addr->v4.sin_addr, QUIC_ADDR4_LEN);
     400          13 :         p += QUIC_ADDR4_LEN;
     401          26 :         memcpy(p, &addr->v4.sin_port, QUIC_PORT_LEN);
     402          13 :         p += QUIC_PORT_LEN;
     403          13 :         memset(p, 0, QUIC_ADDR6_LEN);
     404          13 :         p += QUIC_ADDR6_LEN;
     405          13 :         memset(p, 0, QUIC_PORT_LEN);
     406          13 : }
     407             : 
     408          27 : static void quic_v6_set_pref_addr(struct sock *sk, u8 *p, union quic_addr *addr)
     409             : {
     410          27 :         if (addr->sa.sa_family == AF_INET)
     411          13 :                 return quic_v4_set_pref_addr(sk, p, addr);
     412             : 
     413          14 :         memset(p, 0, QUIC_ADDR4_LEN);
     414          14 :         p += QUIC_ADDR4_LEN;
     415          14 :         memset(p, 0, QUIC_PORT_LEN);
     416          14 :         p += QUIC_PORT_LEN;
     417          28 :         memcpy(p, &addr->v6.sin6_addr, QUIC_ADDR6_LEN);
     418          14 :         p += QUIC_ADDR6_LEN;
     419          28 :         memcpy(p, &addr->v6.sin6_port, QUIC_PORT_LEN);
     420             : }
     421             : 
     422       81465 : static bool quic_v4_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
     423             : {
     424       81465 :         if (a->v4.sin_port != addr->v4.sin_port)
     425             :                 return false;
     426       81380 :         if (a->v4.sin_family != addr->v4.sin_family)
     427             :                 return false;
     428       81380 :         if (a->v4.sin_addr.s_addr == htonl(INADDR_ANY) ||
     429       81332 :             addr->v4.sin_addr.s_addr == htonl(INADDR_ANY))
     430             :                 return true;
     431       81332 :         return a->v4.sin_addr.s_addr == addr->v4.sin_addr.s_addr;
     432             : }
     433             : 
     434    13062041 : static bool quic_v6_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
     435             : {
     436    13062041 :         if (a->v4.sin_port != addr->v4.sin_port)
     437             :                 return false;
     438             : 
     439    13061815 :         if (a->sa.sa_family == AF_INET && addr->sa.sa_family == AF_INET) {
     440     3500152 :                 if (a->v4.sin_addr.s_addr == htonl(INADDR_ANY) ||
     441     3500140 :                     addr->v4.sin_addr.s_addr == htonl(INADDR_ANY))
     442             :                         return true;
     443     3500140 :                 return a->v4.sin_addr.s_addr == addr->v4.sin_addr.s_addr;
     444             :         }
     445             : 
     446     9561663 :         if (a->sa.sa_family != addr->sa.sa_family) {
     447        1220 :                 if (ipv6_only_sock(sk))
     448             :                         return false;
     449        1220 :                 if (a->sa.sa_family == AF_INET6 && ipv6_addr_any(&a->v6.sin6_addr))
     450             :                         return true;
     451          13 :                 if (a->sa.sa_family == AF_INET && addr->sa.sa_family == AF_INET6 &&
     452           7 :                     ipv6_addr_v4mapped(&addr->v6.sin6_addr) &&
     453           0 :                     addr->v6.sin6_addr.s6_addr32[3] == a->v4.sin_addr.s_addr)
     454             :                         return true;
     455          13 :                 if (addr->sa.sa_family == AF_INET && a->sa.sa_family == AF_INET6 &&
     456           6 :                     ipv6_addr_v4mapped(&a->v6.sin6_addr) &&
     457           0 :                     a->v6.sin6_addr.s6_addr32[3] == addr->v4.sin_addr.s_addr)
     458             :                         return true;
     459          13 :                 return false;
     460             :         }
     461             : 
     462     9560443 :         if (ipv6_addr_any(&a->v6.sin6_addr) || ipv6_addr_any(&addr->v6.sin6_addr))
     463             :                 return true;
     464     9560372 :         return ipv6_addr_equal(&a->v6.sin6_addr, &addr->v6.sin6_addr);
     465             : }
     466             : 
     467          62 : static int quic_v4_get_sk_addr(struct socket *sock, struct sockaddr *uaddr, int peer)
     468             : {
     469          62 :         return inet_getname(sock, uaddr, peer);
     470             : }
     471             : 
     472         111 : static int quic_v6_get_sk_addr(struct socket *sock, struct sockaddr *uaddr, int peer)
     473             : {
     474         111 :         union quic_addr *a = quic_addr(uaddr);
     475         111 :         int ret;
     476             : 
     477         111 :         ret = inet6_getname(sock, uaddr, peer);
     478         111 :         if (ret < 0)
     479             :                 return ret;
     480             : 
     481         111 :         if (a->sa.sa_family == AF_INET6 && ipv6_addr_v4mapped(&a->v6.sin6_addr)) {
     482          53 :                 a->v4.sin_family = AF_INET;
     483          53 :                 a->v4.sin_port = a->v6.sin6_port;
     484          53 :                 a->v4.sin_addr.s_addr = a->v6.sin6_addr.s6_addr32[3];
     485             :         }
     486             : 
     487         111 :         if (a->sa.sa_family == AF_INET) {
     488          53 :                 memset(a->v4.sin_zero, 0, sizeof(a->v4.sin_zero));
     489          53 :                 return sizeof(struct sockaddr_in);
     490             :         }
     491             :         return sizeof(struct sockaddr_in6);
     492             : }
     493             : 
     494         272 : static void quic_v4_set_sk_addr(struct sock *sk, union quic_addr *a, bool src)
     495             : {
     496         272 :         if (src) {
     497         147 :                 inet_sk(sk)->inet_sport = a->v4.sin_port;
     498         147 :                 inet_sk(sk)->inet_saddr = a->v4.sin_addr.s_addr;
     499             :         } else {
     500         125 :                 inet_sk(sk)->inet_dport = a->v4.sin_port;
     501         125 :                 inet_sk(sk)->inet_daddr = a->v4.sin_addr.s_addr;
     502             :         }
     503         272 : }
     504             : 
     505        2042 : static void quic_v6_set_sk_addr(struct sock *sk, union quic_addr *a, bool src)
     506             : {
     507        2042 :         if (src) {
     508        1069 :                 inet_sk(sk)->inet_sport = a->v4.sin_port;
     509        1069 :                 if (a->sa.sa_family == AF_INET) {
     510         901 :                         sk->sk_v6_rcv_saddr.s6_addr32[0] = 0;
     511         901 :                         sk->sk_v6_rcv_saddr.s6_addr32[1] = 0;
     512         901 :                         sk->sk_v6_rcv_saddr.s6_addr32[2] = htonl(0x0000ffff);
     513         901 :                         sk->sk_v6_rcv_saddr.s6_addr32[3] = a->v4.sin_addr.s_addr;
     514             :                 } else {
     515         168 :                         sk->sk_v6_rcv_saddr = a->v6.sin6_addr;
     516             :                 }
     517             :         } else {
     518         973 :                 inet_sk(sk)->inet_dport = a->v4.sin_port;
     519         973 :                 if (a->sa.sa_family == AF_INET) {
     520         897 :                         sk->sk_v6_daddr.s6_addr32[0] = 0;
     521         897 :                         sk->sk_v6_daddr.s6_addr32[1] = 0;
     522         897 :                         sk->sk_v6_daddr.s6_addr32[2] = htonl(0x0000ffff);
     523         897 :                         sk->sk_v6_daddr.s6_addr32[3] = a->v4.sin_addr.s_addr;
     524             :                 } else {
     525          76 :                         sk->sk_v6_daddr = a->v6.sin6_addr;
     526             :                 }
     527             :         }
     528        2042 : }
     529             : 
     530        1694 : static void quic_v4_set_sk_ecn(struct sock *sk, u8 ecn)
     531             : {
     532        1694 :         inet_sk(sk)->tos = ((inet_sk(sk)->tos & ~INET_ECN_MASK) | ecn);
     533         225 : }
     534             : 
     535        1469 : static void quic_v6_set_sk_ecn(struct sock *sk, u8 ecn)
     536             : {
     537        1469 :         quic_v4_set_sk_ecn(sk, ecn);
     538        2938 :         inet6_sk(sk)->tclass = ((inet6_sk(sk)->tclass & ~INET_ECN_MASK) | ecn);
     539        1469 : }
     540             : 
     541             : static struct quic_proto_family_ops quic_pf_inet = {
     542             :         .get_user_addr          = quic_v4_get_user_addr,
     543             :         .get_pref_addr          = quic_v4_get_pref_addr,
     544             :         .set_pref_addr          = quic_v4_set_pref_addr,
     545             :         .cmp_sk_addr            = quic_v4_cmp_sk_addr,
     546             :         .get_sk_addr            = quic_v4_get_sk_addr,
     547             :         .set_sk_addr            = quic_v4_set_sk_addr,
     548             :         .set_sk_ecn             = quic_v4_set_sk_ecn,
     549             :         .setsockopt             = ip_setsockopt,
     550             :         .getsockopt             = ip_getsockopt,
     551             : };
     552             : 
     553             : static struct quic_proto_family_ops quic_pf_inet6 = {
     554             :         .get_user_addr          = quic_v6_get_user_addr,
     555             :         .get_pref_addr          = quic_v6_get_pref_addr,
     556             :         .set_pref_addr          = quic_v6_set_pref_addr,
     557             :         .cmp_sk_addr            = quic_v6_cmp_sk_addr,
     558             :         .get_sk_addr            = quic_v6_get_sk_addr,
     559             :         .set_sk_addr            = quic_v6_set_sk_addr,
     560             :         .set_sk_ecn             = quic_v6_set_sk_ecn,
     561             :         .setsockopt             = ipv6_setsockopt,
     562             :         .getsockopt             = ipv6_getsockopt,
     563             : };
     564             : 
     565             : static struct quic_proto_family_ops *quic_pfs[] = {
     566             :         &quic_pf_inet,
     567             :         &quic_pf_inet6
     568             : };
     569             : 
     570             : #define quic_pf(sk)             quic_pfs[(sk)->sk_family == AF_INET6]
     571             : 
     572           0 : int quic_common_setsockopt(struct sock *sk, int level, int optname, sockptr_t optval,
     573             :                            unsigned int optlen)
     574             : {
     575           0 :         return quic_pf(sk)->setsockopt(sk, level, optname, optval, optlen);
     576             : }
     577             : 
     578           0 : int quic_common_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
     579             :                            int __user *optlen)
     580             : {
     581           0 :         return quic_pf(sk)->getsockopt(sk, level, optname, optval, optlen);
     582             : }
     583             : 
     584        2344 : u32 quic_encap_len(union quic_addr *a)
     585             : {
     586        2344 :         return sizeof(struct udphdr) + quic_af(a)->iph_len;
     587             : }
     588             : 
     589        1056 : int quic_is_any_addr(union quic_addr *a)
     590             : {
     591        1056 :         return quic_af(a)->is_any_addr(a);
     592             : }
     593             : 
     594         761 : void quic_udp_conf_init(struct sock *sk, struct udp_port_cfg *conf, union quic_addr *a)
     595             : {
     596         761 :         quic_af(a)->udp_conf_init(sk, conf, a);
     597         761 : }
     598             : 
     599    11014139 : int quic_flow_route(struct sock *sk, union quic_addr *da, union quic_addr *sa, struct flowi *fl)
     600             : {
     601    11014139 :         return quic_af(da)->flow_route(sk, da, sa, fl);
     602             : }
     603             : 
     604     6557359 : void quic_lower_xmit(struct sock *sk, struct sk_buff *skb, union quic_addr *da, struct flowi *fl)
     605             : {
     606     6557359 :         quic_af(da)->lower_xmit(sk, skb, fl);
     607     6557356 : }
     608             : 
     609         105 : void quic_seq_dump_addr(struct seq_file *seq, union quic_addr *addr)
     610             : {
     611         105 :         quic_af(addr)->seq_dump_addr(seq, addr);
     612         105 : }
     613             : 
     614     6576601 : void quic_get_msg_addrs(union quic_addr *da, union quic_addr *sa, struct sk_buff *skb)
     615             : {
     616     6576601 :         memset(sa, 0, sizeof(*sa));
     617     6576601 :         memset(da, 0, sizeof(*da));
     618     6576601 :         quic_af_skb(skb)->get_msg_addrs(da, sa, skb);
     619     6575699 : }
     620             : 
     621        3242 : int quic_get_mtu_info(struct sk_buff *skb, u32 *info)
     622             : {
     623        3242 :         return quic_af_skb(skb)->get_mtu_info(skb, info);
     624             : }
     625             : 
     626     6575112 : u8 quic_get_msg_ecn(struct sk_buff *skb)
     627             : {
     628     6575112 :         return quic_af_skb(skb)->get_msg_ecn(skb);
     629             : }
     630             : 
     631        1162 : int quic_get_user_addr(struct sock *sk, union quic_addr *a, struct sockaddr *addr, int addr_len)
     632             : {
     633        1162 :         memset(a, 0, sizeof(*a));
     634        1162 :         return quic_pf(sk)->get_user_addr(sk, a, addr, addr_len);
     635             : }
     636             : 
     637          28 : void quic_get_pref_addr(struct sock *sk, union quic_addr *addr, u8 **pp, u32 *plen)
     638             : {
     639          28 :         memset(addr, 0, sizeof(*addr));
     640          28 :         quic_pf(sk)->get_pref_addr(sk, addr, pp, plen);
     641          28 : }
     642             : 
     643          27 : void quic_set_pref_addr(struct sock *sk, u8 *p, union quic_addr *addr)
     644             : {
     645          27 :         quic_pf(sk)->set_pref_addr(sk, p, addr);
     646          27 : }
     647             : 
     648    13141827 : bool quic_cmp_sk_addr(struct sock *sk, union quic_addr *a, union quic_addr *addr)
     649             : {
     650    13141827 :         return quic_pf(sk)->cmp_sk_addr(sk, a, addr);
     651             : }
     652             : 
     653         173 : int quic_get_sk_addr(struct socket *sock, struct sockaddr *a, bool peer)
     654             : {
     655         173 :         return quic_pf(sock->sk)->get_sk_addr(sock, a, peer);
     656             : }
     657             : 
     658        2314 : void quic_set_sk_addr(struct sock *sk, union quic_addr *a, bool src)
     659             : {
     660        2314 :         return quic_pf(sk)->set_sk_addr(sk, a, src);
     661             : }
     662             : 
     663        1694 : void quic_set_sk_ecn(struct sock *sk, u8 ecn)
     664             : {
     665        1694 :         quic_pf(sk)->set_sk_ecn(sk, ecn);
     666        1694 : }