/* SPDX-License-Identifier: GPL-2.0 */
#undef TRACE_SYSTEM
#define TRACE_SYSTEM handshake

#if !defined(_TRACE_HANDSHAKE_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_HANDSHAKE_H

#include <linux/net.h>
#include <net/tls_prot.h>
#include <linux/tracepoint.h>
#include <trace/events/net_probe_common.h>

#define TLS_RECORD_TYPE_LIST \
        record_type(CHANGE_CIPHER_SPEC) \
        record_type(ALERT) \
        record_type(HANDSHAKE) \
        record_type(DATA) \
        record_type(HEARTBEAT) \
        record_type(TLS12_CID) \
        record_type_end(ACK)

#undef record_type
#undef record_type_end
#define record_type(x)          TRACE_DEFINE_ENUM(TLS_RECORD_TYPE_##x);
#define record_type_end(x)      TRACE_DEFINE_ENUM(TLS_RECORD_TYPE_##x);

TLS_RECORD_TYPE_LIST

#undef record_type
#undef record_type_end
#define record_type(x)          { TLS_RECORD_TYPE_##x, #x },
#define record_type_end(x)      { TLS_RECORD_TYPE_##x, #x }

#define show_tls_content_type(type) \
        __print_symbolic(type, TLS_RECORD_TYPE_LIST)

TRACE_DEFINE_ENUM(TLS_ALERT_LEVEL_WARNING);
TRACE_DEFINE_ENUM(TLS_ALERT_LEVEL_FATAL);

#define show_tls_alert_level(level) \
        __print_symbolic(level, \
                { TLS_ALERT_LEVEL_WARNING,      "Warning" }, \
                { TLS_ALERT_LEVEL_FATAL,        "Fatal" })

#define TLS_ALERT_DESCRIPTION_LIST \
        alert_description(CLOSE_NOTIFY) \
        alert_description(UNEXPECTED_MESSAGE) \
        alert_description(BAD_RECORD_MAC) \
        alert_description(RECORD_OVERFLOW) \
        alert_description(HANDSHAKE_FAILURE) \
        alert_description(BAD_CERTIFICATE) \
        alert_description(UNSUPPORTED_CERTIFICATE) \
        alert_description(CERTIFICATE_REVOKED) \
        alert_description(CERTIFICATE_EXPIRED) \
        alert_description(CERTIFICATE_UNKNOWN) \
        alert_description(ILLEGAL_PARAMETER) \
        alert_description(UNKNOWN_CA) \
        alert_description(ACCESS_DENIED) \
        alert_description(DECODE_ERROR) \
        alert_description(DECRYPT_ERROR) \
        alert_description(TOO_MANY_CIDS_REQUESTED) \
        alert_description(PROTOCOL_VERSION) \
        alert_description(INSUFFICIENT_SECURITY) \
        alert_description(INTERNAL_ERROR) \
        alert_description(INAPPROPRIATE_FALLBACK) \
        alert_description(USER_CANCELED) \
        alert_description(MISSING_EXTENSION) \
        alert_description(UNSUPPORTED_EXTENSION) \
        alert_description(UNRECOGNIZED_NAME) \
        alert_description(BAD_CERTIFICATE_STATUS_RESPONSE) \
        alert_description(UNKNOWN_PSK_IDENTITY) \
        alert_description(CERTIFICATE_REQUIRED) \
        alert_description_end(NO_APPLICATION_PROTOCOL)

#undef alert_description
#undef alert_description_end
#define alert_description(x)            TRACE_DEFINE_ENUM(TLS_ALERT_DESC_##x);
#define alert_description_end(x)        TRACE_DEFINE_ENUM(TLS_ALERT_DESC_##x);

TLS_ALERT_DESCRIPTION_LIST

#undef alert_description
#undef alert_description_end
#define alert_description(x)            { TLS_ALERT_DESC_##x, #x },
#define alert_description_end(x)        { TLS_ALERT_DESC_##x, #x }

#define show_tls_alert_description(desc) \
        __print_symbolic(desc, TLS_ALERT_DESCRIPTION_LIST)

DECLARE_EVENT_CLASS(handshake_event_class,
        TP_PROTO(
                const struct net *net,
                const struct handshake_req *req,
                const struct sock *sk
        ),
        TP_ARGS(net, req, sk),
        TP_STRUCT__entry(
                __field(const void *, req)
                __field(const void *, sk)
                __field(unsigned int, netns_ino)
        ),
        TP_fast_assign(
                __entry->req = req;
                __entry->sk = sk;
                __entry->netns_ino = net->ns.inum;
        ),
        TP_printk("req=%p sk=%p",
                __entry->req, __entry->sk
        )
);
#define DEFINE_HANDSHAKE_EVENT(name)                            \
        DEFINE_EVENT(handshake_event_class, name,               \
                TP_PROTO(                                       \
                        const struct net *net,                  \
                        const struct handshake_req *req,        \
                        const struct sock *sk                   \
                ),                                              \
                TP_ARGS(net, req, sk))

DECLARE_EVENT_CLASS(handshake_fd_class,
        TP_PROTO(
                const struct net *net,
                const struct handshake_req *req,
                const struct sock *sk,
                int fd
        ),
        TP_ARGS(net, req, sk, fd),
        TP_STRUCT__entry(
                __field(const void *, req)
                __field(const void *, sk)
                __field(int, fd)
                __field(unsigned int, netns_ino)
        ),
        TP_fast_assign(
                __entry->req = req;
                __entry->sk = req->hr_sk;
                __entry->fd = fd;
                __entry->netns_ino = net->ns.inum;
        ),
        TP_printk("req=%p sk=%p fd=%d",
                __entry->req, __entry->sk, __entry->fd
        )
);
#define DEFINE_HANDSHAKE_FD_EVENT(name)                         \
        DEFINE_EVENT(handshake_fd_class, name,                  \
                TP_PROTO(                                       \
                        const struct net *net,                  \
                        const struct handshake_req *req,        \
                        const struct sock *sk,                  \
                        int fd                                  \
                ),                                              \
                TP_ARGS(net, req, sk, fd))

DECLARE_EVENT_CLASS(handshake_error_class,
        TP_PROTO(
                const struct net *net,
                const struct handshake_req *req,
                const struct sock *sk,
                int err
        ),
        TP_ARGS(net, req, sk, err),
        TP_STRUCT__entry(
                __field(const void *, req)
                __field(const void *, sk)
                __field(int, err)
                __field(unsigned int, netns_ino)
        ),
        TP_fast_assign(
                __entry->req = req;
                __entry->sk = sk;
                __entry->err = err;
                __entry->netns_ino = net->ns.inum;
        ),
        TP_printk("req=%p sk=%p err=%d",
                __entry->req, __entry->sk, __entry->err
        )
);
#define DEFINE_HANDSHAKE_ERROR(name)                            \
        DEFINE_EVENT(handshake_error_class, name,               \
                TP_PROTO(                                       \
                        const struct net *net,                  \
                        const struct handshake_req *req,        \
                        const struct sock *sk,                  \
                        int err                                 \
                ),                                              \
                TP_ARGS(net, req, sk, err))

DECLARE_EVENT_CLASS(handshake_alert_class,
        TP_PROTO(
                const struct sock *sk,
                unsigned char level,
                unsigned char description
        ),
        TP_ARGS(sk, level, description),
        TP_STRUCT__entry(
                /* sockaddr_in6 is always bigger than sockaddr_in */
                __array(__u8, saddr, sizeof(struct sockaddr_in6))
                __array(__u8, daddr, sizeof(struct sockaddr_in6))
                __field(unsigned int, netns_ino)
                __field(unsigned long, level)
                __field(unsigned long, description)
        ),
        TP_fast_assign(
                const struct inet_sock *inet = inet_sk(sk);

                memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
                memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
                TP_STORE_ADDR_PORTS(__entry, inet, sk);

                __entry->netns_ino = sock_net(sk)->ns.inum;
                __entry->level = level;
                __entry->description = description;
        ),
        TP_printk("src=%pISpc dest=%pISpc %s: %s",
                __entry->saddr, __entry->daddr,
                show_tls_alert_level(__entry->level),
                show_tls_alert_description(__entry->description)
        )
);
#define DEFINE_HANDSHAKE_ALERT(name)                            \
        DEFINE_EVENT(handshake_alert_class, name,               \
                TP_PROTO(                                       \
                        const struct sock *sk,                  \
                        unsigned char level,                    \
                        unsigned char description               \
                ),                                              \
                TP_ARGS(sk, level, description))


/*
 * Request lifetime events
 */

DEFINE_HANDSHAKE_EVENT(handshake_submit);
DEFINE_HANDSHAKE_ERROR(handshake_submit_err);
DEFINE_HANDSHAKE_EVENT(handshake_cancel);
DEFINE_HANDSHAKE_EVENT(handshake_cancel_none);
DEFINE_HANDSHAKE_EVENT(handshake_cancel_busy);
DEFINE_HANDSHAKE_EVENT(handshake_destruct);


TRACE_EVENT(handshake_complete,
        TP_PROTO(
                const struct net *net,
                const struct handshake_req *req,
                const struct sock *sk,
                int status
        ),
        TP_ARGS(net, req, sk, status),
        TP_STRUCT__entry(
                __field(const void *, req)
                __field(const void *, sk)
                __field(int, status)
                __field(unsigned int, netns_ino)
        ),
        TP_fast_assign(
                __entry->req = req;
                __entry->sk = sk;
                __entry->status = status;
                __entry->netns_ino = net->ns.inum;
        ),
        TP_printk("req=%p sk=%p status=%d",
                __entry->req, __entry->sk, __entry->status
        )
);

/*
 * Netlink events
 */

DEFINE_HANDSHAKE_ERROR(handshake_notify_err);
DEFINE_HANDSHAKE_FD_EVENT(handshake_cmd_accept);
DEFINE_HANDSHAKE_ERROR(handshake_cmd_accept_err);
DEFINE_HANDSHAKE_FD_EVENT(handshake_cmd_done);
DEFINE_HANDSHAKE_ERROR(handshake_cmd_done_err);

/*
 * TLS Record events
 */

TRACE_EVENT(tls_contenttype,
        TP_PROTO(
                const struct sock *sk,
                unsigned char type
        ),
        TP_ARGS(sk, type),
        TP_STRUCT__entry(
                /* sockaddr_in6 is always bigger than sockaddr_in */
                __array(__u8, saddr, sizeof(struct sockaddr_in6))
                __array(__u8, daddr, sizeof(struct sockaddr_in6))
                __field(unsigned int, netns_ino)
                __field(unsigned long, type)
        ),
        TP_fast_assign(
                const struct inet_sock *inet = inet_sk(sk);

                memset(__entry->saddr, 0, sizeof(struct sockaddr_in6));
                memset(__entry->daddr, 0, sizeof(struct sockaddr_in6));
                TP_STORE_ADDR_PORTS(__entry, inet, sk);

                __entry->netns_ino = sock_net(sk)->ns.inum;
                __entry->type = type;
        ),
        TP_printk("src=%pISpc dest=%pISpc %s",
                __entry->saddr, __entry->daddr,
                show_tls_content_type(__entry->type)
        )
);

/*
 * TLS Alert events
 */

DEFINE_HANDSHAKE_ALERT(tls_alert_send);
DEFINE_HANDSHAKE_ALERT(tls_alert_recv);

#endif /* _TRACE_HANDSHAKE_H */

#include <trace/define_trace.h>