static void do_init(char const* interface)
{
enum ef_pd_flags pd_flags = EF_PD_DEFAULT;
ef_filter_spec filter_spec;
struct pkt_buf* pb;
enum ef_vi_flags vi_flags = 0;
int i;
if( cfg_use_vf )
pd_flags |= EF_PD_VF;
if( cfg_phys_mode )
pd_flags |= EF_PD_PHYS_MODE;
if( cfg_disable_tx_push )
vi_flags |= EF_VI_TX_PUSH_DISABLE;
/* Allocate virtual interface. */
TRY(ef_driver_open(&driver_handle));
if ( cfg_use_vport ) {
TRY(ef_pd_alloc_with_vport(&pd, driver_handle, interface, pd_flags,
EF_PD_VLAN_NONE));
} else {
TRY(ef_pd_alloc_by_name(&pd, driver_handle, interface, pd_flags));
}
TRY(ef_vi_alloc_from_pd(&vi, driver_handle, &pd, driver_handle,
-1, -1, -1, NULL, -1, vi_flags));
ef_filter_spec_init(&filter_spec, EF_FILTER_FLAG_NONE);
TRY(ef_filter_spec_set_ip4_local(&filter_spec, IPPROTO_UDP,
sa_local.sin_addr.s_addr,
sa_local.sin_port));
TRY(ef_vi_filter_add(&vi, driver_handle, &filter_spec, &filter_cookie));
{
int bytes = N_BUFS * BUF_SIZE;
TEST(posix_memalign(&pkt_buf_mem, CI_PAGE_SIZE, bytes) == 0);
TRY(ef_memreg_alloc(&memreg, driver_handle, &pd, driver_handle, pkt_buf_mem,
bytes));
for( i = 0; i < N_BUFS; ++i ) {
pb = (void*) ((char*) pkt_buf_mem + i * BUF_SIZE);
pb->id = i;
pb->dma_buf_addr = ef_memreg_dma_addr(&memreg, i * BUF_SIZE);
pb->dma_buf_addr += MEMBER_OFFSET(struct pkt_buf, dma_buf);
pkt_bufs[i] = pb;
}
}
for( i = 0; i < N_RX_BUFS; ++i )
pkt_bufs[i]->dma_buf_addr += cfg_rx_align;
for( i = FIRST_TX_BUF; i < N_BUFS; ++i )
pkt_bufs[i]->dma_buf_addr += cfg_tx_align;
pb = pkt_bufs[FIRST_TX_BUF];
tx_frame_len = init_udp_pkt(pb->dma_buf + cfg_tx_align, cfg_payload_len);
}
static void do_init(int ifindex)
{
enum ef_pd_flags pd_flags = 0;
ef_filter_spec filter_spec;
struct pkt_buf* pb;
enum ef_vi_flags vi_flags = 0;
int i;
if( cfg_use_vf )
pd_flags |= EF_PD_VF;
if( cfg_phys_mode )
pd_flags |= EF_PD_PHYS_MODE;
if( cfg_disable_tx_push )
vi_flags |= EF_VI_TX_PUSH_DISABLE;
/* Allocate virtual interface. */
TRY(ef_driver_open(&driver_handle));
TRY(ef_pd_alloc(&pd, driver_handle, ifindex, pd_flags));
TRY(ef_vi_alloc_from_pd(&vi, driver_handle, &pd, driver_handle,
-1, -1, -1, NULL, -1, vi_flags));
#ifdef __x86_64__
TRY(ef_pio_alloc(&pio, driver_handle, &pd, -1, driver_handle));
TRY(ef_pio_link_vi(&pio, driver_handle, &vi, driver_handle));
#else
/* PIO is only available on x86_64 systems */
TEST(0);
#endif
ef_filter_spec_init(&filter_spec, EF_FILTER_FLAG_NONE);
TRY(ef_filter_spec_set_ip4_local(&filter_spec, IPPROTO_UDP,
sa_local.sin_addr.s_addr,
sa_local.sin_port));
TRY(ef_vi_filter_add(&vi, driver_handle, &filter_spec, NULL));
{
int bytes = (N_RX_BUFS + 1) * RX_BUF_SIZE;
void* p;
TEST(posix_memalign(&p, 4096, bytes) == 0);
TRY(ef_memreg_alloc(&memreg, driver_handle, &pd, driver_handle, p, bytes));
for( i = 0; i <= N_RX_BUFS; ++i ) {
pkt_bufs[i] = (void*) ((char*) p + i * RX_BUF_SIZE);
pkt_bufs[i]->dma_buf_addr = ef_memreg_dma_addr(&memreg, i * RX_BUF_SIZE);
}
}
for( i = 0; i <= N_RX_BUFS; ++i ) {
pb = pkt_bufs[i];
pb->id = i;
pb->dma_buf_addr += MEMBER_OFFSET(struct pkt_buf, dma_buf);
}
init_udp_pkt(pkt_bufs[N_RX_BUFS]->dma_buf, cfg_payload_len);
tx_frame_len = cfg_payload_len + header_size();
}
static int sc_stream_add(struct sc_stream* s, void* vi_or_set,
ef_driver_handle dh, ef_filter_cookie *cookie_out)
{
ef_filter_spec spec;
ef_filter_spec_init(&spec, EF_FILTER_FLAG_NONE);
switch( s->fields ) {
case SC_SF_ALL:
TRY(ef_filter_spec_set_unicast_all(&spec));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
ef_filter_spec_init(&spec, EF_FILTER_FLAG_NONE);
TRY(ef_filter_spec_set_multicast_all(&spec));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
break;
case SC_SF_SNIFF:
TRY(ef_filter_spec_set_port_sniff(&spec, s->promiscuous));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
break;
case SC_SF_ETH_DHOST:
TRY(ef_filter_spec_set_eth_local(&spec, EF_FILTER_VLAN_ID_ANY,
s->eth_dhost));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
break;
case SC_SF_ETH_DHOST | SC_SF_ETH_VLAN_ID:
TRY(ef_filter_spec_set_eth_local(&spec, s->eth_vlan_id, s->eth_dhost));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
break;
case SC_SF_ETH_TYPE | SC_SF_IP4_PROTOCOL | SC_SF_IP4_DEST_ADDR |
SC_SF_IP4_DEST_PORT:
TRY(ef_filter_spec_set_ip4_local(&spec, s->ip4_protocol,
s->ip4_dest_addr, s->ip4_dest_port));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
break;
case SC_SF_ETH_TYPE | SC_SF_IP4_PROTOCOL | SC_SF_IP4_DEST_ADDR |
SC_SF_IP4_DEST_PORT | SC_SF_IP4_SOURCE_ADDR | SC_SF_IP4_SOURCE_PORT:
TRY(ef_filter_spec_set_ip4_full(&spec, s->ip4_protocol,
s->ip4_dest_addr, s->ip4_dest_port,
s->ip4_source_addr, s->ip4_source_port));
TRY(ef_vi_set_filter_add(vi_or_set, dh, &spec, cookie_out));
break;
default:
fprintf(stderr, "ERROR: sc_vi[_set]_add_stream_string: "
"unsupported combination of fields (0x%x)\n", s->fields);
return -EINVAL;
}
return 0;
}
int filter_parse(ef_filter_spec* fs, const char* s_in)
{
struct sockaddr_in lsin, rsin;
const char* type;
const char* hostport;
char* vlan;
char* remainder;
char *s;
int rc = -EINVAL;
int protocol;
int i;
ef_filter_spec_init(fs, EF_FILTER_FLAG_NONE);
s = strdup(s_in);
if( (type = strtok(s, ":")) == NULL )
goto out;
if( ! strcmp("udp", type) || ! strcmp("tcp", type) ) {
protocol = strcasecmp(type, "tcp") ? IPPROTO_UDP : IPPROTO_TCP;
remainder = strtok(NULL, "");
if( ! strncmp("mcastloop-rx,", remainder, strlen("mcastloop-rx,")) ) {
ef_filter_spec_init(fs, EF_FILTER_FLAG_MCAST_LOOP_RECEIVE);
strtok(remainder, ",");
remainder = strtok(NULL, "");
}
if( ! strncmp("vid=", remainder, strlen("vid=")) ) {
vlan = strtok(remainder, ",");
remainder = strtok(NULL, "");
if( ! vlan )
goto out;
vlan = strchr(vlan, '=');
++vlan;
TRY(ef_filter_spec_set_vlan(fs, atoi(vlan)));
}
if( strchr(remainder, ',') ) {
hostport = strtok(remainder, ",");
remainder = strtok(NULL, "");
TRY(hostport_parse(&lsin, hostport));
TRY(hostport_parse(&rsin, remainder));
TRY(ef_filter_spec_set_ip4_full(fs, protocol, lsin.sin_addr.s_addr,
lsin.sin_port, rsin.sin_addr.s_addr,
rsin.sin_port));
rc = 0;
}
else {
TRY(hostport_parse(&lsin, strtok(remainder, ",")));
TRY(ef_filter_spec_set_ip4_local(fs, protocol, lsin.sin_addr.s_addr,
lsin.sin_port));
rc = 0;
}
}
else if( ! strcmp("eth", type) ) {
uint8_t mac[6];
int vlan_id = EF_FILTER_VLAN_ID_ANY;
vlan = strtok(NULL, ",");
remainder = strtok(NULL, "");
if( remainder == '\0' ) /* No vlan */
remainder = vlan;
else {
if( strncmp("vid=", vlan, strlen("vid=")) )
goto out;
vlan = strchr(vlan, '=');
++vlan;
vlan_id = atoi(vlan);
}
for( i = 0; i < 6; ++i ) {
mac[i] = strtol(remainder, &remainder, 16);
if( i != 5 ) {
if( *remainder != ':' )
goto out;
++remainder;
if( ! strlen(remainder) )
goto out;
}
}
if( strlen(remainder) )
goto out;
TRY(ef_filter_spec_set_eth_local(fs, vlan_id, mac));
rc = 0;
}
else if( ! strcmp("multicast-all", type) ) {
if( strlen(type) != strlen(s_in) )
goto out;
TRY(ef_filter_spec_set_multicast_all(fs));
rc = 0;
}
else if( ! strcmp("unicast-all", type) ) {
if( strlen(type) != strlen(s_in) )
goto out;
TRY(ef_filter_spec_set_unicast_all(fs));
rc = 0;
}
else if( ! strcmp("multicast-mis", type) ) {
TRY(ef_filter_spec_set_multicast_mismatch(fs));
if( strlen(type) != strlen(s_in) ) {
remainder = strtok(NULL, "");
if( ! (vlan = strchr(remainder, '=')) )
goto out;
++vlan;
TRY(ef_filter_spec_set_vlan(fs, atoi(vlan)));
}
rc = 0;
}
else if( ! strcmp("unicast-mis", type) ) {
TRY(ef_filter_spec_set_unicast_mismatch(fs));
if( strlen(type) != strlen(s_in) ) {
remainder = strtok(NULL, "");
if( ! (vlan = strchr(remainder, '=')) )
goto out;
++vlan;
TRY(ef_filter_spec_set_vlan(fs, atoi(vlan)));
}
rc = 0;
}
else if( ! strcmp("sniff", type) ) {
if( strlen(type) == strlen(s_in) ) {
TRY(ef_filter_spec_set_port_sniff(fs, 1));
}
else {
remainder = strtok(NULL, "");
if( ! strcmp("promisc", remainder) )
TRY(ef_filter_spec_set_port_sniff(fs, 1));
else if( ! strcmp("no-promisc", remainder) )
TRY(ef_filter_spec_set_port_sniff(fs, 0));
else
TRY(-EINVAL);
}
rc = 0;
}
else if( ! strcmp("tx-sniff", type) ) {
TRY(ef_filter_spec_set_tx_port_sniff(fs));
rc = 0;
}
else if( ! strcmp("block-kernel", type) ) {
TRY(ef_filter_spec_set_block_kernel(fs));
rc = 0;
}
else if( ! strcmp("block-kernel-unicast", type) ) {
TRY(ef_filter_spec_set_block_kernel_unicast(fs));
rc = 0;
}
else if( ! strcmp("block-kernel-multicast", type) ) {
TRY(ef_filter_spec_set_block_kernel_multicast(fs));
rc = 0;
}
out:
free(s);
return rc;
}
