stellar-stellar/src/session/gtest_session.cpp

#include <gtest/gtest.h>

#include "session_private.h"

#define SESSION_KEY_IPV4_TCP(name)                        \
    struct session_key name;                              \
    memset(&name, 0, sizeof(struct session_key));         \
    (name).ip_type = IP_TYPE_V4;                          \
    (name).src_addr.v4.s_addr = inet_addr("192.168.1.2"); \
    (name).dst_addr.v4.s_addr = inet_addr("192.168.1.3"); \
    (name).src_port = htons(1234);                        \
    (name).dst_port = htons(5678);                        \
    (name).ip_proto = IPPROTO_TCP;                        \
    (name).security_zone = 0;

#define SESSION_KEY_IPV6_UDP(name)                                           \
    struct session_key name;                                                 \
    memset(&name, 0, sizeof(struct session_key));                            \
    (name).ip_type = IP_TYPE_V6;                                             \
    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:8329", &(name).src_addr.v6); \
    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:832a", &(name).dst_addr.v6); \
    (name).src_port = htons(1234);                                           \
    (name).dst_port = htons(5678);                                           \
    (name).ip_proto = IPPROTO_UDP;                                           \
    (name).security_zone = 0;

#define SESSION_KEY_IPV6_TCP(name)                                           \
    struct session_key name;                                                 \
    memset(&name, 0, sizeof(struct session_key));                            \
    (name).ip_type = IP_TYPE_V6;                                             \
    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:8329", &(name).src_addr.v6); \
    inet_pton(AF_INET6, "2001:db8:0:0:0:ff00:42:832a", &(name).dst_addr.v6); \
    (name).src_port = htons(1234);                                           \
    (name).dst_port = htons(5678);                                           \
    (name).ip_proto = IPPROTO_TCP;                                           \
    (name).security_zone = 0;

void free_ex_data(struct session *sess, uint8_t idx, void *ex_ptr, void *arg)
{
    if (ex_ptr)
    {
        printf("free_ex_data: %s\n", (char *)ex_ptr);
        free(ex_ptr);
        ex_ptr = NULL;
    }
}

TEST(SESSION, EX_NEW_INDEX)
{
    uint8_t idx1 = session_get_ex_new_index("key1", NULL, NULL);
    uint8_t idx2 = session_get_ex_new_index("key2", NULL, NULL);
    uint8_t idx3 = session_get_ex_new_index("key1", NULL, NULL);
    EXPECT_TRUE(idx1 != idx2);
    EXPECT_TRUE(idx1 == idx3);
}

TEST(SESSION, EX_SET_GET)
{
    struct session sess;
    memset(&sess, 0, sizeof(sess));
    uint8_t idx = session_get_ex_new_index("ex_set_get", NULL, NULL);
    session_set_ex_data(&sess, idx, (void *)0x1234);
    EXPECT_TRUE(session_get0_ex_data(&sess, idx) == (void *)0x1234);
}

TEST(SESSION, EX_FREE_BY_RESET_NULL)
{
    struct session sess;
    memset(&sess, 0, sizeof(sess));
    uint8_t idx = session_get_ex_new_index("ex_free_by_reset_null", free_ex_data, NULL);
    char *ptr = strdup("hello");
    session_set_ex_data(&sess, idx, ptr);
    session_set_ex_data(&sess, idx, NULL);
}

TEST(SESSION, EX_FREE_BY_CALL_API)
{
    struct session sess;
    memset(&sess, 0, sizeof(sess));
    uint8_t idx = session_get_ex_new_index("ex_free_by_call_api", free_ex_data, NULL);
    char *ptr = strdup("hello");
    session_set_ex_data(&sess, idx, ptr);
    session_free_ex_data(&sess, idx);
}

TEST(SESSION, EV_QUEUE)
{
    uint32_t event = 0;
    struct session sess;
    session_init(&sess);
    EXPECT_TRUE(session_pop_event(&sess, &event) == false);
    EXPECT_TRUE(session_push_event(&sess, 0x1234) == true);
    EXPECT_TRUE(session_pop_event(&sess, &event) == true);
    EXPECT_TRUE(event == 0x1234);
    EXPECT_TRUE(session_pop_event(&sess, &event) == false);

    for (int j = 0; j < 10; j++)
    {
        for (uint32_t i = 0; i < SESSION_EVENT_QUEUE_SIZE - 1; i++)
        {
            EXPECT_TRUE(session_push_event(&sess, i) == true);
        }
        EXPECT_TRUE(session_push_event(&sess, 0) == false);

        for (uint32_t i = 0; i < SESSION_EVENT_QUEUE_SIZE - 1; i++)
        {
            EXPECT_TRUE(session_pop_event(&sess, &event) == true);
            EXPECT_TRUE(event == i);
        }
        EXPECT_TRUE(session_pop_event(&sess, &event) == false);
    }
}

TEST(SESSION, SESSION_KEY)
{
    char buf[128] = {0};
    SESSION_KEY_IPV4_TCP(key1);
    SESSION_KEY_IPV6_UDP(key2);
    SESSION_KEY_IPV6_TCP(key3);

    struct session_key reverse_key1;
    struct session_key reverse_key2;
    struct session_key reverse_key3;
    struct session_key reverse_temp;

    // tostring
    memset(buf, 0, sizeof(buf));
    session_key_tostring(&key1, buf, sizeof(buf));
    EXPECT_STREQ(buf, "192.168.1.2:1234 -> 192.168.1.3:5678, proto: 6, zone: 0");
    memset(buf, 0, sizeof(buf));
    session_key_tostring(&key2, buf, sizeof(buf));
    EXPECT_STREQ(buf, "2001:db8::ff00:42:8329:1234 -> 2001:db8::ff00:42:832a:5678, proto: 17, zone: 0");
    memset(buf, 0, sizeof(buf));
    session_key_tostring(&key3, buf, sizeof(buf));
    EXPECT_STREQ(buf, "2001:db8::ff00:42:8329:1234 -> 2001:db8::ff00:42:832a:5678, proto: 6, zone: 0");

    // reverse
    session_key_reverse(&key1, &reverse_key1);
    session_key_reverse(&key2, &reverse_key2);
    session_key_reverse(&key3, &reverse_key3);
    memset(buf, 0, sizeof(buf));
    session_key_tostring(&reverse_key1, buf, sizeof(buf));
    EXPECT_STREQ(buf, "192.168.1.3:5678 -> 192.168.1.2:1234, proto: 6, zone: 0");
    memset(buf, 0, sizeof(buf));
    session_key_tostring(&reverse_key2, buf, sizeof(buf));
    EXPECT_STREQ(buf, "2001:db8::ff00:42:832a:5678 -> 2001:db8::ff00:42:8329:1234, proto: 17, zone: 0");
    memset(buf, 0, sizeof(buf));
    session_key_tostring(&reverse_key3, buf, sizeof(buf));
    EXPECT_STREQ(buf, "2001:db8::ff00:42:832a:5678 -> 2001:db8::ff00:42:8329:1234, proto: 6, zone: 0");

    // hash
    EXPECT_TRUE(session_key_hash(&key1) == session_key_hash(&reverse_key1));
    EXPECT_TRUE(session_key_hash(&key2) == session_key_hash(&reverse_key2));
    EXPECT_TRUE(session_key_hash(&key3) == session_key_hash(&reverse_key3));

    // cmp
    EXPECT_TRUE(session_key_cmp(&key1, &key1) == 0);
    EXPECT_TRUE(session_key_cmp(&key2, &key2) == 0);
    EXPECT_TRUE(session_key_cmp(&key3, &key3) == 0);

    EXPECT_TRUE(session_key_cmp(&key1, &reverse_key1) != 0);
    EXPECT_TRUE(session_key_cmp(&key2, &reverse_key2) != 0);
    EXPECT_TRUE(session_key_cmp(&key3, &reverse_key3) != 0);

    session_key_reverse(&reverse_key1, &reverse_temp);
    EXPECT_TRUE(session_key_cmp(&key1, &reverse_temp) == 0);

    session_key_reverse(&reverse_key2, &reverse_temp);
    EXPECT_TRUE(session_key_cmp(&key2, &reverse_temp) == 0);

    session_key_reverse(&reverse_key3, &reverse_temp);
    EXPECT_TRUE(session_key_cmp(&key3, &reverse_temp) == 0);
}

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