← Back to team overview

rohc team mailing list archive

Error using the ROHC compressor

 

Hello,

I'm trying to use the rohc-compressor in a program I'm using for packet
injection.

However I get the following error when i attempt to compile :


In file included from headers.h:8,
                 from packetforwardrohc.c:9:
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:197: warning: ‘struct ip_packet’
declared inside parameter list
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:197: warning: its scope is only
this definition or declaration, which is probably not what you want
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:205: warning: ‘struct ip_packet’
declared inside parameter list
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:210: warning: ‘struct ip_packet’
declared inside parameter list
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:279: warning: ‘struct ip_packet’
declared inside parameter list
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:280: warning: ‘struct ip_packet’
declared inside parameter list
/home/josie/rohc-1.2.0/src/comp/rohc_comp.h:290: warning: ‘struct ip_packet’
declared inside parameter list
In file included from packetforwardrohc.c:9:
headers.h:14:1: warning: "ETHER_ADDR_LEN" redefined
In file included from /usr/include/libnet.h:57,
                 from packetforwardrohc.c:8:
/usr/include/net/ethernet.h:52:1: warning: this is the location of the
previous definition
packetforwardrohc.c: In function ‘got_packet’:
packetforwardrohc.c:494: warning: passing argument 2 of ‘rohc_compress’
discards qualifiers from pointer target type
/usr/lib/gcc/i486-linux-gnu/4.2.4/../../../../lib/crt1.o: In function
`_start':
(.text+0x18): undefined reference to `main'
/tmp/cc2r5eZ0.o: In function `got_packet':
packetforwardrohc.c:(.text+0xd38): undefined reference to `rohc_compress'
/tmp/cc2r5eZ0.o: In function `main.5994':
packetforwardrohc.c:(.text+0xe08): undefined reference to `crc_get_polynom'
packetforwardrohc.c:(.text+0xe16): undefined reference to `crc_table_3'
packetforwardrohc.c:(.text+0xe1b): undefined reference to `crc_init_table'
packetforwardrohc.c:(.text+0xe27): undefined reference to `crc_get_polynom'
packetforwardrohc.c:(.text+0xe35): undefined reference to `crc_table_7'
packetforwardrohc.c:(.text+0xe3a): undefined reference to `crc_init_table'
packetforwardrohc.c:(.text+0xe46): undefined reference to `crc_get_polynom'
packetforwardrohc.c:(.text+0xe54): undefined reference to `crc_table_8'
packetforwardrohc.c:(.text+0xe59): undefined reference to `crc_init_table'
packetforwardrohc.c:(.text+0xe7d): undefined reference to
`rohc_alloc_compressor'
packetforwardrohc.c:(.text+0xffa): undefined reference to
`rohc_activate_profile'
packetforwardrohc.c:(.text+0x1010): undefined reference to
`rohc_activate_profile'
packetforwardrohc.c:(.text+0x1026): undefined reference to
`rohc_activate_profile'
packetforwardrohc.c:(.text+0x103c): undefined reference to
`rohc_activate_profile'
packetforwardrohc.c:(.text+0x1052): undefined reference to
`rohc_activate_profile'
packetforwardrohc.c:(.text+0x121f): undefined reference to
`rohc_alloc_compressor'
packetforwardrohc.c:(.text+0x13a1): undefined reference to
`rohc_free_compressor'
collect2: ld returned 1 exit status


Could you tell me what I might be doing wrong? Attached is the sample code.

Would really appreciate your feedback, thanks.

Regards,
Josephine
/*
 * packetforward.c
 * Copyright (c) 2008 by Micky Holdorf
 *
 */

#include <pcap.h>
#include <libnet.h>
#include "headers.h"


#include "/home/josie/rohc-1.2.0/src/common/rohc.h"
#include "/home/josie/rohc-1.2.0/src/comp/rohc_comp.h"


#define APP_NAME		"PacketForward 0.8.1"
#define APP_DESC		"IP packet capture and forward application based on libpcap and libnet."
#define APP_COPYRIGHT	"Copyright (c) 2008 by Micky Holdorf"

/* default snap length (maximum bytes per packet to capture) */
#define SNAP_LEN 4096


char *dev = NULL;						/* capture device1 name */
char *dev2 = NULL;						/* capture device2 name */
char *daddr1 = NULL;
char *daddr2 = NULL;
char *saddr1 = NULL;
char *saddr2 = NULL;

u_char enet_src[6] = {0x0d, 0x0e, 0x0a, 0x0d, 0x00, 0x00};
u_char enet_dst[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
int hide_header = 0;
int hide_payload = 0;
int capture_only = 0;

void send_packet(char *protocol, int sport, int dport, int id, int ttl, int count, const u_char *payload, int payload_size);
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);
void print_payload(const u_char *payload, int len);
void print_hex_ascii_line(const u_char *payload, int len, int offset);
void print_app_banner(void);
void print_app_usage(char *name);

/* app name/banner */
void print_app_banner(void) {

	printf("\n%s\n", APP_NAME);
	printf("%s\n", APP_DESC);
	printf("%s\n", APP_COPYRIGHT);
	printf("\n");

	return;
}

/* print help text */
void print_app_usage(char *name) {

	print_app_banner();

	printf("usage:\n   %s <interface> [options]\n\n", name);
	printf("interface:\n");
	printf("   -i interface1      Capture packets from interface1.\n\n");
	printf("options:\n");
	printf("   -I interface2      Forward packets to interface2.\n");
	printf("   -d ip address      Destination ip address of forwarded packets.\n");
	printf("   -n number          Number of packets to capture.\n");
	printf("   -h                 Hide packet headers.\n");
	printf("   -p                 Hide payload.\n");
	printf("   -c                 Capture packets only.\n");
	printf("   -f 'filter'        Tcpdump packet filter expression.\n\n");
	printf("example:\n");
	printf("   sudo packetforward -i en1 -I tap0 -d 5.124.100.100 -f 'udp port 6112 and dst host 255.255.255.255'\n\n'");

	return;
}

/* print data to file */
void fprint_ascii_line(const u_char *payload, int len, int offset) {

	int i;
	int gap;
	const u_char *ch;
	FILE *file;
	file = fopen("/tmp/payload.txt", "w+");
	
	/* ascii */
	ch = payload;
	for(i = 0; i < len; i++) {
		fprintf(file, "%c", *ch);
		ch++;
	}
	fclose (file);

	return;
}

/*
 * print data in rows of 16 bytes: offset   hex   ascii
 * 00000   4745 5420 2f20 4854   5450 2f31 2e31 0d0a   GET / HTTP/1.1..
 */
void print_hex_ascii_line(const u_char *payload, int len, int offset) {

	int i;
	int gap;
	const u_char *ch;

	/* offset */
	printf("%05d   ", offset);
	
	/* hex */
	ch = payload;
	for(i = 0; i < len; i++) {
		printf("%02x", *ch);
		ch++;
		/* print extra space after for visual aid */
		if (i%2 != 0)
			printf(" ");
		if (i == 7)
			printf("   ");
	}
	/* print space to handle line less than 8 bytes */
	if (len < 8)
		printf("   ");
	
	/* fill hex gap with spaces if not full line */
	if (len < 16) {
		gap = 16 - len;
		for (i = 0; i < gap; i++) {
			printf("  ");
			if (i%2 == 0)
				printf(" ");
		}
	}
	printf("   ");
	
	/* ascii (if printable) */
	ch = payload;
	for(i = 0; i < len; i++) {
		if (isprint(*ch))
			printf("%c", *ch);
		else
			printf(".");
		ch++;
	}

	printf("\n");

	return;
}

/*
 * print packet payload data (avoid printing binary data)
 */
void print_payload(const u_char *payload, int len) {

	int len_rem = len;
	int line_width = 16;			/* number of bytes per line */
	int line_len;
	int offset = 0;					/* zero-based offset counter */
	const u_char *ch = payload;

	if (len <= 0)
		return;

	/* data fits on one line */
	if (len <= line_width) {
		print_hex_ascii_line(ch, len, offset);
		return;
	}

	/* data spans multiple lines */
	for ( ;; ) {
		/* compute current line length */
		line_len = line_width % len_rem;
		/* print line */
		print_hex_ascii_line(ch, line_len, offset);
		/* compute total remaining */
		len_rem = len_rem - line_len;
		/* shift pointer to remaining bytes to print */
		ch = ch + line_len;
		/* add offset */
		offset = offset + line_width;
		/* check if we have line width chars or less */
		if (len_rem <= line_width) {
			/* print last line and get out */
			print_hex_ascii_line(ch, len_rem, offset);
			break;
		}
	}

	return;
}

void send_packet(char *protocol, int sport2, int dport2, int id, int ttl, int count, const u_char *payload, int payload_size) {

	char errbuf[LIBNET_ERRBUF_SIZE];   /* error buffer */
	struct libnet_link_int *network;   /* pointer to link interface struct */
    int packet_size;                   /* size of our packet */
    int ip_size;				       /* size of our ip */
    int udp_size;                           /* size of our udp */
    int tcp_size;                           /* size of our tcp */
	int c;                
    u_char *packet;                    /* pointer to our packet buffer */
	
	  
    /*
     *  Step 1: Network Initialization (interchangable with step 2).
     */
	if ((network = libnet_open_link_interface(dev2, errbuf)) == NULL) {
        libnet_error(LIBNET_ERR_FATAL, "libnet_open_link_interface: %s\n", errbuf);
    }

    /*
     *  We're going to build a UDP packet with a payload using the
     *  link-layer API, so this time we need memory for a ethernet header
     *  as well as memory for the ICMP and IP headers and our payload.
     */
	if (protocol == "udp") {
		packet_size = LIBNET_ETH_H + LIBNET_IP_H + LIBNET_UDP_H + payload_size;
		ip_size = LIBNET_IP_H + LIBNET_UDP_H + payload_size;
		udp_size = LIBNET_UDP_H + payload_size;

		/*
		*  Step 2: Memory Initialization (interchangable with step 1).
		*/
		if (libnet_init_packet(packet_size, &packet) == -1) {
			libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed\n");
		}

		/*
		*  Step 3: Packet construction (ethernet header).
		*/
		libnet_build_ethernet(
				enet_dst,
				enet_src,
				ETHERTYPE_IP,
				NULL,
				0,
				packet);

		printf("\n--- Injected packet number %i on %s ---\n", count, dev2);

		/*
		*  Step 3: Packet construction (IP header).
		*/
		libnet_build_ip(
				LIBNET_UDP_H + payload_size,
				0,                      /* IP tos */
				id,                     /* IP ID */
				0,                      /* Frag */
				ttl,                    /* TTL */
				IPPROTO_UDP,            /* Transport protocol */
				inet_addr(saddr2),         /* Source IP */
				inet_addr(daddr2),         /* Destination IP */
				payload,                   /* Pointer to payload (none) */
				0,
				packet + LIBNET_ETH_H); /* Packet header memory */

		/*
		*  Step 3: Packet construction (UDP header).
		*/
		libnet_build_udp(
				sport2,                 /* source port */
				dport2,                 /* dest. port */
				payload,                /* payload */ 
				payload_size,           /* payload length */ 
				packet + LIBNET_ETH_H + LIBNET_IP_H);
	
		/*
		*  Step 4: Packet checksums (ICMP header *AND* IP header).
		*/
		if (libnet_do_checksum(packet + ETH_H, IPPROTO_UDP, LIBNET_UDP_H + payload_size) == -1) {
			libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");
		}
		if (libnet_do_checksum(packet + ETH_H, IPPROTO_IP, LIBNET_IP_H) == -1) {
			libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");
		}
		
		
		/* print packet info */
		if (!hide_header) {
			printf("IP header    Src Addr: %s", saddr2);
			printf("   Dst Addr: %s\n", daddr2);
			printf("             Len: %i   ID: %i   TTL: %i\n", ip_size, id, ttl);
			printf("UDP header   Src port: %i   Dst port: %i   Len: %i\n", sport2, dport2, udp_size);
		}
		if (!hide_payload) {
			printf("Payload (%d bytes)\n", payload_size);
			print_payload(payload, payload_size);
		}
	}
	
	if (protocol == "tcp") {
		packet_size = LIBNET_ETH_H + LIBNET_IP_H + LIBNET_TCP_H + payload_size;
		ip_size = LIBNET_IP_H + LIBNET_TCP_H + payload_size;
		tcp_size = LIBNET_TCP_H + payload_size;
		
		/*
		*  Step 2: Memory Initialization (interchangable with step 1).
		*/
		if (libnet_init_packet(packet_size, &packet) == -1) {
			libnet_error(LIBNET_ERR_FATAL, "libnet_init_packet failed\n");
		}

		/*
		*  Step 3: Packet construction (ethernet header).
		*/
		libnet_build_ethernet(
				enet_dst,
				enet_src,
				ETHERTYPE_IP,
				NULL,
				0,
				packet);

		printf("\n--- Injected packet number %i on %s ---\n", count, dev2);

		/*
		*  Step 3: Packet construction (IP header).
		*/
		libnet_build_ip(
				LIBNET_TCP_H + payload_size,
				0,                      /* IP tos */
				id,                     /* IP ID */
				0,                      /* Frag */
				ttl,                    /* TTL */
				IPPROTO_TCP,            /* Transport protocol */
				inet_addr(saddr2),         /* Source IP */
				inet_addr(daddr2),         /* Destination IP */
				payload,                /* Pointer to payload */
				0,
				packet + LIBNET_ETH_H); /* Packet header memory */

		/*
		*  Step 3: Packet construction (TCP header).
		*/
		libnet_build_tcp(
				sport2,                /* source TCP port */
				dport2,                /* destination TCP port */
				0xa1d95,                /* sequence number */
				0x53,                   /* acknowledgement number */
				TH_SYN,                 /* control flags */
				1024,                   /* window size */
				0,                      /* urgent pointer */
				NULL,                   /* payload (none) */
				0,                      /* payload length */
				packet + LIBNET_ETH_H + LIBNET_IP_H);
	
		/*
		*  Step 4: Packet checksums (ICMP header *AND* IP header).
		*/
		if (libnet_do_checksum(packet + ETH_H, IPPROTO_TCP, LIBNET_TCP_H + payload_size) == -1) {
			libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");
		}
		if (libnet_do_checksum(packet + ETH_H, IPPROTO_IP, LIBNET_IP_H) == -1) {
			libnet_error(LIBNET_ERR_FATAL, "libnet_do_checksum failed\n");
		}
		
		/* print packet info */
		if (!hide_header) {
			printf("IP header    Src Addr: %s", saddr2);
			printf("   Dst Addr: %s\n", daddr2);
			printf("             Len: %i   ID: %i   TTL: %i\n", ip_size, id, ttl);
			printf("TCP header   Src port: %i   Dst port: %i   Len: %i\n", sport2, dport2, tcp_size);
		}
		if (!hide_payload) {
			printf("Payload (%d bytes)\n", payload_size);
			print_payload(payload, payload_size);
		}
	}

	/*
	 *  Step 5: Packet injection.
	 */
	c = libnet_write_link_layer(network, dev2, packet, packet_size);
	if (c < packet_size) {
		libnet_error(LN_ERR_WARNING, "libnet_write_link_layer only wrote %d bytes\n", c);
	}

    /*
     *  Shut down the interface.
     */
    if (libnet_close_link_interface(network) == -1) {   
        libnet_error(LN_ERR_WARNING, "libnet_close_link_interface couldn't close the interface");
    }

    /*
     *  Free packet memory.
     */
    libnet_destroy_packet(&packet);
	printf("\n");
}

/*
 * dissect/print packet
 */
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {

	static int count = 1;                   /* packet counter */
	
	/* declare pointers to packet headers */
	const struct sniff_ethernet *ethernet;  /* The ethernet header [1] */
	const struct sniff_ip *ip;              /* The IP header */
	const struct sniff_tcp *tcp;            /* The TCP header */
	const struct sniff_udp *udp;            /* The UDP header */
	const u_char *payload;                  /* Packet payload */

	int size_ip;
	int size_tcp;
	int size_udp;
	int size_payload;
	char *protocol;
	char nemesis[1000];
	int sport,dport;
	const u_char *ch;
	char *errbuf;
	struct libnet_link_int *link2 = NULL;
	int id, ttl;

	struct rohc_comp *comp;
	/*unsigned char packet[SNAP_LEN]; */
  	unsigned int packet_len;
  	unsigned char rohc_packet[SNAP_LEN];
  	int rohc_size;
		
	printf("\n--- Captured packet number %i on %s ---\n", count,dev);
	
	/* define ethernet header */
	ethernet = (struct sniff_ethernet*)(packet);
	
	/* define/compute ip header offset */
	ip = (struct sniff_ip*)(packet + SIZE_ETHERNET);
	size_ip = IP_HL(ip)*4;
	if (size_ip < 20) {
		printf("\n  Error: invalid IP header length: %u bytes\n", size_ip);
		return;
	}
		
	/* determine protocol */	
	switch(ip->ip_p) {
		case IPPROTO_UDP:
			goto udp;
		case IPPROTO_ICMP:
			printf("  ICMP header\n");
			return;
		case IPPROTO_IP:
			printf("  IP header\n");
			return;
		default:
			printf("  Unknown header\n");
			return;
	}
	

udp:
	/* this packet is UDP */	
	protocol="udp";
	
	/* define/compute udp header offset */
	udp = (struct sniff_udp*)(packet + SIZE_ETHERNET + size_ip);
	size_udp = 8;
		
	/* define/compute tcp payload (segment) offset */
	payload = (u_char *)(packet + SIZE_ETHERNET + size_ip + size_udp);
	
	/* compute udp payload (segment) size */
	size_payload = ntohs(ip->ip_len) - (size_ip + size_udp);

	sport=ntohs(udp->uh_sport);
	dport=ntohs(udp->uh_dport);
	
	if (!hide_header) {
	/* print source and destination IP addresses */
		printf("IP header    Src Addr: %s", inet_ntoa(ip->ip_src));
		printf("   Dst Addr: %s\n", inet_ntoa(ip->ip_dst));
		printf("             Len: %i   ID: %i   TTL: %i\n", size_ip+size_udp+size_payload, ip->ip_id, ip->ip_ttl);
		printf("UDP header   Src Port: %i   Dst Port: %i   Len: %i\n", ntohs(udp->uh_sport), ntohs(udp->uh_dport), size_udp+size_payload);
	}
	if (!hide_payload) {
		/* Print payload data; it might be binary, so don't just treat it as a string. */
		printf("Payload (%d bytes)\n", size_payload);
		print_payload(payload, size_payload);
	}
	goto end;

end:	
	if (daddr2 == NULL) daddr2 = inet_ntoa(ip->ip_dst);
	id = ip->ip_id;
	ttl = ip->ip_ttl;
	
	if (!capture_only)
		{
		
		rohc_size = rohc_compress(comp, packet, packet_len, rohc_packet, SNAP_LEN);
                                                        

		send_packet(protocol, sport, dport, id, ttl, count, payload, size_payload);
/*	
	ch = payload;
	fprint_ascii_line(ch, size_payload, 0);
	sprintf(nemesis,"sudo nemesis %s -x %i -y %i -S %s -D %s -d %s -T 255 -P/tmp/payload.txt", 
				protocol, sport, dport, saddr2, daddr2, dev2);
	system(nemesis);
*/
	count++;
	return;
}

int main(int argc, char **argv) {

	bpf_u_int32 mask, mask2;				/* subnet mask */
	bpf_u_int32 net, net2;					/* ip */
	char errbuf[PCAP_ERRBUF_SIZE];			/* error buffer */
	pcap_t *handle;							/* packet capture handle */
	char filter_exp[] = "ip";				/* filter expression */
	struct bpf_program fp;					/* compiled filter program (expression) */
	int c,num_packets = -1;					/* number of packets to capture */
    
	struct libnet_link_int *l;
	u_long i;
	struct rohc_comp *comp;

	 /* init the CRC tables */
	crc_init_table(crc_table_3, crc_get_polynom(CRC_TYPE_3));
	crc_init_table(crc_table_7, crc_get_polynom(CRC_TYPE_7));
	crc_init_table(crc_table_8, crc_get_polynom(CRC_TYPE_8));

	/* create the compressor */
	comp = rohc_alloc_compressor(15, 0, 0, 0);
	if(comp == NULL)
	{
		printf("cannot create the compressor 1\n");
		printf("\t\t</log>\n");
		printf("\t\t<status>failed</status>\n");
		printf("\t</startup>\n\n");
		goto destroy_comp;
	}
	/* check command-line options */
    while ((c = getopt(argc, argv, "i:I:d:n:hpcf:")) != EOF) {
        switch (c) {
            case 'i':
				dev = optarg;
				dev2 = dev;				
                break;
            case 'I':
				dev2 = optarg;
				break;
			case 'd':
				daddr2 = optarg;
                break;
            case 'n':
				num_packets = atoi(optarg);
                break;
            case 'f':
				strcpy(filter_exp, optarg);
                break;
            case 'h':
				hide_header = 1;
                break;
            case 'p':
				hide_payload = 1;
                break;
            case 'c':
				capture_only = 1;
                break;
            default:
                print_app_usage(argv[0]);
                exit(EXIT_FAILURE);
        }
    }

	if (dev == NULL) {
		print_app_usage(argv[0]);
		exit(EXIT_FAILURE);
	}

	
	
	rohc_activate_profile(comp, ROHC_PROFILE_UNCOMPRESSED);
	rohc_activate_profile(comp, ROHC_PROFILE_UDP);
	rohc_activate_profile(comp, ROHC_PROFILE_IP);
	rohc_activate_profile(comp, ROHC_PROFILE_UDPLITE);
	rohc_activate_profile(comp, ROHC_PROFILE_RTP);

	/* get source ip address associated with forward device */
	l = libnet_open_link_interface(dev2, errbuf);
	if (!l) {
        printf("libnet_open_link_interface: %s\n", errbuf);
        goto failure;
    }
	
	i = libnet_get_ipaddr(l, dev2, errbuf);
	if (!i) {
        printf("Can't get ip address: %s\n", errbuf);
        goto failure;
    }
	
	saddr2 = (char *)libnet_host_lookup(ntohl(i), 0);
					
	/* get network number and mask associated with capture device */
	if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
		printf("  Error: couldn't get netmask for interface %s\n\n", errbuf);
		goto failure;
	}

	/* print capture info */
	printf("\n Capture from: %s\n", dev);
	printf("   Forward to: %s\n", dev2);
	printf("  Src Address: %s\n", saddr2);
	if (daddr2) printf("  Dst Address: %s\n", daddr2);
	else printf("  Dst Address: Not changed\n");
	if(num_packets > 0) printf("Packets to capture: %d\n", num_packets);
	printf("Packet Filter: %s\n", filter_exp);
	printf("\n");



	/* create ROHC compressor */
        comp = rohc_alloc_compressor(15, 0, 0, 0);
  if(comp == NULL)

	/* open capture device */
	handle = pcap_open_live(dev, SNAP_LEN, 1, 1000, errbuf);
	if (handle == NULL) {
		printf("\n  Error: couldn't open interface %s: %s\n\n", dev, errbuf);
		goto failure;
	}

	/* make sure we're capturing on an Ethernet device */
	if (pcap_datalink(handle) != DLT_EN10MB) {
		printf("\n  Error: %s is not on ethernet\n\n", dev);
		goto failure;
	}

	/* compile the filter expression */
	if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
		printf("\n  Error: couldn't parse filter %s: %s\n\n", filter_exp, pcap_geterr(handle));
		goto failure;
	}

	/* apply the compiled filter */
	if (pcap_setfilter(handle, &fp) == -1) {
		printf("\n  Error: couldn't install filter %s: %s\n\n", filter_exp, pcap_geterr(handle));
		goto failure;
	}

	/* now we can set our callback function */
	pcap_loop(handle, num_packets, got_packet, NULL);

destroy_comp:
	rohc_free_compressor(comp);
	printf("\nDeleting compressor..\n\n");

	/* cleanup */
	pcap_freecode(&fp);
	pcap_close(handle);

	printf("\nCapture, compression and forward complete.\n\n");
	exit(EXIT_SUCCESS);

failure:
	exit(EXIT_FAILURE);

}
}

Follow ups