hackney

/* Copyright (c) 2017 - 2022 LiteSpeed Technologies Inc.  See LICENSE. */
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <inttypes.h>
#include <string.h>
#include <sys/queue.h>
#ifdef WIN32
#include <Ws2tcpip.h>
#else
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#endif

#include <openssl/ssl.h>
#include <openssl/x509.h>

#include "lsquic.h"
#include "lsquic_types.h"
#include "lsquic_int_types.h"
#include "lsquic_packet_common.h"
#include "lsquic_packet_in.h"
#include "lsquic_packet_out.h"
#include "lsquic_util.h"
#include "lsquic_qlog.h"

#define LSQUIC_LOGGER_MODULE LSQLM_QLOG
#include "lsquic_logger.h"

#define LSQUIC_LOG_CONN_ID cid
#define LCID(...) LSQ_LOG2(LSQ_LOG_DEBUG, __VA_ARGS__)

#define MAX_IP_LEN INET6_ADDRSTRLEN
#define QLOG_PACKET_RAW_SZ 64


void
lsquic_qlog_create_connection (const lsquic_cid_t* cid,
                                const struct sockaddr *local_sa,
                                const struct sockaddr *peer_sa)
{
    uint32_t ip_version, srcport, dstport;
    struct sockaddr_in *local4, *peer4;
    struct sockaddr_in6 *local6, *peer6;
    char srcip[MAX_IP_LEN], dstip[MAX_IP_LEN];

    if (!local_sa || !peer_sa)
        return;

    if (local_sa->sa_family == AF_INET)
    {
        ip_version = 4;
        local4 = (struct sockaddr_in *)local_sa;
        peer4 = (struct sockaddr_in *)peer_sa;
        srcport = ntohs(local4->sin_port);
        dstport = ntohs(peer4->sin_port);
        inet_ntop(local4->sin_family, &local4->sin_addr, srcip, MAX_IP_LEN);
        inet_ntop(peer4->sin_family, &peer4->sin_addr, dstip, MAX_IP_LEN);
    }
    else if (local_sa->sa_family == AF_INET6)
    {
        ip_version = 6;
        local6 = (struct sockaddr_in6 *)local_sa;
        peer6 = (struct sockaddr_in6 *)peer_sa;
        srcport = ntohs(local6->sin6_port);
        dstport = ntohs(peer6->sin6_port);
        inet_ntop(local6->sin6_family, &local6->sin6_addr, srcip, MAX_IP_LEN);
        inet_ntop(peer6->sin6_family, &peer6->sin6_addr, dstip, MAX_IP_LEN);
    }
    else
        return;

    LCID("[%" PRIu64 ",\"CONNECTIVITY\",\"NEW_CONNECTION\",\"LINE\","
            "{"
                "\"ip_version\":\"%u\","
                "\"srcip\":\"%s\","
                "\"dstip\":\"%s\","
                "\"srcport\":\"%u\","
                "\"dstport\":\"%u\""
            "}]",
            lsquic_time_now(), ip_version, srcip, dstip, srcport, dstport);
}


#define QLOG_FRAME_DICT_PREFIX_COMMA ",{\"frame_type\":\""
#define QLOG_FRAME_DICT_PREFIX "{\"frame_type\":\""
#define QLOG_FRAME_DICT_SUFFIX "\"}"
#define QLOG_FRAME_LIST_PREFIX ",\"frames\":["
#define QLOG_FRAME_LIST_SUFFIX "]"
#define QLOG_FRAME_LIST_MAX \
    sizeof(QLOG_FRAME_LIST_PREFIX) + \
    sizeof(QLOG_FRAME_LIST_SUFFIX) + \
    lsquic_frame_types_str_sz + \
    (N_QUIC_FRAMES * \
    (sizeof(QLOG_FRAME_DICT_PREFIX_COMMA) + \
     sizeof(QLOG_FRAME_DICT_SUFFIX)))

void
lsquic_qlog_packet_rx (const lsquic_cid_t* cid,
                        const struct lsquic_packet_in *packet_in,
                        const unsigned char *packet_in_data,
                        size_t packet_in_size)
{
    int i, first, ret;
    unsigned cur;
    size_t raw_bytes_written;
    char data[QLOG_PACKET_RAW_SZ];
    char frame_list[QLOG_FRAME_LIST_MAX + 1];

    if (!packet_in || !packet_in_data)
        return;

    if (packet_in->pi_frame_types)
    {
        memcpy(frame_list, QLOG_FRAME_LIST_PREFIX,
                                            sizeof(QLOG_FRAME_LIST_PREFIX));
        cur = sizeof(QLOG_FRAME_LIST_PREFIX) - 1;
        for (i = 0, first = 0; i < N_QUIC_FRAMES; i++)
            if (packet_in->pi_frame_types & (1 << i))
            {
                ret = snprintf(frame_list + cur,
                                QLOG_FRAME_LIST_MAX - cur,
                                /* prefix + FRAME_NAME + suffix */
                                "%s%s%s",
                                /* skip comma in prefix if first frame */
                                (first++ ?
                                    QLOG_FRAME_DICT_PREFIX_COMMA :
                                    QLOG_FRAME_DICT_PREFIX),
                                QUIC_FRAME_NAME(i),
                                QLOG_FRAME_DICT_SUFFIX);
                if (ret < 0 || (unsigned)ret > QLOG_FRAME_LIST_MAX - cur)
                    break;
                cur += ret;
            }
        if (cur + sizeof(QLOG_FRAME_LIST_SUFFIX) <= QLOG_FRAME_LIST_MAX)
            memcpy(frame_list + cur, QLOG_FRAME_LIST_SUFFIX,
                                        sizeof(QLOG_FRAME_LIST_SUFFIX));
    }
    else
        frame_list[0] = '\0';

    raw_bytes_written = lsquic_hex_encode(packet_in_data, packet_in_size,
                                                    data, QLOG_PACKET_RAW_SZ);

    LCID("[%" PRIu64 ",\"TRANSPORT\",\"PACKET_RX\",\"LINE\","
            "{"
                "\"raw\":\"%s%s\","
                "\"header\":{"
                    "\"type\":\"%s\","
                    "\"payload_length\":\"%d\","
                    "\"packet_number\":\"%" PRIu64 "\""
                "}%s"
            "}]",
            packet_in->pi_received,
            data, (raw_bytes_written < packet_in_size) ? "..." : "",
            lsquic_hety2str[packet_in->pi_header_type],
            packet_in->pi_data_sz,
            packet_in->pi_packno,
            frame_list);
}


void
lsquic_qlog_hsk_completed (const lsquic_cid_t* cid)
{
    LCID("[%" PRIu64 ",\"CONNECTIVITY\",\"HANDSHAKE\",\"PACKET_RX\","
            "{\"status\":\"complete\"}]", lsquic_time_now());
}


void
lsquic_qlog_sess_resume (const lsquic_cid_t* cid)
{
    LCID("[%" PRIu64 ",\"RECOVERY\",\"RTT_UPDATE\",\"PACKET_RX\","
            "{\"zero_rtt\":\"successful\"}]", lsquic_time_now());
}


void
lsquic_qlog_check_certs (const lsquic_cid_t* cid, const lsquic_str_t **certs,
                                                                size_t count)
{
    size_t i;
    size_t buf_sz = 0;
    char *buf = NULL;
    char *new_buf;

    for (i = 0; i < count; i++)
    {
        if (buf_sz < (lsquic_str_len(certs[i]) * 2) + 1)
        {
            buf_sz = (lsquic_str_len(certs[i]) * 2) + 1;
            new_buf = realloc(buf, buf_sz);
            if (!new_buf)
                break;
            buf = new_buf;
        }
        lsquic_hex_encode(lsquic_str_cstr(certs[i]), lsquic_str_len(certs[i]),
                                                                buf, buf_sz);
        LCID("[%" PRIu64 ",\"SECURITY\",\"CHECK_CERT\",\"CERTLOG\","
                "{\"certificate\":\"%s\"}]", lsquic_time_now(), buf);
    }
    if (buf)
        free(buf);
}


void
lsquic_qlog_cert_chain (const lsquic_cid_t* cid, struct stack_st_X509 *chain)
{
    X509 *cert;
    unsigned i;
    unsigned char *buf;
    char *hexbuf, *newbuf;
    size_t hexbuf_sz;
    int len;
    lsquic_time_t now;

    now = lsquic_time_now();
    hexbuf = NULL;
    hexbuf_sz = 0;
    for (i = 0; i < sk_X509_num(chain); ++i)
    {
        cert = sk_X509_value(chain, i);
        buf = NULL;
        len = i2d_X509(cert, &buf);
        if (len <= 0)
            break;
        if ((size_t) len * 2 + 1 > hexbuf_sz)
        {
            hexbuf_sz = len * 2 + 1;
            newbuf = realloc(hexbuf, hexbuf_sz);
            if (!newbuf)
                break;
            hexbuf = newbuf;
        }
        lsquic_hexstr(buf, (size_t) len, hexbuf, hexbuf_sz);
        LCID("[%" PRIu64 ",\"SECURITY\",\"CHECK_CERT\",\"CERTLOG\","
                "{\"certificate\":\"%s\"}]", now, hexbuf);
        OPENSSL_free(buf);
    }

    if (hexbuf)
        free(hexbuf);
}


void
lsquic_qlog_version_negotiation (const lsquic_cid_t* cid,
                                        const char *action, const char *ver)
{
    char *trig;

    if (!action || !ver)
        return;
    if (strcmp(action, "proposed") == 0)
        trig = "LINE";
    else if (strcmp(action, "supports") == 0 || strcmp(action, "agreed") == 0)
        trig = "PACKET_RX";
    else
        return;
    LCID("[%" PRIu64 ",\"CONNECTIVITY\",\"VERNEG\",\"%s\","
            "{\"%s_version\":\"%s\"}]", lsquic_time_now(), trig, action, ver);
}