forked from snooda/net-speeder
-
Notifications
You must be signed in to change notification settings - Fork 0
/
net_speeder.c
131 lines (108 loc) · 3.08 KB
/
net_speeder.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
#include <pcap.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <libnet.h>
/* default snap length (maximum bytes per packet to capture) */
#define SNAP_LEN 65535
#ifdef COOKED
#define ETHERNET_H_LEN 16
#else
#define ETHERNET_H_LEN 14
#endif
#define SPECIAL_TTL 88
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet);
void print_usage(void);
/*
* print help text
*/
void print_usage(void) {
printf("Usage: %s [interface][\"filter rule\"]\n", "net_speeder");
printf("\n");
printf("Options:\n");
printf(" interface Listen on <interface> for packets.\n");
printf(" filter Rules to filter packets.\n");
printf("\n");
}
void got_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
static int count = 1;
struct libnet_ipv4_hdr *ip;
libnet_t *libnet_handler = (libnet_t *)args;
count++;
ip = (struct libnet_ipv4_hdr*)(packet + ETHERNET_H_LEN);
if(ip->ip_ttl != SPECIAL_TTL) {
ip->ip_ttl = SPECIAL_TTL;
int len_written = libnet_adv_write_raw_ipv4(libnet_handler, (u_int8_t *)ip, ntohs(ip->ip_len));
if(len_written < 0) {
printf("packet len:[%d] actual write:[%d]\n", ntohs(ip->ip_len), len_written);
printf("err msg:[%s]\n", libnet_geterror(libnet_handler));
}
} else {
//The packet net_speeder sent. nothing todo
}
return;
}
libnet_t* start_libnet(char *dev) {
char errbuf[LIBNET_ERRBUF_SIZE];
libnet_t *libnet_handler = libnet_init(LIBNET_RAW4_ADV, dev, errbuf);
if(NULL == libnet_handler) {
printf("libnet_init: error %s\n", errbuf);
}
return libnet_handler;
}
#define ARGC_NUM 3
int main(int argc, char **argv) {
char *dev = NULL;
char errbuf[PCAP_ERRBUF_SIZE];
pcap_t *handle;
char *filter_rule = NULL;
struct bpf_program fp;
bpf_u_int32 net, mask;
if (argc == ARGC_NUM) {
dev = argv[1];
filter_rule = argv[2];
printf("Device: %s\n", dev);
printf("Filter rule: %s\n", filter_rule);
} else {
print_usage();
return -1;
}
printf("ethernet header len:[%d](14:normal, 16:cooked)\n", ETHERNET_H_LEN);
if (pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
printf("Couldn't get netmask for device %s: %s\n", dev, errbuf);
net = 0;
mask = 0;
}
printf("init pcap\n");
handle = pcap_open_live(dev, SNAP_LEN, 1, 1000, errbuf);
if(handle == NULL) {
printf("pcap_open_live dev:[%s] err:[%s]\n", dev, errbuf);
printf("init pcap failed\n");
return -1;
}
printf("init libnet\n");
libnet_t *libnet_handler = start_libnet(dev);
if(NULL == libnet_handler) {
printf("init libnet failed\n");
return -1;
}
if (pcap_compile(handle, &fp, filter_rule, 0, net) == -1) {
printf("filter rule err:[%s][%s]\n", filter_rule, pcap_geterr(handle));
return -1;
}
if (pcap_setfilter(handle, &fp) == -1) {
printf("set filter failed:[%s][%s]\n", filter_rule, pcap_geterr(handle));
return -1;
}
while(1) {
pcap_loop(handle, 1, got_packet, (u_char *)libnet_handler);
}
/* cleanup */
pcap_freecode(&fp);
pcap_close(handle);
libnet_destroy(libnet_handler);
return 0;
}