stellar-stellar/src/session/test/gtest_overload_evict_udp_sess.cpp

#include "test_utils.h"

static void overwrite_ipv4_saddr(struct packet *pkt, uint32_t saddr)
{
    const struct layer *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_TYPE_IPV4);
    EXPECT_TRUE(ipv4_layer);
    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
    ipv4_hdr_set_src_addr(hdr, saddr);
}

#if 1
TEST(OVERLOAD, EVICT_UDP_OLD_SESS)
{
    struct tuple6 key;
    struct packet pkt;
    struct session *sess = NULL;
    struct session_manager *mgr = NULL;
    char buffer[1500] = {0};

    timestamp_update();

    mgr = session_manager_new(&opts);
    EXPECT_TRUE(mgr != NULL);

    for (uint64_t i = 0; i < opts.max_udp_session_num; i++)
    {
        // C2S REQ Packet
        printf("\n====================== new session (%lu) ======================\n\n", i + 1);
        printf("=> packet parse: UDP C2S REQ packet\n");
        memcpy(buffer, udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
        packet_parse(&pkt, (const char *)buffer, sizeof(udp_pkt1_dns_req));
        overwrite_ipv4_saddr(&pkt, i + 1);
        printf("<= packet parse\n\n");
        sess = session_manager_update_session(mgr, &pkt);
        EXPECT_TRUE(sess);

        __session_dispatch(sess);
        session_manager_print_stat(mgr);

        if (i == opts.max_udp_session_num - 1)
        {
            __session_manager_check_counter(mgr,
                                            0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
                                            i, 0, 1, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
                                            0, 0,    // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
                                            0, 1);   // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
        }
        else
        {
            __session_manager_check_counter(mgr,
                                            0, 0, 0,     // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
                                            i + 1, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
                                            0, 0,        // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
                                            0, 0);       // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
        }
    }
    printf("\n====================== evicted session ======================\n\n");
    // evicted oldest session
    sess = session_manager_get_evicted_session(mgr);
    EXPECT_TRUE(sess);
    EXPECT_TRUE(session_get_state(sess) == SESSION_STATE_CLOSING);
    EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_EVICTED);

    packet_parse(&pkt, (const char *)udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
    overwrite_ipv4_saddr(&pkt, 1);
    memset(&key, 0, sizeof(struct tuple6));
    packet_get_innermost_tuple6(&pkt, &key);
    EXPECT_TRUE(tuple6_cmp(session_get0_key(sess), &key) == 0);
    __session_dispatch(sess);
    session_manager_print_stat(mgr);

    printf("\n====================== expired session ======================\n\n");
    __session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
    __session_manager_wait(mgr, CLOSING_BY_TIMEOUT);

    printf("\n====================== end status ======================\n\n");
    session_manager_print_stat(mgr);
    __session_manager_check_counter(mgr,
                                    0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
                                    0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
                                    0, 0,    // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
                                    0, 1);   // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
    session_manager_free(mgr);
}
#endif

#if 1
TEST(OVERLOAD, EVICT_UDP_NEW_SESS)
{
    struct packet pkt;
    struct session *sess = NULL;
    struct session_manager *mgr = NULL;
    char buffer[1500] = {0};
    struct session_manager_options _opts;
    memcpy(&_opts, &opts, sizeof(struct session_manager_options));
    _opts.udp_overload_evict_old_sess = 0;

    timestamp_update();

    mgr = session_manager_new(&_opts);
    EXPECT_TRUE(mgr != NULL);

    for (uint64_t i = 0; i <= _opts.max_udp_session_num; i++)
    {
        // C2S REQ Packet
        printf("\n====================== new session (%lu) ======================\n\n", i + 1);
        printf("=> packet parse: UDP C2S REQ packet\n");
        memcpy(buffer, udp_pkt1_dns_req, sizeof(udp_pkt1_dns_req));
        packet_parse(&pkt, (const char *)buffer, sizeof(udp_pkt1_dns_req));
        overwrite_ipv4_saddr(&pkt, i + 1);
        printf("<= packet parse\n\n");
        sess = session_manager_update_session(mgr, &pkt);

        if (i == _opts.max_udp_session_num)
        {
            EXPECT_TRUE(sess == NULL);
            __session_manager_check_counter(mgr,
                                            0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
                                            i, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
                                            0, 0,    // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
                                            1, 0);   // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
        }
        else
        {
            EXPECT_TRUE(sess);
            __session_manager_check_counter(mgr,
                                            0, 0, 0,     // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
                                            i + 1, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
                                            0, 0,        // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
                                            0, 0);       // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
        }

        __session_dispatch(sess);
        session_manager_print_stat(mgr);
    }

    printf("\n====================== expired session ======================\n\n");
    __session_manager_wait(mgr, CLOSING_BY_TIMEOUT);
    __session_manager_wait(mgr, CLOSING_BY_TIMEOUT);

    printf("\n====================== end status ======================\n\n");
    session_manager_print_stat(mgr);
    __session_manager_check_counter(mgr,
                                    0, 0, 0, // tcp_opening_sess_num, tcp_active_sess_num, tcp_closing_sess_num,
                                    0, 0, 0, // udp_opening_sess_num, udp_active_sess_num, udp_closing_sess_num,
                                    0, 0,    // tcp_overload_evict_new_sess_num, tcp_overload_evict_old_sess_num,
                                    1, 0);   // udp_overload_evict_new_sess_num, udp_overload_evict_old_sess_num,
    session_manager_free(mgr);
}
#endif

int main(int argc, char **argv)
{
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}