We initialise treq->af_specific in cookie_tcp_reqsk_alloc() so that
we can look up a key later in tcp_create_openreq_child().
Initially, that change was added for MD5 by commit 
ba5a4fdd63ae ("tcp:
make sure treq->af_specific is initialized"), but it has not been used
since commit 
d0f2b7a9ca0a ("tcp: Disable header prediction for MD5
flow.").
Now, treq->af_specific is used only by TCP-AO, so, we can move that
initialisation into tcp_ao_syncookie().
In addition to that, l3index in cookie_v[46]_check() is only used for
tcp_ao_syncookie(), so let's move it as well.
While at it, we move down tcp_ao_syncookie() in cookie_v4_check() so
that it will be called after security_inet_conn_request() to make
functions order consistent with cookie_v6_check().
Signed-off-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Reviewed-by: Simon Horman <horms@kernel.org>
Reviewed-by: Eric Dumazet <edumazet@google.com>
Link: https://lore.kernel.org/r/20231129022924.96156-7-kuniyu@amazon.com
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
 
 int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th);
 struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb);
 struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops,
-                                           const struct tcp_request_sock_ops *af_ops,
                                            struct sock *sk, struct sk_buff *skb);
 #ifdef CONFIG_SYN_COOKIES
 
 
 void tcp_ao_finish_connect(struct sock *sk, struct sk_buff *skb);
 void tcp_ao_connect_init(struct sock *sk);
 void tcp_ao_syncookie(struct sock *sk, const struct sk_buff *skb,
-                     struct tcp_request_sock *treq,
-                     unsigned short int family, int l3index);
+                     struct request_sock *req, unsigned short int family);
 #else /* CONFIG_TCP_AO */
 
 static inline int tcp_ao_transmit_skb(struct sock *sk, struct sk_buff *skb,
 }
 
 static inline void tcp_ao_syncookie(struct sock *sk, const struct sk_buff *skb,
-                                   struct tcp_request_sock *treq,
-                                   unsigned short int family, int l3index)
+                                   struct request_sock *req, unsigned short int family)
 {
 }
 
 
 EXPORT_SYMBOL(cookie_ecn_ok);
 
 struct request_sock *cookie_tcp_reqsk_alloc(const struct request_sock_ops *ops,
-                                           const struct tcp_request_sock_ops *af_ops,
-                                           struct sock *sk,
-                                           struct sk_buff *skb)
+                                           struct sock *sk, struct sk_buff *skb)
 {
        struct tcp_request_sock *treq;
        struct request_sock *req;
 
        treq = tcp_rsk(req);
 
-       /* treq->af_specific might be used to perform TCP_MD5 lookup */
-       treq->af_specific = af_ops;
-
        treq->syn_tos = TCP_SKB_CB(skb)->ip_dsfield;
        treq->req_usec_ts = false;
 
        struct rtable *rt;
        __u8 rcv_wscale;
        u32 tsoff = 0;
-       int l3index;
 
        if (!READ_ONCE(net->ipv4.sysctl_tcp_syncookies) ||
            !th->ack || th->rst)
        if (!cookie_timestamp_decode(net, &tcp_opt))
                goto out;
 
-       req = cookie_tcp_reqsk_alloc(&tcp_request_sock_ops,
-                                    &tcp_request_sock_ipv4_ops, sk, skb);
+       req = cookie_tcp_reqsk_alloc(&tcp_request_sock_ops, sk, skb);
        if (!req)
                goto out_drop;
 
 
        ireq->ir_iif = inet_request_bound_dev_if(sk, skb);
 
-       l3index = l3mdev_master_ifindex_by_index(net, ireq->ir_iif);
-       tcp_ao_syncookie(sk, skb, treq, AF_INET, l3index);
-
        /* We throwed the options of the initial SYN away, so we hope
         * the ACK carries the same options again (see RFC1122 4.2.3.8)
         */
        if (security_inet_conn_request(sk, skb, req))
                goto out_free;
 
+       tcp_ao_syncookie(sk, skb, req, AF_INET);
+
        req->num_retrans = 0;
 
        /*
 
 }
 
 void tcp_ao_syncookie(struct sock *sk, const struct sk_buff *skb,
-                     struct tcp_request_sock *treq,
-                     unsigned short int family, int l3index)
+                     struct request_sock *req, unsigned short int family)
 {
+       struct tcp_request_sock *treq = tcp_rsk(req);
        const struct tcphdr *th = tcp_hdr(skb);
        const struct tcp_ao_hdr *aoh;
        struct tcp_ao_key *key;
+       int l3index;
+
+       /* treq->af_specific is used to perform TCP_AO lookup
+        * in tcp_create_openreq_child().
+        */
+#if IS_ENABLED(CONFIG_IPV6)
+       if (family == AF_INET6)
+               treq->af_specific = &tcp_request_sock_ipv6_ops;
+       else
+#endif
+               treq->af_specific = &tcp_request_sock_ipv4_ops;
 
        treq->maclen = 0;
 
        if (tcp_parse_auth_options(th, NULL, &aoh) || !aoh)
                return;
 
+       l3index = l3mdev_master_ifindex_by_index(sock_net(sk), inet_rsk(req)->ir_iif);
        key = tcp_ao_inbound_lookup(family, sk, skb, -1, aoh->keyid, l3index);
        if (!key)
                /* Key not found, continue without TCP-AO */
 
        int full_space, mss;
        __u8 rcv_wscale;
        u32 tsoff = 0;
-       int l3index;
 
        if (!READ_ONCE(net->ipv4.sysctl_tcp_syncookies) ||
            !th->ack || th->rst)
        if (!cookie_timestamp_decode(net, &tcp_opt))
                goto out;
 
-       req = cookie_tcp_reqsk_alloc(&tcp6_request_sock_ops,
-                                    &tcp_request_sock_ipv6_ops, sk, skb);
+       req = cookie_tcp_reqsk_alloc(&tcp6_request_sock_ops, sk, skb);
        if (!req)
                goto out_drop;
 
        treq->ts_off = tsoff;
        treq->txhash = net_tx_rndhash();
 
-       l3index = l3mdev_master_ifindex_by_index(net, ireq->ir_iif);
-       tcp_ao_syncookie(sk, skb, treq, AF_INET6, l3index);
+       tcp_ao_syncookie(sk, skb, req, AF_INET6);
 
        if (IS_ENABLED(CONFIG_SMC))
                ireq->smc_ok = 0;