void
test_group_table_lookup(void) {
struct bridge *bridge;
struct group_table *group_table;
struct group *group, *gl;
struct ofp_group_mod group_mod;
struct bucket_list bucket_list;
struct ofp_error error;
lagopus_result_t ret;
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "bridge alloc error.");
TAILQ_INIT(&bucket_list);
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "group_table alloc error.");
bridge->group_table = group_table;
group_mod.group_id = 1;
group_mod.type = OFPGT_ALL;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
gl = group_table_lookup(group_table, 0);
TEST_ASSERT_NULL_MESSAGE(gl, "invalid group found error");
gl = group_table_lookup(group_table, 1);
TEST_ASSERT_EQUAL_MESSAGE(gl, group,
"invalid group found error");
}
void
test_port_config(void) {
datastore_bridge_info_t info;
struct ofp_port_mod port_mod;
struct ofp_error error;
struct bridge *bridge;
lagopus_result_t rv;
memset(&info, 0, sizeof(info));
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
TEST_ASSERT_EQUAL(dp_bridge_create("br0", &info), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_create("port1"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_interface_create("interface1"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_interface_set("port1", "interface1"),
LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_port_set("br0", "port1", 1), LAGOPUS_RESULT_OK);
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL(bridge);
port_mod.port_no = 1;
port_mod.hw_addr[0] = 0xe0;
port_mod.hw_addr[1] = 0x4d;
port_mod.hw_addr[2] = 0xff;
port_mod.hw_addr[3] = 0x00;
port_mod.hw_addr[4] = 0x10;
port_mod.hw_addr[5] = 0x04;
port_mod.config = 0;
port_mod.mask = 0;
rv = port_config(bridge, &port_mod, &error);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK,
"port_config error");
}
void
test_mactable_cmd_dump_02(void) {
#ifdef HYBRID
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
char *str = NULL;
const char format_str[] =
"{\"name\":\":br0\",\n"
"\"mactable\":[{\"num_entries\":2,\n"
"\"max_entries\":8192,\n"
"\"ageing_time\":300,\n"
"\"entries\":[{\"mac_addr\":\"1a:2b:3c:4d:5e:6f\",\n"
"\"port_no\":2,\n"
"\"update_time\":%ld,\n"
"\"address_type\":\"static\"},\n"
"{\"mac_addr\":\"aa:bb:cc:dd:ee:ff\",\n"
"\"port_no\":1,\n"
"\"update_time\":%ld,\n"
"\"address_type\":\"static\"}]}]}";
char test_str[1000];
uint8_t eth1[6];
uint8_t eth2[6];
uint32_t port1 = 1;
uint32_t port2 = 2;
struct timespec now;
struct bridge *bridge;
/* add mac entries */
eth1[0] = 0xaa;
eth1[1] = 0xbb;
eth1[2] = 0xcc;
eth1[3] = 0xdd;
eth1[4] = 0xee;
eth1[5] = 0xff;
eth2[0] = 0x1a;
eth2[1] = 0x2b;
eth2[2] = 0x3c;
eth2[3] = 0x4d;
eth2[4] = 0x5e;
eth2[5] = 0x6f;
/* preparation */
ret = dp_bridge_mactable_entry_set(bridge_name, eth1, port1);
TEST_ASSERT_EQUAL(ret, LAGOPUS_RESULT_OK);
ret = dp_bridge_mactable_entry_set(bridge_name, eth2, port2);
TEST_ASSERT_EQUAL(ret, LAGOPUS_RESULT_OK);
now = get_current_time();
sprintf(test_str, format_str, now.tv_sec, now.tv_sec);
bridge = dp_bridge_lookup(bridge_name);
mactable_update(&bridge->mactable);
/* test target. */
(void) lagopus_dstring_clear(&ds);
ret = dump_bridge_mactable(bridge_name, is_bridge_first, &ds);
TEST_ASSERT_EQUAL(ret, LAGOPUS_RESULT_OK);
TEST_DSTRING(ret, &ds, str, test_str, true);
#else /* HYBRID */
TEST_IGNORE_MESSAGE("HYBRID is not defined.");
#endif /* HYBRID */
}
void
test_group_table_alloc(void) {
struct bridge *bridge;
struct group_table *group_table;
lagopus_result_t rv;
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "bridge alloc error.");
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(group_table, "alloc error");
}
void
setUp(void) {
datastore_bridge_info_t info;
memset(&info, 0, sizeof(info));
info.dpid = dpid;
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
TEST_ASSERT_NULL(bridge);
TEST_ASSERT_EQUAL(dp_api_init(), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_create(bridge_name, &info), LAGOPUS_RESULT_OK);
bridge = dp_bridge_lookup(bridge_name);
TEST_ASSERT_NOT_NULL(bridge);
}
void
test_lagopus_get_port_statistics(void) {
datastore_bridge_info_t info;
struct bridge *bridge;
struct ofp_port_stats_request req;
struct port_stats_list list;
struct ofp_error error;
lagopus_result_t rv;
memset(&info, 0, sizeof(info));
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
rv = dp_bridge_create("br0", &info);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK,
"bridge add error");
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "dp_bridge_lookup error");
req.port_no = 1;
TAILQ_INIT(&list);
rv = lagopus_get_port_statistics(bridge->ports, &req, &list, &error);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OFP_ERROR, "result error");
req.port_no = OFPP_ANY;
TAILQ_INIT(&list);
rv = lagopus_get_port_statistics(bridge->ports, &req, &list, &error);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK, "result error");
TEST_ASSERT_NULL_MESSAGE(TAILQ_FIRST(&list), "empty list error");
TEST_ASSERT_EQUAL(dp_port_create("port1"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_interface_create("interface1"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_interface_set("port1", "interface1"),
LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_port_set("br0", "port1", 1), LAGOPUS_RESULT_OK);
req.port_no = OFPP_ANY;
TAILQ_INIT(&list);
rv = lagopus_get_port_statistics(bridge->ports, &req, &list, &error);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK, "result error");
TEST_ASSERT_NOT_NULL_MESSAGE(TAILQ_FIRST(&list), "list error");
req.port_no = 1;
TAILQ_INIT(&list);
rv = lagopus_get_port_statistics(bridge->ports, &req, &list, &error);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK, "result error");
TEST_ASSERT_NOT_NULL_MESSAGE(TAILQ_FIRST(&list), "list error");
req.port_no = 5;
TAILQ_INIT(&list);
rv = lagopus_get_port_statistics(bridge->ports, &req, &list, &error);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OFP_ERROR, "result error");
}
void
test_group_desc(void) {
struct bridge *bridge;
struct group_table *group_table;
struct group *group;
struct ofp_group_mod group_mod;
struct bucket_list bucket_list;
struct group_desc_list group_desc_list;
struct group_desc *desc;
struct ofp_error error;
lagopus_result_t ret;
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "bridge alloc error.");
TAILQ_INIT(&bucket_list);
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "group_table alloc error.");
bridge->group_table = group_table;
group_mod.group_id = 1;
group_mod.type = OFPGT_ALL;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
group_mod.group_id = 1000000;
group_mod.type = OFPGT_SELECT;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
TAILQ_INIT(&group_desc_list);
ret = group_descs(group_table, &group_desc_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get desc error");
desc = TAILQ_FIRST(&group_desc_list);
TEST_ASSERT_NOT_NULL_MESSAGE(desc, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.group_id, 1,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.type, OFPGT_ALL,
"group type error");
desc = TAILQ_NEXT(desc, entry);
TEST_ASSERT_NOT_NULL_MESSAGE(desc, "number of groups error");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.group_id, 1000000,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(desc->ofp.type, OFPGT_SELECT,
"group type error");
}
void
test_group_live_bucket(void) {
struct bridge *bridge;
struct group_table *group_table;
struct group *group;
struct ofp_group_mod group_mod;
struct bucket_list bucket_list;
struct bucket *bucket;
struct action *action;
struct ofp_error error;
lagopus_result_t rv;
bridge = dp_bridge_lookup("br0");
group_table = bridge->group_table;
group_mod.group_id = 1;
group_mod.type = OFPGT_ALL;
TAILQ_INIT(&bucket_list);
action = action_alloc(sizeof(uint32_t));
TEST_ASSERT_NOT_NULL(action);
action->ofpat.type = OFPAT_OUTPUT;
bucket = calloc(1, sizeof(struct bucket));
TEST_ASSERT_NOT_NULL(bucket);
bucket->ofp.watch_port = 1;
TAILQ_INIT(&bucket->action_list);
((struct ofp_action_output *)&action->ofpat)->port = 1;
((struct ofp_action_group *)&action->ofpat)->len =
sizeof(struct ofp_action_header) + sizeof(uint32_t);
TAILQ_INSERT_TAIL(&bucket->action_list, action, entry);
TAILQ_INSERT_TAIL(&bucket_list, bucket, entry);
action = action_alloc(sizeof(uint32_t));
TEST_ASSERT_NOT_NULL(action);
action->ofpat.type = OFPAT_OUTPUT;
bucket = calloc(1, sizeof(struct bucket));
TEST_ASSERT_NOT_NULL(bucket);
TAILQ_INIT(&bucket->action_list);
((struct ofp_action_output *)&action->ofpat)->port = 3;
((struct ofp_action_output *)&action->ofpat)->len =
sizeof(struct ofp_action_header) + sizeof(uint32_t);
TAILQ_INSERT_TAIL(&bucket->action_list, action, entry);
TAILQ_INSERT_TAIL(&bucket_list, bucket, entry);
group = group_alloc(&group_mod, &bucket_list);
rv = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL(rv, LAGOPUS_RESULT_OK);
TEST_ASSERT_NULL(group_live_bucket(bridge, group));
}
void
test_set_field_IN_PORT(void) {
datastore_bridge_info_t info;
struct action_list action_list;
struct bridge *bridge;
struct port *port;
struct action *action;
struct ofp_action_set_field *action_set;
struct port nport;
struct lagopus_packet pkt;
OS_MBUF *m;
/* setup bridge and port */
memset(&info, 0, sizeof(info));
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
TEST_ASSERT_EQUAL(dp_bridge_create("br0", &info), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_create("port0"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_create("port1"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_port_set("br0", "port0", 1), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_port_set("br0", "port1", 2), LAGOPUS_RESULT_OK);
TAILQ_INIT(&action_list);
action = calloc(1, sizeof(*action) + 64);
action_set = (struct ofp_action_set_field *)&action->ofpat;
action_set->type = OFPAT_SET_FIELD;
lagopus_set_action_function(action);
TAILQ_INSERT_TAIL(&action_list, action, entry);
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL(bridge);
pkt.in_port = port_lookup(bridge->ports, 1);
TEST_ASSERT_NOT_NULL(pkt.in_port);
lagopus_packet_init(&pkt, m);
set_match(action_set->field, 4, OFPXMT_OFB_IN_PORT << 1,
0x00, 0x00, 0x00, 0x02);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(pkt.in_port->ofp_port.port_no, 2,
"SET_FIELD IN_PORT error.");
}
void
setUp(void) {
size_t s;
char buf[128];
dpid_base = 0;
printf("dpid_base = 0x%llx (%llu)\n", (unsigned long long)dpid_base,
(unsigned long long)dpid_base);
for (s = 0; s < ARRAY_LEN(bridge); s++) {
TEST_ASSERT_NULL(bridge_name[s]);
TEST_ASSERT_NULL(bridge[s]);
TEST_ASSERT_NULL(flowdb[s]);
}
for (s = 0; s < ARRAY_LEN(port_name); s++) {
TEST_ASSERT_NULL(port_name[s]);
}
for (s = 0; s < ARRAY_LEN(ifname); s++) {
TEST_ASSERT_NULL(ifname[s]);
}
/* Make the bridge names and port configurations. */
for (s = 0; s < ARRAY_LEN(bridge); s++) {
snprintf(buf, sizeof(buf), bridge_name_format, (int)s);
bridge_name[s] = strdup(buf);
snprintf(buf, sizeof(buf), port_name_format, TEST_PORT_IFINDEX(s));
port_name[s] = strdup(buf);
snprintf(buf, sizeof(buf), ifname_format, TEST_PORT_IFINDEX(s));
ifname[s] = strdup(buf);
}
TEST_ASSERT_EQUAL(dp_api_init(), LAGOPUS_RESULT_OK);
for (s = 0; s < ARRAY_LEN(bridge); s++) {
datastore_bridge_info_t info;
memset(&info, 0, sizeof(info));
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
info.dpid = TEST_DPID(s);
TEST_ASSERT_TRUE(LAGOPUS_RESULT_OK == dp_bridge_create(bridge_name[s],
&info));
TEST_ASSERT_NOT_NULL(bridge[s] = dp_bridge_lookup(bridge_name[s]));
TEST_ASSERT_NOT_NULL(flowdb[s] = bridge[s]->flowdb);
}
}
void
setUp(void) {
datastore_bridge_info_t info;
struct ofp_error err;
TEST_ASSERT_NULL(bridge);
TEST_ASSERT_NULL(flowdb);
memset(&info, 0, sizeof(info));
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
TEST_ASSERT_EQUAL(dp_api_init(), LAGOPUS_RESULT_OK);
TEST_ASSERT_TRUE(LAGOPUS_RESULT_OK == dp_bridge_create(bridge_name, &info));
TEST_ASSERT_NOT_NULL(bridge = dp_bridge_lookup(bridge_name));
TEST_ASSERT_NOT_NULL(flowdb = bridge->flowdb);
TAILQ_INIT(&features_list);
memset(&err, 0, sizeof(err));
TEST_ASSERT_TRUE(LAGOPUS_RESULT_OK == flowdb_get_table_features(flowdb,
&features_list, &err));
}
void
setUp(void) {
datastore_bridge_info_t info;
TEST_ASSERT_NULL(bridge);
TEST_ASSERT_NULL(flowdb);
TEST_ASSERT_NULL(ports);
TEST_ASSERT_NULL(group_table);
TEST_ASSERT_EQUAL(dp_api_init(), LAGOPUS_RESULT_OK);
memset(&info, 0, sizeof(info));
info.dpid = dpid;
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
TEST_ASSERT_TRUE(LAGOPUS_RESULT_OK == dp_bridge_create(bridge_name, &info));
TEST_ASSERT_NOT_NULL(bridge = dp_bridge_lookup(bridge_name));
TEST_ASSERT_NOT_NULL(flowdb = bridge->flowdb);
TEST_ASSERT_EQUAL(lagopus_hashmap_create(&ports,
LAGOPUS_HASHMAP_TYPE_ONE_WORD,
NULL), LAGOPUS_RESULT_OK);
TEST_ASSERT_NOT_NULL(group_table = group_table_alloc(bridge));
}
void
test_group_table_add(void) {
struct bridge *bridge;
struct group_table *group_table;
struct group *group;
struct ofp_group_mod group_mod;
struct bucket_list bucket_list;
struct bucket *bucket;
struct action *action;
struct ofp_error error;
lagopus_result_t ret;
bridge = dp_bridge_lookup("br0");
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "group_table alloc error.");
bridge->group_table = group_table;
group_mod.group_id = 1;
group_mod.type = OFPGT_ALL;
TAILQ_INIT(&bucket_list);
group = group_alloc(&group_mod, &bucket_list);
TEST_ASSERT_NOT_NULL_MESSAGE(group, "group_alloc error");
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
group_mod.group_id = 2;
group_mod.type = OFPGT_ALL;
TAILQ_INIT(&bucket_list);
action = action_alloc(sizeof(uint32_t));
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action alloc error");
action->ofpat.type = OFPAT_GROUP;
bucket = calloc(1, sizeof(struct bucket));
TEST_ASSERT_NOT_NULL_MESSAGE(bucket, "bucket alloc error");
TAILQ_INIT(&bucket->action_list);
((struct ofp_action_group *)&action->ofpat)->group_id = 3;
((struct ofp_action_group *)&action->ofpat)->len =
sizeof(struct ofp_action_header) + sizeof(uint32_t);
TAILQ_INSERT_TAIL(&bucket->action_list, action, entry);
TAILQ_INSERT_TAIL(&bucket_list, bucket, entry);
action = action_alloc(sizeof(uint32_t));
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action alloc error");
action->ofpat.type = OFPAT_OUTPUT;
bucket = calloc(1, sizeof(struct bucket));
TEST_ASSERT_NOT_NULL_MESSAGE(bucket, "bucket alloc error");
TAILQ_INIT(&bucket->action_list);
((struct ofp_action_output *)&action->ofpat)->port = 3;
((struct ofp_action_output *)&action->ofpat)->len =
sizeof(struct ofp_action_header) + sizeof(uint32_t);
TAILQ_INSERT_TAIL(&bucket->action_list, action, entry);
TAILQ_INSERT_TAIL(&bucket_list, bucket, entry);
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
bucket = TAILQ_FIRST(&group->bucket_list);
TEST_ASSERT_NOT_NULL_MESSAGE(bucket, "bucket copy error");
action = TAILQ_FIRST(&bucket->action_list);
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action copy error");
TEST_ASSERT_EQUAL_MESSAGE(action->ofpat.type, OFPAT_GROUP,
"action copy error");
bucket = TAILQ_NEXT(bucket, entry);
TEST_ASSERT_NOT_NULL_MESSAGE(bucket, "bucket copy error");
action = TAILQ_FIRST(&bucket->action_list);
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action copy error");
TEST_ASSERT_EQUAL_MESSAGE(action->ofpat.type, OFPAT_OUTPUT,
"action copy error");
TEST_ASSERT_EQUAL_MESSAGE(
((struct ofp_action_output *)&action->ofpat)->port, 3,
"action copy error");
group_mod.group_id = 3;
group_mod.type = OFPGT_ALL;
action = action_alloc(sizeof(uint32_t));
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action alloc error");
action->ofpat.type = OFPAT_GROUP;
((struct ofp_action_group *)&action->ofpat)->group_id = 2;
((struct ofp_action_group *)&action->ofpat)->len =
sizeof(struct ofp_action_header) + sizeof(uint32_t);
bucket = calloc(1, sizeof(struct bucket));
TAILQ_INIT(&bucket->action_list);
TAILQ_INSERT_TAIL(&bucket->action_list, action, entry);
TAILQ_INIT(&bucket_list);
TAILQ_INSERT_TAIL(&bucket_list, bucket, entry);
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OFP_ERROR,
"group_table_add loop error");
TEST_ASSERT_EQUAL_MESSAGE(error.code, OFPGMFC_LOOP,
"loop error detection failed");
}
void
test_group_stats(void) {
struct bridge *bridge;
struct group_table *group_table;
struct group *group;
struct ofp_group_mod group_mod;
struct bucket_list bucket_list;
struct ofp_group_stats_request request;
struct group_stats_list group_stats_list;
struct group_stats *stats;
struct ofp_error error;
struct ofp_flow_mod flow_mod;
struct match_list match_list;
struct instruction_list instruction_list;
struct instruction *instruction;
struct action *action;
lagopus_result_t ret;
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "bridge alloc error.");
TAILQ_INIT(&bucket_list);
group_table = group_table_alloc(bridge);
TEST_ASSERT_NOT_NULL_MESSAGE(bridge, "group_table alloc error.");
bridge->group_table = group_table;
group_mod.group_id = 1;
group_mod.type = OFPGT_ALL;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
group_mod.group_id = 1000000;
group_mod.type = OFPGT_ALL;
group = group_alloc(&group_mod, &bucket_list);
ret = group_table_add(group_table, group, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"group_table_add error");
request.group_id = 1;
TAILQ_INIT(&group_stats_list);
ret = group_stats(group_table, &request, &group_stats_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get stats error");
stats = TAILQ_FIRST(&group_stats_list);
TEST_ASSERT_NOT_NULL_MESSAGE(stats, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.group_id, 1,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.duration_sec, 0,
"duration sec error");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.ref_count, 0,
"ref_count error");
stats = TAILQ_NEXT(stats, entry);
TEST_ASSERT_NULL_MESSAGE(stats, "number of groups error");
TAILQ_INIT(&match_list);
TAILQ_INIT(&instruction_list);
instruction = instruction_alloc();
TEST_ASSERT_NOT_NULL_MESSAGE(instruction, "instruction alloc error.");
instruction->ofpit.type = OFPIT_APPLY_ACTIONS;
TAILQ_INIT(&instruction->action_list);
action = action_alloc(sizeof(struct ofp_action_group));
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action alloc error.");
action->ofpat.type = OFPAT_GROUP;
((struct ofp_action_group *)&action->ofpat)->group_id = 5;
TAILQ_INSERT_TAIL(&instruction->action_list, action, entry);
TAILQ_INSERT_TAIL(&instruction_list, instruction, entry);
flow_mod.table_id = 0;
flow_mod.priority = 1;
flow_mod.flags = 0;
flow_mod.cookie = 0;
ret = flowdb_flow_add(bridge, &flow_mod, &match_list,
&instruction_list, &error);
TEST_ASSERT_NOT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"flowdb_flow_add: group check error");
TAILQ_INIT(&match_list);
TAILQ_INIT(&instruction_list);
instruction = instruction_alloc();
TEST_ASSERT_NOT_NULL_MESSAGE(instruction, "instruction alloc error.");
instruction->ofpit.type = OFPIT_APPLY_ACTIONS;
TAILQ_INIT(&instruction->action_list);
action = action_alloc(sizeof(struct ofp_action_group));
TEST_ASSERT_NOT_NULL_MESSAGE(action, "action alloc error.");
action->ofpat.type = OFPAT_GROUP;
((struct ofp_action_group *)&action->ofpat)->group_id = 1;
TAILQ_INSERT_TAIL(&instruction->action_list, action, entry);
TAILQ_INSERT_TAIL(&instruction_list, instruction, entry);
ret = flowdb_flow_add(bridge, &flow_mod, &match_list,
&instruction_list, &error);
printf("%d.%d\n", error.type, error.code);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"flowdb_flow_add: add to empty table error");
request.group_id = 1;
TAILQ_INIT(&group_stats_list);
ret = group_stats(group_table, &request, &group_stats_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get stats error");
stats = TAILQ_FIRST(&group_stats_list);
TEST_ASSERT_NOT_NULL_MESSAGE(stats, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.group_id, 1,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.duration_sec, 0,
"duration sec error");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.ref_count, 1,
"ref_count error");
stats = TAILQ_NEXT(stats, entry);
TEST_ASSERT_NULL_MESSAGE(stats, "number of groups error");
request.group_id = OFPG_ALL;
TAILQ_INIT(&group_stats_list);
ret = group_stats(group_table, &request, &group_stats_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get stats error");
stats = TAILQ_FIRST(&group_stats_list);
TEST_ASSERT_NOT_NULL_MESSAGE(stats, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.group_id, 1,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.duration_sec, 0,
"duration sec error");
stats = TAILQ_NEXT(stats, entry);
TEST_ASSERT_NOT_NULL_MESSAGE(stats, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.group_id, 1000000,
"group id error");
stats = TAILQ_NEXT(stats, entry);
TEST_ASSERT_NULL_MESSAGE(stats, "number of groups error");
sleep(1);
TAILQ_INIT(&group_stats_list);
ret = group_stats(group_table, &request, &group_stats_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get stats error");
stats = TAILQ_FIRST(&group_stats_list);
TEST_ASSERT_NOT_NULL_MESSAGE(stats, "group not found");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.group_id, 1,
"group id error");
TEST_ASSERT_EQUAL_MESSAGE(stats->ofp.duration_sec, 1,
"duration sec error");
request.group_id = 20;
TAILQ_INIT(&group_stats_list);
ret = group_stats(group_table, &request, &group_stats_list, &error);
TEST_ASSERT_EQUAL_MESSAGE(ret, LAGOPUS_RESULT_OK,
"get stats error");
stats = TAILQ_FIRST(&group_stats_list);
TEST_ASSERT_NULL_MESSAGE(stats, "stats is not empry");
}
void
test_lagopus_find_flow(void) {
datastore_bridge_info_t info;
struct bridge *bridge;
struct port *port;
struct port nport;
struct lagopus_packet *pkt;
struct table *table;
struct flow *flow;
OS_MBUF *m;
/* setup bridge and port */
memset(&info, 0, sizeof(info));
info.fail_mode = DATASTORE_BRIDGE_FAIL_MODE_SECURE;
TEST_ASSERT_EQUAL(dp_bridge_create("br0", &info), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_create("port0"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_port_create("port1"), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_port_set("br0", "port0", 1), LAGOPUS_RESULT_OK);
TEST_ASSERT_EQUAL(dp_bridge_port_set("br0", "port1", 2), LAGOPUS_RESULT_OK);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = pkt->mbuf;
OS_M_APPEND(m, 64);
m->refcnt = 2;
bridge = dp_bridge_lookup("br0");
TEST_ASSERT_NOT_NULL(bridge);
lagopus_packet_init(pkt, m, port_lookup(&bridge->ports, 1));
table = flowdb_get_table(pkt->in_port->bridge->flowdb, 0);
table->userdata = new_flowinfo_eth_type();
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(misc) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(misc) error.");
OS_MTOD(m, uint8_t *)[14] = 0x08;
OS_MTOD(m, uint8_t *)[15] = 0x06;
lagopus_packet_init(pkt, m, &port);
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(arp) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(arp) error.");
OS_MTOD(m, uint8_t *)[14] = 0x08;
OS_MTOD(m, uint8_t *)[15] = 0x00;
lagopus_packet_init(pkt, m, port_lookup(&bridge->ports, 1));
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(ipv4) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(ipv4) error.");
OS_MTOD(m, uint8_t *)[14] = 0x86;
OS_MTOD(m, uint8_t *)[15] = 0xdd;
OS_MTOD(m, uint8_t *)[20] = IPPROTO_TCP;
lagopus_packet_init(pkt, m, port_lookup(&bridge->ports, 1));
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(ipv6) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(ipv6) error.");
OS_MTOD(m, uint8_t *)[14] = 0x88;
OS_MTOD(m, uint8_t *)[15] = 0x47;
lagopus_packet_init(pkt, m, port_lookup(&bridge->ports, 1));
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(mpls) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(mpls) error.");
OS_MTOD(m, uint8_t *)[14] = 0x88;
OS_MTOD(m, uint8_t *)[15] = 0x48;
lagopus_packet_init(pkt, m, port_lookup(&bridge->ports, 1));
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(mpls-mc) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(mpls-mc) error.");
OS_MTOD(m, uint8_t *)[14] = 0x88;
OS_MTOD(m, uint8_t *)[15] = 0xe7;
lagopus_packet_init(pkt, m, port_lookup(&bridge->ports, 1));
flow = lagopus_find_flow(pkt, table);
TEST_ASSERT_EQUAL_MESSAGE(table->lookup_count, 0,
"lookup_count(pbb) error.");
TEST_ASSERT_NULL_MESSAGE(flow,
"flow(pbb) error.");
}
