From: Samuel Jero Date: Wed, 13 Jul 2011 02:34:33 +0000 (-0400) Subject: Multiple Connection Support X-Git-Url: http://sjero.net/git/?p=dccp2tcp;a=commitdiff_plain;h=693b1f41fcb64bcf4872dae265aad082bbe1af1c Multiple Connection Support Restriction on src!=dest ports removed --- diff --git a/Makefile b/Makefile index b4539fd..945bf2d 100644 --- 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 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 1ab8ed1..eb913bf 100644 --- 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 151b22c..4b556cf 100644 --- 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 f5c4ea7..b932bda 100644 --- 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 02aaccd..1b7abca 100644 --- 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_ */