tools/testing/selftests/bpf/progs/sock_destroy_prog.c

   1 // SPDX-License-Identifier: GPL-2.0
   2
   3 #include "vmlinux.h"
   4 #include <bpf/bpf_helpers.h>
   5 #include <bpf/bpf_endian.h>
   6
   7 #include "bpf_tracing_net.h"
   8
   9 __be16 serv_port = 0;
  10
  11 int bpf_sock_destroy(struct sock_common *sk) __ksym;
  12
  13 struct {
  14         __uint(type, BPF_MAP_TYPE_ARRAY);
  15         __uint(max_entries, 1);
  16         __type(key, __u32);
  17         __type(value, __u64);
  18 } tcp_conn_sockets SEC(".maps");
  19
  20 struct {
  21         __uint(type, BPF_MAP_TYPE_ARRAY);
  22         __uint(max_entries, 1);
  23         __type(key, __u32);
  24         __type(value, __u64);
  25 } udp_conn_sockets SEC(".maps");
  26
  27 SEC("cgroup/connect6")
  28 int sock_connect(struct bpf_sock_addr *ctx)
  29 {
  30         __u64 sock_cookie = 0;
  31         int key = 0;
  32         __u32 keyc = 0;
  33
  34         if (ctx->family != AF_INET6 || ctx->user_family != AF_INET6)
  35                 return 1;
  36
  37         sock_cookie = bpf_get_socket_cookie(ctx);
  38         if (ctx->protocol == IPPROTO_TCP)
  39                 bpf_map_update_elem(&tcp_conn_sockets, &key, &sock_cookie, 0);
  40         else if (ctx->protocol == IPPROTO_UDP)
  41                 bpf_map_update_elem(&udp_conn_sockets, &keyc, &sock_cookie, 0);
  42         else
  43                 return 1;
  44
  45         return 1;
  46 }
  47
  48 SEC("iter/tcp")
  49 int iter_tcp6_client(struct bpf_iter__tcp *ctx)
  50 {
  51         struct sock_common *sk_common = ctx->sk_common;
  52         __u64 sock_cookie = 0;
  53         __u64 *val;
  54         int key = 0;
  55
  56         if (!sk_common)
  57                 return 0;
  58
  59         if (sk_common->skc_family != AF_INET6)
  60                 return 0;
  61
  62         sock_cookie  = bpf_get_socket_cookie(sk_common);
  63         val = bpf_map_lookup_elem(&tcp_conn_sockets, &key);
  64         if (!val)
  65                 return 0;
  66         /* Destroy connected client sockets. */
  67         if (sock_cookie == *val)
  68                 bpf_sock_destroy(sk_common);
  69
  70         return 0;
  71 }
  72
  73 SEC("iter/tcp")
  74 int iter_tcp6_server(struct bpf_iter__tcp *ctx)
  75 {
  76         struct sock_common *sk_common = ctx->sk_common;
  77         const struct inet_connection_sock *icsk;
  78         const struct inet_sock *inet;
  79         struct tcp6_sock *tcp_sk;
  80         __be16 srcp;
  81
  82         if (!sk_common)
  83                 return 0;
  84
  85         if (sk_common->skc_family != AF_INET6)
  86                 return 0;
  87
  88         tcp_sk = bpf_skc_to_tcp6_sock(sk_common);
  89         if (!tcp_sk)
  90                 return 0;
  91
  92         icsk = &tcp_sk->tcp.inet_conn;
  93         inet = &icsk->icsk_inet;
  94         srcp = inet->inet_sport;
  95
  96         /* Destroy server sockets. */
  97         if (srcp == serv_port)
  98                 bpf_sock_destroy(sk_common);
  99
 100         return 0;
 101 }
 102
 103
 104 SEC("iter/udp")
 105 int iter_udp6_client(struct bpf_iter__udp *ctx)
 106 {
 107         struct udp_sock *udp_sk = ctx->udp_sk;
 108         struct sock *sk = (struct sock *) udp_sk;
 109         __u64 sock_cookie = 0, *val;
 110         int key = 0;
 111
 112         if (!sk)
 113                 return 0;
 114
 115         sock_cookie  = bpf_get_socket_cookie(sk);
 116         val = bpf_map_lookup_elem(&udp_conn_sockets, &key);
 117         if (!val)
 118                 return 0;
 119         /* Destroy connected client sockets. */
 120         if (sock_cookie == *val)
 121                 bpf_sock_destroy((struct sock_common *)sk);
 122
 123         return 0;
 124 }
 125
 126 SEC("iter/udp")
 127 int iter_udp6_server(struct bpf_iter__udp *ctx)
 128 {
 129         struct udp_sock *udp_sk = ctx->udp_sk;
 130         struct sock *sk = (struct sock *) udp_sk;
 131         struct inet_sock *inet;
 132         __be16 srcp;
 133
 134         if (!sk)
 135                 return 0;
 136
 137         inet = &udp_sk->inet;
 138         srcp = inet->inet_sport;
 139         if (srcp == serv_port)
 140                 bpf_sock_destroy((struct sock_common *)sk);
 141
 142         return 0;
 143 }
 144
 145 char _license[] SEC("license") = "GPL";