lagopus_result_t
check_packet_parse_with_dequeue_expect_error(ofp_handler_proc_t handler_proc,
const char packet[],
void **get,
const struct ofp_error *expected_error) {
lagopus_result_t res = LAGOPUS_RESULT_ANY_FAILURES;
struct channel *channel = create_data_channel();
struct ofp_header xid_header;
struct ofp_bridge *ofpb = NULL;
struct pbuf *pbuf;
struct ofp_error error;
struct ofp_bridgeq *bridgeq;
if (get == NULL) {
return LAGOPUS_RESULT_INVALID_ARGS;
}
/* start ofp_handler */
if (s_start_ofp_handler() == false) {
goto done;
}
/* register ofp_bridge */
res = ofp_bridgeq_mgr_bridge_register(channel_dpid_get(channel));
if (res == LAGOPUS_RESULT_OK) {
res = ofp_bridgeq_mgr_bridge_lookup(channel_dpid_get(channel), &bridgeq);
if (res == LAGOPUS_RESULT_OK) {
ofpb = ofp_bridgeq_mgr_bridge_get(bridgeq);
ofp_bridgeq_mgr_bridgeq_free(bridgeq);
} else {
TEST_FAIL_MESSAGE("handler_test_utils.c: "
"ofp_bridgeq_mgr_bridge_get error.");
}
} else {
lagopus_perror(res);
TEST_FAIL_MESSAGE("handler_test_utils.c: register error.");
goto done;
}
/* create packet */
create_packet(packet, &pbuf);
/* parse header */
if (ofp_header_decode_sneak_test(pbuf, &xid_header) != LAGOPUS_RESULT_OK) {
TEST_FAIL_MESSAGE("handler_test_utils.c: cannot decode header\n");
return LAGOPUS_RESULT_OFP_ERROR;
}
/* call func & check */
res = (handler_proc)(channel, pbuf, &xid_header, &error);
if (res == LAGOPUS_RESULT_OK) {
res = lagopus_bbq_get(&ofpb->event_dataq, get, void *, TIMEOUT);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, res,
"handler_test_utils.c: lagopus_bbq_get error.");
} else if (res == LAGOPUS_RESULT_OFP_ERROR) {
void
test_ofp_bridgeq_mgr_bridge_register_orver_length(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
int data_num = MAX_BRIDGES;
struct {
uint64_t dpid;
char name[20];
} bridges[MAX_BRIDGES + 1];
datastore_bridge_info_t info = {0};
datastore_bridge_queue_info_t q_info =
{1000LL, 1000LL, 1000LL, 1000LL, 1000LL, 1000LL};
int i;
/* create data. */
for (i = 0; i < data_num + 1; i++) {
bridges[i].dpid = (uint64_t) (i + 1);
snprintf(bridges[i].name, sizeof(bridges[i].name), "test_bridge%d", i);
}
/* register bridge. */
for (i = 0; i < data_num; i++) {
ret = ofp_bridgeq_mgr_bridge_register(bridges[i].dpid,
bridges[i].name,
&info,
&q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridge_registererror.");
}
ret = ofp_bridgeq_mgr_bridge_register(bridges[data_num].dpid,
bridges[data_num].name,
&info,
&q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_ITERATION_HALTED, ret,
"ofp_bridgeq_mgr_bridge_register(orver length) error.");
}
struct channel *
create_data_channel(void) {
static uint8_t cnt;
char buf[256];
struct channel *channel;
lagopus_session_t session;
struct addrunion addr;
uint64_t dpid = 0xabc;
if (s_is_init == false) {
s_is_init = true;
/* init dataplane. */
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, dp_api_init());
/* interface. */
s_interface_info.type = DATASTORE_INTERFACE_TYPE_ETHERNET_RAWSOCK;
s_interface_info.eth_rawsock.port_number = 0;
s_interface_info.eth_dpdk_phy.device = strdup("eth0");
if (s_interface_info.eth_dpdk_phy.device == NULL) {
TEST_FAIL_MESSAGE("device is NULL.");
}
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_interface_create(interface_name));
dp_interface_info_set(interface_name, &s_interface_info);
/* port. */
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_port_create(port_name));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_port_interface_set(port_name, interface_name));
/* bridge. */
ofp_bridgeq_mgr_initialize(NULL);
s_bridge_info.dpid = dpid;
s_bridge_info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
s_bridge_info.max_buffered_packets = UINT32_MAX;
s_bridge_info.max_ports = UINT16_MAX;
s_bridge_info.max_tables = UINT8_MAX;
s_bridge_info.max_flows = UINT32_MAX;
s_bridge_info.capabilities = UINT64_MAX;
s_bridge_info.action_types = UINT64_MAX;
s_bridge_info.instruction_types = UINT64_MAX;
s_bridge_info.reserved_port_types = UINT64_MAX;
s_bridge_info.group_types = UINT64_MAX;
s_bridge_info.group_capabilities = UINT64_MAX;
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_bridge_create(bridge_name, &s_bridge_info));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
dp_bridge_port_set(bridge_name, port_name, 0));
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK,
ofp_bridgeq_mgr_bridge_register(
dpid,
bridge_name,
&s_bridge_info,
&s_queue_info));
channel_mgr_initialize();
}
snprintf(buf, sizeof(buf), "127.0.0.%u", cnt++);//XXX
addrunion_ipv4_set(&addr, buf);
channel_mgr_channel_add(bridge_name, dpid, &addr);
channel_mgr_channel_lookup(bridge_name, &addr, &channel);
session = channel_session_get(channel);
session_write_set(session, s_write_tcp);
session_sockfd_set(session, 3);
channel_version_set(channel, 0x04);
channel_xid_set(channel, s_xid);
return channel;
}
void
test_ofp_bridgeq_mgr_bridge(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
uint64_t dpid = 0x01;
const char *bridge_name = "test_bridge01";
char *test_bridge_name = NULL;
struct ofp_bridgeq *bridgeq = NULL;
lagopus_qmuxer_poll_t poll = NULL;
datastore_bridge_info_t info =
{1LL, 2LL, 3LL, 4LL, 5LL,
6LL, 7LL, 8LL, 9LL, 10LL,
11LL, 12LL};
datastore_bridge_info_t test_info;
datastore_bridge_queue_info_t q_info =
{1000LL, 1000LL, 1000LL, 1000LL, 1000LL, 1000LL};
/* register bridge. */
ret = ofp_bridgeq_mgr_bridge_register(dpid, bridge_name, &info, &q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridge_register error.");
/* register same bridge. */
ret = ofp_bridgeq_mgr_bridge_register(dpid, bridge_name, &info, &q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_ALREADY_EXISTS, ret,
"ofp_bridgeq_mgr_bridge_register(same bridge) error.");
/* lookup. */
ret = ofp_bridgeq_mgr_bridge_lookup(dpid, &bridgeq);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridge_lookup error.");
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, bridgeq,
"bridgeq error.");
/* get bridge name. */
ret = ofp_bridgeq_mgr_name_get(dpid, &test_bridge_name);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_name_get error.");
TEST_ASSERT_EQUAL_MESSAGE(0, strcmp(bridge_name, test_bridge_name),
"bad bridge name.");
free(test_bridge_name);
test_bridge_name = NULL;
/* get bridge name (not found). */
ret = ofp_bridgeq_mgr_name_get(0x999, &test_bridge_name);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_NOT_FOUND, ret,
"ofp_bridgeq_mgr_name_get error.");
TEST_ASSERT_EQUAL_MESSAGE(NULL, test_bridge_name,
"bad bridge name.");
/* get bridge info. */
ret = ofp_bridgeq_mgr_info_get(dpid, &test_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_info_get error.");
TEST_ASSERT_EQUAL_MESSAGE(1, ((info.dpid == test_info.dpid) &&
(info.fail_mode == test_info.fail_mode) &&
(info.max_buffered_packets ==
test_info.max_buffered_packets) &&
(info.max_ports == test_info.max_ports) &&
(info.max_tables == test_info.max_tables) &&
(info.max_flows == test_info.max_flows) &&
(info.capabilities == test_info.capabilities) &&
(info.action_types == test_info.action_types) &&
(info.instruction_types ==
test_info.instruction_types) &&
(info.reserved_port_types ==
test_info.reserved_port_types) &&
(info.group_types == test_info.group_types) &&
(info.group_capabilities ==
test_info.group_capabilities)),
"bad bridge info.");
/* get bridge info (not found). */
ret = ofp_bridgeq_mgr_info_get(0x999, &test_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_NOT_FOUND, ret,
"ofp_bridgeq_mgr_info_get error.");
/* check getter. */
poll = NULL;
poll = ofp_bridgeq_mgr_eventq_poll_get(bridgeq);
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, poll,
"ofp_bridgeq_mgr_eventq_poll_get error.");
poll = NULL;
poll = ofp_bridgeq_mgr_dataq_poll_get(bridgeq);
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL, poll,
"ofp_bridgeq_mgr_dataq_poll_get error.");
/* decrement refs. */
ofp_bridgeq_mgr_bridgeq_free(bridgeq);
/* unregister bridge. */
ret = ofp_bridgeq_mgr_bridge_unregister(dpid);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridge_unregister error.");
/* lookup. */
bridgeq = NULL;
ret = ofp_bridgeq_mgr_bridge_lookup(dpid, &bridgeq);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_NOT_FOUND, ret,
"ofp_bridgeq_mgr_bridge_lookup error.");
}
void
test_ofp_bridgeq_mgr_bridgeqs_to_array_unregister(void) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
uint64_t i, j, delete_target = 1;
uint64_t data_num = MAX_LENGTH;
struct {
uint64_t dpid;
const char *name;
bool b;
} bridges[MAX_LENGTH] = {
{0x01, "test_bridge01", false},
{0x02, "test_bridge02", false},
{0x03, "test_bridge02", false}
};
struct ofp_bridgeq *bridgeqs[MAX_BRIDGES];
struct ofp_bridge *bridge;
uint64_t poll_count = 0;
uint64_t bridgeq_count = 0;
lagopus_qmuxer_poll_t *polls =
(lagopus_qmuxer_poll_t *) calloc(MAX_LENGTH * MAX_BRIDGE_POLLS,
sizeof(lagopus_qmuxer_poll_t));
lagopus_qmuxer_poll_t *dp_polls =
(lagopus_qmuxer_poll_t *) calloc(MAX_LENGTH * MAX_BRIDGE_DP_POLLS,
sizeof(lagopus_qmuxer_poll_t));
datastore_bridge_info_t info = {0};
datastore_bridge_queue_info_t q_info =
{1000LL, 1000LL, 1000LL, 1000LL, 1000LL, 1000LL};
/* register bridge. */
for (i = 0; i < data_num; i++) {
ret = ofp_bridgeq_mgr_bridge_register(bridges[i].dpid,
bridges[i].name,
&info,
&q_info);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridge_register error.");
}
ret = ofp_bridgeq_mgr_bridgeqs_to_array(bridgeqs, &bridgeq_count, MAX_LENGTH);
/* delete entry. */
bridge = ofp_bridgeq_mgr_bridge_get(bridgeqs[delete_target]);
ofp_bridgeq_mgr_bridge_unregister(bridge->dpid);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_bridgeqs_to_array(normal) error.");
TEST_ASSERT_EQUAL_MESSAGE(MAX_LENGTH, bridgeq_count,
"index error.");
for (i = 0; i < data_num; i++) {
for (j = 0; j < data_num; j++) {
bridge = ofp_bridgeq_mgr_bridge_get(bridgeqs[i]);
if (bridge->dpid == bridges[j].dpid) {
/* check duplicate. */
if (bridges[j].b == false) {
bridges[j].b = true;
} else {
TEST_FAIL_MESSAGE("duplicate error.");
}
}
}
}
/* check dpid. */
for (i = 0; i < data_num; i++) {
TEST_ASSERT_EQUAL_MESSAGE(true, bridges[i].b,
"dpid error.");
}
/* test ofp_bridgeq_mgr_polls_get() */
poll_count = 0;
ret = ofp_bridgeq_mgr_polls_get(polls, bridgeqs,
&poll_count, data_num);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_polls_get(normal) error.");
TEST_ASSERT_EQUAL_MESSAGE(data_num * MAX_BRIDGE_POLLS, poll_count,
"poll_count error.");
for (i = 0; i < data_num * MAX_BRIDGE_POLLS; i++) {
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL,
polls[i],
"polls error.");
}
/* test ofp_bridgeq_mgr_dp_polls_get() */
poll_count = 0;
ret = ofp_bridgeq_mgr_dp_polls_get(dp_polls, bridgeqs,
&poll_count, data_num);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"ofp_bridgeq_mgr_dp_polls_get(normal) error.");
TEST_ASSERT_EQUAL_MESSAGE(data_num * MAX_BRIDGE_DP_POLLS, poll_count,
"poll_count(DP) error.");
for (i = 0; i < data_num * MAX_BRIDGE_DP_POLLS; i++) {
TEST_ASSERT_NOT_EQUAL_MESSAGE(NULL,
dp_polls[i],
"polls error.");
}
/* test ofp_bridgeq_mgr_bridgeqs_free. */
/* Call func.*/
ofp_bridgeq_mgr_bridgeqs_free(bridgeqs, bridgeq_count);
free(polls);
free(dp_polls);
}
