/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * Copyright 2024 Oxide Computer Company
 */

#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/time.h>

#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in_systm.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <netinet/if_ether.h>
#include <netinet/tcp.h>
#include "snoop.h"

extern char *dlc_header;

#define TCPOPT_HEADER_LEN       2
#define TCPOPT_TSTAMP_LEN       10
#define TCPOPT_SACK_LEN         8
#define TCPOPT_MD5_LEN          18

/*
 * Convert a network byte order 32 bit integer to a host order integer.
 * ntohl() cannot be used because option values may not be aligned properly.
 */
#define GET_UINT32(opt) (((uint_t)*((uchar_t *)(opt) + 0) << 24) | \
        ((uint_t)*((uchar_t *)(opt) + 1) << 16) | \
        ((uint_t)*((uchar_t *)(opt) + 2) << 8) | \
        ((uint_t)*((uchar_t *)(opt) + 3)))

static void print_tcpoptions_summary(uchar_t *, int, char *);
static void print_tcpoptions(uchar_t *, int);

static const struct {
        unsigned int    tf_flag;
        const char      *tf_name;
} tcp_flags[] = {
        { TH_SYN,       "Syn"   },
        { TH_FIN,       "Fin"   },
        { TH_RST,       "Rst"   },
        { TH_PUSH,      "Push"  },
        { TH_ECE,       "ECE"   },
        { TH_CWR,       "CWR"   },
        { 0,            NULL    }
};

int
interpret_tcp(int flags, struct tcphdr *tcp, int iplen, int fraglen)
{
        char *data;
        int hdrlen, tcplen;
        int sunrpc = 0;
        char *pname;
        char buff[32];
        char *line, *endline;
        unsigned int i;

        hdrlen = tcp->th_off * 4;
        data = (char *)tcp + hdrlen;
        tcplen = iplen - hdrlen;
        fraglen -= hdrlen;
        if (fraglen < 0)
                return (fraglen + hdrlen);      /* incomplete header */
        if (fraglen > tcplen)
                fraglen = tcplen;

        if (flags & F_SUM) {
                line = get_sum_line();
                endline = line + MAXLINE;
                (void) snprintf(line, endline - line, "TCP D=%d S=%d",
                    ntohs(tcp->th_dport), ntohs(tcp->th_sport));
                line += strlen(line);

                for (i = 0; tcp_flags[i].tf_name != NULL; i++) {
                        if (tcp->th_flags & tcp_flags[i].tf_flag) {
                                (void) snprintf(line, endline - line, " %s",
                                    tcp_flags[i].tf_name);
                                line += strlen(line);
                        }
                }

                if (tcp->th_flags & TH_URG) {
                        (void) snprintf(line, endline - line, " Urg=%u",
                            ntohs(tcp->th_urp));
                        line += strlen(line);
                }
                if (tcp->th_flags & TH_ACK) {
                        (void) snprintf(line, endline - line, " Ack=%u",
                            ntohl(tcp->th_ack));
                        line += strlen(line);
                }
                if (ntohl(tcp->th_seq)) {
                        (void) snprintf(line, endline - line, " Seq=%u Len=%d",
                            ntohl(tcp->th_seq), tcplen);
                        line += strlen(line);
                }
                (void) snprintf(line, endline - line, " Win=%d",
                    ntohs(tcp->th_win));
                print_tcpoptions_summary((uchar_t *)(tcp + 1),
                    (int)(tcp->th_off * 4 - sizeof (struct tcphdr)), line);
        }

        sunrpc = !reservedport(IPPROTO_TCP, ntohs(tcp->th_dport)) &&
            !reservedport(IPPROTO_TCP, ntohs(tcp->th_sport)) &&
            valid_rpc(data + 4, fraglen - 4);

        if (flags & F_DTAIL) {

        show_header("TCP:  ", "TCP Header", tcplen);
        show_space();
        (void) sprintf(get_line((char *)(uintptr_t)tcp->th_sport -
            dlc_header, 2), "Source port = %d", ntohs(tcp->th_sport));

        if (sunrpc) {
                pname = "(Sun RPC)";
        } else {
                pname = getportname(IPPROTO_TCP, ntohs(tcp->th_dport));
                if (pname == NULL) {
                        pname = "";
                } else {
                        (void) sprintf(buff, "(%s)", pname);
                        pname = buff;
                }
        }
        (void) sprintf(get_line((char *)(uintptr_t)tcp->th_dport -
            dlc_header, 2), "Destination port = %d %s",
            ntohs(tcp->th_dport), pname);
        (void) sprintf(get_line((char *)(uintptr_t)tcp->th_seq -
            dlc_header, 4),     "Sequence number = %u",
            ntohl(tcp->th_seq));
        (void) sprintf(get_line((char *)(uintptr_t)tcp->th_ack - dlc_header, 4),
            "Acknowledgement number = %u",
            ntohl(tcp->th_ack));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_ack - dlc_header) +
            4, 1), "Data offset = %d bytes", tcp->th_off * 4);
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "Flags = 0x%02x", tcp->th_flags);
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_CWR,
            "ECN congestion window reduced",
            "No ECN congestion window reduced"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_ECE,
            "ECN echo", "No ECN echo"));
        (void) sprintf(
            get_line(((char *)(uintptr_t)tcp->th_flags - dlc_header) + 4, 1),
            "      %s", getflag(tcp->th_flags, TH_URG,
            "Urgent pointer", "No urgent pointer"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_ACK,
            "Acknowledgement", "No acknowledgement"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_PUSH,
            "Push", "No push"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_RST,
            "Reset", "No reset"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_SYN,
            "Syn", "No Syn"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_flags -
            dlc_header) + 4, 1), "      %s", getflag(tcp->th_flags, TH_FIN,
            "Fin", "No Fin"));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_win - dlc_header) +
            4, 1), "Window = %d", ntohs(tcp->th_win));
        /* XXX need to compute checksum and print whether correct */
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_sum - dlc_header) +
            4, 1), "Checksum = 0x%04x", ntohs(tcp->th_sum));
        (void) sprintf(get_line(((char *)(uintptr_t)tcp->th_urp - dlc_header) +
            4, 1), "Urgent pointer = %d", ntohs(tcp->th_urp));

        /* Print TCP options - if any */

        print_tcpoptions((uchar_t *)(tcp + 1),
            tcp->th_off * 4 - sizeof (struct tcphdr));

        show_space();
        }

        /* is there any data? */
        if (tcplen == 0)
                return (tcplen);

        /* go to the next protocol layer */

        if (!interpret_reserved(flags, IPPROTO_TCP,
            ntohs(tcp->th_sport), ntohs(tcp->th_dport), data, fraglen)) {
                if (sunrpc && fraglen > 0)
                        interpret_rpc(flags, data, fraglen, IPPROTO_TCP);
        }

        return (tcplen);
}

static void
print_tcpoptions(uchar_t *opt, int optlen)
{
        int      len;
        char     *line;

        if (optlen <= 0) {
                (void) sprintf(get_line((char *)&opt - dlc_header, 1),
                "No options");
                return;
        }

        (void) sprintf(get_line((char *)&opt - dlc_header, 1),
        "Options: (%d bytes)", optlen);

        while (optlen > 0) {
                line = get_line((char *)&opt - dlc_header, 1);
                len = opt[1];
                switch (opt[0]) {
                case TCPOPT_EOL:
                        (void) strcpy(line, "  - End of option list");
                        return;
                case TCPOPT_NOP:
                        (void) strcpy(line, "  - No operation");
                        len = 1;
                        break;
                case TCPOPT_MAXSEG:
                        (void) sprintf(line,
                            "  - Maximum segment size = %d bytes",
                            (opt[2] << 8) + opt[3]);
                        break;
                case TCPOPT_WSCALE:
                        (void) sprintf(line, "  - Window scale = %d", opt[2]);
                        break;
                case TCPOPT_TSTAMP:
                        /* Sanity check. */
                        if (optlen < TCPOPT_TSTAMP_LEN) {
                                (void) sprintf(line,
                                    "  - Incomplete TS option");
                        } else {
                                (void) sprintf(line,
                                    "  - TS Val = %u, TS Echo = %u",
                                    GET_UINT32(opt + 2),
                                    GET_UINT32(opt + 6));
                        }
                        break;
                case TCPOPT_SACK_PERMITTED:
                        (void) sprintf(line, "  - SACK permitted option");
                        break;
                case TCPOPT_SACK: {
                        uchar_t *sack_opt, *end_opt;
                        int sack_len;

                        /*
                         * Sanity check.  Total length should be greater
                         * than just the option header length.
                         */
                        if (optlen <= TCPOPT_HEADER_LEN ||
                            len < TCPOPT_HEADER_LEN) {
                                (void) sprintf(line,
                                    "  - Incomplete SACK option");
                                break;
                        }
                        sack_len = len - TCPOPT_HEADER_LEN;
                        sack_opt = opt + TCPOPT_HEADER_LEN;
                        end_opt = opt + optlen;

                        (void) sprintf(line, "  - SACK blocks:");
                        line = get_line((char *)&opt - dlc_header, 1);
                        (void) sprintf(line, "        ");
                        while (sack_len > 0) {
                                char sack_blk[MAXLINE + 1];

                                /*
                                 * sack_len may not tell us the truth about
                                 * the real length...  Need to be careful
                                 * not to step beyond the option buffer.
                                 */
                                if (sack_opt + TCPOPT_SACK_LEN > end_opt) {
                                        (void) strcat(line,
                                            "...incomplete SACK block");
                                        break;
                                }
                                (void) sprintf(sack_blk, "(%u-%u) ",
                                    GET_UINT32(sack_opt),
                                    GET_UINT32(sack_opt + 4));
                                (void) strcat(line, sack_blk);
                                sack_opt += TCPOPT_SACK_LEN;
                                sack_len -= TCPOPT_SACK_LEN;
                        }
                        break;
                }
                case TCPOPT_MD5: {
                        uint_t i;

                        if (optlen < TCPOPT_MD5_LEN || len != TCPOPT_MD5_LEN) {
                                (void) sprintf(line,
                                    "  - Incomplete MD5 option");
                                break;
                        }

                        (void) sprintf(line, "  - TCP MD5 Signature = 0x");
                        for (i = 2; i < len; i++) {
                                char options[3];

                                (void) sprintf(options, "%02x", opt[i]);
                                (void) strcat(line, options);
                        }
                        break;
                }
                default:
                        (void) sprintf(line,
                            "  - Option %d (unknown - %d bytes) %s",
                            opt[0], len - 2, tohex((char *)&opt[2], len - 2));
                        break;
                }
                if (len <= 0) {
                        (void) sprintf(line, "  - Incomplete option len %d",
                            len);
                        break;
                }
                opt += len;
                optlen -= len;
        }
}

/*
 * This function is basically the same as print_tcpoptions() except that
 * all options are printed on the same line.
 */
static void
print_tcpoptions_summary(uchar_t *opt, int optlen, char *line)
{
        int      len;
        char    options[MAXLINE + 1];

        if (optlen <= 0) {
                return;
        }

        (void) strcat(line, " Options=<");
        while (optlen > 0) {
                len = opt[1];
                switch (opt[0]) {
                case TCPOPT_EOL:
                        (void) strcat(line, "eol>");
                        return;
                case TCPOPT_NOP:
                        (void) strcat(line, "nop");
                        len = 1;
                        break;
                case TCPOPT_MAXSEG:
                        (void) sprintf(options, "mss %d",
                            (opt[2] << 8) + opt[3]);
                        (void) strcat(line, options);
                        break;
                case TCPOPT_WSCALE:
                        (void) sprintf(options, "wscale %d", opt[2]);
                        (void) strcat(line, options);
                        break;
                case TCPOPT_TSTAMP:
                        /* Sanity check. */
                        if (optlen < TCPOPT_TSTAMP_LEN) {
                                (void) strcat(line, "tstamp|");
                        } else {
                                (void) sprintf(options,
                                    "tstamp %u %u", GET_UINT32(opt + 2),
                                    GET_UINT32(opt + 6));
                                (void) strcat(line, options);
                        }
                        break;
                case TCPOPT_SACK_PERMITTED:
                        (void) strcat(line, "sackOK");
                        break;
                case TCPOPT_SACK: {
                        uchar_t *sack_opt, *end_opt;
                        int sack_len;

                        /*
                         * Sanity check.  Total length should be greater
                         * than just the option header length.
                         */
                        if (optlen <= TCPOPT_HEADER_LEN ||
                            len < TCPOPT_HEADER_LEN) {
                                (void) strcat(line, "sack|");
                                break;
                        }
                        sack_len = len - TCPOPT_HEADER_LEN;
                        sack_opt = opt + TCPOPT_HEADER_LEN;
                        end_opt = opt + optlen;

                        (void) strcat(line, "sack");
                        while (sack_len > 0) {
                                /*
                                 * sack_len may not tell us the truth about
                                 * the real length...  Need to be careful
                                 * not to step beyond the option buffer.
                                 */
                                if (sack_opt + TCPOPT_SACK_LEN > end_opt) {
                                        (void) strcat(line, "|");
                                        break;
                                }
                                (void) sprintf(options, " %u-%u",
                                    GET_UINT32(sack_opt),
                                    GET_UINT32(sack_opt + 4));
                                (void) strcat(line, options);
                                sack_opt += TCPOPT_SACK_LEN;
                                sack_len -= TCPOPT_SACK_LEN;
                        }
                        break;
                }
                case TCPOPT_MD5: {
                        uint_t i;

                        if (optlen < TCPOPT_MD5_LEN || len != TCPOPT_MD5_LEN) {
                                (void) strcat(line, "md5|");
                                break;
                        }

                        (void) strcat(line, "md5 0x");
                        for (i = 2; i < len; i++) {
                                (void) sprintf(options, "%02x", opt[i]);
                                (void) strcat(line, options);
                        }
                        break;
                }
                default:
                        (void) sprintf(options, "unknown %d", opt[0]);
                        (void) strcat(line, options);
                        break;
                }
                if (len <= 0) {
                        (void) sprintf(options, "optlen %d", len);
                        (void) strcat(line, options);
                        break;
                }
                opt += len;
                optlen -= len;
                if (optlen > 0) {
                        (void) strcat(line, ",");
                }
        }
        (void) strcat(line, ">");
}