/// Creation function for uptime counters.
naming::gid_type uptime_counter_creator(counter_info const& info,
error_code& ec)
{
switch (info.type_) {
case counter_elapsed_time:
{
// verify the validity of the counter instance name
counter_path_elements paths;
get_counter_path_elements(info.fullname_, paths, ec);
if (ec) return naming::invalid_gid;
// allowed counter names: /runtime(locality#%d/*)/uptime
if (paths.parentinstance_is_basename_) {
HPX_THROWS_IF(ec, bad_parameter, "uptime_counter_creator",
"invalid counter instance parent name: " +
paths.parentinstancename_);
return naming::invalid_gid;
}
// create the counter
return create_counter(info, ec);
}
default:
HPX_THROWS_IF(ec, bad_parameter, "uptime_counter_creator",
"invalid counter type requested");
return naming::invalid_gid;
}
}
static void open_counters(int cpu, pid_t pid)
{
int counter;
group_fd = -1;
for (counter = 0; counter < nr_counters; counter++)
create_counter(counter, cpu, pid);
nr_cpu++;
}
int
ether_out(unsigned char *dst_mac, char *src_mac, uint16_t ether_type, struct rte_mbuf *mbuf)
{
int i = 0;
struct ether_hdr *eth;
eth = (struct ether_hdr *)rte_pktmbuf_prepend (mbuf, sizeof(struct ether_hdr));
eth->ether_type = htons(ether_type);
for(i=0;i<6;i++) {
eth->d_addr.addr_bytes[i] = dst_mac[i];
}
// for(i=0;i<6;i++) {
eth->s_addr.addr_bytes[0] = 0x6a;
eth->s_addr.addr_bytes[1] = 0x9c;
eth->s_addr.addr_bytes[2] = 0xba;
eth->s_addr.addr_bytes[3] = 0xa0;
eth->s_addr.addr_bytes[4] = 0x96;
eth->s_addr.addr_bytes[5] = 0x24;
// }
// fix this this should be automatically detect the network interface id.
send_packet_out(mbuf, 0);
static int counter_id = -1;
if(counter_id == -1) {
counter_id = create_counter("sent_rate");
}
int data_len = rte_pktmbuf_data_len(mbuf);
counter_abs(counter_id, data_len);
{
static int counter_id = -1;
if(counter_id == -1) {
counter_id = create_counter("wire_sent");
}
int data_len = rte_pktmbuf_data_len(mbuf);
counter_inc(counter_id, data_len);
}
(void) src_mac; // jusat to avoid warning
src_mac = NULL;
return 0;
}
void sendtcpdata(struct tcb *ptcb, unsigned char *data, int len)
{
printf("Sending tcp data\n");
static int counter_id = -1;
if(counter_id == -1) {
counter_id = create_counter("tcp_sent");
}
counter_inc(counter_id, len);
//uint8_t tcp_len = 0x50 + add_mss_option(mbuf, 1300);// + add_winscale_option(mbuf, 7);
struct rte_mbuf *mbuf = get_mbuf(); // remove mbuf from parameters.
uint8_t data_len = add_tcp_data(mbuf, data, len);
uint8_t option_len = 0;//add_winscale_option(mbuf, 7) + add_mss_option(mbuf, 1300) + add_timestamp_option(mbuf, 203032, 0);
uint8_t tcp_len = 20 + option_len;
uint8_t pad = (tcp_len%4) ? 4 - (tcp_len % 4): 0;
tcp_len += pad;
logger(LOG_TCP, NORMAL, "padding option %d for tcb %u\n", pad, ptcb->identifier);
char *nop = rte_pktmbuf_prepend (mbuf, pad); // always pad the option to make total size multiple of 4.
memset(nop, 0, pad);
tcp_len = (tcp_len + 3) / 4; // len is in multiple of 4 bytes; 20 will be 5
tcp_len = tcp_len << 4; // len has upper 4 bits position in tcp header.
logger(LOG_TCP, NORMAL, "sending tcp data of len %d total %d for tcb %u\n", data_len, tcp_len, ptcb->identifier);
struct tcp_hdr *ptcphdr = (struct tcp_hdr *)rte_pktmbuf_prepend (mbuf, sizeof(struct tcp_hdr));
// printf("head room2 = %d\n", rte_pktmbuf_headroom(mbuf));
if(ptcphdr == NULL) {
// printf("tcp header is null\n");
}
ptcphdr->src_port = htons(ptcb->dport);
ptcphdr->dst_port = htons(ptcb->sport);
ptcphdr->sent_seq = htonl(ptcb->next_seq);
ptcb->next_seq += data_len;
if(((ptcb->tcp_flags & TCP_FLAG_SYN) == TCP_FLAG_SYN) || ((ptcb->tcp_flags & TCP_FLAG_FIN) == TCP_FLAG_FIN)) {
logger(LOG_TCP, NORMAL, "Increasing seq number by one for flag syn or fin for tcb %u\n", ptcb->identifier);
ptcb->next_seq += 1;
}
logger(LOG_TCP, LOG_LEVEL_NORMAL, "Next seq number is %u flags %u for tcb %u\n", ptcb->next_seq, ptcb->tcp_flags, ptcb->identifier);
ptcphdr->recv_ack = htonl(ptcb->ack);
ptcphdr->data_off = tcp_len;
ptcphdr->tcp_flags = ptcb->tcp_flags;
ptcphdr->rx_win = 12000;
ptcphdr->cksum = 0x0000;
ptcphdr->tcp_urp = 0;
ptcb->tcp_flags = 0; //reset the flags as we have sent them in packet now.
//mbuf->ol_flags |= PKT_TX_IP_CKSUM; // someday will calclate checkum here only.
// printf(" null\n");
// fflush(stdout);
logger(LOG_TCP, NORMAL, "[SENDING TCP PACKET] sending tcp packet seq %u ack %u and datalen %u for tcb %u\n", ntohl(ptcphdr->sent_seq), ntohl(ptcphdr->recv_ack), data_len, ptcb->identifier);
// push the mbuf in send_window unacknowledged data and increase the refrence count of this segment also start the rto timer for this tcb.
PushDataToSendWindow(ptcb, mbuf, ntohl(ptcphdr->sent_seq), ptcb->next_seq, data_len);
ip_out(ptcb, mbuf, ptcphdr, data_len);
}
int
main( int argc, char *argv[] ) {
init_trema( &argc, &argv );
traffic db;
db.counter = create_counter();
db.fdb = create_fdb();
add_periodic_event_callback( 10, show_counter, &db );
set_packet_in_handler( handle_packet_in, &db );
set_flow_removed_handler( handle_flow_removed, &db );
start_trema();
delete_fdb( db.fdb );
delete_counter( db.counter );
return 0;
}
int main(int argc, char *argv[])
{
GtkWidget *window, *vbox;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "USB Counter");
vbox = gtk_vbox_new(FALSE, 1);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);
gtk_box_pack_start(GTK_BOX(vbox), create_menubar(window), FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), create_counter(), TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
void window_load(){
create_counter();
create_text();
display_counter();
}
