--- /dev/null
+#include <stdlib.h>
+#include <stdio.h>
+#ifdef linux
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/poll.h>
+#endif
+
+#include "vtl_harness.h"
+
+DEBUG_DECLARE();
+
+
+#define F_NONE 0
+#define F_LOCAL_ACK 1
+
+unsigned short g_fflags;
+
+
+int g_do_local_ack = 0;
+/* IP Address utility functions */
+
+
+
+/* Global Pipe Descriptors */
+int vtp_in_fd, vtp_out_fd;
+
+
+/* Connection List Handling */
+struct VTP_CON g_vtp_cons[MAX_VTP_CONS];
+int g_first_vtp;
+int g_last_vtp;
+int g_num_vtp_cons;
+
+int add_vtp_con(RawEthernetPacket * pkt, unsigned long seq_num);
+int find_vtp_con(RawEthernetPacket * pkt);
+int find_remote_vtp_con(RawEthernetPacket * pkt);
+
+/* Packet Handlers */
+int handle_fifo_pkt(RawEthernetPacket * pkt, struct in_addr server_addr);
+int handle_tcp_pkt(RawEthernetPacket * pkt, struct in_addr server_addr);
+int handle_rem_tcp_pkt(RawEthernetPacket * pkt);
+int handle_control_pkt(RawEthernetPacket * pkt, struct in_addr server_addr);
+int handle_config_pkt(RawEthernetPacket * pkt);
+
+/* Packet functions */
+int make_ack_pkt(RawEthernetPacket * pkt, int vcon_i);
+int init_ack_template(RawEthernetPacket * pkt);
+
+
+int main(int argc, char ** argv) {
+
+ fd_set all_set, rset;
+ int maxfd = 0;
+ int conns;
+ timeval timeout;
+ timeval * tm_ptr;
+ RawEthernetPacket pkt;
+ RawEthernetPacket * recv_pkts;
+ int vtp_socket;
+ int i = 0;
+
+ debug_init("/tmp/vtp.1");
+
+ JRLDBG("Starting VTP Daemon\n");
+
+ for (i = 0; i < MAX_VTP_CONS; i++) {
+ g_vtp_cons[i].rem_seq_num = 0;
+ g_vtp_cons[i].dest_ip = 0;
+ g_vtp_cons[i].src_ip = 0;
+ g_vtp_cons[i].src_port = 0;
+ g_vtp_cons[i].dest_port = 0;
+ g_vtp_cons[i].tcp_timestamp = 0;
+ g_vtp_cons[i].in_use = false;
+ g_vtp_cons[i].next = -1;
+ g_vtp_cons[i].prev = -1;
+ }
+
+ g_last_vtp = -1;
+ g_first_vtp = -1;
+
+ g_num_vtp_cons = 0;
+
+ vtp_in_fd = open(VTP_FIFO_RECVFILE, O_WRONLY);
+ JRLDBG("Opened RECVFILE pipe\n");
+
+ vtp_out_fd = open(VTP_FIFO_SENDFILE, O_RDONLY);
+ JRLDBG("Opened SENDFILE pipe\n");
+
+
+ if ((vtp_socket = vtp_init()) < 0) {
+ JRLDBG("VTP Transport Layer failed to initialize\n");
+ exit(-1);
+ }
+
+ FD_ZERO(&all_set);
+ FD_SET(vtp_out_fd, &all_set);
+
+ if (vtp_socket > 0) {
+ FD_SET(vtp_socket, &all_set);
+
+ maxfd = (vtp_out_fd > vtp_socket) ? vtp_out_fd : vtp_socket ;
+
+ // block indefinately, because we have all the socks in the FDSET
+ tm_ptr = NULL;
+ } else {
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 0;
+
+ tm_ptr = &timeout;
+ }
+
+
+ while(1) {
+ int n_pkts_recvd = 0;
+ rset = all_set;
+
+ conns = select(maxfd + 1, &rset, NULL, NULL, tm_ptr);
+ if ((conns > 0) && (FD_ISSET(vtp_out_fd, &rset))) {
+ struct in_addr server_addr;
+ JRLDBG("Reception on vtp_out_fd\n");
+ // we got a packet on the FIFO
+ if (pkt.VtpUnserialize(vtp_out_fd, &server_addr) <= 0) {
+ JRLDBG("VNET Connection has closed. We are exiting\n");
+ exit(0);
+ }
+ handle_fifo_pkt(&pkt, server_addr);
+ }
+
+ //JRLDBG("Calling VTP Receive routine\n");
+ if ((vtp_socket == 0) || ((conns > 0) && (vtp_socket > 0) && FD_ISSET(vtp_socket, &rset))) {
+ if ((n_pkts_recvd = vtp_recv(&recv_pkts)) > 0) {
+ int i = 0;
+ struct in_addr tmp;
+ JRLDBG("Receive returned %d packets\n", n_pkts_recvd);
+
+ for (i = 0; i < n_pkts_recvd; i++) {
+
+ if (is_tcp_pkt(&(recv_pkts[i])) == 1) {
+ JRLDBG("Received a TCP packet\n");
+ if (g_do_local_ack == 1) {
+ handle_rem_tcp_pkt(&(recv_pkts[i]));
+ }
+ }
+
+ JRLDBG("Serializing packet %d to VNET\n", i);
+ recv_pkts[i].VtpSerialize(vtp_in_fd, &tmp);
+ usleep(50000);
+ }
+
+ //delete recv_pkts;
+ }
+ }
+ }
+
+ fclose(logfile);
+ close(vtp_in_fd);
+ close(vtp_out_fd);
+
+ return(0);
+}
+
+int handle_fifo_pkt(RawEthernetPacket * pkt, struct in_addr server_addr) {
+ JRLDBG("Received a packet\n");
+ // if (strncmp(pkt->type,"et",2) == 0) {
+ if ((pkt->type[0] == 'e') && (pkt->type[1] == 't')) {
+ JRLDBG("Packet is Ethernet\n");
+ if (is_tcp_pkt(pkt) == 0) {
+ JRLDBG("Packet is a non-TCP Packet\n");
+ vtp_send(pkt, server_addr);
+ } else {
+ JRLDBG("Packet is a TCP Packet\n");
+ handle_tcp_pkt(pkt, server_addr);
+ }
+
+ } else if (strncmp(pkt->type,"lc",2) == 0) {
+ JRLDBG("Packet is a Link Control Packet\n");
+ handle_control_pkt(pkt, server_addr);
+ } else if (strncmp(pkt->type, "cf", 2) == 0) {
+ JRLDBG("Packet is a Configuration packet\n");
+ handle_config_pkt(pkt);
+ }
+ return 0;
+}
+
+
+int handle_config_pkt(RawEthernetPacket * pkt) {
+
+ return 0;
+}
+
+
+int handle_control_pkt(RawEthernetPacket* pkt, struct in_addr server_addr) {
+ if (strncmp(pkt->data,"con",3) == 0) {
+ struct in_addr con_addr;
+ unsigned short con_port = 0;
+ unsigned int offset = 3;
+#ifdef DEBUG
+ char ip[256];
+ do_binary_to_string((unsigned char*)(&server_addr),ip);
+ JRLDBG("Control Message: Connect to %s\n", ip);
+#endif
+ memcpy(&con_addr, pkt->data + offset,sizeof(struct in_addr));
+ offset += sizeof(struct in_addr);
+ con_port = *((unsigned short *)(pkt->data + offset));
+
+ vtp_connect(con_addr, con_port);
+ } else if (strncmp(pkt->data, "gwc", 3) == 0) {
+ struct in_addr con_addr;
+ unsigned short con_port;
+ unsigned int offset = 3;
+
+ memcpy(&con_addr, pkt->data + offset, sizeof(struct in_addr));
+ offset += sizeof(struct in_addr);
+ con_port = *((unsigned short *)(pkt->data + offset));
+
+ vtp_connect(con_addr, con_port);
+
+ } else if (strncmp(pkt->data, "stop", 4) == 0) {
+ exit(0);
+ }
+
+ return 0;
+}
+
+
+int handle_tcp_pkt(RawEthernetPacket *pkt, struct in_addr server_addr) {
+
+ if (g_do_local_ack == 1) {
+ unsigned short ip_pkt_len = 0;
+ // unsigned char ip_hdr_len = (*(pkt->data + ETH_HDR_LEN) & 0x0f) << 2;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+ unsigned short * ip_pkt_len_ptr = (unsigned short *)(pkt->data + ETH_HDR_LEN + 2);
+ ip_pkt_len = ntohs(*ip_pkt_len_ptr);
+
+ JRLDBG("IP Header Length = %d(%x)\n", ip_hdr_len, *(pkt->data + ETH_HDR_LEN));
+ JRLDBG("IP Packet Length = %hu\n", ip_pkt_len);
+
+ if (is_syn_pkt(pkt) == 0) {
+ // we don't mess with connection establishment
+ int vcon_i;
+ unsigned long payload_len = 0;
+ unsigned short tcp_hdr_len = 0;
+ struct in_addr tmp;
+
+
+ tcp_hdr_len = (*(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) & 0xf0) >> 2;
+ payload_len = ip_pkt_len - (ip_hdr_len + tcp_hdr_len);
+
+ if ((payload_len == 0) && (is_ack_pkt(pkt) == 1)) {
+ // we just kill empty acks.
+ //return 0;
+ }
+
+ vcon_i = find_remote_vtp_con(pkt);
+
+ // Create ACK and send it.
+ make_ack_pkt(pkt, vcon_i);
+
+ g_vtp_cons[vcon_i].ack_template.VtpSerialize(vtp_in_fd, &tmp);
+
+ } else {
+ if(is_ack_pkt(pkt) == 1) {
+ int vcon_i = find_remote_vtp_con(pkt);
+ struct in_addr tmp;
+ make_ack_pkt(pkt, vcon_i);
+
+ g_vtp_cons[vcon_i].ack_template.VtpSerialize(vtp_in_fd, &tmp);
+ }
+#ifdef DEBUG
+ unsigned long * seq_num_ptr ;
+ unsigned long seq_num = 0;
+ unsigned long payload_len = 0;
+ unsigned short tcp_hdr_len = 0;
+ unsigned long ack = 0;
+
+ JRLDBG("Packet is a Syn Packet\n");
+
+ seq_num_ptr = (unsigned long *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 4);
+ seq_num = ntohl(*seq_num_ptr);
+ JRLDBG("Sequence Number = %lu\n", seq_num);
+
+ tcp_hdr_len = (*(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) & 0xf0) >> 2;
+ payload_len = ip_pkt_len - (ip_hdr_len + tcp_hdr_len);
+
+ JRLDBG("TCP Header Length = %hu\n", tcp_hdr_len);
+ JRLDBG("Payload Length = %lu\n", payload_len);
+
+
+
+ ack = (payload_len > 0) ? (seq_num + payload_len) : (seq_num + 1);
+ JRLDBG("Ack Num = %lu\n", ack);
+#endif
+ }
+
+ }
+
+ vtp_send(pkt, server_addr);
+
+ return 0;
+}
+
+int handle_rem_tcp_pkt(RawEthernetPacket * pkt) {
+ unsigned long * seq_num_ptr;
+ unsigned long seq_num;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+
+ seq_num_ptr = (unsigned long *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 4);
+ seq_num = ntohl(*seq_num_ptr);
+ JRLDBG("Received Packet, SeqNum = %lu\n", seq_num);
+
+ if (is_syn_pkt(pkt) == 1) {
+ // syn packet
+ seq_num++;
+ add_vtp_con(pkt, seq_num);
+ JRLDBG("Received Syn Packet, SeqNum = %lu\n", seq_num);
+ } else {
+ unsigned short ip_pkt_len = 0;
+ unsigned short * ip_pkt_len_ptr = (unsigned short *)(pkt->data + ETH_HDR_LEN + 2);
+ unsigned long payload_len = 0;
+ unsigned short tcp_hdr_len = 0;
+ int i_vcon = find_vtp_con(pkt);
+
+ ip_pkt_len = ntohs(*ip_pkt_len_ptr);
+
+ tcp_hdr_len = (*(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) & 0xf0) >> 2;
+
+ if (tcp_hdr_len > 20) {
+ unsigned long ts = get_tcp_timestamp(pkt->data + ETH_HDR_LEN + ip_hdr_len + 20, tcp_hdr_len - 20);
+ JRLDBG("TCP Timestamp = %lu(%lu)\n", ts, (unsigned long)ntohl(ts));
+ g_vtp_cons[i_vcon].tcp_timestamp = ts;
+ }
+
+ payload_len = ip_pkt_len - (ip_hdr_len + tcp_hdr_len);
+ seq_num += payload_len;
+ JRLDBG("Received Data Packet, SeqNum = %lu\n", seq_num);
+ g_vtp_cons[i_vcon].rem_seq_num = seq_num;
+ JRLDBG("Remote Sequence Number (con: %d) = %lu\n", i_vcon, seq_num);
+
+#if 0
+ {
+ int offset = 0;
+ unsigned short tcp_cksum = 0;
+ // Zero Ack Field
+ *(unsigned long *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 8) = 0;
+
+ // Zero Ack Flag
+ offset = ETH_HDR_LEN + ip_hdr_len + 13;
+ *(pkt->data + offset) &= 0xef;
+
+ // Zero TCP chksum
+ *(unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 16) = 0;
+
+ // Get TCP chksum
+ tcp_cksum = get_tcp_checksum(pkt, ip_pkt_len - ip_hdr_len);
+
+ // Set TCP chksum
+ *(unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 16) = tcp_cksum;
+ }
+#endif
+
+
+ }
+ return 0;
+}
+
+
+
+int make_ack_pkt(RawEthernetPacket * pkt, int vcon_i) {
+ unsigned long * seq_num_ptr ;
+ unsigned long seq_num = 0;
+ unsigned long rem_seq_num = 0;
+ unsigned long payload_len = 0;
+ unsigned short tcp_hdr_len = 0;
+ unsigned long ack = 0;
+ unsigned long local_ts = 0;
+ unsigned short tcp_cksum = 0;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+ unsigned short ip_pkt_len = *(unsigned short *)(pkt->data + ETH_HDR_LEN + 2);
+ RawEthernetPacket * ack_pkt = &(g_vtp_cons[vcon_i].ack_template);
+ unsigned short ack_ip_pkt_len = *(unsigned short *)(ack_pkt->data + ETH_HDR_LEN + 2);
+ unsigned char ack_ip_hdr_len = IP_HDR_LEN(ack_pkt->data);
+
+ ip_pkt_len = ntohs(ip_pkt_len);
+ ack_ip_pkt_len = ntohs(ack_ip_pkt_len);
+
+ seq_num_ptr = (unsigned long *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 4);
+ seq_num = ntohl(*seq_num_ptr);
+ JRLDBG("Sequence Number = %lu\n", seq_num);
+
+ tcp_hdr_len = (*(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) & 0xf0) >> 2;
+
+ if (is_syn_pkt(pkt) == 1) {
+ ack = seq_num + 1;
+ } else {
+ payload_len = ip_pkt_len - (ip_hdr_len + tcp_hdr_len);
+
+ JRLDBG("TCP Header Length = %hu\n", tcp_hdr_len);
+ JRLDBG("Payload Length = %lu\n", payload_len);
+
+ ack = seq_num + payload_len;
+ JRLDBG("Ack Num = %lu\n", ack);
+ }
+
+ // Set IP id
+ g_vtp_cons[vcon_i].ip_id--;
+ *(unsigned short *)(ack_pkt->data + ETH_HDR_LEN + 4) = htons(g_vtp_cons[vcon_i].ip_id);
+
+ // Recompute IP checksum
+ *(unsigned short *)(ack_pkt->data + ETH_HDR_LEN + 10) = 0;
+ *(unsigned short *)(ack_pkt->data + ETH_HDR_LEN + 10) = get_ip_checksum(ack_pkt);
+
+ //return 0;
+ // Set Sequence Number
+ rem_seq_num = htonl(g_vtp_cons[vcon_i].rem_seq_num);
+ *(unsigned long *)(ack_pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 4) = rem_seq_num;
+
+ // Set ACK Number
+ ack = htonl(ack);
+ *(unsigned long *)(ack_pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 8) = ack;
+
+ // Set TCP Timestamp option
+ local_ts = get_tcp_timestamp(pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 20, tcp_hdr_len - 20);
+
+ /* We use this for debugging:
+ * If the TCPDump trace shows timestamps with the value of '5' then they are our packets
+ */
+
+ *(unsigned long *)(ack_pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 24) = g_vtp_cons[vcon_i].tcp_timestamp;
+ //*(unsigned long *)(ack_pkt->data + ETH_HDR_LEN + ip_hdr_len + 24) = htonl(5);
+
+
+ *(unsigned long *)(ack_pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 28) = local_ts;
+
+ // Zero TCP chksum
+ *(unsigned short *)(ack_pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 16) = 0;
+
+ // Get TCP chksum
+ tcp_cksum = get_tcp_checksum(ack_pkt, ack_ip_pkt_len - ack_ip_hdr_len);
+
+ // Set TCP chksum
+ *(unsigned short *)(ack_pkt->data + ETH_HDR_LEN + ack_ip_hdr_len + 16) = tcp_cksum;
+
+ return 0;
+}
+
+
+
+
+
+/* Connection List Handling */
+
+int find_vtp_con(RawEthernetPacket * pkt) {
+ int index = -1;
+ int i = 0;
+ unsigned long * src_addr;
+ unsigned long * dest_addr;
+ unsigned short * src_port;
+ unsigned short * dest_port;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+
+ src_addr = (unsigned long *)(pkt->data + ETH_HDR_LEN + 12);
+ dest_addr = (unsigned long *)(pkt->data + ETH_HDR_LEN + 16);
+ src_port = (unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len);
+ dest_port = (unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 2);
+
+ // for (i = 0; i < MAX_CONS; i++) {
+ FOREACH_VTP_CON(i,g_vtp_cons) {
+ if ((g_vtp_cons[i].dest_ip == *dest_addr) && (g_vtp_cons[i].src_ip == *src_addr) &&
+ (g_vtp_cons[i].dest_port = *dest_port) && (g_vtp_cons[i].src_port == *src_port)) {
+ index = i;
+ break;
+ }
+ }
+ return index;
+}
+
+
+/* An received packet has the header fields reversed wrt src/dest
+ * So we have to be able to index remote packets as well
+ */
+int find_remote_vtp_con(RawEthernetPacket * pkt) {
+ int index = -1;
+ int i = 0;
+ unsigned long * src_addr;
+ unsigned long * dest_addr;
+ unsigned short * src_port;
+ unsigned short * dest_port;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+
+ src_addr = (unsigned long *)(pkt->data + ETH_HDR_LEN + 12);
+ dest_addr = (unsigned long *)(pkt->data + ETH_HDR_LEN + 16);
+ src_port = (unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len);
+ dest_port = (unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 2);
+
+ // for (i = 0; i < MAX_CONS; i++) {
+ FOREACH_VTP_CON(i,g_vtp_cons) {
+ if ((g_vtp_cons[i].src_ip == *dest_addr) && (g_vtp_cons[i].dest_ip == *src_addr) &&
+ (g_vtp_cons[i].src_port = *dest_port) && (g_vtp_cons[i].dest_port == *src_port)) {
+ index = i;
+ break;
+ }
+ }
+ return index;
+}
+
+
+int add_vtp_con(RawEthernetPacket * pkt, unsigned long seq_num) {
+ int i;
+ unsigned long * src_addr;
+ unsigned long * dest_addr;
+ unsigned short * src_port;
+ unsigned short * dest_port;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+ unsigned short tcp_hdr_len = (*(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) & 0xf0) >> 2;
+
+ src_addr = (unsigned long *)(pkt->data + ETH_HDR_LEN + 12);
+ dest_addr = (unsigned long *)(pkt->data + ETH_HDR_LEN + 16);
+ src_port = (unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len);
+ dest_port = (unsigned short *)(pkt->data + ETH_HDR_LEN + ip_hdr_len + 2);
+
+ for (i = 0; i < MAX_VTP_CONS; i++) {
+ if (!(g_vtp_cons[i].in_use)) {
+ JRLDBG("Adding connection in slot %d\n", i);
+ g_vtp_cons[i].rem_seq_num = seq_num;
+
+ // ADD PACKET CONNECTION INFO
+ g_vtp_cons[i].dest_ip = *dest_addr;
+ g_vtp_cons[i].src_ip = *src_addr;
+ g_vtp_cons[i].src_port = *src_port;
+ g_vtp_cons[i].dest_port = *dest_port;
+ g_vtp_cons[i].ack_template = *pkt;
+ g_vtp_cons[i].ip_id = ntohs(*(unsigned short *)(pkt->data + ETH_HDR_LEN + 4));
+
+ init_ack_template(&(g_vtp_cons[i].ack_template));
+
+ if (tcp_hdr_len > 20) {
+ unsigned long ts = get_tcp_timestamp(pkt->data + ETH_HDR_LEN + ip_hdr_len + 20, tcp_hdr_len - 20);
+ JRLDBG("TCP Timestamp = %lu(%lu)\n", ts, (unsigned long)ntohl(ts));
+ g_vtp_cons[i].tcp_timestamp = ts;
+ }
+
+ g_vtp_cons[i].in_use = true;
+
+ if (g_first_vtp == -1)
+ g_first_vtp = i;
+
+ g_vtp_cons[i].prev = g_last_vtp;
+ g_vtp_cons[i].next = -1;
+
+ if (g_last_vtp != -1) {
+ g_vtp_cons[g_last_vtp].next = i;
+ }
+
+ g_last_vtp = i;
+
+ g_num_vtp_cons++;
+ return 0;
+ }
+ }
+ return -1;
+}
+
+
+int init_ack_template(RawEthernetPacket * pkt) {
+ // We assume here that the ethernet and ip headers are ok, except for ip pkt length
+ // TCP is mostly right because its pulled off of a syn packet
+ // we need to zero the data, and reset the syn flag.
+
+ unsigned short IP_PACKET_LEN = 52;
+ unsigned short TCP_HEADER_LEN = 32;
+ unsigned char ip_hdr_len = IP_HDR_LEN(pkt->data);
+ unsigned short ip_pkt_len = 0;
+ unsigned short tcp_hdr_len = 0;
+ unsigned short payload_len = 0;
+ unsigned short * ip_pkt_len_ptr = (unsigned short *)(pkt->data + ETH_HDR_LEN + 2);
+ unsigned int offset = 0;
+ unsigned short ip_chksum = 0;
+
+ JRLDBG("--> Initializing ACK Template <--\n");
+
+ ip_pkt_len = ntohs(*ip_pkt_len_ptr);
+ JRLDBG("ip_pkt_len = %hu\n", ip_pkt_len);
+
+ tcp_hdr_len = (*(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) & 0xf0) >> 2;
+ payload_len = ip_pkt_len - (ip_hdr_len + tcp_hdr_len);
+ JRLDBG("tcp_hdr_len = %hu\n", tcp_hdr_len);
+ JRLDBG("payload_len = %hu\n", payload_len);
+
+ // set only the ack flags
+ offset = ETH_HDR_LEN + ip_hdr_len + 13;
+ *(pkt->data + offset) |= 0x10;
+ *(pkt->data + offset) &= 0xd0;
+
+ // set up tcp options
+ offset = ETH_HDR_LEN + ip_hdr_len + 20;
+ *(pkt->data + offset) = 0x01;
+ offset++;
+ *(pkt->data + offset) = 0x01;
+ offset++;
+ *(pkt->data + offset) = 0x08;
+ offset++;
+ *(pkt->data + offset) = 0x0a;
+
+ // Set Header Lengths
+ // IP HEADER = 20 (same)
+ // IP PACKET LEN = 52
+ // TCP Header len = 32
+
+ ip_pkt_len = htons(IP_PACKET_LEN);
+ memcpy(pkt->data + ETH_HDR_LEN + 2, &ip_pkt_len, 2);
+ tcp_hdr_len = (TCP_HEADER_LEN << 2);
+ *(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) &= 0x0f;
+ *(pkt->data + ETH_HDR_LEN + ip_hdr_len + 12) |= tcp_hdr_len;
+
+ JRLDBG("Setting TEMPLATE TCPLEN = %2x\n", *(pkt->data + ETH_HDR_LEN +ip_hdr_len + 12));
+
+ // Set IP Header chksum
+ *(unsigned short *)(pkt->data + ETH_HDR_LEN + 10) = 0;
+ ip_chksum = get_ip_checksum(pkt);
+ *(unsigned short *)(pkt->data + ETH_HDR_LEN + 10) = ip_chksum;
+
+
+ // Set RawEthernetPacket size
+ pkt->set_size(IP_PACKET_LEN + ETH_HDR_LEN);
+ pkt->set_type("et");
+
+ JRLDBG("--> ACK Template Initialized <--\n");
+
+
+ return 0;
+}
+
