stellar-stellar/src/session/session.cpp

#include <assert.h>

#include "session_private.h"
#include "tcp_utils.h"
#include "tcp_reassembly.h"

#define EX_KEY_MAX_LEN 64

struct ex_schema
{
    char key[EX_KEY_MAX_LEN];
    session_ex_free_cb *free_cb;
    void *args;
};

struct ex_manager
{
    struct ex_schema schemas[EX_DATA_MAX_COUNT];
    uint8_t count;
};

static struct ex_manager g_ex_manager = {0};

/******************************************************************************
 * session set/get
 ******************************************************************************/

void session_init(struct session *sess)
{
    memset(sess, 0, sizeof(struct session));
}

void session_set_id(struct session *sess, uint64_t id)
{
    sess->id = id;
}

uint64_t session_get_id(const struct session *sess)
{
    return sess->id;
}

void session_set_tuple(struct session *sess, const struct tuple6 *tuple)
{
    memcpy(&sess->tuple, tuple, sizeof(struct tuple6));
}

const struct tuple6 *session_get_tuple(const struct session *sess)
{
    return &sess->tuple;
}

void session_set_tuple_direction(struct session *sess, enum session_direction dir)
{
    sess->tuple_dir = dir;
}

enum session_direction session_get_tuple_direction(const struct session *sess)
{
    return sess->tuple_dir;
}

const char *session_get_tuple_str(const struct session *sess)
{
    return sess->tuple_str;
}

void session_set_current_direction(struct session *sess, enum session_direction dir)
{
    sess->cur_dir = dir;
}

enum session_direction session_get_current_direction(const struct session *sess)
{
    return sess->cur_dir;
}

void session_set_state(struct session *sess, enum session_state state)
{
    sess->state = state;
}

enum session_state session_get_state(const struct session *sess)
{
    return sess->state;
}

void session_set_type(struct session *sess, enum session_type type)
{
    sess->type = type;
}

enum session_type session_get_type(const struct session *sess)
{
    return sess->type;
}

void session_set_dup_traffic(struct session *sess)
{
    sess->dup = 1;
}

int session_has_dup_traffic(const struct session *sess)
{
    return sess->dup;
}

void session_set_closing_reason(struct session *sess, enum closing_reason reason)
{
    sess->reason = reason;
}

enum closing_reason session_get_closing_reason(const struct session *sess)
{
    return sess->reason;
}

void session_inc_stat(struct session *sess, enum session_direction dir, enum session_stat stat, uint64_t val)
{
    sess->stats[dir][stat] += val;
}

uint64_t session_get_stat(const struct session *sess, enum session_direction dir, enum session_stat stat)
{
    return sess->stats[dir][stat];
}

void session_set_timestamp(struct session *sess, enum session_timestamp type, uint64_t value)
{
    sess->timestamps[type] = value;
}

uint64_t session_get_timestamp(const struct session *sess, enum session_timestamp type)
{
    return sess->timestamps[type];
}

void session_set_1st_packet(struct session *sess, enum session_direction dir, const struct packet *pkt)
{
    sess->first_pkt[dir] = packet_dup(pkt);
}

const struct packet *session_get_1st_packet(const struct session *sess, enum session_direction dir)
{
    return sess->first_pkt[dir];
}

void session_set_current_packet(struct session *sess, const struct packet *pkt)
{
    sess->curr_pkt = pkt;
}

const struct packet *session_get_current_packet(const struct session *sess)
{
    return sess->curr_pkt;
}

void session_set_user_data(struct session *sess, void *user_data)
{
    sess->user_data = user_data;
}

void *session_get_user_data(const struct session *sess)
{
    return sess->user_data;
}

struct tcp_segment *session_get_tcp_segment(struct session *sess)
{
    enum session_direction dir = session_get_current_direction(sess);
    struct tcp_half *half = &sess->tcp_halfs[dir];

    if (half->in_order.data != NULL && half->in_order.len > 0)
    {
        return &half->in_order;
    }
    else
    {
        struct tcp_segment *seg = tcp_reassembly_pop(half->assembler);
        if (seg)
        {
            session_inc_stat(sess, dir, STAT_TCP_SEGS_REORDERED, 1);
            session_inc_stat(sess, dir, STAT_TCP_PLDS_REORDERED, seg->len);

            sess->mgr_stat->nr_tcp_seg_reorded++;
        }
        return seg;
    }
}

void session_free_tcp_segment(struct session *sess, struct tcp_segment *seg)
{
    if (seg == NULL)
    {
        return;
    }

    enum session_direction dir = session_get_current_direction(sess);
    struct tcp_half *half = &sess->tcp_halfs[dir];

    if (seg == &half->in_order)
    {
        half->in_order.data = NULL;
        half->in_order.len = 0;
        return;
    }
    else
    {
        session_inc_stat(sess, dir, STAT_TCP_SEGS_RELEASED, 1);
        session_inc_stat(sess, dir, STAT_TCP_PLDS_RELEASED, seg->len);
        sess->mgr_stat->nr_tcp_seg_released++;

        tcp_segment_free(seg);
    }
}

/******************************************************************************
 * session ex data
 ******************************************************************************/

/*
 * the exdata prodoced by user, and comsumed by same user.
 * so, the exdata is not shared by different user.
 * otherwise, the exdata need dup by refer count, and free by refer count.
 *
 * if key exist, not allow update, return original index.
 */
uint8_t session_get_ex_new_index(const char *key, session_ex_free_cb *free_cb, void *args)
{
    if (g_ex_manager.count >= EX_DATA_MAX_COUNT)
    {
        abort();
        return EX_DATA_MAX_COUNT;
    }

    for (uint8_t i = 0; i < g_ex_manager.count; i++)
    {
        if (strcmp(g_ex_manager.schemas[i].key, key) == 0)
        {
            return i;
        }
    }

    uint8_t idx = g_ex_manager.count;
    g_ex_manager.count++;

    struct ex_schema *schema = &g_ex_manager.schemas[idx];
    strncpy(schema->key, key, EX_KEY_MAX_LEN);
    schema->free_cb = free_cb;
    schema->args = args;

    return idx;
}

/*
 * Support update ex_data.
 *
 * if key exist: run free_cb free old value, then set new value.
 *     if not run free_cb, old value will be memory leak.
 *     if not allow update, new value will be memory leak.
 * if key not exist: set new value.
 */
void session_set_ex_data(struct session *sess, uint8_t idx, void *val)
{
    if (idx >= g_ex_manager.count)
    {
        assert(0);
        return;
    }

    session_free_ex_data(sess, idx);
    sess->ex_data[idx] = val;
}

void *session_get0_ex_data(const struct session *sess, uint8_t idx)
{
    if (idx >= g_ex_manager.count)
    {
        assert(0);
        return NULL;
    }

    return sess->ex_data[idx];
}

/*
 * after set ex_data, the owner of ex_data is session, so user should not free it directly.
 * if user want to free ex_data, should use session_free_ex_data.
 */
void session_free_ex_data(struct session *sess, uint8_t idx)
{
    if (idx >= g_ex_manager.count)
    {
        assert(0);
        return;
    }

    struct ex_schema *schema = &g_ex_manager.schemas[idx];
    if (schema->free_cb != NULL && sess->ex_data[idx] != NULL)
    {
        printf("free ex_data, idx: %d, key: %s, val: %p\n", idx, schema->key, sess->ex_data[idx]);
        schema->free_cb(sess, idx, sess->ex_data[idx], schema->args);
    }

    sess->ex_data[idx] = NULL;
}

void session_free_all_ex_data(struct session *sess)
{
    if (sess)
    {
        for (uint8_t i = 0; i < g_ex_manager.count; i++)
        {
            session_free_ex_data(sess, i);
        }
    }
}

/******************************************************************************
 * to string
 ******************************************************************************/

const char *closing_reason_to_str(enum closing_reason reason)
{
    switch (reason)
    {
    case CLOSING_BY_TIMEOUT:
        return "closing by timeout";
    case CLOSING_BY_EVICTED:
        return "closing by evicted";
    case CLOSING_BY_CLIENT_FIN:
        return "closing by client FIN";
    case CLOSING_BY_CLIENT_RST:
        return "closing by client RST";
    case CLOSING_BY_SERVER_FIN:
        return "closing by server FIN";
    case CLOSING_BY_SERVER_RST:
        return "closing by server RST";
    default:
        return "unknown";
    }
}

const char *session_state_to_str(enum session_state state)
{
    switch (state)
    {
    case SESSION_STATE_INIT:
        return "init";
    case SESSION_STATE_OPENING:
        return "opening";
    case SESSION_STATE_ACTIVE:
        return "active";
    case SESSION_STATE_CLOSING:
        return "closing";
    case SESSION_STATE_DISCARD:
        return "discard";
    case SESSION_STATE_CLOSED:
        return "closed";
    default:
        return "unknown";
    }
}

const char *session_type_to_str(enum session_type type)
{
    switch (type)
    {
    case SESSION_TYPE_TCP:
        return "TCP";
    case SESSION_TYPE_UDP:
        return "UDP";
    default:
        return "unknown";
    }
}

const char *session_direction_to_str(enum session_direction dir)
{
    switch (dir)
    {
    case SESSION_DIRECTION_C2S:
        return "C2S";
    case SESSION_DIRECTION_S2C:
        return "S2C";
    default:
        return "unknown";
    }
}

static void tcp_flags_to_str(uint8_t flags, char *buffer, size_t len)
{
    int used = 0;

    if (flags & TH_SYN)
    {
        used += snprintf(buffer + used, len - used, "SYN ");
    }
    if (flags & TH_ACK)
    {
        used += snprintf(buffer + used, len - used, "ACK ");
    }
    if (flags & TH_FIN)
    {
        used += snprintf(buffer + used, len - used, "FIN ");
    }
    if (flags & TH_RST)
    {
        used += snprintf(buffer + used, len - used, "RST ");
    }
}

void session_dump(struct session *sess)
{
    char buffer[1024] = {0};
    tuple6_to_str(session_get_tuple(sess), buffer, sizeof(buffer));

    printf("session id                 : %" PRIu64 "\n", session_get_id(sess));
    printf("session timestamp          : %" PRIu64 " -> %" PRIu64 "\n", session_get_timestamp(sess, SESSION_TIMESTAMP_START), session_get_timestamp(sess, SESSION_TIMESTAMP_LAST));
    printf("session tuple              : %s (%s)\n", buffer, session_direction_to_str(session_get_tuple_direction(sess)));
    printf("session type               : %s\n", session_type_to_str(session_get_type(sess)));
    printf("session state              : %s\n", session_state_to_str(session_get_state(sess)));
    printf("session closing reason     : %s\n", closing_reason_to_str(session_get_closing_reason(sess)));
    printf("session dup traffic        : %d\n", session_has_dup_traffic(sess));
    printf("session C2S first packet   : %p\n", session_get_1st_packet(sess, SESSION_DIRECTION_C2S));
    printf("session S2C first packet   : %p\n", session_get_1st_packet(sess, SESSION_DIRECTION_S2C));
    printf("session current packet     : %p (%s)\n", session_get_current_packet(sess), session_direction_to_str(session_get_current_direction(sess)));
    if (session_get_type(sess) == SESSION_TYPE_TCP)
    {
        memset(buffer, 0, sizeof(buffer));
        tcp_flags_to_str(sess->tcp_halfs[SESSION_DIRECTION_C2S].flags, buffer, sizeof(buffer));
        printf("TCP C2S half: seq: %u, ack: %u, flags: %s\n", sess->tcp_halfs[SESSION_DIRECTION_C2S].seq, sess->tcp_halfs[SESSION_DIRECTION_C2S].ack, buffer);

        memset(buffer, 0, sizeof(buffer));
        tcp_flags_to_str(sess->tcp_halfs[SESSION_DIRECTION_S2C].flags, buffer, sizeof(buffer));
        printf("TCP S2C half: seq: %u, ack: %u, flags: %s\n", sess->tcp_halfs[SESSION_DIRECTION_S2C].seq, sess->tcp_halfs[SESSION_DIRECTION_S2C].ack, buffer);
    }
    // exdata
    printf("session exdata:\n");
    for (uint8_t i = 0; i < g_ex_manager.count; i++)
    {
        printf("    idx: %d, key: %s, data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
    }
    // stats
    printf("session stats:\n");
    printf("+------------------------------------------------+\n");
    printf("| %-20s | %-10s | %-10s |\n", "stat", "C2S", "S2C");
    printf("+------------------------------------------------+\n");
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_RX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_RX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_TX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_TX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_PKTS_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_PKTS_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_PKTS_DROP));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "RAW_BYTES_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_RAW_BYTES_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_RAW_BYTES_DROP));
    printf("+------------------------------------------------+\n");
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "DUP_PKTS_BYPASS", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_DUP_PKTS_BYPASS), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_DUP_PKTS_BYPASS));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "DUP_BYTES_BYPASS", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_DUP_BYTES_BYPASS), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_DUP_BYTES_BYPASS));
    printf("+------------------------------------------------+\n");
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_RX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_RX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_TX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_TX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_TX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_TX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_PKTS_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_PKTS_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_PKTS_DROP));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "CTRL_BYTES_DROP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_CTRL_BYTES_DROP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_CTRL_BYTES_DROP));
    printf("+------------------------------------------------+\n");
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_RX", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RX), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RX));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_EXPIRED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_EXPIRED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_EXPIRED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_EXPIRED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_EXPIRED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_EXPIRED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_OVERLAP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_OVERLAP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_OVERLAP));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_OVERLAP", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_OVERLAP), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_OVERLAP));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_NOSPACE", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_NOSPACE), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_NOSPACE));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_NOSPACE", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_NOSPACE), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_NOSPACE));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_INORDER", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_INORDER), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_INORDER));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_INORDER", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_INORDER), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_INORDER));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_REORDERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_REORDERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_REORDERED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_REORDERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_REORDERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_REORDERED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_BUFFERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_BUFFERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_BUFFERED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_BUFFERED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_BUFFERED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_BUFFERED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_SEGS_RELEASED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_SEGS_RELEASED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_SEGS_RELEASED));
    printf("| %-20s | %-10" PRIu64 " | %-10" PRIu64 " |\n", "TCP_PLDS_RELEASED", session_get_stat(sess, SESSION_DIRECTION_C2S, STAT_TCP_PLDS_RELEASED), session_get_stat(sess, SESSION_DIRECTION_S2C, STAT_TCP_PLDS_RELEASED));
    printf("+------------------------------------------------+\n");
}