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); }
static int controller_func_internal(const char *bridge_str, const char *controller_str, uint16_t type, lagopus_result_t (*func)(struct bridge *, uint64_t dpid, struct addrunion *)) { struct bridge *bridge; struct addrunion addr; lagopus_result_t result; uint64_t dpid = 0x00; /* Lookup bridge. */ bridge = dpmgr_bridge_lookup(dpmgr, bridge_str); if (! bridge) { return CONFIG_FAILURE; } result = dpmgr_bridge_dpid_lookup(dpmgr, bridge_str, &dpid); if (result != LAGOPUS_RESULT_OK ) { return CONFIG_FAILURE; } addrunion_ipv4_set(&addr, controller_str); if (type == CONFSYS_MSG_TYPE_SET) { struct channel *chan; /* Add controller to dpmgr. */ dpmgr_controller_add(dpmgr, bridge_str, controller_str); /* Register channel to dpmgr. */ result = func(bridge, dpid, &addr); if (result != LAGOPUS_RESULT_OK) { lagopus_perror(result); return CONFIG_FAILURE; } /* Lookup channel from channel mgr and return. */ result = channel_mgr_channel_lookup(bridge, &addr, &chan); if (result != LAGOPUS_RESULT_OK) { lagopus_perror(result); return CONFIG_FAILURE; } } else if (type == CONFSYS_MSG_TYPE_UNSET) { /* Delete controller from dpmgr. */ dpmgr_controller_delete(dpmgr, bridge_str, controller_str); /* Remove channel from channel mgr. */ result = channel_mgr_channel_delete(bridge, &addr); if (result != LAGOPUS_RESULT_OK) { lagopus_perror(result); return CONFIG_FAILURE; } } return CONFIG_SUCCESS; }
void setUp(void) { size_t s; struct addrunion au; uint8_t *p; /* Make the root flowinfo. */ TEST_ASSERT_NULL(flowinfo); flowinfo = new_flowinfo_vlan_vid(); TEST_ASSERT_NOT_NULL(flowinfo); TEST_ASSERT_FLOWINFO_FLOW_NUM(flowinfo, 0, __func__); /* * Make the test flows. * * ARP matches have the prerequisite. */ for (s = 0; s < ARRAY_LEN(test_flow); s++) { TEST_ASSERT_NULL(test_flow[s]); test_flow[s] = allocate_test_flow(10 * sizeof(struct match)); TEST_ASSERT_NOT_NULL(test_flow[s]); test_flow[s]->priority = (int)s; FLOW_ADD_ARP_PREREQUISITE(test_flow[s]); } /* Make the test addresses. */ for (s = 0; s < ARRAY_LEN(test_flow); s++) { addrunion_ipv4_set(&au, ipv4srcstr); p = (uint8_t *)&au.addr4.s_addr; p[sizeof(au.addr4.s_addr) - 1] = (uint8_t)(TEST_IPV4_ADDR_LSB(s) & 0xff); OS_MEMCPY(&ipv4src[s], &au.addr4, sizeof(ipv4src[s])); addrunion_ipv4_set(&au, ipv4tgtstr); p = (uint8_t *)&au.addr4.s_addr; p[sizeof(au.addr4.s_addr) - 1] = (uint8_t)(TEST_IPV4_ADDR_LSB(s) & 0xff); OS_MEMCPY(&ipv4tgt[s], &au.addr4, sizeof(ipv4tgt[s])); addrunion_ipv4_set(&au, ipv4maskstr); OS_MEMCPY(&ipv4mask[s], &au.addr4, sizeof(ipv4mask[s])); } }
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; }
struct channel * s_create_data_channel(void) { uint64_t dpid = 0x01; struct channel *channel; lagopus_session_t session; struct addrunion addr = {0,{{0}}}; addrunion_ipv4_set(&addr, "127.0.0.1"); channel = channel_alloc(&addr, dpid); (void) session_create(SESSION_TCP|SESSION_ACTIVE, &session); session_write_set(session, write_tcp); channel_version_set(channel, 0x04); channel_session_set(channel, session); channel_xid_set(channel, 0x10); return 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); }
void test_session_tcp(void) { lagopus_result_t ret; char cbuf[256] = {0}; char sbuf[256] = {0}; bool b; lagopus_session_t sesc, sess, sesa, sesp[3]; struct addrunion dst, src; ret = session_create(SESSION_TCP|SESSION_PASSIVE, &sess); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); addrunion_ipv4_set(&src, "0.0.0.0"); ret = session_bind(sess, &src, 10022); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = session_create(SESSION_TCP|SESSION_ACTIVE, &sesc); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); addrunion_ipv4_set(&dst, "127.0.0.1"); ret = session_connect(sesc, &dst, 10022, NULL, 0); if (ret == 0 || errno == EINPROGRESS) { TEST_ASSERT(true); } else { TEST_ASSERT(false); } session_write_event_set(sesc); session_read_event_set(sess); sesp[0] = sesc; sesp[1] = sess; ret = session_poll(sesp, 2, 1); TEST_ASSERT_EQUAL(2, ret); ret = session_is_writable(sesc, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_TRUE(b); ret = session_is_readable(sess, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_TRUE(b); ret = session_accept(sess, &sesa); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_NOT_NULL(sesa); TEST_ASSERT_TRUE(session_is_alive(sess)); TEST_ASSERT_TRUE(session_is_alive(sesc)); TEST_ASSERT_TRUE(session_is_alive(sesa)); session_write_event_set(sesc); session_read_event_set(sess); session_read_event_set(sesa); sesp[0] = sesc; sesp[1] = sess; sesp[2] = sesa; ret = session_poll(sesp, 3, 1); TEST_ASSERT_EQUAL(1, ret); ret = session_is_writable(sesc, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_TRUE(b); ret = session_is_readable(sess, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_FALSE(b); ret = session_is_readable(sesa, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_FALSE(b); snprintf(cbuf, sizeof(cbuf), "hogehoge\n"); ret = session_write(sesc, cbuf, strlen(cbuf)); TEST_ASSERT_EQUAL(ret, strlen(cbuf)); session_read_event_set(sesa); sesp[0] = sesa; ret = session_poll(sesp, 1, 1); TEST_ASSERT_EQUAL(1, ret); ret = session_is_readable(sesa, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_TRUE(b); ret = session_read(sesa, sbuf, sizeof(sbuf)); TEST_ASSERT_EQUAL(ret, strlen(sbuf)); ret = session_write(sesa, sbuf, strlen(sbuf)); TEST_ASSERT_EQUAL(ret, strlen(sbuf)); ret = session_read(sesc, cbuf, sizeof(cbuf)); TEST_ASSERT_EQUAL(ret, strlen(cbuf)); session_close(sesc); TEST_ASSERT_FALSE(session_is_alive(sesc)); session_close(sesa); TEST_ASSERT_FALSE(session_is_alive(sesa)); session_close(sess); TEST_ASSERT_FALSE(session_is_alive(sesa)); session_write_event_set(sesc); session_read_event_set(sess); session_read_event_set(sesa); sesp[0] = sesc; sesp[1] = sess; sesp[2] = sesa; ret = session_poll(sesp, 3, 1); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_TIMEDOUT, ret); ret = session_is_writable(sesc, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_FALSE(b); ret = session_is_readable(sess, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_FALSE(b); ret = session_is_readable(sesa, &b); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_FALSE(b); session_destroy(sesc); session_destroy(sesa); session_destroy(sess); }
void test_session_fgets(void) { ssize_t ret; char *c; #if 0 char cbuf[256] = {0}; #endif char sbuf[256] = {0}; lagopus_session_t sesc, sess, sesa, sesp[1]; struct addrunion dst, src; ret = session_create(SESSION_TCP|SESSION_PASSIVE, &sess); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); addrunion_ipv4_set(&src, "0.0.0.0"); ret = session_bind(sess, &src, 10022); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = session_create(SESSION_TCP|SESSION_ACTIVE, &sesc); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); addrunion_ipv4_set(&dst, "127.0.0.1"); ret = session_connect(sesc, &dst, 10022, NULL, 0); if (ret == 0 || errno == EINPROGRESS) { TEST_ASSERT(true); } else { TEST_ASSERT(false); } ret = session_accept(sess, &sesa); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_NOT_NULL(sesa); TEST_ASSERT_TRUE(session_is_alive(sess)); TEST_ASSERT_TRUE(session_is_alive(sesc)); TEST_ASSERT_TRUE(session_is_alive(sesa)); ret = session_printf(sesc, "%s", "hogehoge\n\nhoge"); TEST_ASSERT_EQUAL(ret, strlen("hogehoge\n\nhoge")); session_read_event_set(sesa); sesp[0] = sesa; ret = session_poll(sesp, 1, 1); TEST_ASSERT_EQUAL(ret, 1); c = session_fgets(sbuf, 5, sesa); fprintf(stderr, "1.%s\n", sbuf); TEST_ASSERT_NOT_NULL(c); TEST_ASSERT_EQUAL(0, strncmp(sbuf, "hoge", 5)); c = session_fgets(sbuf, 10, sesa); fprintf(stderr, "2.%s\n", sbuf); TEST_ASSERT_NOT_NULL(c); TEST_ASSERT_EQUAL(0, strncmp(sbuf, "hoge\n", 5)); c = session_fgets(sbuf, 10, sesa); fprintf(stderr, "3.%s\n", sbuf); TEST_ASSERT_NOT_NULL(c); TEST_ASSERT_EQUAL(0, strncmp(sbuf, "\n", 1)); c = session_fgets(sbuf, 5, sesa); fprintf(stderr, "4.%s\n", sbuf); TEST_ASSERT_NOT_NULL(c); TEST_ASSERT_EQUAL(0, strncmp(sbuf, "hoge", 5)); #if 0 do { fprintf(stderr, "out:%s", sbuf); fgets(cbuf, sizeof(cbuf), stdin); fprintf(stderr, "in :%s", cbuf); session_write(sesc, cbuf, strlen(cbuf)); } while (session_fgets(sbuf, sizeof(sbuf), sesa) != NULL); #endif session_close(sesc); TEST_ASSERT_FALSE(session_is_alive(sesc)); session_close(sesa); TEST_ASSERT_FALSE(session_is_alive(sesa)); session_close(sess); TEST_ASSERT_FALSE(session_is_alive(sesa)); session_destroy(sesc); session_destroy(sesa); session_destroy(sess); }
void test_session_tls(void) { #if 0 /* this test code is not work, use openssl s_server/s_client commands for tls session tests. */ lagopus_result_t ret; char cbuf[256] = {0}; char sbuf[256] = {0}; lagopus_session_t sesc, sess, sesa; struct addrunion src, dst; session_tls_set_ca_dir("ca"); session_tls_set_server_cert("./server1.pem"); session_tls_set_server_key("./server1_key_nopass.pem"); session_tls_set_client_key("./client1_key_nopass.pem"); ret = session_create(SESSION_TCP|SESSION_PASSIVE|SESSION_TLS, &sess); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); addrunion_ipv4_set(&src, "0.0.0.0"); ret = session_bind(sess, &src, 10024); addrunion_ipv4_set(&dst, "127.0.0.1"); ret = session_create(SESSION_TCP|SESSION_TLS|SESSION_ACTIVE, &sesc); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = session_connect(sesc, &dst, 10024, &dst, 0); if (ret == 0 || errno == EINPROGRESS) { TEST_ASSERT(true); } else { TEST_ASSERT(false); } ret = session_accept(sess, &sesa); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_NOT_NULL(sesa); TEST_ASSERT_TRUE(session_is_alive(sess)); TEST_ASSERT_TRUE(session_is_alive(sesa)); ret = session_read(sesa, sbuf, sizeof(sbuf)); TEST_ASSERT_EQUAL(ret, strlen(sbuf)); ret = session_write(sesa, sbuf, strlen(sbuf)); TEST_ASSERT_EQUAL(ret, strlen(sbuf)); TEST_ASSERT_TRUE(session_is_alive(sesc)); snprintf(cbuf, sizeof(cbuf), "hogehoge\n"); ret = session_write(sesc, cbuf, strlen(cbuf)); TEST_ASSERT_EQUAL(ret, strlen(cbuf)); ret = session_read(sesa, sbuf, sizeof(sbuf)); TEST_ASSERT_EQUAL(ret, strlen(sbuf)); ret = session_write(sesa, sbuf, strlen(sbuf)); TEST_ASSERT_EQUAL(ret, strlen(sbuf)); ret = session_read(sesc, cbuf, sizeof(cbuf)); TEST_ASSERT_EQUAL(ret, strlen(cbuf)); session_destroy(sesc); session_destroy(sesa); session_destroy(sess); #endif }
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_channel_tcp(void) { int sock4, sock6; socklen_t size; struct sockaddr_in sin; struct addrunion addr4, addr6; struct channel_list *chan_list ; struct channel *chan4, *chan6, *chan = NULL; lagopus_result_t ret; int cnt; printf("test_channel_tcp in\n"); channel_mgr_initialize(); ret = channel_mgr_channels_lookup_by_dpid(dpid, &chan_list ); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); TEST_ASSERT_EQUAL(NULL, chan_list ); addrunion_ipv4_set(&addr4, "127.0.0.1"); addrunion_ipv6_set(&addr6, "::1"); ret = channel_mgr_channel_add(bridge_name, dpid, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_add(bridge_name, dpid, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_add(bridge_name, dpid, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ALREADY_EXISTS, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr4, &chan4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_EQUAL(0, channel_id_get(chan4)); ret = channel_port_set(chan4, 10022); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_port_set(chan4, 20022); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_addr_set(chan4, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_add(bridge_name, dpid, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_ALREADY_EXISTS, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr6, &chan6); TEST_ASSERT_EQUAL(1, channel_id_get(chan6)); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_port_set(chan6, 10023); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_port_set(chan6, 20023); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_local_addr_set(chan6, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_lookup_by_channel_id(dpid, 1, &chan); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_NOT_EQUAL(NULL, chan); ret = channel_mgr_channel_lookup_by_channel_id(dpid, 9999, &chan); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); TEST_ASSERT_EQUAL(NULL, chan); cnt = 0; ret = channel_mgr_channels_lookup_by_dpid(dpid, &chan_list ); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_list_iterate(chan_list , channel_count, &cnt); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_EQUAL(2, cnt); cnt = 0; ret = channel_mgr_dpid_iterate(dpid, channel_count, &cnt); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); TEST_ASSERT_EQUAL(2, cnt); run = true; size = sizeof(sin); printf("accept in\n"); sock4 = accept(s4, (struct sockaddr *)&sin, &size); TEST_ASSERT_NOT_EQUAL(-1, sock4); sock6 = accept(s6, (struct sockaddr *)&sin, &size); TEST_ASSERT_NOT_EQUAL(-1, sock6); ret = channel_mgr_channel_lookup(bridge_name, &addr4, &chan4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); channel_refs_get(chan4); ret = channel_mgr_channel_delete(bridge_name, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); channel_refs_put(chan4); ret = channel_mgr_channel_delete(bridge_name, &addr4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr4, &chan4); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); ret = channel_mgr_channel_delete(bridge_name, &addr6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); ret = channel_mgr_channel_lookup(bridge_name, &addr6, &chan6); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret); TEST_ASSERT_FALSE(channel_mgr_has_alive_channel_by_dpid(dpid)); ret = channel_mgr_event_upcall(); TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret); close(sock4); close(sock6); }