Multiple Connection Support

Restriction on src!=dest ports removed

diff --git a/Makefile b/Makefile
index b4539fda78afe9e3735caefd9b0fd7a3bd5c9de5..945bf2d75c904171d8a103aee627bdebe55178d2 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -22,14 +22,17 @@ MANDIR = /usr/local/man
 
 all: dccp2tcp
 
-dccp2tcp: dccp2tcp.o encap.o
-       gcc ${CFLAGS} ${LDLIBS} --std=gnu99 dccp2tcp.o encap.o -odccp2tcp
+dccp2tcp: dccp2tcp.o encap.o connections.o
+       gcc ${CFLAGS} ${LDLIBS} --std=gnu99 dccp2tcp.o encap.o connections.o -odccp2tcp
 
 dccp2tcp.o: dccp2tcp.h dccp2tcp.c
        gcc ${CFLAGS} ${LDLIBS} --std=gnu99 -c dccp2tcp.c -odccp2tcp.o
 
 encap.o: encap.c dccp2tcp.h encap.h
        gcc ${CFLAGS} ${LDLIBS} --std=gnu99 -c encap.c -oencap.o
+       
+connections.o: dccp2tcp.h connections.c
+       gcc ${CFLAGS} ${LDLIBS} --std=gnu99 -c connections.c -oconnections.o
 
 install: dccp2tcp
        install -m 755 -o bin -g bin dccp2tcp ${BINDIR}/dccp2tcp

diff --git a/connections.c b/connections.c
new file mode 100644 (file)
index 0000000..511692f
--- /dev/null
+++ b/connections.c
@@ -0,0 +1,91 @@
+/******************************************************************************
+Author: Samuel Jero
+
+Date: 7/2011
+
+Description: Functions for differentiating different DCCP connections.
+
+******************************************************************************/
+#include "dccp2tcp.h"
+
+/*Lookup a connection. If it doesn't exist, add a new connection and return it.*/
+int get_host(uint32_t src_id, uint32_t dest_id, int src_port, int dest_port, struct host *fwd, struct host *rev){
+       struct connection *ptr;
+
+       /*Empty list*/
+       if(chead==NULL){
+               if(add_connection(src_id, dest_id, src_port, dest_port)==NULL){
+                       return 1;
+               }
+               fwd=&chead->A;
+               rev=&chead->B;
+               return 0;
+       }
+
+       /*Loop list looking for connection*/
+       ptr=chead;
+       while(ptr!=NULL){
+               if(ptr->A.id==src_id && ptr->A.port==src_port && ptr->A.state!=CLOSE){
+                       fwd=&ptr->A;
+                       rev=&ptr->B;
+                       return 0;
+               }
+               if(ptr->B.id==src_id && ptr->B.port==src_port && ptr->B.state!=CLOSE){
+                       fwd=&ptr->B;
+                       rev=&ptr->A;
+                       return 0;
+               }
+               ptr=ptr->next;
+       }
+
+       /*Add new connection*/
+       ptr=add_connection(src_id, dest_id, src_port, dest_port);
+       if(ptr==NULL){
+               return 1;
+       }
+       fwd=&ptr->A;
+       rev=&ptr->B;
+       return 0;
+}
+
+/*Add a connection. Return it. On failure, return NULL*/
+struct connection *add_connection(uint32_t src_id, uint32_t dest_id, int src_port, int dest_port){
+       struct connection *ptr;
+       struct connection *prev;
+
+       /*Allocate memory*/
+       if(chead){
+               ptr=chead=malloc(sizeof(struct connection));
+       }else{
+               ptr=chead;
+               prev=chead;
+               while(ptr!=NULL){
+                       prev=ptr;
+                       ptr=ptr->next;
+               }
+               ptr=prev->next=malloc(sizeof(struct connection));
+       }
+
+       if(ptr==NULL){
+               dbgprintf(0,"Error: Couldn't allocate Memory\n");
+               exit(1);
+       }
+
+       /*Initialize*/
+       ptr->A.id=src_id;
+       ptr->A.state=INIT;
+       ptr->B.id=dest_id;
+       ptr->B.port=dest_port;
+       ptr->B.state=INIT;
+
+       return ptr;
+}
+
+/*Update the state on a host*/
+int update_state(struct host* hst, enum con_state st){
+       if(!hst){
+               return 1;
+       }
+       hst->state=st;
+       return 0;
+}

diff --git a/dccp2tcp.c b/dccp2tcp.c
index 1ab8ed198372618fba2074448b8d24870d84560b..eb913bf9dc23652d84b97774cda2cd5e61dd7a90 100644 (file)
--- a/dccp2tcp.c
+++ b/dccp2tcp.c
@@ -1,19 +1,18 @@
 /******************************************************************************
 Author: Samuel Jero
 
-Date: 5/2011
+Date: 7/2011
 
 Description: Program to convert a DCCP flow to a TCP flow for DCCP analysis via
                tcptrace.
 
 Notes:
-       1)Supports only a single DCCP contection per capture
-       2)Source Port!=Destination Port
-       3)DCCP MUST use 48 bit sequence numbers
-       4)Checksums are not computed (they are zeroed)
-       5)Only implements those packet types normally used in a session
-       6)DCCP Ack packets show up as TCP packets containing one byte
-       7)Very little error checking of packet headers
+       1)CCID2 ONLY
+       2)DCCP MUST use 48 bit sequence numbers
+       3)Checksums are not computed (they are zeroed)
+       4)Only implements those packet types normally used in a session
+       5)DCCP Ack packets show up as TCP packets containing one byte
+       6)Very little error checking of packet headers
 ******************************************************************************/
 #include "dccp2tcp.h"
 
@@ -24,22 +23,21 @@ int green=0;        /*tcptrace green line as currently acked packet*/
 int sack=0;            /*add TCP SACKS*/
 
 pcap_t*                        in;                     /*libpcap input file discriptor*/
-pcap_dumper_t  *out;   /*libpcap output file discriptor*/
-struct seq_num *s1;    /*sequence number structure for side one of connection*/
-struct seq_num *s2;    /*sequence number structure for side two of connection*/
+pcap_dumper_t  *out;           /*libpcap output file discriptor*/
+struct connection *chead;      /*connection list*/
 
 
 
 void PcapSavePacket(struct pcap_pkthdr *h, u_char *data);
 void process_packets();
 void handle_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes);
-int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length);
+int convert_packet(struct packet *new, const struct const_packet* old);
 unsigned int interp_ack_vect(u_char* hdr);
-u_int32_t initialize_seq(struct seq_num **seq, __be16 source, __be32 initial);
-u_int32_t add_new_seq(struct seq_num *seq, __be32 num, int size, enum dccp_pkt_type type);
-u_int32_t convert_ack(struct seq_num *seq, __be32 num);
-int acked_packet_size(struct seq_num *seq, __be32 num);
-void ack_vect2sack(struct seq_num *seq, struct tcphdr *tcph, u_char* tcpopts, u_char* dccphdr, __be32 dccpack);
+u_int32_t initialize_seq(struct host *seq, __be16 source, __be32 initial);
+u_int32_t add_new_seq(struct host *seq, __be32 num, int size, enum dccp_pkt_type type);
+u_int32_t convert_ack(struct host *seq, __be32 num);
+int acked_packet_size(struct host *seq, __be32 num);
+void ack_vect2sack(struct host *seq, struct tcphdr *tcph, u_char* tcpopts, u_char* dccphdr, __be32 dccpack);
 
 
 /*Parse commandline options and open files*/
@@ -140,32 +138,36 @@ return 0;
 void handle_packet(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes)
 {
        u_char                          *ndata;
-       u_char                          *nptr;
-       int                                     length;
-       int                                     nlength;
        struct pcap_pkthdr      nh;
        int                                     link_type;
+       struct packet           new;
+       struct const_packet     old;
 
        /*Determine the link type for this packet*/
        link_type=pcap_datalink(in);
 
        /*create new libpcap header*/
        memcpy(&nh, h, sizeof(struct pcap_pkthdr));
-       length=h->caplen;
-       nlength=MAX_PACKET;
+
+       /*Setup packet structs*/
+       old.h=h;
+       old.length=h->caplen;
+       old.data=bytes;
+       new.h=&nh;
+       new.length=MAX_PACKET;
 
        /*create buffer for new packet*/
-       nptr=ndata=malloc(MAX_PACKET);
+       new.data=ndata=malloc(MAX_PACKET);
        if(ndata==NULL){
                dbgprintf(0,"Error: Couldn't allocate Memory\n");
                exit(1);
        }
 
        /*make sure the packet is all zero*/
-       memset(nptr, 0, MAX_PACKET);
+       memset(new.data, 0, MAX_PACKET);
        
        /*do all the fancy conversions*/
-       if(!do_encap(link_type, &nh, &nptr, &nlength, &bytes, &length)){
+       if(!do_encap(link_type, &new, &old)){
                free(ndata);
                return;
        }
@@ -179,34 +181,54 @@ return;
 
 
 /*do all the dccp to tcp conversions*/
-int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length)
+int convert_packet(struct packet *new, const struct const_packet* old)
 {      
-       u_char* ncur=*nptr;
-       const u_char* ocur=*optr;
-       struct tcphdr *tcph;
-       struct dccp_hdr *dccph;
-       struct dccp_hdr_ext *dccphex;
-       struct dccp_hdr_ack_bits *dccphack;
-       int datalength;
-       int     len=0;
-       const u_char* pd;
-       u_char* npd;
-       u_char* tcpopt;
+       struct tcphdr                           *tcph;
+       struct dccp_hdr                         *dccph;
+       struct dccp_hdr_ext             *dccphex;
+       struct dccp_hdr_ack_bits        *dccphack;
+       struct host                                     *h1=NULL;
+       struct host                                     *h2=NULL;
+       int                                             datalength;
+       int                                                     len=0;
+       const u_char*                           pd;
+       u_char*                                         npd;
+       u_char*                                         tcpopt;
+
+       /*Safety checks*/
+       if(!new || !old || !new->data || !old->data || !new->h || !old->h){
+               dbgprintf(0,"Error:  Convert Packet Function given bad data!\n");
+               return 0;
+       }
+       if(old->length < sizeof(struct dccp_hdr) || new->length < sizeof(struct dccp_hdr)){
+               dbgprintf(0, "Error: Convert Packet Function given packet of wrong size!\n");
+               return 0;
+       }
 
        /*cast header pointers*/
-       tcph=(struct tcphdr*)ncur;
-       tcpopt=ncur+ sizeof(struct tcphdr);
-       dccph=(struct dccp_hdr*)ocur;
-       dccphex=(struct dccp_hdr_ext*)(ocur+sizeof(struct dccp_hdr));
-       dccphack=(struct dccp_hdr_ack_bits*)(ocur+ sizeof(struct dccp_hdr) + sizeof(struct dccp_hdr_ext));
+       tcph=(struct tcphdr*)new->data;
+       tcpopt=new->data + sizeof(struct tcphdr);
+       dccph=(struct dccp_hdr*)old->data;
+       dccphex=(struct dccp_hdr_ext*)(old->data+sizeof(struct dccp_hdr));
+       dccphack=(struct dccp_hdr_ack_bits*)(old->data+ sizeof(struct dccp_hdr) + sizeof(struct dccp_hdr_ext));
 
        dbgprintf(2,"Sequence Number: %llu\n", (unsigned long long)(((unsigned long)ntohs(dccph->dccph_seq)<<32) + ntohl(dccphex->dccph_seq_low)));
 
+       /*Get Hosts*/
+       if(get_host(new->src_id, new->dest_id, dccph->dccph_sport, dccph->dccph_dport, h1, h2)){
+               dbgprintf(0,"Error: Can't Get Hosts!\n");
+               return 0;
+       }
+       if(!h1 || !h2){
+               dbgprintf(0, "Error: Can't Get Hosts!\n");
+               return 0;
+       }
+
        /*determine data length*/
-       datalength=*length - dccph->dccph_doff*4;
-       pd=*optr + dccph->dccph_doff*4;
+       datalength=old->length - dccph->dccph_doff*4;
+       pd=old->data + dccph->dccph_doff*4;
 
-       /*set tcp standard features*/
+       /*set TCP standard features*/
        tcph->source=dccph->dccph_sport;
        tcph->dest=dccph->dccph_dport;
        tcph->doff=5;
@@ -218,20 +240,15 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
                tcph->window=htons(30000);
        }
 
-       /*Only accept the first connection*/
-       if(s1 && s2 && dccph->dccph_sport!=s1->addr && dccph->dccph_dport!=s1->addr){
-               return 0;
-       }
-
        /*make changes by packet type*/
        if(dccph->dccph_type==DCCP_PKT_REQUEST){//DCCP REQUEST -->TCP SYN
                dbgprintf(2,"Packet Type: Request\n");
-               if(!s1){
+               if(h1->state==INIT){
                        if(yellow){
                                tcph->window=htons(0);
                        }
                        tcph->ack_seq=htonl(0);
-                       tcph->seq=htonl(initialize_seq(&s1, dccph->dccph_sport, ntohl(dccphex->dccph_seq_low)));
+                       tcph->seq=htonl(initialize_seq(h1, dccph->dccph_sport, ntohl(dccphex->dccph_seq_low)));
                        tcph->syn=1;
                        tcph->ack=0;
                        tcph->fin=0;
@@ -252,12 +269,12 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
 
        if(dccph->dccph_type==DCCP_PKT_RESPONSE){//DCCP RESPONSE-->TCP SYN,ACK
                dbgprintf(2,"Packet Type: Response\n");
-               if(s1 && !s2){
-                       tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
+               if(h2->state==OPEN && h1->state==INIT){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
                        if(yellow){
                                tcph->window=htons(0);
                        }
-                       tcph->seq=htonl(initialize_seq(&s2, dccph->dccph_sport, ntohl(dccphex->dccph_seq_low)));
+                       tcph->seq=htonl(initialize_seq(h1, dccph->dccph_sport, ntohl(dccphex->dccph_seq_low)));
                        tcph->syn=1;
                        tcph->ack=1;
                        tcph->fin=0;
@@ -282,36 +299,18 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
 
        if(dccph->dccph_type==DCCP_PKT_DATAACK){//DCCP DATAACK-->TCP ACK with data
                dbgprintf(2,"Packet Type: DataAck\n");
-               if(s1 && s2 && dccph->dccph_sport==s1->addr){ //determine which side of connection is sending this packet
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s1, ntohl(dccphex->dccph_seq_low),datalength, dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s2, ntohl(dccphack->dccph_ack_nr_low)));
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
-                       }
-               }else if(s1 && s2 && dccph->dccph_sport==s2->addr){
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s2, ntohl(dccphex->dccph_seq_low),datalength,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s1, ntohl(dccphack->dccph_ack_nr_low)));
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-
-                               }
+               if(green){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
+               }
+               tcph->seq=htonl(add_new_seq(h1, ntohl(dccphex->dccph_seq_low),datalength, dccph->dccph_type));
+               if(yellow){
+                       tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(h2, ntohl(dccphack->dccph_ack_nr_low)));
+               }
+               if(sack){
+                       if(sack!=2 || interp_ack_vect((u_char*)dccph)){
+                               ack_vect2sack(h2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
                        }
                }
 
@@ -321,7 +320,7 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
                tcph->rst=0;
 
                /*copy data*/
-               npd=*nptr + tcph->doff*4;
+               npd=new->data + tcph->doff*4;
                memcpy(npd, pd, datalength);
 
                /*calculate length*/
@@ -330,41 +329,21 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
 
        if(dccph->dccph_type==DCCP_PKT_ACK){ //DCCP ACK -->TCP ACK with no data
                dbgprintf(2,"Packet Type: Ack\n");
-               if(s1 && s2 && dccph->dccph_sport==s1->addr){//determine which side of connection is sending this packet
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s1, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*1400);
-                               if(-interp_ack_vect((u_char*)dccph)*1400 > 65535){
-                                       printf("Note: TCP Window Overflow @ %d.%d\n", (int)h->ts.tv_sec, (int)h->ts.tv_usec);
-                               }
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
-                       }
-               }else if(s1 && s2 && dccph->dccph_sport==s2->addr){
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s2, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*1400);
-                               if(-interp_ack_vect((u_char*)dccph)*1400 > 65535){
-                                       printf("Note: TCP Window Overflow @ %d.%d\n", (int)h->ts.tv_sec, (int)h->ts.tv_usec);
-                               }
+               if(green){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
+               }
+               tcph->seq=htonl(add_new_seq(h1, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
+               if(yellow){
+                       tcph->window=htons(-interp_ack_vect((u_char*)dccph)*1400);
+                       if(-interp_ack_vect((u_char*)dccph)*1400 > 65535){
+                               printf("Note: TCP Window Overflow @ %d.%d\n", (int)old->h->ts.tv_sec, (int)old->h->ts.tv_usec);
                        }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s1, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
+               }
+               if(sack){
+                       if(sack!=2 || interp_ack_vect((u_char*)dccph)){
+                               ack_vect2sack(h2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
                        }
                }
 
@@ -384,35 +363,19 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
 
        if(dccph->dccph_type==DCCP_PKT_CLOSE){//DCCP CLOSE-->TCP FIN,ACK
                dbgprintf(2,"Packet Type: Close\n");
-               if(s1 && s2 && dccph->dccph_sport==s1->addr){//determine which side of connection is sending this packet
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s1, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s2, ntohl(dccphack->dccph_ack_nr_low)));
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
-                       }
-               }else if(s1 && s2 && dccph->dccph_sport==s2->addr){
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s2, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s1, ntohl(dccphack->dccph_ack_nr_low)));
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s1, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
+               update_state(h1,CLOSE);
+               if(green){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
+               }
+               tcph->seq=htonl(add_new_seq(h1, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
+               if(yellow){
+                       tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(h2, ntohl(dccphack->dccph_ack_nr_low)));
+               }
+               if(sack){
+                       if(sack!=2 || interp_ack_vect((u_char*)dccph)){
+                               ack_vect2sack(h2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
                        }
                }
 
@@ -426,36 +389,22 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
        }
 
        if(dccph->dccph_type==DCCP_PKT_RESET){//DCCP RESET-->TCP FIN,ACK (only seen at end of connection as CLOSE ACK)
+               if(h2->state==CLOSE){
+                       update_state(h1,CLOSE);
+               }
                dbgprintf(2,"Packet Type: Reset\n");
-               if(s1 && s2 && dccph->dccph_sport==s1->addr){//determine which side of connection is sending this packet
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s1, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s2, ntohl(dccphack->dccph_ack_nr_low)));
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
-                       }
-               }else if(s1 && s2 && dccph->dccph_sport==s2->addr){
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s2, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s1, ntohl(dccphack->dccph_ack_nr_low)));
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s1, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
+               if(green){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
+               }
+               tcph->seq=htonl(add_new_seq(h1, ntohl(dccphex->dccph_seq_low),1,dccph->dccph_type));
+               if(yellow){
+                       tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(h2, ntohl(dccphack->dccph_ack_nr_low)));
+               }
+               if(sack){
+                       if(sack!=2 || interp_ack_vect((u_char*)dccph)){
+                               ack_vect2sack(h2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
                        }
                }
 
@@ -470,39 +419,20 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
 
        if(dccph->dccph_type==DCCP_PKT_SYNC){//DCCP SYNC
                dbgprintf(2,"Packet Type: Sync\n");
-               if(s1 && s2 && dccph->dccph_sport==s1->addr){//determine which side of connection is sending this packet
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s1, ntohl(dccphex->dccph_seq_low),0,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s2, ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->window=htons(0);
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
-                       }
-               }else if(s1 && s2 && dccph->dccph_sport==s2->addr){
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s2, ntohl(dccphex->dccph_seq_low),0,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s1, ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->window=htons(0);
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s1, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
+               if(green){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
+               }
+               tcph->seq=htonl(add_new_seq(h1, ntohl(dccphex->dccph_seq_low),0,dccph->dccph_type));
+               if(yellow){
+                       tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(h2, ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->window=htons(0);
+               }
+               if(sack){
+                       if(sack!=2 || interp_ack_vect((u_char*)dccph)){
+                               ack_vect2sack(h2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
                        }
                }
 
@@ -517,39 +447,20 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
 
        if(dccph->dccph_type==DCCP_PKT_SYNCACK){//DCCP SYNACK
                dbgprintf(2,"Packet Type: SyncAck\n");
-               if(s1 && s2 && dccph->dccph_sport==s1->addr){//determine which side of connection is sending this packet
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s1, ntohl(dccphex->dccph_seq_low),0,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s2, ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->window=htons(0);
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low));
-                               }
-                       }
-               }else if(s1 && s2 && dccph->dccph_sport==s2->addr){
-                       if(green){
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->ack_seq=htonl(convert_ack(s1,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
-                       }
-                       tcph->seq=htonl(add_new_seq(s2, ntohl(dccphex->dccph_seq_low),0,dccph->dccph_type));
-                       if(yellow){
-                               tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(s1, ntohl(dccphack->dccph_ack_nr_low)));
-                       }else{
-                               tcph->window=htons(0);
-                       }
-                       if(sack){
-                               if(sack!=2 || interp_ack_vect((u_char*)dccph)){
-                                       ack_vect2sack(s1, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low) );
-                               }
+               if(green){
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->ack_seq=htonl(convert_ack(h2,ntohl(dccphack->dccph_ack_nr_low)+interp_ack_vect((u_char*)dccph)));
+               }
+               tcph->seq=htonl(add_new_seq(h1, ntohl(dccphex->dccph_seq_low),0,dccph->dccph_type));
+               if(yellow){
+                       tcph->window=htons(-interp_ack_vect((u_char*)dccph)*acked_packet_size(h2, ntohl(dccphack->dccph_ack_nr_low)));
+               }else{
+                       tcph->window=htons(0);
+               }
+               if(sack){
+                       if(sack!=2 || interp_ack_vect((u_char*)dccph)){
+                               ack_vect2sack(h2, tcph, tcpopt, (u_char*)dccph, ntohl(dccphack->dccph_ack_nr_low));
                        }
                }
 
@@ -567,7 +478,7 @@ int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
                return 0;
        }
 
-       *nlength=len;
+       new->length=len;
 return 1;
 }
 
@@ -639,38 +550,31 @@ return additional;
 
 
 /* Setup Sequence Number Structure*/
-u_int32_t initialize_seq(struct seq_num **seq, __be16 source, __be32 initial)
+u_int32_t initialize_seq(struct host *seq, __be16 source, __be32 initial)
 {
-       /*allocate structure*/
-       *seq=(struct seq_num*)malloc(sizeof(struct seq_num));
-       if(*seq==NULL){
-               dbgprintf(0,"Can't Allocate Memory!\n");
-               exit(1);
-       }
-
        /*set default values*/
-       (*seq)->cur=0;
-       (*seq)->addr=source;
-       (*seq)->size=TBL_SZ;
+       seq->cur=0;
+       seq->size=TBL_SZ;
        
        /*allocate table*/
-       (*seq)->table=(struct tbl*)malloc(sizeof(struct tbl)*TBL_SZ);
-       if((*seq)->table==NULL){
+       seq->table=(struct tbl*)malloc(sizeof(struct tbl)*TBL_SZ);
+       if(seq->table==NULL){
                dbgprintf(0,"Can't Allocate Memory!\n");
                exit(1);
        }
 
        /*add first sequence number*/
-       (*seq)->table[0].old=initial;
-       (*seq)->table[0].new=initial;
-       (*seq)->table[0].type=DCCP_PKT_REQUEST;
-       (*seq)->table[0].size=0;
+       seq->table[0].old=initial;
+       seq->table[0].new=initial;
+       seq->table[0].type=DCCP_PKT_REQUEST;
+       seq->table[0].size=0;
+       update_state(seq,OPEN);
 return initial;
 }
 
 
 /*Convert Sequence Numbers*/
-u_int32_t add_new_seq(struct seq_num *seq, __be32 num, int size, enum dccp_pkt_type type)
+u_int32_t add_new_seq(struct host *seq, __be32 num, int size, enum dccp_pkt_type type)
 {
        int prev;
        if(seq==NULL){
@@ -713,7 +617,7 @@ return seq->table[seq->cur].new +1;
 
 
 /*Convert Ack Numbers*/
-u_int32_t convert_ack(struct seq_num *seq, __be32 num)
+u_int32_t convert_ack(struct host *seq, __be32 num)
 {
        if(seq==NULL){
                dbgprintf(0,"ERROR NULL POINTER!\n");
@@ -733,7 +637,7 @@ return 0;
 
 
 /* Get size of packet being acked*/
-int acked_packet_size(struct seq_num *seq, __be32 num)
+int acked_packet_size(struct host *seq, __be32 num)
 {
        if(seq==NULL){
                dbgprintf(0,"ERROR NULL POINTER!\n");
@@ -753,7 +657,7 @@ return 0;
 
 
 /*Ack Vector to SACK Option*/
-void ack_vect2sack(struct seq_num *seq, struct tcphdr *tcph, u_char* tcpopts, u_char* dccphdr, __be32 dccpack)
+void ack_vect2sack(struct host *seq, struct tcphdr *tcph, u_char* tcpopts, u_char* dccphdr, __be32 dccpack)
 {
        int hdrlen=((struct dccp_hdr*)dccphdr)->dccph_doff*4;
        int optlen;

diff --git a/dccp2tcp.h b/dccp2tcp.h
index 151b22cb3a957943c3358370adbb917f41ce69cc..4b556cfcc979eb9ca39dff29b42cc71f803094e6 100644 (file)
--- a/dccp2tcp.h
+++ b/dccp2tcp.h
@@ -1,19 +1,18 @@
 /******************************************************************************
 Author: Samuel Jero
 
-Date: 5/2011
+Date: 7/2011
 
 Description: Header file for program to convert a DCCP flow to a TCP flow for DCCP
                 analysis via tcptrace.
 
 Notes:
-       1)Supports only a single DCCP connection per capture
-       2)Source Port!=Destination Port
-       3)DCCP MUST use 48 bit sequence numbers
-       4)Checksums are not computed (they are zeroed)
-       5)Only implements those packet types normally used in a session
-       6)DCCP Ack packets show up as TCP packets containing one byte
-       7)Very little error checking of packet headers
+       1)CCID2 ONLY
+       2)DCCP MUST use 48 bit sequence numbers
+       3)Checksums are not computed (they are zeroed)
+       4)Only implements those packet types normally used in a session
+       5)DCCP Ack packets show up as TCP packets containing one byte
+       6)Very little error checking of packet headers
 ******************************************************************************/
 #ifndef _DCCP2TCP_H
 #define _DCCP2TCP_H
@@ -48,12 +47,47 @@ Notes:
 
 
 
-/*sequence number structure--one per side of the connection */
-struct seq_num{
-       int cur;                        /*current sequence number */
-       __be16 addr;            /*connection half id---source port */
-       struct tbl *table;      /*sequence number table */
-       int size;                       /*sequence number table size */
+
+/*Packet structure*/
+struct packet{
+       struct pcap_pkthdr      *h;             /*libpcap header*/
+       u_char                          *data;  /*Packet Data*/
+       int                                     length; /*Packet length*/
+       uint32_t                        src_id; /*Source ID of packet*/
+       uint32_t                        dest_id; /*Destination ID of packet*/
+};
+
+/*Constant Packet structure*/
+struct const_packet{
+       const struct pcap_pkthdr *h;    /*libpcap header*/
+       const u_char                    *data;  /*Packet Data*/
+       int                                             length; /*Packet length*/
+       uint32_t                                src_id; /*Source ID of packet*/
+       uint32_t                                dest_id;/*Destination ID of packet*/
+};
+
+/*Connection states*/
+enum con_state{
+       INIT,
+       OPEN,
+       CLOSE,
+};
+
+/*Host---half of a connection*/
+struct host{
+       uint32_t                        id;             /*Host ID*/
+       __be16                          port;   /*Host DCCP port*/
+       struct tbl                      *table; /*Host Sequence Number Table*/
+       int                                     size;   /*Size of Sequence Number Table*/
+       int                                     cur;    /*Current TCP Sequence Number*/
+       enum con_state          state;  /*Connection state*/
+};
+
+/*Connection structure*/
+struct connection{
+       struct connection       *next;  /*List pointer*/
+       struct host                     A;              /*Host A*/
+       struct host                     B;              /*Host B*/
 };
 
 /*sequence number table structure */
@@ -70,9 +104,7 @@ extern int yellow;           /*tcptrace yellow line as currently acked packet*/
 extern int green;              /*tcptrace green line as currently acked packet*/
 extern int sack;               /*add TCP SACKS*/
 
-/*Half Connection Structures*/
-extern struct seq_num  *s1;    /*sequence number structure for side one of connection*/
-extern struct seq_num  *s2;    /*sequence number structure for side two of connection*/
+extern struct connection *chead;/*connection list*/
 
 
 /*debug printf
@@ -84,6 +116,11 @@ extern struct seq_num       *s2;    /*sequence number structure for side two of connectio
 void dbgprintf(int level, const char *fmt, ...);
 
 /*Function to parse encapsulation*/
-int do_encap(int link, struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length);
+int do_encap(int link, struct packet *new, const struct const_packet *old);
+
+/*Connection functions*/
+int get_host(uint32_t src_id, uint32_t dest_id, int src_port, int dest_port, struct host *fwd, struct host *rev);
+struct connection *add_connection(uint32_t src_id, uint32_t dest_id, int src_port, int dest_port);
+int update_state(struct host* hst, enum con_state st);
 
 #endif

diff --git a/encap.c b/encap.c
index f5c4ea77ec20d368a7e7e9c8f4fa0eec8eab21fc..b932bda706b1b04fdf56d150f5437e4e7e474fa5 100644 (file)
--- a/encap.c
+++ b/encap.c
@@ -1,7 +1,7 @@
 /******************************************************************************
 Author: Samuel Jero
 
-Date: 5/2011
+Date: 7/2011
 
 Description: Encapsulation Functions for DCCP conversion to TCP
 
@@ -11,24 +11,24 @@ Description: Encapsulation Functions for DCCP conversion to TCP
 #include "pcap/sll.h"
 
 /*Encapsulation start point and link layer selector*/
-int do_encap(int link, struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length)
+int do_encap(int link, struct packet *new, const struct const_packet *old)
 {
        switch(link){
                case DLT_EN10MB:
                                /*Ethernet*/
-                               if(!ethernet_encap(h, nptr, nlength, optr, length)){
+                               if(!ethernet_encap(new, old)){
                                                return 0;
                                }
                                break;
                case DLT_RAW:
                                /*Raw. Just IP*/
-                               if(!ipv4_encap(h, nptr, nlength, optr, length)){
+                               if(!ipv4_encap(new, old)){
                                                return 0;
                                }
                                break;
                case DLT_LINUX_SLL:
                                /*Linux Cooked Capture*/
-                               if(!linux_cooked_encap(h, nptr, nlength, optr, length)){
+                               if(!linux_cooked_encap(new, old)){
                                        return 0;
                                }
                                break;
@@ -38,49 +38,47 @@ int do_encap(int link, struct pcap_pkthdr *h, u_char **nptr, int *nlength, const
        }
 
        /*Adjust libpcap header*/
-       if(h->caplen >= h->len || h->caplen >= *nlength){
-               h->caplen=*nlength;
+       if(new->h->caplen >= new->h->len || new->h->caplen >= new->length){
+               new->h->caplen=new->length;
        }
-       h->len=*nlength;
+       new->h->len=new->length;
 
 return 1;
 }
 
 /*Standard Ethernet Encapsulation*/
-int ethernet_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length)
+int ethernet_encap(struct packet *new, const struct const_packet *old)
 {
-               struct ether_header             *ethh;
-               int                                             next_len;
-               int                                             next_nlen;
-               u_char                                  *next_nptr;
-               const u_char                    *next_optr;
+               struct ether_header     *ethh;
+               struct const_packet nold;
+               struct packet           nnew;
 
                /*Safety checks*/
-               if(!h || !nptr || !nlength || !optr || !length || !*nptr || !*optr){
+               if(!new || !old || !new->data || !old->data || !new->h || !old->h){
                        dbgprintf(0,"Error: Ethernet Encapsulation Function given bad data!\n");
                        return 0;
                }
-               if(*length < sizeof(struct ether_header) || *nlength < sizeof(struct ether_header)){
+               if(old->length < sizeof(struct ether_header) || new->length < sizeof(struct ether_header)){
                        dbgprintf(0, "Error: Ethernet Encapsulation Function given packet of wrong size!\n");
                        return 0;
                }
 
                /*Copy Ethernet header over*/
-               memcpy(*nptr, *optr, sizeof(struct ether_header));
+               memcpy(new->data, old->data, sizeof(struct ether_header));
 
                /*Cast Pointer*/
-               ethh=(struct ether_header*)(*nptr);
+               ethh=(struct ether_header*)(new->data);
 
                /*Adjust pointers and lengths*/
-               next_optr= *optr+ sizeof(struct ether_header);
-               next_nptr= *nptr+ sizeof(struct ether_header);
-               next_len= *length- sizeof(struct ether_header);
-               next_nlen= *nlength- sizeof(struct ether_header);
+               nold.data= old->data+ sizeof(struct ether_header);
+               nnew.data= new->data + sizeof(struct ether_header);
+               nold.length= old->length - sizeof(struct ether_header);
+               nnew.length= new->length - sizeof(struct ether_header);
 
                /*Select Next Protocol*/
                switch(ntohs(ethh->ether_type)){
                        case ETHERTYPE_IP:
-                                       if(!ipv4_encap(h, &next_nptr, &next_nlen, &next_optr, &next_len)){
+                                       if(!ipv4_encap(&nnew, &nold)){
                                                        return 0;
                                        }
                                        break;
@@ -91,40 +89,38 @@ int ethernet_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_c
                }
 
                /*Adjust length*/
-               *nlength=next_nlen + sizeof(struct ether_header);
+               new->length=nnew.length + sizeof(struct ether_header);
 return 1;
 }
 
 /*IPv4 Encapsulation*/
-int ipv4_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length)
+int ipv4_encap(struct packet *new, const struct const_packet *old)
 {
-               struct iphdr                    *iph;
-               int                                             next_len;
-               int                                             next_nlen;
-               u_char                                  *next_nptr;
-               const u_char                    *next_optr;
+               struct iphdr            *iph;
+               struct packet           nnew;
+               struct const_packet     nold;
 
                /*Safety checks*/
-               if(!h || !nptr || !nlength || !optr || !length || !*nptr || !*optr){
+               if(!new || !old || !new->data || !old->data || !new->h || !old->h){
                        dbgprintf(0,"Error: IPv4 Encapsulation Function given bad data!\n");
                        return 0;
                }
-               if(*length < sizeof(struct iphdr) || *nlength < sizeof(struct iphdr)){
+               if(old->length < sizeof(struct iphdr) || new->length < sizeof(struct iphdr)){
                        dbgprintf(0, "Error: IPv4 Encapsulation Function given packet of wrong size!\n");
                        return 0;
                }
 
                /*Copy IPv4 header over*/
-               memcpy(*nptr, *optr, sizeof(struct iphdr));
+               memcpy(new->data, old->data, sizeof(struct iphdr));
 
                /*Cast Pointer*/
-               iph=(struct iphdr*)(*nptr);
+               iph=(struct iphdr*)(new->data);
 
                /*Adjust pointers and lengths*/
-               next_optr= *optr +iph->ihl*4;
-               next_nptr= *nptr +iph->ihl*4;
-               next_len= *length -iph->ihl*4;
-               next_nlen= *nlength-iph->ihl*4;
+               nold.data= old->data +iph->ihl*4;
+               nnew.data= new->data +iph->ihl*4;
+               nold.length= old->length -iph->ihl*4;
+               nnew.length= new->length -iph->ihl*4;
 
                /*Confirm that this is IPv4*/
                if(iph->version!=4){
@@ -136,7 +132,9 @@ int ipv4_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char
                switch(iph->protocol){
                        case 0x21:
                                        /*DCCP*/
-                                       if(!convert_packet(h, &next_nptr, &next_nlen, &next_optr, &next_len)){
+                                       nnew.src_id=iph->saddr;
+                                       nnew.dest_id=iph->daddr;
+                                       if(!convert_packet(&nnew, &nold)){
                                                return 0;
                                        }
                                        break;
@@ -151,49 +149,47 @@ int ipv4_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char
                iph->check=htonl(0);
 
                /*Adjust length*/
-               *nlength=next_nlen + iph->ihl*4;
+               new->length=nnew.length + iph->ihl*4;
 
                /*Determine if computed length is reasonable*/
-               if(*nlength > 0xFFFF){
+               if(nnew.length > 0xFFFF){
                                dbgprintf(1, "Error: Given TCP header+data length is too large for an IPv4 packet!\n");
                                return 0;
                }
 
                /*Adjust IPv4 header to account for packet's total length*/
-               iph->tot_len=htons(*nlength);
+               iph->tot_len=htons(nnew.length);
 return 1;
 }
 
-int linux_cooked_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length)
+int linux_cooked_encap(struct packet *new, const struct const_packet *old)
 {
-       struct sll_header       *slh;
-       int                                     next_len;
-       int                                     next_nlen;
-       u_char                          *next_nptr;
-       const u_char            *next_optr;
+       struct sll_header               *slh;
+       struct packet                   nnew;
+       struct const_packet             nold;
 
 
        /*Safety checks*/
-       if(!h || !nptr || !nlength || !optr || !length || !*nptr || !*optr){
+       if(!new|| !old || !new->data || !old->data || !new->h || !old->h){
                dbgprintf(0,"Error: SLL Encapsulation Function given bad data!\n");
                return 0;
        }
-       if(*length < sizeof(struct sll_header) || *nlength < sizeof(struct sll_header)){
+       if(old->length < sizeof(struct sll_header) || new->length < sizeof(struct sll_header)){
                dbgprintf(0, "Error: SLL Encapsulation Function given packet of wrong size!\n");
                return 0;
        }
 
        /*Copy SLL header over*/
-       memcpy(*nptr, *optr, sizeof(struct sll_header));
+       memcpy(new->data, old->data, sizeof(struct sll_header));
 
        /*Cast Pointer*/
-       slh=(struct sll_header*)(*nptr);
+       slh=(struct sll_header*)(new->data);
 
        /*Adjust pointers and lengths*/
-       next_optr= *optr + sizeof(struct sll_header);
-       next_nptr= *nptr + sizeof(struct sll_header);
-       next_len= *length - sizeof(struct sll_header);
-       next_nlen= *nlength- sizeof(struct sll_header);
+       nold.data= old->data + sizeof(struct sll_header);
+       nnew.data= new->data + sizeof(struct sll_header);
+       nold.length= old->length - sizeof(struct sll_header);
+       nnew.length= new->length- sizeof(struct sll_header);
 
        /*Confirm that this is SLL*/
        if(ntohs(slh->sll_pkttype) > 4){
@@ -204,7 +200,7 @@ int linux_cooked_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const
        /*Select Next Protocol*/
        switch(ntohs(slh->sll_protocol)){
                case ETHERTYPE_IP:
-                               if(!ipv4_encap(h, &next_nptr, &next_nlen, &next_optr, &next_len)){
+                               if(!ipv4_encap(&nnew, &nold)){
                                                return 0;
                                }
                                break;
@@ -215,6 +211,6 @@ int linux_cooked_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const
        }
 
        /*Adjust length*/
-       *nlength=next_nlen + sizeof(struct sll_header);
+       new->length=nnew.length + sizeof(struct sll_header);
 return 1;
 }

diff --git a/encap.h b/encap.h
index 02aaccd683cc2b92cb3ecf9b568c5363c4755a94..1b7abca066b0f4a5973a757cdbe2d264cf5d1e3c 100644 (file)
--- a/encap.h
+++ b/encap.h
@@ -1,7 +1,7 @@
 /******************************************************************************
 Author: Samuel Jero
 
-Date: 5/2011
+Date: 7/2011
 
 Description: Header file for Encapsulation Functions for DCCP to TCP conversion
 
@@ -11,38 +11,52 @@ Description: Header file for Encapsulation Functions for DCCP to TCP conversion
 
 /*
  * All Conversion functions use these standard arguments:
- *  struct pcap_pkthdr *h: This is a copy of the libpcap packet structure.
- *                                                You are free to modify and use the fields.
- *
- *  u_char **nptr:             This is a pointer to a buffer for the new packet.
- *                                             Each encapsulation has the responsibility to call
- *                                             When a function is called, this will point at the
- *                                             location for that protocol's header to start.
- *
- *  int *nlength:              The length of the new packet. Each encapsulation
- *                                     can rely on this to contain the remaining buffer
- *                                     space AND must return with this parameter containing
- *                                     the length of the new packet at that layer.
- *
- *  u_char** optr:             This is a pointer to the buffer containing the
- *                                     old packet. When a functio is called, this will
- *                                     point at the location of that protocol's header.
- *
- *  int* length:               The length of the old packet. Each encapsulation
- *                                     layer MUST decrement this by the amount of it's
- *                                     headers. An encapsulation layer MUST never read
- *                                     beyond this into optr.
+ * struct packet *new:         The New packet. It contains the following fields.
+ *
+ *     struct pcap_pkthdr *h: This is a copy of the libpcap packet structure.
+ *                                                        You are free to modify and use the fields.
+ *
+ *     u_char *data:           This is a pointer to a buffer for the new packet.
+ *                                                     Each encapsulation has the responsibility to call
+ *                                                     When a function is called, this will point at the
+ *                                                     location for that protocol's header to start.
+ *
+ *     int length:                     The length of the new packet. Each encapsulation
+ *                                             can rely on this to contain the remaining buffer
+ *                                             space AND must return with this parameter containing
+ *                                             the length of the new packet at that layer.
+ *
+ *     uint32_t src_id:        This is an ID for the source host. If you are going to
+ *                                             demultiplex DCCP on anything but Port Numbers, you
+ *                                             need to set this field. Typically this would be an
+ *                                             IP address.
+ *
+ *     uint32_t dest_id:       This is an ID for the destination host. If you are going to
+ *                                             demultiplex DCCP on anything but Port Numbers, you
+ *                                             need to set this field. Typically this would be an
+ *                                             IP address.
+ *
+ *     struct const_packet *old:       The Old packet. It contains the following fields.
+ *
+ *     u_char* data:           This is a pointer to the buffer containing the
+ *                                             old packet. When a function is called, this will
+ *                                             point at the location of that protocol's header.
+ *
+ *     int length:                     The length of the old packet. Each encapsulation
+ *                                             layer MUST decrement this by the amount of it's
+ *                                             headers. An encapsulation layer MUST never read
+ *                                             beyond this into old->data.
  */
 
 /*
  * Last Level Conversion Function
  * Converts DCCP to TCP for analysis by TCPTRACE
  */
-int convert_packet(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length);
+int convert_packet(struct packet *new, const struct const_packet *old);
 
 /*Standard Encapsulation Functions*/
-int ethernet_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length);
-int linux_cooked_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length);
-int ipv4_encap(struct pcap_pkthdr *h, u_char **nptr, int *nlength, const u_char **optr, int *length);
+int ethernet_encap(struct packet *new, const struct const_packet *old);
+int linux_cooked_encap(struct packet *new, const struct const_packet *old);
+int ipv4_encap(struct packet *new, const struct const_packet *old);
 
 #endif /* ENCAP_H_ */