void
test_channel_local_addr_get_set_unset(void) {
lagopus_result_t ret;
struct channel *channel;
struct addrunion addr = {0,{{0}}};
struct addrunion addr1 = {0,{{0}}};
channel = s_create_data_channel();
addrunion_ipv4_set(&addr, "127.0.0.1");
ret = channel_local_addr_set(channel, &addr);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_set() error.");
ret = channel_local_addr_get(channel, &addr1);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_get() error.");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&addr, &addr1, sizeof(addr),
"channel_local_addr_get() addr error");
ret = channel_local_addr_unset(channel);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_unset() error.");
ret = channel_local_addr_get(channel, &addr1);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_addr_get() error.");
addrunion_ipv4_set(&addr, "0.0.0.0");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&addr, &addr1, sizeof(addr),
"channel_local_addr_get() addr error");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_local_port_get_set_unset(void) {
uint16_t port;
lagopus_result_t ret;
struct channel *channel;
channel = s_create_data_channel();
ret = channel_local_port_set(channel, 10101);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_set() error.");
ret = channel_local_port_get(channel, &port);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(10101, port,
"channel_local_port_get() port error");
ret = channel_local_port_unset(channel);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_unset() error.");
ret = channel_local_port_get(channel, &port);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(0, port,
"channel_local_port_get() port error");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_proto_get_set_unset(void) {
lagopus_result_t ret;
struct channel *channel;
enum channel_protocol protocol;
channel = s_create_data_channel();
ret = channel_protocol_set(channel, PROTOCOL_TCP6);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_set() error.");
ret = channel_protocol_get(channel, &protocol);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(PROTOCOL_TCP6, protocol,
"channel_protocol_get() proto error");
ret = channel_protocol_unset(channel);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_unset() error.");
ret = channel_protocol_get(channel, &protocol);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(PROTOCOL_TCP, protocol,
"channel_protocol_get() proto error");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_xid_get_set(void) {
struct channel *channel;
uint32_t ret_xid;
uint32_t xid = 0x10;
channel = s_create_data_channel();
/* Call func. */
channel_xid_set(channel, xid);
ret_xid = channel_xid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_xid, xid,
"xid error.");
/* incrementation */
/* Call func. */
ret_xid = channel_xid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_xid, xid + 1,
"xid incrementation error.");
/* max */
/* Call func. */
channel_xid_set(channel, UINT32_MAX);
ret_xid = channel_xid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_xid, 100 /*START_XID*/,
"xid max error.");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_session_get_set(void) {
struct channel *channel;
lagopus_session_t session;
lagopus_session_t ret_session;
channel = s_create_data_channel();
(void) session_create(SESSION_TCP|SESSION_ACTIVE, &session);
TEST_ASSERT_NOT_EQUAL_MESSAGE(session, channel_session_get(channel),
"session error.");
session_destroy(channel_session_get(channel));
/* Call func. */
channel_session_set(channel, session);
ret_session = channel_session_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_session, session,
"session error.");
session_destroy(channel_session_get(channel));
free(channel);
}
struct channel *
create_data_channel(void) {
static uint8_t cnt;
char buf[256];
struct channel *channel;
struct session *session;
struct addrunion addr;
struct port port;
uint64_t dpid = 0xabc;
uint8_t port_hw_addr[OFP_ETH_ALEN] = {0xff, 0xff, 0xff,
0xff, 0xff, 0xff
};
if (s_dpmgr == NULL) {
s_dpmgr = dpmgr_alloc();
dpmgr_bridge_add(s_dpmgr, "br0", dpid);
dpmgr_controller_add(s_dpmgr, "br0", "127.0.0.1");
port.ofp_port.port_no = 0;
memcpy(port.ofp_port.hw_addr, port_hw_addr, OFP_ETH_ALEN);
port.ifindex = 0;
dpmgr_port_add(s_dpmgr, &port);
dpmgr_bridge_port_add(s_dpmgr, "br0", 0, 0);
}
if (s_bridge == NULL) {
s_bridge = dpmgr_bridge_lookup(s_dpmgr, "br0");
}
if (s_event_manager == NULL) {
s_event_manager = event_manager_alloc();
channel_mgr_initialize(s_event_manager);
}
snprintf(buf, sizeof(buf), "127.0.0.%u", cnt++);//XXX
addrunion_ipv4_set(&addr, buf);
channel_mgr_channel_add(s_bridge, dpid, &addr);
channel_mgr_channel_lookup(s_bridge, &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_channel_version_get_set(void) {
struct channel *channel;
uint8_t ret_version;
uint8_t version = 0x10;
channel = s_create_data_channel();
/* Call func. */
channel_version_set(channel, version);
ret_version = channel_version_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(ret_version, version,
"version error.");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_dpid_get_set(void) {
uint64_t dpid;
lagopus_result_t ret;
struct channel *channel;
channel = s_create_data_channel();
/* Call func. */
ret = channel_dpid_set(channel, 0xbeef);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_dpid_set() error.");
dpid = channel_dpid_get(channel);
TEST_ASSERT_EQUAL_MESSAGE(dpid, 0xbeef,
"dpid error.");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_auxiliary_get_set(void) {
bool is_auxiliary;
lagopus_result_t ret;
struct channel *channel;
channel = s_create_data_channel();
/* Call func. */
ret = channel_auxiliary_set(channel, true);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_auxiliary_set() error.");
ret = channel_auxiliary_get(channel, &is_auxiliary);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_auxiliary_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(is_auxiliary, true,
"auxiliary error.");
session_destroy(channel_session_get(channel));
free(channel);
}
void
test_channel_alloc_default_value(void) {
uint16_t port;
lagopus_result_t ret;
struct channel *channel;
enum channel_protocol protocol;
struct addrunion addr = {0,{{0}}};
struct addrunion addr1 = {0,{{0}}};
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&addr, &addr1, sizeof(addr),
"channel_addr_get() addr error");
channel = s_create_data_channel();
addrunion_ipv4_set(&addr1, "127.0.0.1");
ret = channel_port_get(channel, &port);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret, "channel_port_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(6633, port, "channel_port_get() port error");
ret = channel_local_port_get(channel, &port);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_local_port_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(0, port, "channel_local_port_get() port error");
ret = channel_protocol_get(channel, &protocol);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_protocol_get() error.");
TEST_ASSERT_EQUAL_MESSAGE(PROTOCOL_TCP, protocol,
"channel_protocol_get() proto error");
ret = channel_addr_get(channel, &addr);
TEST_ASSERT_EQUAL_MESSAGE(LAGOPUS_RESULT_OK, ret,
"channel_addr_get() error.");
TEST_ASSERT_EQUAL_MEMORY_MESSAGE(&addr1, &addr, sizeof(addr),
"channel_addr_get() addr error");
session_destroy(channel_session_get(channel));
free(channel);
}
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;
}
