int pfring_mod_stack_open(pfring *ring) {
int rc;
u_int32_t dummy = 0;
rc = pfring_mod_open(ring);
if (rc != 0)
return rc;
rc = setsockopt(ring->fd, 0, SO_SET_STACK_INJECTION_MODE, &dummy, sizeof(dummy));
if (rc != 0) {
pfring_close(ring);
return rc;
}
pfring_set_direction(ring, tx_only_direction);
pfring_set_socket_mode(ring, send_and_recv_mode);
/* Only send (inject) and recv (intercept tx) are supported, resetting unused func ptrs */
ring->set_direction = NULL;
ring->set_cluster = NULL;
ring->remove_from_cluster = NULL;
ring->set_master_id = NULL;
ring->set_master = NULL;
ring->enable_rss_rehash = NULL;
ring->set_virtual_device = NULL;
ring->add_hw_rule = NULL;
ring->remove_hw_rule = NULL;
ring->send_last_rx_packet = NULL;
return 0;
}
int frame_pfring(pfring *pd, struct frame_buf *f){
fbuf = f;
pfcount = 0;
packet_direction direction = rx_and_tx_direction;
int rc;
pfring_set_direction(pd, direction);
if((rc = pfring_set_socket_mode(pd, recv_only_mode)) != 0)
fprintf(stderr, "pfring_set_socket_mode returned [rc=%d]\n", rc);
pfring_set_application_stats(pd, "statistics not yet computed, please try again...\n");
if(pfring_enable_ring(pd) != 0){
fprintf(stderr, "unable to enable ring\n");
pfring_close(pd);
return -1;
}
printf("capture start...\n");
pfring_loop(pd, pf_dummy_packet, (u_char *)NULL, 1);
pfring_close(pd);
return 0;
}
long stream_pfring_open(struct stream** stptr, const struct ether_addr* addr, const char* iface, size_t buffer_size){
int ret = 0;
assert(stptr);
/* validate arguments */
if ( !(addr && iface) ){
return EINVAL;
}
/* get MTU for interface */
const int if_mtu = iface_mtu(iface);
if ( if_mtu < 0 ){
return errno;
}
pfring_config(99);
/* open pfring */
char* derp = strdup(iface);
pfring* pd = pfring_open(derp, 1, 9000, 0);
if ( !pd ){
return errno;
}
pfring_set_application_name(pd, "libcap_utils");
uint32_t version;
pfring_version(pd, &version);
fprintf(stderr, "Using PF_RING v.%d.%d.%d\n",
(version & 0xFFFF0000) >> 16,
(version & 0x0000FF00) >> 8,
version & 0x000000FF);
if((ret = pfring_set_direction(pd, rx_and_tx_direction)) != 0)
fprintf(stderr, "pfring_set_direction returned %d (perhaps you use a direction other than rx only with DNA ?)\n", ret);
if((ret = pfring_set_socket_mode(pd, recv_only_mode)) != 0)
fprintf(stderr, "pfring_set_socket_mode returned [rc=%d]\n", ret);
char bpfFilter[] = "ether proto 0x810";
ret = pfring_set_bpf_filter(pd, bpfFilter);
if ( ret != 0 ) {
fprintf(stderr, "pfring_set_bpf_filter(%s) returned %d\n", bpfFilter, ret);
} else {
fprintf(stderr, "Successfully set BPF filter '%s'\n", bpfFilter);
}
/* default buffer_size of 25*MTU */
if ( buffer_size == 0 ){
buffer_size = 250 * if_mtu;
}
/* ensure buffer is a multiple of MTU and can hold at least one frame */
if ( buffer_size < if_mtu ){
return ERROR_BUFFER_LENGTH;
} else if ( buffer_size % if_mtu != 0 ){
return ERROR_BUFFER_MULTIPLE;
}
/* additional memory for the frame pointers */
size_t frames = buffer_size / if_mtu;
size_t frame_offset = sizeof(char*) * frames;
buffer_size += frame_offset;
/* Initialize the structure */
if ( (ret = stream_alloc(stptr, PROTOCOL_ETHERNET_MULTICAST, sizeof(struct stream_pfring), buffer_size) != 0) ){
return ret;
}
struct stream_pfring* st = (struct stream_pfring*)*stptr;
st->pd = pd;
st->num_address = 0;
st->if_mtu = if_mtu;
memset(st->seqnum, 0, sizeof(long unsigned int) * MAX_ADDRESS);
if (pfring_enable_ring(pd) != 0) {
fprintf(stderr, "Unable to enable ring :-(\n");
pfring_close(pd);
return(-1);
}
/* setup buffer pointers (see brief overview at struct declaration) */
st->num_frames = frames;
st->num_packets = 0;
st->read_ptr = NULL;
st->base.readPos = 0;
st->base.writePos = 0;
for ( unsigned int i = 0; i < frames; i++ ){
st->frame[i] = st->base.buffer + frame_offset + i * if_mtu;
}
/* add membership to group */
if ( (ret=stream_pfring_add(&st->base, addr)) != 0 ){
return ret;
}
/*
if ( (ret=stream_pfring_init(stptr, addr, iface, ETH_P_ALL, buffer_size)) != 0 ){
return ret;
}
*/
st->base.type = PROTOCOL_ETHERNET_MULTICAST;
st->base.FH.comment_size = 0;
st->base.comment = NULL;
/* callbacks */
st->base.fill_buffer = NULL;
st->base.destroy = (destroy_callback)destroy;
st->base.write = NULL;
st->base.read = (read_callback)stream_pfring_read;
return 0;
}
static int pfring_daq_open(Pfring_Context_t *context, int id) {
uint32_t default_net = 0xFFFFFF00;
char *device = context->devices[id];
int pfring_rc;
pfring *ring_handle;
char buf[32];
if(!device) {
DPE(context->errbuf, "%s", "PF_RING a device must be specified");
return -1;
}
if(device) {
if(strncmp(device, "dna", 3) == 0) {
DPE(context->errbuf, "DNA is not supported by daq_pfring. Please get daq_pfring_dna from http://shop.ntop.org");
return(-1);
}
context->pkt_buffer = NULL;
ring_handle = pfring_open(device, context->snaplen,
PF_RING_LONG_HEADER
| (context->promisc_flag ? PF_RING_PROMISC : 0));
if(!ring_handle) {
DPE(context->errbuf, "pfring_open(): unable to open device '%s'. Please use -i <device>", device);
return -1;
}
}
pfring_get_bound_device_ifindex(ring_handle, &context->ifindexes[id]);
/* TODO this is because rules purging is not yet available with hw rules */
pfring_set_filtering_mode(ring_handle, software_only);
if (context->mode == DAQ_MODE_INLINE) {
/* Default mode: recv_and_send_mode */
pfring_set_direction(ring_handle, rx_only_direction);
} else if (context->mode == DAQ_MODE_PASSIVE) {
/* Default direction: rx_and_tx_direction */
if(context->num_reflector_devices > id) { /* lowlevelbridge ON */
filtering_rule rule;
memset(&rule, 0, sizeof(rule));
rule.rule_id = 1;
rule.rule_action = reflect_packet_and_continue_rule_evaluation;
snprintf(rule.reflector_device_name, REFLECTOR_NAME_LEN, "%s", context->reflector_devices[id]);
if(pfring_add_filtering_rule(ring_handle, &rule) < 0) {
DPE(context->errbuf, "unable to set the low level packet reflector %s -> %s", device, rule.reflector_device_name);
pfring_close(ring_handle);
return -1;
} else
printf("%s -> %s\n", context->devices[id], context->reflector_devices[id]);
pfring_set_direction(ring_handle, rx_only_direction);
}
pfring_set_socket_mode(ring_handle, recv_only_mode);
}
if(context->clusterids[id] > 0) {
pfring_rc = pfring_set_cluster(ring_handle, context->clusterids[id], context->cluster_mode);
if(pfring_rc != 0) {
DPE(context->errbuf, "pfring_set_cluster returned %d", pfring_rc);
pfring_close(ring_handle);
return -1;
}
snprintf(buf, sizeof(buf), "snort-cluster-%d-socket-%d", context->clusterids[id], id);
pfring_set_application_name(ring_handle, buf);
} else {
snprintf(buf, sizeof(buf), "snort-socket-%d", id);
pfring_set_application_name(ring_handle, buf);
}
pfring_set_poll_watermark(ring_handle, context->watermark);
context->netmask = htonl(default_net);
context->ring_handles[id] = ring_handle;
return(0);
}
int main(int argc, char* argv[]) {
pfring *a_ring, *b_ring;
char *a_dev = NULL, *b_dev = NULL, c;
u_int8_t verbose = 0, use_pfring_send = 0;
int a_ifindex, b_ifindex;
int bind_core = -1;
u_int16_t watermark = 1;
while((c = getopt(argc,argv, "ha:b:c:fvpg:w:")) != -1) {
switch(c) {
case 'h':
printHelp();
return 0;
break;
case 'a':
a_dev = strdup(optarg);
break;
case 'b':
b_dev = strdup(optarg);
break;
case 'p':
use_pfring_send = 1;
break;
case 'v':
verbose = 1;
break;
case 'g':
bind_core = atoi(optarg);
break;
case 'w':
watermark = atoi(optarg);
break;
}
}
if ((!a_dev) || (!b_dev)) {
printf("You must specify two devices!\n");
return -1;
}
if(strcmp(a_dev, b_dev) == 0) {
printf("Bridge devices must be different!\n");
return -1;
}
/* Device A */
if((a_ring = pfring_open(a_dev, MAX_PKT_LEN, PF_RING_PROMISC | PF_RING_LONG_HEADER |
(use_pfring_send ? 0 : PF_RING_RX_PACKET_BOUNCE))
) == NULL) {
printf("pfring_open error for %s [%s]\n", a_dev, strerror(errno));
return(-1);
}
pfring_set_application_name(a_ring, "pfbridge-a");
pfring_set_direction(a_ring, rx_only_direction);
pfring_set_socket_mode(a_ring, recv_only_mode);
pfring_set_poll_watermark(a_ring, watermark);
pfring_get_bound_device_ifindex(a_ring, &a_ifindex);
/* Device B */
if((b_ring = pfring_open(b_dev, MAX_PKT_LEN, PF_RING_PROMISC|PF_RING_LONG_HEADER)) == NULL) {
printf("pfring_open error for %s [%s]\n", b_dev, strerror(errno));
pfring_close(a_ring);
return(-1);
}
pfring_set_application_name(b_ring, "pfbridge-b");
pfring_set_socket_mode(b_ring, send_only_mode);
pfring_get_bound_device_ifindex(b_ring, &b_ifindex);
/* Enable Sockets */
if (pfring_enable_ring(a_ring) != 0) {
printf("Unable enabling ring 'a' :-(\n");
pfring_close(a_ring);
pfring_close(b_ring);
return(-1);
}
if(use_pfring_send) {
if (pfring_enable_ring(b_ring)) {
printf("Unable enabling ring 'b' :-(\n");
pfring_close(a_ring);
pfring_close(b_ring);
return(-1);
}
} else {
pfring_close(b_ring);
}
signal(SIGALRM, my_sigalarm);
alarm(1);
if(bind_core >= 0)
bind2core(bind_core);
while(1) {
u_char *buffer;
struct pfring_pkthdr hdr;
if(pfring_recv(a_ring, &buffer, 0, &hdr, 1) > 0) {
int rc;
if(use_pfring_send) {
rc = pfring_send(b_ring, (char *) buffer, hdr.caplen, 1);
if(rc < 0)
printf("pfring_send(caplen=%u <= mtu=%u?) error %d\n", hdr.caplen, b_ring->mtu_len, rc);
else if(verbose)
printf("Forwarded %d bytes packet\n", hdr.len);
} else {
rc = pfring_send_last_rx_packet(a_ring, b_ifindex);
if(rc < 0)
printf("pfring_send_last_rx_packet() error %d\n", rc);
else if(verbose)
printf("Forwarded %d bytes packet\n", hdr.len);
}
if(rc >= 0) num_sent++;
}
}
pfring_close(a_ring);
if(use_pfring_send) pfring_close(b_ring);
return(0);
}
int main(int argc, char* argv[]) {
char *device = NULL, c, *bind_mask = NULL;
int snaplen = DEFAULT_SNAPLEN, rc, watermark = 0, rehash_rss = 0;
packet_direction direction = rx_only_direction;
long i;
u_int16_t cpu_percentage = 0, poll_duration = 0;
u_int32_t version;
u_int32_t flags = 0;
startTime.tv_sec = 0;
thiszone = gmt2local(0);
numCPU = sysconf( _SC_NPROCESSORS_ONLN );
memset(thread_core_affinity, -1, sizeof(thread_core_affinity));
while((c = getopt(argc,argv,"hi:l:mvae:w:b:rp:g:")) != -1) {
switch(c) {
case 'h':
printHelp();
return(0);
break;
case 'a':
wait_for_packet = 0;
break;
case 'e':
switch(atoi(optarg)) {
case rx_and_tx_direction:
case rx_only_direction:
case tx_only_direction:
direction = atoi(optarg);
break;
}
break;
case 'l':
snaplen = atoi(optarg);
break;
case 'i':
device = strdup(optarg);
break;
case 'm':
use_extended_pkt_header = 1;
break;
case 'v':
verbose = 1;
break;
case 'w':
watermark = atoi(optarg);
break;
case 'b':
cpu_percentage = atoi(optarg);
break;
case 'r':
rehash_rss = 1;
break;
case 'p':
poll_duration = atoi(optarg);
break;
case 'g':
bind_mask = strdup(optarg);
break;
}
}
if(verbose) watermark = 1;
if(device == NULL) device = DEFAULT_DEVICE;
printf("Capturing from %s\n", device);
flags |= PF_RING_PROMISC; /* hardcode: promisc=1 */
#if 0
flags |= PF_RING_DNA_FIXED_RSS_Q_0;
#else
flags |= PF_RING_DNA_SYMMETRIC_RSS; /* Note that symmetric RSS is ignored by non-DNA drivers */
#endif
if(use_extended_pkt_header) flags |= PF_RING_LONG_HEADER;
num_channels = pfring_open_multichannel(device, snaplen, flags, ring);
if(num_channels <= 0) {
fprintf(stderr, "pfring_open_multichannel() returned %d [%s]\n", num_channels, strerror(errno));
return(-1);
}
if (num_channels > MAX_NUM_THREADS)
{
printf("WARNING: Too many channels (%d), using %d channels\n", num_channels, MAX_NUM_THREADS);
num_channels = MAX_NUM_THREADS;
}
else if (num_channels > numCPU)
{
printf("WARNING: More channels (%d) than available cores (%d), using %d channels\n", num_channels, numCPU, numCPU);
num_channels = numCPU;
}
else
{
printf("Found %d channels\n", num_channels);
}
if(bind_mask != NULL)
{
char *id = strtok(bind_mask, ":");
int idx = 0;
while(id != NULL) {
thread_core_affinity[idx++] = atoi(id) % numCPU;
if(idx >= num_channels) break;
id = strtok(NULL, ":");
}
}
pfring_version(ring[0], &version);
printf("Using PF_RING v.%d.%d.%d\n",
(version & 0xFFFF0000) >> 16,
(version & 0x0000FF00) >> 8,
version & 0x000000FF);
for(i=0; i<num_channels; i++)
{
char buf[32];
snprintf(buf, sizeof(buf), "pfcount_multichannel-thread %ld", i);
pfring_set_application_name(ring[i], buf);
if((rc = pfring_set_direction(ring[i], direction)) != 0)
fprintf(stderr, "pfring_set_direction returned %d [direction=%d] (you can't capture TX with DNA)\n", rc, direction);
if((rc = pfring_set_socket_mode(ring[i], recv_only_mode)) != 0)
fprintf(stderr, "pfring_set_socket_mode returned [rc=%d]\n", rc);
if(watermark > 0) {
if((rc = pfring_set_poll_watermark(ring[i], watermark)) != 0)
fprintf(stderr, "pfring_set_poll_watermark returned [rc=%d][watermark=%d]\n", rc, watermark);
}
#if 0
setup_steering(ring[0], "192.168.30.207", -1);
/* UTDF */
setup_steering(ring[0], "224.0.1.92", 1);
setup_steering(ring[0], "224.0.1.94", 1);
setup_steering(ring[0], "224.0.1.96", 1);
/* BATS */
setup_steering(ring[0], "224.0.62.2", 2);
/* default: should go to channel 0 */
#endif
if(rehash_rss)
pfring_enable_rss_rehash(ring[i]);
if(poll_duration > 0)
pfring_set_poll_duration(ring[i], poll_duration);
pfring_enable_ring(ring[i]);
pthread_create(&pd_thread[i], NULL, packet_consumer_thread, (void*)i);
usleep(500);
}
if(cpu_percentage > 0) {
if(cpu_percentage > 99) cpu_percentage = 99;
pfring_config(cpu_percentage);
}
signal(SIGINT, sigproc);
signal(SIGTERM, sigproc);
signal(SIGINT, sigproc);
if(!verbose) {
signal(SIGALRM, my_sigalarm);
alarm(ALARM_SLEEP);
}
for(i=0; i<num_channels; i++) {
pthread_join(pd_thread[i], NULL);
pfring_close(ring[i]);
}
return(0);
}
int main(int argc, char* argv[]) {
char c, *pcap_in = NULL, mac_address[6];
int promisc, i, verbose = 0, active_poll = 0, reforge_mac = 0;
u_int mac_a, mac_b, mac_c, mac_d, mac_e, mac_f;
char buffer[1500];
int send_len = 60;
u_int32_t num = 1;
int bind_core = -1;
u_int16_t cpu_percentage = 0;
double gbit_s = 0, td, pps;
ticks tick_start = 0, tick_delta = 0;
ticks hz = 0;
struct packet *tosend;
while((c = getopt(argc,argv,"hi:n:g:l:af:r:vm:"
#if 0
"b:"
#endif
)) != -1) {
switch(c) {
case 'h':
printHelp();
break;
case 'i':
in_dev = strdup(optarg);
break;
case 'f':
pcap_in = strdup(optarg);
break;
case 'n':
num = atoi(optarg);
break;
case 'g':
bind_core = atoi(optarg);
break;
case 'l':
send_len = atoi(optarg);
break;
case 'v':
verbose = 1;
break;
case 'a':
active_poll = 1;
break;
case 'r':
sscanf(optarg, "%lf", &gbit_s);
break;
#if 0
case 'b':
cpu_percentage = atoi(optarg);
#endif
break;
case 'm':
if(sscanf(optarg, "%02X:%02X:%02X:%02X:%02X:%02X", &mac_a, &mac_b, &mac_c, &mac_d, &mac_e, &mac_f) != 6) {
printf("Invalid MAC address format (XX:XX:XX:XX:XX:XX)\n");
return(0);
} else {
reforge_mac = 1;
mac_address[0] = mac_a, mac_address[1] = mac_b, mac_address[2] = mac_c;
mac_address[3] = mac_d, mac_address[4] = mac_e, mac_address[5] = mac_f;
}
break;
}
}
if(in_dev == NULL) printHelp();
printf("Sending packets on %s\n", in_dev);
/* hardcode: promisc=1, to_ms=500 */
promisc = 1;
pd = pfring_open(in_dev, promisc, 1500, 0);
if(pd == NULL) {
printf("pfring_open %s error\n", in_dev);
return(-1);
} else {
u_int32_t version;
pfring_set_application_name(pd, "pfdnasend");
pfring_version(pd, &version);
printf("Using PF_RING v.%d.%d.%d\n", (version & 0xFFFF0000) >> 16,
(version & 0x0000FF00) >> 8, version & 0x000000FF);
}
signal(SIGINT, sigproc);
signal(SIGTERM, sigproc);
signal(SIGINT, sigproc);
if(send_len < 60)
send_len = 60;
if(gbit_s > 0) {
/* cumputing usleep delay */
tick_start = getticks();
usleep(1);
tick_delta = getticks() - tick_start;
/* cumputing CPU freq */
tick_start = getticks();
usleep(1001);
hz = (getticks() - tick_start - tick_delta) * 1000 /*kHz -> Hz*/;
printf("Estimated CPU freq: %llu Hz\n", hz);
/* computing max rate */
pps = ((gbit_s * 1000000000) / 8 /*byte*/) / (8 /*Preamble*/ + send_len + 4 /*CRC*/ + 12 /*IFG*/);
td = (double)(hz / pps);
tick_delta = (ticks)td;
printf("Number of %d-byte Packet Per Second at %.2f Gbit/s: %.2f\n", (send_len + 4 /*CRC*/), gbit_s, pps);
}
if(pcap_in) {
char ebuf[256];
u_char *pkt;
struct pcap_pkthdr *h;
pcap_t *pt = pcap_open_offline(pcap_in, ebuf);
u_int num_pcap_pkts = 0;
if(pt) {
struct packet *last = NULL;
while(1) {
struct packet *p;
int rc = pcap_next_ex(pt, &h, (const u_char**)&pkt);
if(rc <= 0) break;
p = (struct packet*)malloc(sizeof(struct packet));
if(p) {
p->len = h->caplen;
p->next = NULL;
p->pkt = (char*)malloc(p->len);
if(p->pkt == NULL) {
printf("Not enough memory\n");
break;
} else {
memcpy(p->pkt, pkt, p->len);
if(reforge_mac) memcpy(p->pkt, mac_address, 6);
}
if(last) {
last->next = p;
last = p;
} else
pkt_head = p, last = p;
} else {
printf("Not enough memory\n");
break;
}
if(verbose)
printf("Read %d bytes packet from pcap file %s\n",
p->len, pcap_in);
num_pcap_pkts++;
} /* while */
pcap_close(pt);
printf("Read %d packets from pcap file %s\n",
num_pcap_pkts, pcap_in);
last->next = pkt_head; /* Loop */
num *= num_pcap_pkts;
} else {
printf("Unable to open file %s\n", pcap_in);
pfring_close(pd);
return(-1);
}
} else {
struct packet *p;
for(i=0; i<send_len; i++) buffer[i] = i;
if(reforge_mac) memcpy(buffer, mac_address, 6);
p = (struct packet*)malloc(sizeof(struct packet));
if(p) {
p->len = send_len;
p->next = p; /* Loop */
p->pkt = (char*)malloc(p->len);
memcpy(p->pkt, buffer, send_len);
pkt_head = p;
}
}
if(bind_core >= 0)
bind2core(bind_core);
if(wait_for_packet && (cpu_percentage > 0)) {
if(cpu_percentage > 99) cpu_percentage = 99;
pfring_config(cpu_percentage);
}
if(!verbose) {
signal(SIGALRM, my_sigalarm);
alarm(1);
}
gettimeofday(&startTime, NULL);
memcpy(&lastTime, &startTime, sizeof(startTime));
if(gbit_s > 0)
tick_start = getticks();
tosend = pkt_head;
i = 0;
pfring_set_direction(pd, tx_only_direction);
if(pfring_enable_ring(pd) != 0) {
printf("Unable to enable ring :-(\n");
pfring_close(pd);
return(-1);
}
while(!num || i < num) {
int rc;
redo:
rc = pfring_send(pd, tosend->pkt, tosend->len, 0 /* Don't flush (it does PF_RING automatically) */);
if(verbose)
printf("[%d] pfring_send(%d) returned %d\n", i, tosend->len, rc);
if(rc == -1) {
/* Not enough space in buffer */
if(gbit_s == 0) {
if(!active_poll) {
if(bind_core >= 0)
usleep(1);
else
pfring_poll(pd, 0);
}
} else {
/* Just waste some time */
while((getticks() - tick_start) < (num_pkt_good_sent * tick_delta)) ;
}
goto redo;
} else
num_pkt_good_sent++, num_bytes_good_sent += tosend->len+24 /* 8 Preamble + 4 CRC + 12 IFG */, tosend = tosend->next;
if(num > 0) i++;
} /* for */
print_stats(0);
pfring_close(pd);
return(0);
}
int main(int argc, char* argv[]) {
pfring *a_ring, *b_ring;
char *a_dev = NULL, *b_dev = NULL, c;
u_int8_t verbose = 0, use_pfring_send = 0;
int a_ifindex, b_ifindex;
while((c = getopt(argc,argv, "ha:b:c:fvp")) != -1) {
switch(c) {
case 'h':
printHelp();
return 0;
break;
case 'a':
a_dev = strdup(optarg);
break;
case 'b':
b_dev = strdup(optarg);
break;
case 'p':
use_pfring_send = 1;
break;
case 'v':
verbose = 1;
break;
}
}
if ((!a_dev) || (!b_dev)) {
printf("You must specify two devices!\n");
return -1;
}
if(strcmp(a_dev, b_dev) == 0) {
printf("Bridge devices must be different!\n");
return -1;
}
/* open devices */
if((a_ring = pfring_open(a_dev, 1500, PF_RING_PROMISC|PF_RING_LONG_HEADER)) == NULL) {
printf("pfring_open error for %s [%s]\n", a_dev, strerror(errno));
return(-1);
} else {
pfring_set_application_name(a_ring, "pfbridge-a");
pfring_set_direction(a_ring, rx_and_tx_direction);
pfring_get_bound_device_ifindex(a_ring, &a_ifindex);
}
if((b_ring = pfring_open(b_dev, 1500, PF_RING_PROMISC|PF_RING_LONG_HEADER)) == NULL) {
printf("pfring_open error for %s [%s]\n", b_dev, strerror(errno));
pfring_close(a_ring);
return(-1);
} else {
pfring_set_application_name(b_ring, "pfbridge-b");
pfring_set_direction(b_ring, rx_and_tx_direction);
pfring_get_bound_device_ifindex(b_ring, &b_ifindex);
}
/* Enable rings */
pfring_enable_ring(a_ring);
if(use_pfring_send)
pfring_enable_ring(b_ring);
else
pfring_close(b_ring);
signal(SIGALRM, my_sigalarm);
alarm(1);
while(1) {
u_char *buffer;
struct pfring_pkthdr hdr;
if(pfring_recv(a_ring, &buffer, 0, &hdr, 1) > 0) {
int rc;
if(use_pfring_send) {
rc = pfring_send(b_ring, (char*)buffer, hdr.caplen, 1);
if(rc < 0)
printf("pfring_send_last_rx_packet() error %d\n", rc);
else if(verbose)
printf("Forwarded %d bytes packet\n", hdr.len);
} else {
rc = pfring_send_last_rx_packet(a_ring, b_ifindex);
if(rc < 0)
printf("pfring_send_last_rx_packet() error %d\n", rc);
else if(verbose)
printf("Forwarded %d bytes packet\n", hdr.len);
}
if(rc >= 0) num_sent++;
}
}
pfring_close(a_ring);
if(use_pfring_send) pfring_close(b_ring);
return(0);
}
