stellar-stellar/src/session/session.cpp

#include <assert.h>

#include "session_private.h"
#include "packet_utils.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
 ******************************************************************************/

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

// session id
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;
}

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

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

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

enum session_dir session_get_key_dir(const struct session *sess)
{
    return sess->tuple_dir;
}

// session state
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;
}

// session type
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;
}

// session dup traffic flag
void session_set_dup_traffic_flag(struct session *sess, enum dup_traffic_flag flag)
{
    sess->dup_flag = flag;
}

enum dup_traffic_flag session_get_dup_traffic_flag(const struct session *sess)
{
    return sess->dup_flag;
}

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

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

// session metrics
void session_inc_c2s_metrics(struct session *sess, uint64_t packets, uint64_t bytes)
{
    sess->c2s_bytes += bytes;
    sess->c2s_packets += packets;
}

void session_inc_s2c_metrics(struct session *sess, uint64_t packets, uint64_t bytes)
{
    sess->s2c_bytes += bytes;
    sess->s2c_packets += packets;
}

uint64_t session_get_c2s_bytes(const struct session *sess)
{
    return sess->c2s_bytes;
}

uint64_t session_get_s2c_bytes(const struct session *sess)
{
    return sess->s2c_bytes;
}

uint64_t session_get_c2s_packets(const struct session *sess)
{
    return sess->c2s_packets;
}

uint64_t session_get_s2c_packets(const struct session *sess)
{
    return sess->s2c_packets;
}

// session timestamp
void session_set_create_time(struct session *sess, uint64_t timestamp)
{
    sess->create_time = timestamp;
}

void session_set_last_time(struct session *sess, uint64_t timestamp)
{
    sess->last_time = timestamp;
}

uint64_t session_get_create_time(const struct session *sess)
{
    return sess->create_time;
}

uint64_t session_get_last_time(const struct session *sess)
{
    return sess->last_time;
}

// session tcp state
void session_set_tcp_state(struct session *sess, enum tcp_state state)
{
    sess->tcp_state = state;
}

enum tcp_state session_get_tcp_state(const struct session *sess)
{
    return sess->tcp_state;
}

// session udp state
void session_set_udp_state(struct session *sess, enum udp_state state)
{
    sess->udp_state = state;
}

enum udp_state session_get_udp_state(const struct session *sess)
{
    return sess->udp_state;
}

/******************************************************************************
 * session packet
 ******************************************************************************/

void session_set_c2s_1st_pkt(struct session *sess, const struct packet *pkt)
{
    sess->c2s_1st_pkt = packet_dup(pkt);
}

void session_set_s2c_1st_pkt(struct session *sess, const struct packet *pkt)
{
    sess->s2c_1st_pkt = packet_dup(pkt);
}

const struct packet *session_get0_c2s_1st_pkt(const struct session *sess)
{
    return sess->c2s_1st_pkt;
}

const struct packet *session_get0_s2c_1st_pkt(const struct session *sess)
{
    return sess->s2c_1st_pkt;
}

const struct packet *session_get0_1st_pkt(const struct session *sess)
{
    const struct packet *c2s_1st_pkt = session_get0_c2s_1st_pkt(sess);
    if (c2s_1st_pkt)
    {
        return c2s_1st_pkt;
    }
    else
    {
        return session_get0_s2c_1st_pkt(sess);
    }
}

// session current packet
void session_set0_cur_pkt(struct session *sess, const struct packet *pkt)
{
    sess->cur_pkt = pkt;
}

const struct packet *session_get0_cur_pkt(const struct session *sess)
{
    return sess->cur_pkt;
}

// session current dir
void session_set_cur_dir(struct session *sess, enum session_dir dir)
{
    sess->cur_dir = dir;
}

enum session_dir session_get_cur_dir(const struct session *sess)
{
    return sess->cur_dir;
}

/******************************************************************************
 * 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(struct session *sess)
{
    if (sess)
    {
        for (uint8_t i = 0; i < g_ex_manager.count; i++)
        {
            session_free_ex_data(sess, i);
        }

        if (sess->c2s_1st_pkt)
        {
            packet_free(sess->c2s_1st_pkt);
            sess->c2s_1st_pkt = NULL;
        }

        if (sess->s2c_1st_pkt)
        {
            packet_free(sess->s2c_1st_pkt);
            sess->s2c_1st_pkt = NULL;
        }
    }
}

/******************************************************************************
 * session expire
 ******************************************************************************/

// session expire
void session_set_expirecb(struct session *sess, session_expire_cb expire_cb, void *expire_arg, uint64_t expire_abs_ts)
{
    struct timeout *timeout = &sess->timeout;

    timeout_init(timeout, TIMEOUT_ABS);
    timeout_setcb(timeout, NULL, sess);
    sess->expire_cb = expire_cb;
    sess->expire_arg = expire_arg;
    sess->expire_abs_ts = expire_abs_ts;
}

void session_del_expirecb(struct session *sess)
{
    struct timeout *timeout = &sess->timeout;

    timeout_init(timeout, 0);
    sess->expire_cb = NULL;
    sess->expire_arg = NULL;
    sess->expire_abs_ts = 0;
}

void session_run_expirecb(struct session *sess)
{
    if (sess->expire_cb)
    {
        sess->expire_cb(sess, sess->expire_arg);
    }
}

/******************************************************************************
 * session dump
 ******************************************************************************/

static void tcp_state_tostring(enum tcp_state state, char *buffer, size_t buffer_len)
{
    if (state == 0)
    {
        return;
    }

    int nused = 0;
    if (state & TCP_SYN_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_SYN_RECVED ");
    }

    if (state & TCP_SYNACK_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_SYNACK_RECVED ");
    }

    if (state & TCP_C2S_ACK_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_ACK_RECVED ");
    }

    if (state & TCP_S2C_ACK_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_ACK_RECVED ");
    }

    if (state & TCP_C2S_DATA_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_DATA_RECVED ");
    }

    if (state & TCP_S2C_DATA_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_DATA_RECVED ");
    }

    if (state & TCP_C2S_FIN_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_FIN_RECVED ");
    }

    if (state & TCP_S2C_FIN_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_FIN_RECVED ");
    }

    if (state & TCP_C2S_RST_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_C2S_RST_RECVED ");
    }

    if (state & TCP_S2C_RST_RECVED)
    {
        nused += snprintf(buffer + nused, buffer_len - nused, "TCP_S2C_RST_RECVED ");
    }
}

static void udp_state_tostring(enum udp_state state, char *buffer, size_t buffer_len)
{
    if (state == 0)
    {
        return;
    }

    int nused = 0;
    if (state & UDP_C2S_RECVED)
    {
        snprintf(buffer + nused, buffer_len - nused, "UDP_C2S_RECVED ");
    }

    if (state & UDP_S2C_RECVED)
    {
        snprintf(buffer + nused, buffer_len - nused, "UDP_S2C_RECVED ");
    }
}

const char *session_closing_reason_tostring(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_tostring(enum session_state state)
{
    switch (state)
    {
    case SESSION_STATE_OPENING:
        return "opening";
    case SESSION_STATE_ACTIVE:
        return "active";
    case SESSION_STATE_CLOSING:
        return "closing";
    case SESSION_STATE_CLOSED:
        return "closed";
    default:
        return "unknown";
    }
}

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

const char *session_dir_tostring(enum session_dir dir)
{
    switch (dir)
    {
    case SESSION_DIR_C2S:
        return "C2S";
    case SESSION_DIR_S2C:
        return "S2C";
    default:
        return "unknown";
    }
}

const char *dup_traffic_flag_tostring(enum dup_traffic_flag flag)
{
    switch (flag)
    {
    case DUP_TRAFFIC_YES:
        return "YES";
    case DUP_TRAFFIC_NO:
        return "NO";
    default:
        return "unknown";
    }
}

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

    printf("session id                 : %" PRIu64 "\n", session_get_id(sess));
    printf("session key                : %s\n", buffer);
    printf("session key dir            : %s\n", session_dir_tostring(session_get_key_dir(sess)));
    printf("session state              : %s\n", session_state_tostring(session_get_state(sess)));
    printf("session type               : %s\n", session_type_tostring(session_get_type(sess)));
    printf("session dup traffic flag   : %s\n", dup_traffic_flag_tostring(session_get_dup_traffic_flag(sess)));
    printf("session closing reason     : %s\n", session_closing_reason_tostring(session_get_closing_reason(sess)));
    printf("session c2s packets        : %" PRIu64 "\n", session_get_c2s_packets(sess));
    printf("session c2s bytes          : %" PRIu64 "\n", session_get_c2s_bytes(sess));
    printf("session s2c packets        : %" PRIu64 "\n", session_get_s2c_packets(sess));
    printf("session s2c bytes          : %" PRIu64 "\n", session_get_s2c_bytes(sess));
    printf("session create time        : %" PRIu64 "\n", session_get_create_time(sess));
    printf("session last time          : %" PRIu64 "\n", session_get_last_time(sess));
    if (session_get_type(sess) == SESSION_TYPE_TCP)
    {
        memset(buffer, 0, sizeof(buffer));
        tcp_state_tostring(session_get_tcp_state(sess), buffer, sizeof(buffer));
        printf("session tcp state          : %s\n", buffer);
    }
    else if (session_get_type(sess) == SESSION_TYPE_UDP)
    {
        memset(buffer, 0, sizeof(buffer));
        udp_state_tostring(session_get_udp_state(sess), buffer, sizeof(buffer));
        printf("session udp state          : %s\n", buffer);
    }
    printf("session current packet ptr : %p\n", (void *)session_get0_cur_pkt(sess));
    printf("session current packet dir : %s\n", session_dir_tostring(session_get_cur_dir(sess)));
    printf("session ex data: \n");
    for (uint8_t i = 0; i < g_ex_manager.count; i++)
    {
        printf("    ex_idx: %d, ex_key: %s, ex_data: %p\n", i, g_ex_manager.schemas[i].key, sess->ex_data[i]);
    }
}