void
test_match_basic_IPV4_SCTP_DST(void) {
struct lagopus_packet *pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = pkt->mbuf;
OS_M_APPEND(m, 64);
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x08, 0x00);
OS_MTOD(m, uint8_t *)[12] = 0x81;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[16] = 0x08;
OS_MTOD(m, uint8_t *)[17] = 0x00;
OS_MTOD(m, uint8_t *)[18] = 0x45;
add_match(&flow->match_list, 1, OFPXMT_OFB_IP_PROTO << 1,
IPPROTO_SCTP);
OS_MTOD(m, uint8_t *)[27] = IPPROTO_SCTP;
/* SCTP_DST */
add_match(&flow->match_list, 2, OFPXMT_OFB_SCTP_DST << 1,
0, 80);
OS_MTOD(m, uint8_t *)[40] = 80;
OS_MTOD(m, uint8_t *)[41] = 0;
refresh_match(flow);
lagopus_packet_init(pkt, m, &port);
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"SCTP_DST mismatch error.");
OS_MTOD(m, uint8_t *)[40] = 0;
OS_MTOD(m, uint8_t *)[41] = 80;
lagopus_packet_init(pkt, m, &port);
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"SCTP_DST match error.");
free(m);
}
void
test_port_add(void) {
struct vector *ports;
struct port port;
lagopus_result_t rv;
ports = ports_alloc();
TEST_ASSERT_NOT_NULL_MESSAGE(ports, "ports_alloc error");
strncpy(port.ofp_port.name, "port1", sizeof(port.ofp_port.name));
port.ofp_port.port_no = 1;
port.ifindex = 120;
port.type = LAGOPUS_PORT_TYPE_NULL;
rv = port_add(ports, &port);
TEST_ASSERT_EQUAL_MESSAGE(rv, LAGOPUS_RESULT_OK, "port_add error");
}
void
test_set_field_IPV6_SCTP_SRC(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_PKTLEN(m) = 128;
OS_MTOD(m, uint8_t *)[12] = 0x86;
OS_MTOD(m, uint8_t *)[13] = 0xdd;
OS_MTOD(m, uint8_t *)[20] = IPPROTO_SCTP;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 2, OFPXMT_OFB_SCTP_SRC << 1,
0x80, 0x21);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[54], 0x80,
"SET_FIELD IPV6_SCTP_SRC[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[55], 0x21,
"SET_FIELD IPV6_SCTP_SRC[1] error.");
OS_MTOD(m, uint8_t *)[20] = IPPROTO_DSTOPTS;
OS_MTOD(m, uint8_t *)[54] = IPPROTO_SCTP;
OS_MTOD(m, uint8_t *)[55] = 0;
lagopus_packet_init(pkt, m, &port);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[54], IPPROTO_SCTP,
"SET_FIELD IPV6_SCTP_SRC proto error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[62], 0x80,
"SET_FIELD IPV6_SCTP_SRC[0](next hdr) error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[63], 0x21,
"SET_FIELD IPV6_SCTP_SRC[1](next hdr) error.");
}
void
test_set_field_IPV6_SCTP_DST(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
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];
OS_M_PKTLEN(m) = 128;
m->data[12] = 0x86;
m->data[13] = 0xdd;
m->data[20] = IPPROTO_SCTP;
lagopus_packet_init(&pkt, m, &port);
set_match(action_set->field, 2, OFPXMT_OFB_SCTP_DST << 1,
0x80, 0x21);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[56], 0x80,
"SET_FIELD IPV6_SCTP_DST[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[57], 0x21,
"SET_FIELD IPV6_SCTP_DST[1] error.");
m->data[20] = IPPROTO_DSTOPTS;
m->data[54] = IPPROTO_SCTP;
m->data[55] = 0;
lagopus_packet_init(&pkt, m, &port);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[54], IPPROTO_SCTP,
"SET_FIELD IPV6_SCTP_DST proto error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[64], 0x80,
"SET_FIELD IPV6_SCTP_DST[0](next hdr) error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[65], 0x21,
"SET_FIELD IPV6_SCTP_DST[1](next hdr) error.");
}
void
test_match_basic_IPV4_SCTP_SRC(void) {
struct lagopus_packet pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt.in_port = &port;
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x08, 0x00);
m->data[12] = 0x81;
m->data[13] = 0x00;
m->data[16] = 0x08;
m->data[17] = 0x00;
m->data[18] = 0x45;
add_match(&flow->match_list, 1, OFPXMT_OFB_IP_PROTO << 1,
IPPROTO_SCTP);
m->data[27] = IPPROTO_SCTP;
/* SCTP_SRC */
add_match(&flow->match_list, 2, OFPXMT_OFB_SCTP_SRC << 1,
0xf0, 0x00);
m->data[38] = 0;
m->data[39] = 0xf0;
refresh_match(flow);
lagopus_packet_init(&pkt, m);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"SCTP_SRC mismatch error.");
m->data[38] = 0xf0;
m->data[39] = 0x00;
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"SCTP_SRC match error.");
free(m);
}
void
test_controller_conf_delete_not_initialize(void) {
lagopus_result_t rc;
controller_conf_t *conf = NULL;
const char *name = "controller_name";
rc = controller_conf_create(&conf, name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(conf, "conf_create() will create new controller");
rc = controller_conf_delete(conf);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_STARTED, rc);
controller_conf_destroy(conf);
controller_finalize();
}
void
test_controller_attr_public_channel_name(void) {
lagopus_result_t rc;
controller_conf_t *conf = NULL;
const char *name = "controller_name";
char *actual_channel_name = NULL;
const char *expected_channel_name = "";
controller_initialize();
rc = controller_conf_create(&conf, name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(conf, "conf_create() will create new controller");
rc = controller_conf_add(conf);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
// Normal case of getter
{
rc = datastore_controller_get_channel_name(name, true, &actual_channel_name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_OBJECT, rc);
rc = datastore_controller_get_channel_name(name, false, &actual_channel_name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_STRING(expected_channel_name, actual_channel_name);
}
// Abnormal case of getter
{
rc = datastore_controller_get_channel_name(NULL, true, &actual_channel_name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = datastore_controller_get_channel_name(NULL, false, &actual_channel_name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = datastore_controller_get_channel_name(name, true, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = datastore_controller_get_channel_name(name, false, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
free((void *)actual_channel_name);
controller_finalize();
}
void
test_set_field_ARP_SPA(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = pkt->mbuf;
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x08;
OS_MTOD(m, uint8_t *)[13] = 0x06;
OS_MTOD(m, uint8_t *)[20] = 0x00;
OS_MTOD(m, uint8_t *)[21] = ARPOP_REQUEST;
OS_MTOD(m, uint8_t *)[28] = 172;
OS_MTOD(m, uint8_t *)[29] = 21;
OS_MTOD(m, uint8_t *)[30] = 0;
OS_MTOD(m, uint8_t *)[31] = 1;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 4, OFPXMT_OFB_ARP_SPA << 1,
192, 168, 1, 2);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[28], 192,
"SET_FIELD ARP_SPA[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[29], 168,
"SET_FIELD ARP_SPA[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[30], 1,
"SET_FIELD ARP_SPA[2] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[31], 2,
"SET_FIELD ARP_SPA[3] error.");
}
void
test_match_basic_PBB_ISID_W(void) {
struct lagopus_packet pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
#ifndef PBB_IS_VLAN
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x88, 0xe7);
#endif
m->data[12] = 0x88;
m->data[13] = 0xe7;
add_match(&flow->match_list, 6, (OFPXMT_OFB_PBB_ISID << 1) + 1,
0x5a, 0xc3, 0x00, 0xff, 0xff, 0x00);
refresh_match(flow);
lagopus_packet_init(&pkt, m, &port);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"PBB_ISID_W mismatch(1) error.");
m->data[15] = 0x3c;
m->data[16] = 0xc3;
m->data[17] = 0x5a;
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"PBB_ISID_W mismatch(2) error.");
m->data[15] = 0x5a;
m->data[16] = 0xc3;
m->data[17] = 0x3c;
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"PBB_ISID_W match error.");
}
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
test_set_field_ETH_TYPE(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
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];
OS_M_PKTLEN(m) = 64;
m->data[12] = 0x08;
m->data[13] = 0x00;
lagopus_packet_init(&pkt, m, &port);
set_match(action_set->field, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x20, 0xf1);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[12], 0x20,
"SET_FIELD ETH_TYPE[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[13], 0xf1,
"SET_FIELD ETH_TYPE[1] error.");
m->data[12] = 0x81;
m->data[13] = 0x00;
lagopus_packet_init(&pkt, m, &port);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[16], 0x20,
"SET_FIELD(vlan) ETH_TYPE[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[17], 0xf1,
"SET_FIELD(vlan) ETH_TYPE[1] error.");
}
void
test_controller_attr_public_role(void) {
lagopus_result_t rc;
controller_conf_t *conf = NULL;
const char *name = "controller_name";
datastore_controller_role_t actual_role = DATASTORE_CONTROLLER_ROLE_UNKNOWN;
const datastore_controller_role_t expected_role = actual_role;
controller_initialize();
rc = controller_conf_create(&conf, name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(conf, "conf_create() will create new controller");
rc = controller_conf_add(conf);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
// Normal case of getter
{
rc = datastore_controller_get_role(name, true, &actual_role);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_OBJECT, rc);
rc = datastore_controller_get_role(name, false, &actual_role);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(expected_role, actual_role);
}
// Abnormal case of getter
{
rc = datastore_controller_get_role(NULL, true, &actual_role);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = datastore_controller_get_role(NULL, false, &actual_role);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = datastore_controller_get_role(name, true, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = datastore_controller_get_role(name, false, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
controller_finalize();
}
void
test_pop_vlan(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_pop_mpls *action_pop;
struct lagopus_packet *pkt;
OS_MBUF *m;
TAILQ_INIT(&action_list);
action = calloc(1, sizeof(*action));
action_pop = (struct ofp_action_pop_mpls *)&action->ofpat;
action_pop->type = OFPAT_POP_VLAN;
lagopus_set_action_function(action);
TAILQ_INSERT_TAIL(&action_list, action, entry);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = pkt->mbuf;
OS_M_APPEND(m, 64 + 4);
OS_MTOD(m, uint8_t *)[12] = 0x81;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[14] = 0x30;
OS_MTOD(m, uint8_t *)[15] = 50;
OS_MTOD(m, uint8_t *)[16] = 0x08;
OS_MTOD(m, uint8_t *)[17] = 0x00;
OS_MTOD(m, uint8_t *)[18] = 0x45;
OS_MTOD(m, uint8_t *)[26] = 240;
lagopus_packet_init(pkt, m, &port);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_M_PKTLEN(m), 64,
"POP_VLAN length error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[12], 0x08,
"POP_VLAN ethertype[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[13], 0x00,
"POP_VLAN ethertype[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[14], 0x45,
"POP_VLAN ip_vhl error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[22], 240,
"POP_VLAN ip_ttl error.");
}
void
test_match_basic_PBB_ISID_W(void) {
struct lagopus_packet *pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
#ifndef PBB_IS_VLAN
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x88, 0xe7);
#endif
OS_MTOD(m, uint8_t *)[12] = 0x88;
OS_MTOD(m, uint8_t *)[13] = 0xe7;
add_match(&flow->match_list, 6, (OFPXMT_OFB_PBB_ISID << 1) + 1,
0x5a, 0xc3, 0x00, 0xff, 0xff, 0x00);
refresh_match(flow);
lagopus_packet_init(pkt, m, &port);
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"PBB_ISID_W mismatch(1) error.");
OS_MTOD(m, uint8_t *)[15] = 0x3c;
OS_MTOD(m, uint8_t *)[16] = 0xc3;
OS_MTOD(m, uint8_t *)[17] = 0x5a;
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"PBB_ISID_W mismatch(2) error.");
OS_MTOD(m, uint8_t *)[15] = 0x5a;
OS_MTOD(m, uint8_t *)[16] = 0xc3;
OS_MTOD(m, uint8_t *)[17] = 0x3c;
rv = match_basic(pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"PBB_ISID_W match error.");
}
void
test_set_field_ETH_TYPE(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x08;
OS_MTOD(m, uint8_t *)[13] = 0x00;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x20, 0xf1);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[12], 0x20,
"SET_FIELD ETH_TYPE[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[13], 0xf1,
"SET_FIELD ETH_TYPE[1] error.");
OS_MTOD(m, uint8_t *)[12] = 0x81;
OS_MTOD(m, uint8_t *)[13] = 0x00;
lagopus_packet_init(pkt, m, &port);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[16], 0x20,
"SET_FIELD(vlan) ETH_TYPE[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[17], 0xf1,
"SET_FIELD(vlan) ETH_TYPE[1] error.");
}
void
test_controller_conf_create_and_destroy(void) {
lagopus_result_t rc;
controller_conf_t *conf = NULL;
const char *name = "controller_name";
controller_initialize();
// Normal case
{
rc = controller_conf_create(&conf, name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(conf, "conf_create() will create new controller");
// name
TEST_ASSERT_EQUAL_STRING(name, conf->name);
// current_attr
TEST_ASSERT_NULL(conf->current_attr);
// modified_attr
TEST_ASSERT_NOT_NULL(conf->modified_attr);
// enabled
TEST_ASSERT_FALSE(conf->is_enabled);
// used
TEST_ASSERT_FALSE(conf->is_used);
}
// Abnormal case
{
rc = controller_conf_create(NULL, name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_conf_create(&conf, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
controller_conf_destroy(conf);
controller_finalize();
}
void
test_controller_get_attr(void) {
lagopus_result_t rc;
controller_conf_t *conf = NULL;
controller_attr_t *attr = NULL;
const char *name = "controller_name";
controller_initialize();
rc = controller_conf_create(&conf, name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(conf, "conf_create() will create new controller");
rc = controller_conf_add(conf);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
// Normal case of getter
{
rc = controller_get_attr(name, true, &attr);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_OBJECT, rc);
rc = controller_get_attr(name, false, &attr);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL(attr);
}
// Abnormal case of getter
{
rc = controller_get_attr(NULL, true, &attr);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_get_attr(NULL, false, &attr);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_get_attr(name, true, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
rc = controller_get_attr(name, false, NULL);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_INVALID_ARGS, rc);
}
controller_finalize();
}
void
test_classify_packet_IPV6_other(void) {
struct port port;
struct lagopus_packet *pkt;
OS_MBUF *m;
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x86;
OS_MTOD(m, uint8_t *)[13] = 0xdd;
OS_MTOD(m, uint8_t *)[20] = IPPROTO_RSVP;
lagopus_packet_init(pkt, m, &port);
TEST_ASSERT_EQUAL_MESSAGE(pkt->ether_type, ETHERTYPE_IPV6,
"ether_type error.");
/* with exthdr */
OS_MTOD(m, uint8_t *)[20] = IPPROTO_DSTOPTS;
OS_MTOD(m, uint8_t *)[54] = IPPROTO_RSVP;
OS_MTOD(m, uint8_t *)[55] = 0;
classify_ether_packet(pkt);
TEST_ASSERT_EQUAL_MESSAGE(pkt->ether_type, ETHERTYPE_IPV6,
"ether_type(exthdr) error.");
/* with VLAN */
OS_MTOD(m, uint8_t *)[12] = 0x81;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[16] = 0x86;
OS_MTOD(m, uint8_t *)[17] = 0xdd;
OS_MTOD(m, uint8_t *)[24] = IPPROTO_RSVP;
classify_ether_packet(pkt);
TEST_ASSERT_EQUAL_MESSAGE(pkt->ether_type, ETHERTYPE_IPV6,
"ether_type(vlan) error.");
/* with VLAN and exthdr */
OS_MTOD(m, uint8_t *)[24] = IPPROTO_DSTOPTS;
OS_MTOD(m, uint8_t *)[58] = IPPROTO_RSVP;
OS_MTOD(m, uint8_t *)[59] = 0;
classify_ether_packet(pkt);
TEST_ASSERT_EQUAL_MESSAGE(pkt->ether_type, ETHERTYPE_IPV6,
"ether_type(vlan+exthdr) error.");
}
void
test_set_field_ETH_DST(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
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];
OS_M_PKTLEN(m) = 64;
m->data[12] = 0x08;
m->data[13] = 0x00;
lagopus_packet_init(&pkt, m, &port);
set_match(action_set->field, 6, OFPXMT_OFB_ETH_DST << 1,
0x23, 0x45, 0x67, 0x89, 0xab, 0xcd);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[0], 0x23,
"SET_FIELD ETH_DST[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[1], 0x45,
"SET_FIELD ETH_DST[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[2], 0x67,
"SET_FIELD ETH_DST[2] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[3], 0x89,
"SET_FIELD ETH_DST[3] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[4], 0xab,
"SET_FIELD ETH_DST[4] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[5], 0xcd,
"SET_FIELD ETH_DST[5] error.");
}
void
test_set_field_ETH_SRC(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
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];
OS_M_PKTLEN(m) = 64;
m->data[12] = 0x08;
m->data[13] = 0x00;
lagopus_packet_init(&pkt, m, &port);
set_match(action_set->field, 6, OFPXMT_OFB_ETH_SRC << 1,
0x22, 0x44, 0x66, 0x88, 0xaa, 0xcc);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[6], 0x22,
"SET_FIELD ETH_SRC[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[7], 0x44,
"SET_FIELD ETH_SRC[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[8], 0x66,
"SET_FIELD ETH_SRC[2] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[9], 0x88,
"SET_FIELD ETH_SRC[3] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[10], 0xaa,
"SET_FIELD ETH_SRC[4] error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[11], 0xcc,
"SET_FIELD ETH_SRC[5] error.");
}
void
test_set_field_ICMPV6_TYPE(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x86;
OS_MTOD(m, uint8_t *)[13] = 0xdd;
OS_MTOD(m, uint8_t *)[20] = IPPROTO_ICMPV6;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 2, OFPXMT_OFB_ICMPV6_TYPE << 1,
ICMP6_ECHO_REQUEST);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[54], ICMP6_ECHO_REQUEST,
"SET_FIELD ICMPV6_TYPE error.");
OS_MTOD(m, uint8_t *)[20] = IPPROTO_DSTOPTS;
OS_MTOD(m, uint8_t *)[54] = IPPROTO_ICMPV6;
OS_MTOD(m, uint8_t *)[55] = 0;
lagopus_packet_init(pkt, m, &port);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[54], IPPROTO_ICMPV6,
"SET_FIELD ICMPV6_TYPE proto error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[62], ICMP6_ECHO_REQUEST,
"SET_FIELD ICMPV6_TYPE(next hdr) error.");
}
void
test_set_field_ICMPV6_TYPE(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
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];
OS_M_PKTLEN(m) = 64;
m->data[12] = 0x86;
m->data[13] = 0xdd;
m->data[20] = IPPROTO_ICMPV6;
lagopus_packet_init(&pkt, m, &port);
set_match(action_set->field, 2, OFPXMT_OFB_ICMPV6_TYPE << 1,
ICMP6_ECHO_REQUEST);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[54], ICMP6_ECHO_REQUEST,
"SET_FIELD ICMPV6_TYPE error.");
m->data[20] = IPPROTO_DSTOPTS;
m->data[54] = IPPROTO_ICMPV6;
m->data[55] = 0;
lagopus_packet_init(&pkt, m, &port);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[54], IPPROTO_ICMPV6,
"SET_FIELD ICMPV6_TYPE proto error.");
TEST_ASSERT_EQUAL_MESSAGE(m->data[62], ICMP6_ECHO_REQUEST,
"SET_FIELD ICMPV6_TYPE(next hdr) error.");
}
void
test_set_field_ETH_SRC(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x08;
OS_MTOD(m, uint8_t *)[13] = 0x00;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 6, OFPXMT_OFB_ETH_SRC << 1,
0x22, 0x44, 0x66, 0x88, 0xaa, 0xcc);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[6], 0x22,
"SET_FIELD ETH_SRC[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[7], 0x44,
"SET_FIELD ETH_SRC[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[8], 0x66,
"SET_FIELD ETH_SRC[2] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[9], 0x88,
"SET_FIELD ETH_SRC[3] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[10], 0xaa,
"SET_FIELD ETH_SRC[4] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[11], 0xcc,
"SET_FIELD ETH_SRC[5] error.");
}
void
test_set_field_ETH_DST(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x08;
OS_MTOD(m, uint8_t *)[13] = 0x00;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 6, OFPXMT_OFB_ETH_DST << 1,
0x23, 0x45, 0x67, 0x89, 0xab, 0xcd);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[0], 0x23,
"SET_FIELD ETH_DST[0] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[1], 0x45,
"SET_FIELD ETH_DST[1] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[2], 0x67,
"SET_FIELD ETH_DST[2] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[3], 0x89,
"SET_FIELD ETH_DST[3] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[4], 0xab,
"SET_FIELD ETH_DST[4] error.");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[5], 0xcd,
"SET_FIELD ETH_DST[5] error.");
}
void
test_match_basic_IPV6_FLABEL(void) {
struct lagopus_packet pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt.in_port = &port;
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x86, 0xdd);
m->data[12] = 0x86;
m->data[13] = 0xdd;
m->data[15] = 0x00;
m->data[16] = 0x12;
m->data[17] = 0x34;
add_match(&flow->match_list, 4, OFPXMT_OFB_IPV6_FLABEL << 1,
0x00, 0x01, 0x23, 0x45);
refresh_match(flow);
lagopus_packet_init(&pkt, m);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"IPV6_FLABEL mismatch error.");
m->data[15] = 0x01;
m->data[16] = 0x23;
m->data[17] = 0x45;
lagopus_packet_init(&pkt, m);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"IPV6_FLABEL match error.");
}
void
test_controller_attr_create_and_destroy(void) {
lagopus_result_t rc;
controller_attr_t *attr = NULL;
char *actual_channel_name = NULL;
const char *expected_channel_name = "";
datastore_controller_role_t actual_role = DATASTORE_CONTROLLER_ROLE_UNKNOWN;
const datastore_controller_role_t expected_role = actual_role;
datastore_controller_connection_type_t actual_type
= DATASTORE_CONTROLLER_CONNECTION_TYPE_UNKNOWN;
const datastore_controller_connection_type_t expected_type = actual_type;
controller_initialize();
rc = controller_attr_create(&attr);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_NOT_NULL_MESSAGE(attr, "attr_create() will create new controller");
// default value
{
// channel_name
rc = controller_get_channel_name(attr, &actual_channel_name);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_STRING(expected_channel_name, actual_channel_name);
// role
rc = controller_get_role(attr, &actual_role);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(expected_role, actual_role);
// type
rc = controller_get_connection_type(attr, &actual_type);
TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, rc);
TEST_ASSERT_EQUAL_UINT32(expected_type, actual_type);
}
controller_attr_destroy(attr);
free((void *)actual_channel_name);
controller_finalize();
}
void
test_classify_packet_IPV4_UDP(void) {
struct port port;
struct lagopus_packet *pkt;
OS_MBUF *m;
/* prepare packet */
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_PKTLEN(m) = 128;
OS_MTOD(m, uint8_t *)[12] = 0x08;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[14] = 0x45;
OS_MTOD(m, uint8_t *)[23] = IPPROTO_UDP;
lagopus_packet_init(pkt, m, &port);
TEST_ASSERT_EQUAL_MESSAGE(pkt->ether_type, ETHERTYPE_IP,
"ether_type error.");
TEST_ASSERT_EQUAL_MESSAGE(pkt->l3_hdr, &OS_MTOD(m, uint8_t *)[14],
"l3_hdr error.");
TEST_ASSERT_EQUAL_MESSAGE(pkt->l4_hdr, &OS_MTOD(m, uint8_t *)[34],
"l4_hdr error.");
/* with VLAN */
OS_MTOD(m, uint8_t *)[12] = 0x81;
OS_MTOD(m, uint8_t *)[13] = 0x00;
OS_MTOD(m, uint8_t *)[16] = 0x08;
OS_MTOD(m, uint8_t *)[17] = 0x00;
OS_MTOD(m, uint8_t *)[18] = 0x45;
OS_MTOD(m, uint8_t *)[27] = IPPROTO_UDP;
classify_ether_packet(pkt);
TEST_ASSERT_EQUAL_MESSAGE(pkt->ether_type, ETHERTYPE_IP,
"ether_type(vlan) error.");
TEST_ASSERT_EQUAL_MESSAGE(pkt->l3_hdr, &OS_MTOD(m, uint8_t *)[18],
"l3_hdr(vlan) error.");
TEST_ASSERT_EQUAL_MESSAGE(pkt->l4_hdr, &OS_MTOD(m, uint8_t *)[38],
"l4_hdr(vlan) error.");
}
void
test_match_basic_IPV4_IP_ECN(void) {
struct lagopus_packet pkt;
struct port port;
struct flow *flow;
OS_MBUF *m;
bool rv;
/* prepare packet */
pkt.in_port = &port;
m = calloc(1, sizeof(*m));
TEST_ASSERT_NOT_NULL_MESSAGE(m, "calloc error.");
m->data = &m->dat[128];
OS_M_PKTLEN(m) = 64;
/* prepare flow */
flow = calloc(1, sizeof(struct flow) + 10 * sizeof(struct match));
TAILQ_INIT(&flow->match_list);
add_match(&flow->match_list, 2, OFPXMT_OFB_ETH_TYPE << 1,
0x08, 0x00);
refresh_match(flow);
m->data[12] = 0x08;
m->data[13] = 0x00;
m->data[14] = 0x45;
add_match(&flow->match_list, 1, OFPXMT_OFB_IP_ECN << 1,
0x3);
m->data[15] = 0xcc;
refresh_match(flow);
lagopus_packet_init(&pkt, m);
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, false,
"IP_ECN mismatch error.");
m->data[15] = 0x03;
rv = match_basic(&pkt, flow);
TEST_ASSERT_EQUAL_MESSAGE(rv, true,
"IP_ECN match error.");
}
void
test_set_field_IPV6_FLABEL(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet *pkt;
OS_MBUF *m;
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);
pkt = alloc_lagopus_packet();
TEST_ASSERT_NOT_NULL_MESSAGE(pkt, "lagopus_alloc_packet error.");
m = PKT2MBUF(pkt);
OS_M_APPEND(m, 64);
OS_MTOD(m, uint8_t *)[12] = 0x86;
OS_MTOD(m, uint8_t *)[13] = 0xdd;
OS_MTOD(m, uint8_t *)[14] = 0x6f;
lagopus_packet_init(pkt, m, &port);
set_match(action_set->field, 4, OFPXMT_OFB_IPV6_FLABEL << 1,
0x00, 0x0e, 0xab, 0xcd);
execute_action(pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[14], 0x6f,
"SET_FIELD IPV6_IPV6_FLABEL[0] error");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[15], 0x0e,
"SET_FIELD IPV6_IPV6_FLABEL[1] error");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[16], 0xab,
"SET_FIELD IPV6_IPV6_FLABEL[2] error");
TEST_ASSERT_EQUAL_MESSAGE(OS_MTOD(m, uint8_t *)[17], 0xcd,
"SET_FIELD IPV6_IPV6_FLABEL[3] error");
}
void
test_set_field_IPV6_FLABEL(void) {
struct port port;
struct action_list action_list;
struct action *action;
struct ofp_action_set_field *action_set;
struct lagopus_packet pkt;
OS_MBUF *m;
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];
OS_M_PKTLEN(m) = 64;
m->data[12] = 0x86;
m->data[13] = 0xdd;
m->data[14] = 0x6f;
lagopus_packet_init(&pkt, m, &port);
set_match(action_set->field, 4, OFPXMT_OFB_IPV6_FLABEL << 1,
0x00, 0x0e, 0xab, 0xcd);
execute_action(&pkt, &action_list);
TEST_ASSERT_EQUAL_MESSAGE(m->data[14], 0x6f,
"SET_FIELD IPV6_IPV6_FLABEL[0] error");
TEST_ASSERT_EQUAL_MESSAGE(m->data[15], 0x0e,
"SET_FIELD IPV6_IPV6_FLABEL[1] error");
TEST_ASSERT_EQUAL_MESSAGE(m->data[16], 0xab,
"SET_FIELD IPV6_IPV6_FLABEL[2] error");
TEST_ASSERT_EQUAL_MESSAGE(m->data[17], 0xcd,
"SET_FIELD IPV6_IPV6_FLABEL[3] error");
}
