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             :  * Written or modified by:
       8             :  *    Xin Long <lucien.xin@gmail.com>
       9             :  */
      10             : 
      11             : #ifndef __net_quic_h__
      12             : #define __net_quic_h__
      13             : 
      14             : #include <net/udp_tunnel.h>
      15             : #include <linux/quic.h>
      16             : 
      17             : #include "pnspace.h"
      18             : #include "common.h"
      19             : #include "family.h"
      20             : #include "stream.h"
      21             : #include "connid.h"
      22             : #include "crypto.h"
      23             : #include "path.h"
      24             : #include "cong.h"
      25             : 
      26             : #include "packet.h"
      27             : #include "frame.h"
      28             : 
      29             : #include "protocol.h"
      30             : #include "outqueue.h"
      31             : #include "inqueue.h"
      32             : #include "timer.h"
      33             : 
      34             : extern struct proto quic_prot;
      35             : extern struct proto quicv6_prot;
      36             : 
      37             : enum quic_state {
      38             :         QUIC_SS_CLOSED          = TCP_CLOSE,
      39             :         QUIC_SS_LISTENING       = TCP_LISTEN,
      40             :         QUIC_SS_ESTABLISHING    = TCP_SYN_RECV,
      41             :         QUIC_SS_ESTABLISHED     = TCP_ESTABLISHED,
      42             : };
      43             : 
      44             : enum quic_tsq_enum {
      45             :         QUIC_MTU_REDUCED_DEFERRED,
      46             :         QUIC_LOSS_DEFERRED,
      47             :         QUIC_SACK_DEFERRED,
      48             :         QUIC_PATH_DEFERRED,
      49             :         QUIC_PMTU_DEFERRED,
      50             :         QUIC_TSQ_DEFERRED,
      51             : };
      52             : 
      53             : enum quic_tsq_flags {
      54             :         QUIC_F_MTU_REDUCED_DEFERRED     = BIT(QUIC_MTU_REDUCED_DEFERRED),
      55             :         QUIC_F_LOSS_DEFERRED            = BIT(QUIC_LOSS_DEFERRED),
      56             :         QUIC_F_SACK_DEFERRED            = BIT(QUIC_SACK_DEFERRED),
      57             :         QUIC_F_PATH_DEFERRED            = BIT(QUIC_PATH_DEFERRED),
      58             :         QUIC_F_PMTU_DEFERRED            = BIT(QUIC_PMTU_DEFERRED),
      59             :         QUIC_F_TSQ_DEFERRED             = BIT(QUIC_TSQ_DEFERRED),
      60             : };
      61             : 
      62             : #define QUIC_DEFERRED_ALL (QUIC_F_MTU_REDUCED_DEFERRED |        \
      63             :                            QUIC_F_LOSS_DEFERRED |               \
      64             :                            QUIC_F_SACK_DEFERRED |               \
      65             :                            QUIC_F_PATH_DEFERRED |               \
      66             :                            QUIC_F_PMTU_DEFERRED |               \
      67             :                            QUIC_F_TSQ_DEFERRED)
      68             : 
      69             : struct quic_request_sock {
      70             :         struct list_head        list;
      71             : 
      72             :         struct quic_conn_id     dcid;
      73             :         struct quic_conn_id     scid;
      74             :         union quic_addr         daddr;
      75             :         union quic_addr         saddr;
      76             : 
      77             :         struct quic_conn_id     orig_dcid;
      78             :         u32                     version;
      79             :         u8                      retry;
      80             : };
      81             : 
      82             : struct quic_sock {
      83             :         struct inet_sock                inet;
      84             :         struct list_head                reqs;
      85             : 
      86             :         struct quic_config              config;
      87             :         struct quic_data                ticket;
      88             :         struct quic_data                token;
      89             :         struct quic_data                alpn;
      90             : 
      91             :         struct quic_stream_table        streams;
      92             :         struct quic_conn_id_set         source;
      93             :         struct quic_conn_id_set         dest;
      94             :         struct quic_path_group          paths;
      95             :         struct quic_cong                cong;
      96             :         struct quic_pnspace             space[QUIC_PNSPACE_MAX];
      97             :         struct quic_crypto              crypto[QUIC_CRYPTO_MAX];
      98             : 
      99             :         struct quic_outqueue            outq;
     100             :         struct quic_inqueue             inq;
     101             :         struct quic_packet              packet;
     102             :         struct quic_timer               timers[QUIC_TIMER_MAX];
     103             : };
     104             : 
     105             : struct quic6_sock {
     106             :         struct quic_sock        quic;
     107             :         struct ipv6_pinfo       inet6;
     108             : };
     109             : 
     110             : static inline struct quic_sock *quic_sk(const struct sock *sk)
     111             : {
     112             :         return (struct quic_sock *)sk;
     113             : }
     114             : 
     115        1905 : static inline struct list_head *quic_reqs(const struct sock *sk)
     116             : {
     117        1905 :         return &quic_sk(sk)->reqs;
     118             : }
     119             : 
     120         420 : static inline struct quic_config *quic_config(const struct sock *sk)
     121             : {
     122    24905519 :         return &quic_sk(sk)->config;
     123             : }
     124             : 
     125         473 : static inline struct quic_data *quic_token(const struct sock *sk)
     126             : {
     127        3573 :         return &quic_sk(sk)->token;
     128             : }
     129             : 
     130        3199 : static inline struct quic_data *quic_ticket(const struct sock *sk)
     131             : {
     132        5310 :         return &quic_sk(sk)->ticket;
     133             : }
     134             : 
     135        2043 : static inline struct quic_data *quic_alpn(const struct sock *sk)
     136             : {
     137        3161 :         return &quic_sk(sk)->alpn;
     138             : }
     139             : 
     140    21563002 : static inline struct quic_stream_table *quic_streams(const struct sock *sk)
     141             : {
     142    38134009 :         return &quic_sk(sk)->streams;
     143             : }
     144             : 
     145       11537 : static inline struct quic_conn_id_set *quic_source(const struct sock *sk)
     146             : {
     147       12524 :         return &quic_sk(sk)->source;
     148             : }
     149             : 
     150     6583092 : static inline struct quic_conn_id_set *quic_dest(const struct sock *sk)
     151             : {
     152    26592497 :         return &quic_sk(sk)->dest;
     153             : }
     154             : 
     155    24600701 : static inline struct quic_path_group *quic_paths(const struct sock *sk)
     156             : {
     157    75701469 :         return &quic_sk(sk)->paths;
     158             : }
     159             : 
     160    26487757 : static inline bool quic_is_serv(const struct sock *sk)
     161             : {
     162    26486764 :         return quic_paths(sk)->serv;
     163             : }
     164             : 
     165     7686553 : static inline struct quic_cong *quic_cong(const struct sock *sk)
     166             : {
     167    14248950 :         return &quic_sk(sk)->cong;
     168             : }
     169             : 
     170    60766142 : static inline struct quic_pnspace *quic_pnspace(const struct sock *sk, u8 level)
     171             : {
     172    88235800 :         return &quic_sk(sk)->space[level % QUIC_CRYPTO_EARLY];
     173             : }
     174             : 
     175    77902163 : static inline struct quic_crypto *quic_crypto(const struct sock *sk, u8 level)
     176             : {
     177    80030512 :         return &quic_sk(sk)->crypto[level];
     178             : }
     179             : 
     180     8310934 : static inline struct quic_outqueue *quic_outq(const struct sock *sk)
     181             : {
     182   167520704 :         return &quic_sk(sk)->outq;
     183             : }
     184             : 
     185      551574 : static inline struct quic_inqueue *quic_inq(const struct sock *sk)
     186             : {
     187    20314353 :         return &quic_sk(sk)->inq;
     188             : }
     189             : 
     190             : static inline struct quic_packet *quic_packet(const struct sock *sk)
     191             : {
     192   164802645 :         return &quic_sk(sk)->packet;
     193             : }
     194             : 
     195    13940203 : static inline void *quic_timer(const struct sock *sk, u8 type)
     196             : {
     197    13935727 :         return (void *)&quic_sk(sk)->timers[type];
     198             : }
     199             : 
     200        6570 : static inline bool quic_is_establishing(struct sock *sk)
     201             : {
     202        6570 :         return sk->sk_state == QUIC_SS_ESTABLISHING;
     203             : }
     204             : 
     205    13295109 : static inline bool quic_is_established(struct sock *sk)
     206             : {
     207    13293374 :         return sk->sk_state == QUIC_SS_ESTABLISHED;
     208             : }
     209             : 
     210     6858920 : static inline bool quic_is_listen(struct sock *sk)
     211             : {
     212     6858920 :         return sk->sk_state == QUIC_SS_LISTENING;
     213             : }
     214             : 
     215     9279716 : static inline bool quic_is_closed(struct sock *sk)
     216             : {
     217     9279716 :         return sk->sk_state == QUIC_SS_CLOSED;
     218             : }
     219             : 
     220        3619 : static inline void quic_set_state(struct sock *sk, int state)
     221             : {
     222        3619 :         struct net *net = sock_net(sk);
     223        3619 :         int mib;
     224             : 
     225        3619 :         if (sk->sk_state == state)
     226             :                 return;
     227             : 
     228        3230 :         if (state == QUIC_SS_ESTABLISHED) {
     229        1986 :                 mib = quic_is_serv(sk) ? QUIC_MIB_CONN_PASSIVEESTABS
     230         993 :                                        : QUIC_MIB_CONN_ACTIVEESTABS;
     231         993 :                 QUIC_INC_STATS(net, mib);
     232         993 :                 QUIC_INC_STATS(net, QUIC_MIB_CONN_CURRENTESTABS);
     233        2237 :         } else if (quic_is_established(sk)) {
     234         993 :                 QUIC_DEC_STATS(net, QUIC_MIB_CONN_CURRENTESTABS);
     235             :         }
     236             : 
     237        3230 :         if (state == QUIC_SS_CLOSED)
     238        1118 :                 sk->sk_prot->unhash(sk);
     239             : 
     240        3230 :         inet_sk_set_state(sk, state);
     241        3230 :         sk->sk_state_change(sk);
     242             : }
     243             : 
     244             : struct sock *quic_listen_sock_lookup(struct sk_buff *skb, union quic_addr *sa, union quic_addr *da,
     245             :                                      struct quic_data *alpns);
     246             : struct sock *quic_sock_lookup(struct sk_buff *skb, union quic_addr *sa, union quic_addr *da,
     247             :                               struct quic_conn_id *dcid);
     248             : bool quic_accept_sock_exists(struct sock *sk, struct sk_buff *skb);
     249             : 
     250             : int quic_request_sock_enqueue(struct sock *sk, struct quic_conn_id *odcid, u8 retry);
     251             : bool quic_request_sock_exists(struct sock *sk);
     252             : 
     253             : #endif /* __net_quic_h__ */