Typedef refresh
This commit is contained in:
+375
-173
@@ -42,18 +42,50 @@
|
||||
#include <pcap.h>
|
||||
#include <signal.h>
|
||||
#include <pthread.h>
|
||||
#include <sys/socket.h>
|
||||
|
||||
#include "../config.h"
|
||||
#include "ndpi_api.h"
|
||||
|
||||
#ifdef HAVE_JSON_C
|
||||
#include <json.h>
|
||||
#endif
|
||||
|
||||
#include "ndpi_api.h"
|
||||
|
||||
#include <sys/socket.h>
|
||||
|
||||
#define MAX_NUM_READER_THREADS 16
|
||||
#define IDLE_SCAN_PERIOD 10 /* msec (use detection_tick_resolution = 1000) */
|
||||
#define MAX_IDLE_TIME 30000
|
||||
#define IDLE_SCAN_BUDGET 1024
|
||||
#define NUM_ROOTS 512
|
||||
#define GTP_U_V1_PORT 2152
|
||||
#define TZSP_PORT 37008
|
||||
#define MAX_NDPI_FLOWS 200000000
|
||||
|
||||
#ifndef ETH_P_IP
|
||||
#define ETH_P_IP 0x0800 /* IPv4 */
|
||||
#endif
|
||||
|
||||
#ifndef ETH_P_IPv6
|
||||
#define ETH_P_IPV6 0x86dd /* IPv6 */
|
||||
#endif
|
||||
|
||||
#define SLARP 0x8035 /* Cisco Slarp */
|
||||
#define CISCO_D_PROTO 0x2000 /* Cisco Discovery Protocol */
|
||||
|
||||
#define VLAN 0x8100
|
||||
#define MPLS_UNI 0x8847
|
||||
#define MPLS_MULTI 0x8848
|
||||
#define PPPoE 0x8864
|
||||
#define SNAP 0xaa
|
||||
|
||||
/* mask for FCF */
|
||||
#define WIFI_DATA 0x2 /* 0000 0010 */
|
||||
#define FCF_TYPE(fc) (((fc) >> 2) & 0x3) /* 0000 0011 = 0x3 */
|
||||
#define FCF_SUBTYPE(fc) (((fc) >> 4) & 0xF) /* 0000 1111 = 0xF */
|
||||
#define FCF_TO_DS(fc) ((fc) & 0x0100)
|
||||
#define FCF_FROM_DS(fc) ((fc) & 0x0200)
|
||||
|
||||
/* mask for Bad FCF presence */
|
||||
#define BAD_FCS 0x50 /* 0101 0000 */
|
||||
|
||||
/**
|
||||
* @brief Set main components necessary to the detection
|
||||
@@ -100,12 +132,6 @@ static u_int32_t detection_tick_resolution = 1000;
|
||||
static time_t capture_for = 0;
|
||||
static time_t capture_until = 0;
|
||||
|
||||
#define IDLE_SCAN_PERIOD 10 /* msec (use detection_tick_resolution = 1000) */
|
||||
#define MAX_IDLE_TIME 30000
|
||||
#define IDLE_SCAN_BUDGET 1024
|
||||
|
||||
#define NUM_ROOTS 512
|
||||
|
||||
static u_int32_t num_flows;
|
||||
|
||||
struct thread_stats {
|
||||
@@ -143,21 +169,15 @@ struct reader_thread {
|
||||
|
||||
static struct reader_thread ndpi_thread_info[MAX_NUM_READER_THREADS];
|
||||
|
||||
#define GTP_U_V1_PORT 2152
|
||||
#define MAX_NDPI_FLOWS 200000000
|
||||
/**
|
||||
* @brief ID tracking
|
||||
*/
|
||||
typedef struct ndpi_id {
|
||||
u_int8_t ip[4]; //< Ip address
|
||||
struct ndpi_id_struct *ndpi_id; //< nDpi worker structure
|
||||
u_int8_t ip[4]; // Ip address
|
||||
struct ndpi_id_struct *ndpi_id; // nDpi worker structure
|
||||
} ndpi_id_t;
|
||||
|
||||
static u_int32_t size_id_struct = 0; //< ID tracking structure size
|
||||
|
||||
#ifndef ETH_P_IP
|
||||
#define ETH_P_IP 0x0800
|
||||
#endif
|
||||
static u_int32_t size_id_struct = 0; // ID tracking structure size
|
||||
|
||||
// flow tracking
|
||||
typedef struct ndpi_flow {
|
||||
@@ -168,10 +188,9 @@ typedef struct ndpi_flow {
|
||||
u_int8_t detection_completed, protocol;
|
||||
u_int16_t vlan_id;
|
||||
struct ndpi_flow_struct *ndpi_flow;
|
||||
char lower_name[32], upper_name[32];
|
||||
|
||||
char lower_name[48], upper_name[48];
|
||||
u_int8_t ip_version;
|
||||
u_int64_t last_seen;
|
||||
|
||||
u_int64_t bytes;
|
||||
u_int32_t packets;
|
||||
|
||||
@@ -207,7 +226,7 @@ static void help(u_int long_help) {
|
||||
#endif
|
||||
" -d | Disable protocol guess and use only DPI\n"
|
||||
" -q | Quiet mode\n"
|
||||
" -t | Dissect GTP tunnels\n"
|
||||
" -t | Dissect GTP/TZSP tunnels\n"
|
||||
" -r | Print nDPI version and git revision\n"
|
||||
" -w <path> | Write test output on the specified file. This is useful for\n"
|
||||
" | testing purposes in order to compare results across runs\n"
|
||||
@@ -476,19 +495,18 @@ static void printFlow(u_int16_t thread_id, struct ndpi_flow *flow) {
|
||||
FILE *out = results_file ? results_file : stdout;
|
||||
|
||||
if(!json_flag) {
|
||||
#if 0
|
||||
fprintf(out, "\t%s [VLAN: %u] %s:%u <-> %s:%u\n",
|
||||
ipProto2Name(flow->protocol), flow->vlan_id,
|
||||
flow->lower_name, ntohs(flow->lower_port),
|
||||
flow->upper_name, ntohs(flow->upper_port));
|
||||
|
||||
#else
|
||||
fprintf(out, "\t%u", ++num_flows);
|
||||
|
||||
fprintf(out, "\t%s %s:%u <-> %s:%u ",
|
||||
ipProto2Name(flow->protocol),
|
||||
flow->lower_name, ntohs(flow->lower_port),
|
||||
flow->upper_name, ntohs(flow->upper_port));
|
||||
fprintf(out, "\t%s %s%s%s:%u <-> %s%s%s:%u ",
|
||||
ipProto2Name(flow->protocol),
|
||||
(flow->ip_version == 6) ? "[" : "",
|
||||
flow->lower_name,
|
||||
(flow->ip_version == 6) ? "]" : "",
|
||||
ntohs(flow->lower_port),
|
||||
(flow->ip_version == 6) ? "[" : "",
|
||||
flow->upper_name,
|
||||
(flow->ip_version == 6) ? "]" : "",
|
||||
ntohs(flow->upper_port));
|
||||
|
||||
if(flow->vlan_id > 0) fprintf(out, "[VLAN: %u]", flow->vlan_id);
|
||||
|
||||
@@ -505,14 +523,13 @@ static void printFlow(u_int16_t thread_id, struct ndpi_flow *flow) {
|
||||
ndpi_get_proto_name(ndpi_thread_info[thread_id].ndpi_struct, flow->detected_protocol.protocol));
|
||||
|
||||
fprintf(out, "[%u pkts/%llu bytes]",
|
||||
flow->packets, (long long unsigned int)flow->bytes);
|
||||
flow->packets, (long long unsigned int)flow->bytes);
|
||||
|
||||
if(flow->host_server_name[0] != '\0') fprintf(out, "[Host: %s]", flow->host_server_name);
|
||||
if(flow->ssl.client_certificate[0] != '\0') fprintf(out, "[SSL client: %s]", flow->ssl.client_certificate);
|
||||
if(flow->ssl.server_certificate[0] != '\0') fprintf(out, "[SSL server: %s]", flow->ssl.server_certificate);
|
||||
|
||||
fprintf(out, "\n");
|
||||
#endif
|
||||
} else {
|
||||
#ifdef HAVE_JSON_C
|
||||
jObj = json_object_new_object();
|
||||
@@ -633,16 +650,6 @@ static void node_proto_guess_walker(const void *node, ndpi_VISIT which, int dept
|
||||
struct ndpi_flow *flow = *(struct ndpi_flow **) node;
|
||||
u_int16_t thread_id = *((u_int16_t *) user_data);
|
||||
|
||||
#if 0
|
||||
printf("<%d>Walk on node %s (%p)\n",
|
||||
depth,
|
||||
which == preorder?"preorder":
|
||||
which == postorder?"postorder":
|
||||
which == endorder?"endorder":
|
||||
which == leaf?"leaf": "unknown",
|
||||
flow);
|
||||
#endif
|
||||
|
||||
if((which == ndpi_preorder) || (which == ndpi_leaf)) { /* Avoid walking the same node multiple times */
|
||||
if(enable_protocol_guess) {
|
||||
if(flow->detected_protocol.protocol == NDPI_PROTOCOL_UNKNOWN) {
|
||||
@@ -706,23 +713,27 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
const u_int8_t version,
|
||||
u_int16_t vlan_id,
|
||||
const struct ndpi_iphdr *iph,
|
||||
const struct ndpi_ipv6hdr *iph6,
|
||||
u_int16_t ip_offset,
|
||||
u_int16_t ipsize,
|
||||
u_int16_t l4_packet_len,
|
||||
struct ndpi_tcphdr **tcph,
|
||||
struct ndpi_udphdr **udph,
|
||||
u_int16_t *sport, u_int16_t *dport,
|
||||
struct ndpi_id_struct **src,
|
||||
struct ndpi_id_struct **dst,
|
||||
u_int8_t *proto,
|
||||
const struct ndpi_ip6_hdr *iph6) {
|
||||
u_int8_t **payload,
|
||||
u_int16_t *payload_len,
|
||||
u_int8_t *src_to_dst_direction) {
|
||||
u_int32_t idx, l4_offset;
|
||||
struct ndpi_tcphdr *tcph = NULL;
|
||||
struct ndpi_udphdr *udph = NULL;
|
||||
u_int32_t lower_ip;
|
||||
u_int32_t upper_ip;
|
||||
u_int16_t lower_port;
|
||||
u_int16_t upper_port;
|
||||
struct ndpi_flow flow;
|
||||
void *ret;
|
||||
u_int8_t *l3;
|
||||
u_int8_t *l3, *l4;
|
||||
|
||||
/*
|
||||
Note: to keep things simple (ndpiReader is just a demo app)
|
||||
@@ -739,7 +750,7 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
l4_offset = iph->ihl * 4;
|
||||
l3 = (u_int8_t*)iph;
|
||||
} else {
|
||||
l4_offset = sizeof(struct ndpi_ip6_hdr);
|
||||
l4_offset = sizeof(struct ndpi_ipv6hdr);
|
||||
l3 = (u_int8_t*)iph6;
|
||||
}
|
||||
|
||||
@@ -768,19 +779,25 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
}
|
||||
|
||||
*proto = iph->protocol;
|
||||
l4 = ((u_int8_t *) l3 + l4_offset);
|
||||
|
||||
if(iph->protocol == 6 && l4_packet_len >= 20) {
|
||||
u_int tcp_len;
|
||||
|
||||
ndpi_thread_info[thread_id].stats.tcp_count++;
|
||||
|
||||
// tcp
|
||||
tcph = (struct ndpi_tcphdr *) ((u_int8_t *) l3 + l4_offset);
|
||||
*tcph = (struct ndpi_tcphdr *)l4;
|
||||
*sport = ntohs((*tcph)->source), *dport = ntohs((*tcph)->dest);
|
||||
|
||||
if(iph->saddr < iph->daddr) {
|
||||
lower_port = tcph->source;
|
||||
upper_port = tcph->dest;
|
||||
lower_port = (*tcph)->source, upper_port = (*tcph)->dest;
|
||||
*src_to_dst_direction = 1;
|
||||
} else {
|
||||
lower_port = tcph->dest;
|
||||
upper_port = tcph->source;
|
||||
lower_port = (*tcph)->dest;
|
||||
upper_port = (*tcph)->source;
|
||||
|
||||
*src_to_dst_direction = 0;
|
||||
if(iph->saddr == iph->daddr) {
|
||||
if(lower_port > upper_port) {
|
||||
u_int16_t p = lower_port;
|
||||
@@ -790,18 +807,38 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
tcp_len = ndpi_min(4*(*tcph)->doff, l4_packet_len);
|
||||
*payload = &l4[tcp_len];
|
||||
*payload_len = ndpi_max(0, l4_packet_len-4*(*tcph)->doff);
|
||||
} else if(iph->protocol == 17 && l4_packet_len >= 8) {
|
||||
// udp
|
||||
ndpi_thread_info[thread_id].stats.udp_count++;
|
||||
|
||||
udph = (struct ndpi_udphdr *) ((u_int8_t *) l3 + l4_offset);
|
||||
*udph = (struct ndpi_udphdr *)l4;
|
||||
*sport = ntohs((*udph)->source), *dport = ntohs((*udph)->dest);
|
||||
*payload = &l4[sizeof(struct ndpi_udphdr)];
|
||||
*payload_len = ndpi_max(0, l4_packet_len-sizeof(struct ndpi_udphdr));
|
||||
|
||||
if(iph->saddr < iph->daddr) {
|
||||
lower_port = udph->source;
|
||||
upper_port = udph->dest;
|
||||
lower_port = (*udph)->source, upper_port = (*udph)->dest;
|
||||
*src_to_dst_direction = 1;
|
||||
} else {
|
||||
lower_port = udph->dest;
|
||||
upper_port = udph->source;
|
||||
lower_port = (*udph)->dest, upper_port = (*udph)->source;
|
||||
|
||||
*src_to_dst_direction = 0;
|
||||
|
||||
if(iph->saddr == iph->daddr) {
|
||||
if(lower_port > upper_port) {
|
||||
u_int16_t p = lower_port;
|
||||
|
||||
lower_port = upper_port;
|
||||
upper_port = p;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*sport = ntohs(lower_port), *dport = ntohs(upper_port);
|
||||
} else {
|
||||
// non tcp/udp protocols
|
||||
lower_port = 0;
|
||||
@@ -835,6 +872,7 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
newflow->protocol = iph->protocol, newflow->vlan_id = vlan_id;
|
||||
newflow->lower_ip = lower_ip, newflow->upper_ip = upper_ip;
|
||||
newflow->lower_port = lower_port, newflow->upper_port = upper_port;
|
||||
newflow->ip_version = version;
|
||||
|
||||
if(version == 4) {
|
||||
inet_ntop(AF_INET, &lower_ip, newflow->lower_name, sizeof(newflow->lower_name));
|
||||
@@ -871,8 +909,7 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
*src = newflow->src_id, *dst = newflow->dst_id;
|
||||
|
||||
// printFlow(thread_id, newflow);
|
||||
|
||||
return newflow ;
|
||||
return newflow;
|
||||
}
|
||||
} else {
|
||||
struct ndpi_flow *flow = *(struct ndpi_flow**)ret;
|
||||
@@ -891,29 +928,36 @@ static struct ndpi_flow *get_ndpi_flow(u_int16_t thread_id,
|
||||
|
||||
static struct ndpi_flow *get_ndpi_flow6(u_int16_t thread_id,
|
||||
u_int16_t vlan_id,
|
||||
const struct ndpi_ip6_hdr *iph6,
|
||||
const struct ndpi_ipv6hdr *iph6,
|
||||
u_int16_t ip_offset,
|
||||
struct ndpi_tcphdr **tcph,
|
||||
struct ndpi_udphdr **udph,
|
||||
u_int16_t *sport, u_int16_t *dport,
|
||||
struct ndpi_id_struct **src,
|
||||
struct ndpi_id_struct **dst,
|
||||
u_int8_t *proto) {
|
||||
u_int8_t *proto,
|
||||
u_int8_t **payload,
|
||||
u_int16_t *payload_len,
|
||||
u_int8_t *src_to_dst_direction) {
|
||||
struct ndpi_iphdr iph;
|
||||
|
||||
memset(&iph, 0, sizeof(iph));
|
||||
iph.version = 4;
|
||||
iph.saddr = iph6->ip6_src.__u6_addr.__u6_addr32[2] + iph6->ip6_src.__u6_addr.__u6_addr32[3];
|
||||
iph.daddr = iph6->ip6_dst.__u6_addr.__u6_addr32[2] + iph6->ip6_dst.__u6_addr.__u6_addr32[3];
|
||||
iph.saddr = iph6->ip6_src.u6_addr.u6_addr32[2] + iph6->ip6_src.u6_addr.u6_addr32[3];
|
||||
iph.daddr = iph6->ip6_dst.u6_addr.u6_addr32[2] + iph6->ip6_dst.u6_addr.u6_addr32[3];
|
||||
iph.protocol = iph6->ip6_ctlun.ip6_un1.ip6_un1_nxt;
|
||||
|
||||
if(iph.protocol == 0x3C /* IPv6 destination option */) {
|
||||
u_int8_t *options = (u_int8_t*)iph6 + sizeof(const struct ndpi_ip6_hdr);
|
||||
u_int8_t *options = (u_int8_t*)iph6 + sizeof(const struct ndpi_ipv6hdr);
|
||||
|
||||
iph.protocol = options[0];
|
||||
}
|
||||
|
||||
return(get_ndpi_flow(thread_id, 6, vlan_id, &iph, ip_offset,
|
||||
sizeof(struct ndpi_ip6_hdr),
|
||||
return(get_ndpi_flow(thread_id, 6, vlan_id, &iph, iph6, ip_offset,
|
||||
sizeof(struct ndpi_ipv6hdr),
|
||||
ntohs(iph6->ip6_ctlun.ip6_un1.ip6_un1_plen),
|
||||
src, dst, proto, iph6));
|
||||
tcph, udph, sport, dport,
|
||||
src, dst, proto, payload, payload_len, src_to_dst_direction));
|
||||
}
|
||||
|
||||
/* ***************************************************** */
|
||||
@@ -938,8 +982,8 @@ static void setupDetection(u_int16_t thread_id) {
|
||||
ndpi_set_protocol_detection_bitmask2(ndpi_thread_info[thread_id].ndpi_struct, &all);
|
||||
|
||||
// allocate memory for id and flow tracking
|
||||
size_id_struct = ndpi_detection_get_sizeof_ndpi_id_struct();
|
||||
size_flow_struct = ndpi_detection_get_sizeof_ndpi_flow_struct();
|
||||
size_id_struct = sizeof(struct ndpi_id_struct);
|
||||
size_flow_struct = sizeof(struct ndpi_flow_struct);
|
||||
|
||||
// clear memory for results
|
||||
memset(ndpi_thread_info[thread_id].stats.protocol_counter, 0, sizeof(ndpi_thread_info[thread_id].stats.protocol_counter));
|
||||
@@ -970,20 +1014,31 @@ static unsigned int packet_processing(u_int16_t thread_id,
|
||||
const u_int64_t time,
|
||||
u_int16_t vlan_id,
|
||||
const struct ndpi_iphdr *iph,
|
||||
struct ndpi_ip6_hdr *iph6,
|
||||
struct ndpi_ipv6hdr *iph6,
|
||||
u_int16_t ip_offset,
|
||||
u_int16_t ipsize, u_int16_t rawsize) {
|
||||
struct ndpi_id_struct *src, *dst;
|
||||
struct ndpi_flow *flow;
|
||||
struct ndpi_flow_struct *ndpi_flow = NULL;
|
||||
u_int8_t proto;
|
||||
|
||||
struct ndpi_tcphdr *tcph = NULL;
|
||||
struct ndpi_udphdr *udph = NULL;
|
||||
u_int16_t sport, dport, payload_len;
|
||||
u_int8_t *payload;
|
||||
u_int8_t src_to_dst_direction= 1;
|
||||
|
||||
if(iph)
|
||||
flow = get_ndpi_flow(thread_id, 4, vlan_id, iph, ip_offset, ipsize,
|
||||
flow = get_ndpi_flow(thread_id, 4, vlan_id, iph, NULL,
|
||||
ip_offset, ipsize,
|
||||
ntohs(iph->tot_len) - (iph->ihl * 4),
|
||||
&src, &dst, &proto, NULL);
|
||||
&tcph, &udph, &sport, &dport,
|
||||
&src, &dst, &proto,
|
||||
&payload, &payload_len, &src_to_dst_direction);
|
||||
else
|
||||
flow = get_ndpi_flow6(thread_id, vlan_id, iph6, ip_offset, &src, &dst, &proto);
|
||||
flow = get_ndpi_flow6(thread_id, vlan_id, iph6, ip_offset,
|
||||
&tcph, &udph, &sport, &dport,
|
||||
&src, &dst, &proto,
|
||||
&payload, &payload_len, &src_to_dst_direction);
|
||||
|
||||
if(flow != NULL) {
|
||||
ndpi_thread_info[thread_id].stats.ip_packet_count++;
|
||||
@@ -1000,7 +1055,7 @@ static unsigned int packet_processing(u_int16_t thread_id,
|
||||
flow->detected_protocol = ndpi_detection_process_packet(ndpi_thread_info[thread_id].ndpi_struct, ndpi_flow,
|
||||
iph ? (uint8_t *)iph : (uint8_t *)iph6,
|
||||
ipsize, time, src, dst);
|
||||
|
||||
|
||||
if((flow->detected_protocol.protocol != NDPI_PROTOCOL_UNKNOWN)
|
||||
|| ((proto == IPPROTO_UDP) && (flow->packets > 8))
|
||||
|| ((proto == IPPROTO_TCP) && (flow->packets > 10))) {
|
||||
@@ -1016,31 +1071,6 @@ static unsigned int packet_processing(u_int16_t thread_id,
|
||||
snprintf(flow->ssl.server_certificate, sizeof(flow->ssl.server_certificate), "%s", flow->ndpi_flow->protos.ssl.server_certificate);
|
||||
}
|
||||
|
||||
#if 0
|
||||
if(verbose > 1) {
|
||||
if(ndpi_is_proto(flow->detected_protocol, NDPI_PROTOCOL_HTTP)) {
|
||||
char *method;
|
||||
|
||||
printf("[URL] %s\n", ndpi_get_http_url(ndpi_thread_info[thread_id].ndpi_struct, ndpi_flow));
|
||||
printf("[Content-Type] %s\n", ndpi_get_http_content_type(ndpi_thread_info[thread_id].ndpi_struct, ndpi_flow));
|
||||
|
||||
switch(ndpi_get_http_method(ndpi_thread_info[thread_id].ndpi_struct, ndpi_flow)) {
|
||||
case HTTP_METHOD_OPTIONS: method = "HTTP_METHOD_OPTIONS"; break;
|
||||
case HTTP_METHOD_GET: method = "HTTP_METHOD_GET"; break;
|
||||
case HTTP_METHOD_HEAD: method = "HTTP_METHOD_HEAD"; break;
|
||||
case HTTP_METHOD_POST: method = "HTTP_METHOD_POST"; break;
|
||||
case HTTP_METHOD_PUT: method = "HTTP_METHOD_PUT"; break;
|
||||
case HTTP_METHOD_DELETE: method = "HTTP_METHOD_DELETE"; break;
|
||||
case HTTP_METHOD_TRACE: method = "HTTP_METHOD_TRACE"; break;
|
||||
case HTTP_METHOD_CONNECT: method = "HTTP_METHOD_CONNECT"; break;
|
||||
default: method = "HTTP_METHOD_UNKNOWN"; break;
|
||||
}
|
||||
|
||||
printf("[Method] %s\n", method);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
free_ndpi_flow(flow);
|
||||
|
||||
if(verbose > 1) {
|
||||
@@ -1055,11 +1085,6 @@ static unsigned int packet_processing(u_int16_t thread_id,
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
if(ndpi_flow->l4.tcp.host_server_name[0] != '\0')
|
||||
printf("%s\n", ndpi_flow->l4.tcp.host_server_name);
|
||||
#endif
|
||||
|
||||
if(live_capture) {
|
||||
if(ndpi_thread_info[thread_id].last_idle_scan_time + IDLE_SCAN_PERIOD < ndpi_thread_info[thread_id].last_time) {
|
||||
/* scan for idle flows */
|
||||
@@ -1525,86 +1550,229 @@ static void openPcapFileOrDevice(u_int16_t thread_id) {
|
||||
|
||||
/* ***************************************************** */
|
||||
|
||||
static void pcap_packet_callback(u_char *args, const struct pcap_pkthdr *header, const u_char *packet) {
|
||||
static void pcap_packet_callback(u_char *args,
|
||||
const struct pcap_pkthdr *header,
|
||||
const u_char *packet) {
|
||||
|
||||
/*
|
||||
* Declare pointers to packet headers
|
||||
*/
|
||||
|
||||
/* --- Ethernet header --- */
|
||||
const struct ndpi_ethhdr *ethernet;
|
||||
/* --- Ethernet II header --- */
|
||||
const struct ndpi_ethhdr *ethernet_2;
|
||||
/* --- LLC header --- */
|
||||
const struct ndpi_llc_header *llc;
|
||||
|
||||
/* --- Cisco HDLC header --- */
|
||||
const struct ndpi_chdlc *chdlc;
|
||||
/* --- SLARP frame --- */
|
||||
struct ndpi_slarp *slarp;
|
||||
/* --- CDP --- */
|
||||
struct ndpi_cdp *cdp;
|
||||
|
||||
/* --- Radio Tap header --- */
|
||||
const struct ndpi_radiotap_header *radiotap;
|
||||
/* --- Wifi header --- */
|
||||
const struct ndpi_wifi_header *wifi;
|
||||
|
||||
/* --- MPLS header --- */
|
||||
struct ndpi_mpls_header *mpls;
|
||||
|
||||
/** --- IP header --- **/
|
||||
struct ndpi_iphdr *iph;
|
||||
struct ndpi_ip6_hdr *iph6;
|
||||
/** --- IPv6 header --- **/
|
||||
struct ndpi_ipv6hdr *iph6;
|
||||
|
||||
/* lengths and offsets */
|
||||
u_int16_t eth_offset = 0;
|
||||
u_int16_t radio_len;
|
||||
u_int16_t fc;
|
||||
u_int16_t type;
|
||||
int wifi_len;
|
||||
int llc_off;
|
||||
int pyld_eth_len = 0;
|
||||
int check;
|
||||
u_int32_t fcs;
|
||||
|
||||
u_int64_t time;
|
||||
u_int16_t type, ip_offset, ip_len;
|
||||
u_int16_t ip_offset, ip_len, ip6_offset;
|
||||
u_int16_t frag_off = 0, vlan_id = 0;
|
||||
u_int8_t proto = 0, vlan_packet = 0;
|
||||
u_int8_t proto = 0;
|
||||
u_int32_t label;
|
||||
|
||||
u_int16_t thread_id = *((u_int16_t*)args);
|
||||
|
||||
// printf("[ndpiReader] pcap_packet_callback : [%u.%u.%u.%u.%u -> %u.%u.%u.%u.%u]\n", ethernet->h_dest[1],ethernet->h_dest[2],ethernet->h_dest[3],ethernet->h_dest[4],ethernet->h_dest[5],ethernet->h_source[1],ethernet->h_source[2],ethernet->h_source[3],ethernet->h_source[4],ethernet->h_source[5]);
|
||||
/* counters */
|
||||
u_int8_t malformed_pkts = 0, vlan_packet = 0;
|
||||
u_int8_t slarp_pkts = 0, cdp_pkts = 0;
|
||||
|
||||
/* Increment raw packet counter */
|
||||
ndpi_thread_info[thread_id].stats.raw_packet_count++;
|
||||
|
||||
if((capture_until != 0) && (header->ts.tv_sec >= capture_until)) {
|
||||
if(ndpi_thread_info[thread_id]._pcap_handle != NULL)
|
||||
pcap_breakloop(ndpi_thread_info[thread_id]._pcap_handle);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
/* Check if capture is live or not */
|
||||
if (!live_capture) {
|
||||
if (!pcap_start.tv_sec) pcap_start.tv_sec = header->ts.tv_sec, pcap_start.tv_usec = header->ts.tv_usec;
|
||||
pcap_end.tv_sec = header->ts.tv_sec, pcap_end.tv_usec = header->ts.tv_usec;
|
||||
}
|
||||
|
||||
/* setting time */
|
||||
time = ((uint64_t) header->ts.tv_sec) * detection_tick_resolution +
|
||||
header->ts.tv_usec / (1000000 / detection_tick_resolution);
|
||||
|
||||
if(ndpi_thread_info[thread_id].last_time > time) { /* safety check */
|
||||
// printf("\nWARNING: timestamp bug in the pcap file (ts delta: %llu, repairing)\n", ndpi_thread_info[thread_id].last_time - time);
|
||||
/* safety check */
|
||||
if(ndpi_thread_info[thread_id].last_time > time) {
|
||||
/* printf("\nWARNING: timestamp bug in the pcap file (ts delta: %llu, repairing)\n", ndpi_thread_info[thread_id].last_time - time); */
|
||||
time = ndpi_thread_info[thread_id].last_time;
|
||||
}
|
||||
/* update last time value */
|
||||
ndpi_thread_info[thread_id].last_time = time;
|
||||
|
||||
if(ndpi_thread_info[thread_id]._pcap_datalink_type == DLT_NULL) {
|
||||
if(ntohl(*((u_int32_t*)packet)) == 2)
|
||||
type = ETH_P_IP;
|
||||
else
|
||||
type = 0x86DD; /* IPv6 */
|
||||
/*** check Data Link type ***/
|
||||
int datalink_type = ndpi_thread_info[thread_id]._pcap_datalink_type;
|
||||
|
||||
ip_offset = 4;
|
||||
} else if(ndpi_thread_info[thread_id]._pcap_datalink_type == DLT_EN10MB) {
|
||||
ethernet = (struct ndpi_ethhdr *) packet;
|
||||
ip_offset = sizeof(struct ndpi_ethhdr);
|
||||
type = ntohs(ethernet->h_proto);
|
||||
} else if(ndpi_thread_info[thread_id]._pcap_datalink_type == 113 /* Linux Cooked Capture */) {
|
||||
type = (packet[14] << 8) + packet[15];
|
||||
ip_offset = 16;
|
||||
} else
|
||||
return;
|
||||
datalink_check:
|
||||
switch(datalink_type) {
|
||||
|
||||
while(1) {
|
||||
if(type == 0x8100 /* VLAN */) {
|
||||
vlan_id = ((packet[ip_offset] << 8) + packet[ip_offset+1]) & 0xFFF;
|
||||
type = (packet[ip_offset+2] << 8) + packet[ip_offset+3];
|
||||
ip_offset += 4;
|
||||
vlan_packet = 1;
|
||||
} else if(type == 0x8847 /* MPLS */) {
|
||||
u_int32_t label = ntohl(*((u_int32_t*)&packet[ip_offset]));
|
||||
case DLT_NULL :
|
||||
if(ntohl(*((u_int32_t*)&packet[eth_offset])) == 2)
|
||||
type = ETH_P_IP;
|
||||
else
|
||||
type = ETH_P_IPV6;
|
||||
|
||||
ndpi_thread_info[thread_id].stats.mpls_count++;
|
||||
type = 0x800, ip_offset += 4;
|
||||
ip_offset = 4 + eth_offset;
|
||||
|
||||
while((label & 0x100) != 0x100) {
|
||||
ip_offset += 4;
|
||||
label = ntohl(*((u_int32_t*)&packet[ip_offset]));
|
||||
}
|
||||
} else if(type == 0x8864 /* PPPoE */) {
|
||||
ndpi_thread_info[thread_id].stats.pppoe_count++;
|
||||
type = 0x0800;
|
||||
ip_offset += 8;
|
||||
} else
|
||||
/* Cisco PPP in HDLC-like framing - 50 */
|
||||
case DLT_PPP_SERIAL:
|
||||
chdlc = (struct ndpi_chdlc *) &packet[eth_offset];
|
||||
ip_offset = sizeof(struct ndpi_chdlc); /* CHDLC_OFF = 4 */
|
||||
type = ntohs(chdlc->proto_code);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Cisco PPP with HDLC framing - 104 */
|
||||
case DLT_C_HDLC:
|
||||
chdlc = (struct ndpi_chdlc *) &packet[eth_offset];
|
||||
ip_offset = sizeof(struct ndpi_chdlc); /* CHDLC_OFF = 4 */
|
||||
type = ntohs(chdlc->proto_code);
|
||||
break;
|
||||
|
||||
/* IEEE 802.3 Ethernet - 1 */
|
||||
case DLT_EN10MB :
|
||||
ethernet = (struct ndpi_ethhdr *) &packet[eth_offset];
|
||||
ip_offset = sizeof(struct ndpi_ethhdr) + eth_offset;
|
||||
check = ntohs(ethernet->h_proto);
|
||||
|
||||
if(check <= 1500)
|
||||
pyld_eth_len = check;
|
||||
else if (check >= 1536)
|
||||
type = check;
|
||||
|
||||
if(pyld_eth_len != 0) {
|
||||
/* check for LLC layer with SNAP extension */
|
||||
if(packet[ip_offset] == SNAP) {
|
||||
llc = (struct ndpi_llc_header *)(&packet[ip_offset]);
|
||||
type = llc->snap.proto_ID;
|
||||
ip_offset += + 8;
|
||||
}
|
||||
}
|
||||
break;
|
||||
|
||||
/* Linux Cooked Capture - 113 */
|
||||
case DLT_LINUX_SLL :
|
||||
type = (packet[eth_offset+14] << 8) + packet[eth_offset+15];
|
||||
ip_offset = 16 + eth_offset;
|
||||
break;
|
||||
|
||||
/* Radiotap link-layer - 127 */
|
||||
case DLT_IEEE802_11_RADIO :
|
||||
radiotap = (struct ndpi_radiotap_header *) &packet[eth_offset];
|
||||
radio_len = radiotap->len;
|
||||
|
||||
/* Check Bad FCS presence */
|
||||
if((radiotap->flags & BAD_FCS) == BAD_FCS) {
|
||||
malformed_pkts += 1;
|
||||
ndpi_thread_info[thread_id].stats.total_discarded_bytes += header->len;
|
||||
return;
|
||||
}
|
||||
|
||||
fcs = header->len - 4;
|
||||
|
||||
/* Calculate 802.11 header length (variable) */
|
||||
wifi = (struct ndpi_wifi_header*)( packet + eth_offset + radio_len);
|
||||
fc = wifi->fc;
|
||||
|
||||
/* check wifi data presence */
|
||||
if(FCF_TYPE(fc) == WIFI_DATA) {
|
||||
if((FCF_TO_DS(fc) && FCF_FROM_DS(fc) == 0x0) ||
|
||||
(FCF_TO_DS(fc) == 0x0 && FCF_FROM_DS(fc)))
|
||||
wifi_len = 26; /* + 4 byte fcs */
|
||||
} else /* no data frames */
|
||||
break;
|
||||
|
||||
/* Check ether_type from LLC */
|
||||
llc = (struct ndpi_llc_header*)(packet + eth_offset + wifi_len + radio_len);
|
||||
if(llc->dsap == SNAP)
|
||||
type = ntohs(llc->snap.proto_ID);
|
||||
|
||||
/* Set IP header offset */
|
||||
ip_offset = wifi_len + radio_len + sizeof(struct ndpi_llc_header) + eth_offset;
|
||||
break;
|
||||
|
||||
default:
|
||||
return;
|
||||
}
|
||||
|
||||
/* check ether type */
|
||||
if(type == VLAN) {
|
||||
vlan_id = ((packet[ip_offset] << 8) + packet[ip_offset+1]) & 0xFFF;
|
||||
type = (packet[ip_offset+2] << 8) + packet[ip_offset+3];
|
||||
ip_offset += 4;
|
||||
vlan_packet = 1;
|
||||
}
|
||||
else if(type == MPLS_UNI || type == MPLS_MULTI) {
|
||||
|
||||
mpls = (struct ndpi_mpls_header *) &packet[ip_offset];
|
||||
label = ntohl(mpls->label);
|
||||
/* label = ntohl(*((u_int32_t*)&packet[ip_offset])); */
|
||||
ndpi_thread_info[thread_id].stats.mpls_count++;
|
||||
type = ETH_P_IP, ip_offset += 4;
|
||||
|
||||
while((label & 0x100) != 0x100) {
|
||||
ip_offset += 4;
|
||||
label = ntohl(mpls->label);
|
||||
}
|
||||
}
|
||||
else if(type == SLARP) {
|
||||
slarp = (struct ndpi_slarp *) &packet[ip_offset];
|
||||
if(slarp->slarp_type == 0x02 || slarp->slarp_type == 0x00 || slarp->slarp_type == 0x01) {
|
||||
/* TODO if info are needed */
|
||||
}
|
||||
slarp_pkts++;
|
||||
}
|
||||
else if(type == CISCO_D_PROTO) {
|
||||
cdp = (struct ndpi_cdp *) &packet[ip_offset];
|
||||
cdp_pkts++;
|
||||
}
|
||||
else if(type == PPPoE) {
|
||||
ndpi_thread_info[thread_id].stats.pppoe_count++;
|
||||
type = ETH_P_IP;
|
||||
ip_offset += 8;
|
||||
}
|
||||
|
||||
ndpi_thread_info[thread_id].stats.vlan_count += vlan_packet;
|
||||
|
||||
iph_check:
|
||||
/* Check and set IP header size and total packet length */
|
||||
iph = (struct ndpi_iphdr *) &packet[ip_offset];
|
||||
|
||||
// just work on Ethernet packets that contain IP
|
||||
/* just work on Ethernet packets that contain IP */
|
||||
if(type == ETH_P_IP && header->caplen >= ip_offset) {
|
||||
frag_off = ntohs(iph->frag_off);
|
||||
|
||||
@@ -1623,10 +1791,15 @@ static void pcap_packet_callback(u_char *args, const struct pcap_pkthdr *header,
|
||||
ip_len = ((u_short)iph->ihl * 4);
|
||||
iph6 = NULL;
|
||||
|
||||
if(iph->protocol == 41) {
|
||||
ip_offset += ip_len;
|
||||
goto iph_check;
|
||||
}
|
||||
|
||||
if((frag_off & 0x3FFF) != 0) {
|
||||
static u_int8_t ipv4_frags_warning_used = 0;
|
||||
|
||||
ndpi_thread_info[thread_id].stats.fragmented_count++;
|
||||
|
||||
if(ipv4_frags_warning_used == 0) {
|
||||
if((!json_flag) && (!quiet_mode)) printf("\n\nWARNING: IPv4 fragments are not handled by this demo (nDPI supports them)\n");
|
||||
ipv4_frags_warning_used = 1;
|
||||
@@ -1636,27 +1809,27 @@ static void pcap_packet_callback(u_char *args, const struct pcap_pkthdr *header,
|
||||
return;
|
||||
}
|
||||
} else if(iph->version == 6) {
|
||||
iph6 = (struct ndpi_ip6_hdr *)&packet[ip_offset];
|
||||
iph6 = (struct ndpi_ipv6hdr *)&packet[ip_offset];
|
||||
proto = iph6->ip6_ctlun.ip6_un1.ip6_un1_nxt;
|
||||
ip_len = sizeof(struct ndpi_ip6_hdr);
|
||||
ip_len = sizeof(struct ndpi_ipv6hdr);
|
||||
|
||||
if(proto == 0x3C /* IPv6 destination option */) {
|
||||
u_int8_t *options = (u_int8_t*)&packet[ip_offset+ip_len];
|
||||
|
||||
u_int8_t *options = (u_int8_t*)&packet[ip_offset+ip_len];
|
||||
proto = options[0];
|
||||
ip_len += 8 * (options[1] + 1);
|
||||
}
|
||||
|
||||
iph = NULL;
|
||||
|
||||
} else {
|
||||
static u_int8_t ipv4_warning_used = 0;
|
||||
|
||||
v4_warning:
|
||||
if(ipv4_warning_used == 0) {
|
||||
if((!json_flag) && (!quiet_mode)) printf("\n\nWARNING: only IPv4/IPv6 packets are supported in this demo (nDPI supports both IPv4 and IPv6), all other packets will be discarded\n\n");
|
||||
if((!json_flag) && (!quiet_mode))
|
||||
printf("\n\nWARNING: only IPv4/IPv6 packets are supported in this demo (nDPI supports both IPv4 and IPv6), all other packets will be discarded\n\n");
|
||||
ipv4_warning_used = 1;
|
||||
}
|
||||
|
||||
ndpi_thread_info[thread_id].stats.total_discarded_bytes += header->len;
|
||||
return;
|
||||
}
|
||||
@@ -1671,9 +1844,10 @@ static void pcap_packet_callback(u_char *args, const struct pcap_pkthdr *header,
|
||||
u_int8_t flags = packet[offset];
|
||||
u_int8_t message_type = packet[offset+1];
|
||||
|
||||
if((((flags & 0xE0) >> 5) == 1 /* GTPv1 */) && (message_type == 0xFF /* T-PDU */)) {
|
||||
ip_offset = ip_offset+ip_len+sizeof(struct ndpi_udphdr)+8 /* GTPv1 header len */;
|
||||
if((((flags & 0xE0) >> 5) == 1 /* GTPv1 */) &&
|
||||
(message_type == 0xFF /* T-PDU */)) {
|
||||
|
||||
ip_offset = ip_offset+ip_len+sizeof(struct ndpi_udphdr)+8; /* GTPv1 header len */
|
||||
if(flags & 0x04) ip_offset += 1; /* next_ext_header is present */
|
||||
if(flags & 0x02) ip_offset += 4; /* sequence_number is present (it also includes next_ext_header and pdu_number) */
|
||||
if(flags & 0x01) ip_offset += 1; /* pdu_number is present */
|
||||
@@ -1685,10 +1859,48 @@ static void pcap_packet_callback(u_char *args, const struct pcap_pkthdr *header,
|
||||
goto v4_warning;
|
||||
}
|
||||
}
|
||||
} else if((sport == TZSP_PORT) || (dport == TZSP_PORT)) {
|
||||
/* https://en.wikipedia.org/wiki/TZSP */
|
||||
u_int offset = ip_offset+ip_len+sizeof(struct ndpi_udphdr);
|
||||
u_int8_t version = packet[offset];
|
||||
u_int8_t type = packet[offset+1];
|
||||
u_int16_t encapsulates = ntohs(*((u_int16_t*)&packet[offset+2]));
|
||||
|
||||
if((version == 1) && (type == 0) && (encapsulates == 1)) {
|
||||
u_int8_t stop = 0;
|
||||
|
||||
offset += 4;
|
||||
|
||||
while((!stop) && (offset < header->caplen)) {
|
||||
u_int8_t tag_type = packet[offset];
|
||||
u_int8_t tag_len;
|
||||
|
||||
switch(tag_type) {
|
||||
case 0: /* PADDING Tag */
|
||||
tag_len = 1;
|
||||
break;
|
||||
case 1: /* END Tag */
|
||||
tag_len = 1, stop = 1;
|
||||
break;
|
||||
default:
|
||||
tag_len = packet[offset+1];
|
||||
break;
|
||||
}
|
||||
|
||||
offset += tag_len;
|
||||
|
||||
if(offset >= header->caplen)
|
||||
return; /* Invalid packet */
|
||||
else {
|
||||
eth_offset = offset;
|
||||
goto datalink_check;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// process the packet
|
||||
/* process the packet */
|
||||
packet_processing(thread_id, time, vlan_id, iph, iph6,
|
||||
ip_offset, header->len - ip_offset, header->len);
|
||||
}
|
||||
@@ -1823,16 +2035,6 @@ struct timezone {
|
||||
|
||||
/* ***************************************************** */
|
||||
|
||||
#if 0
|
||||
int gettimeofday(struct timeval *tv, void *notUsed) {
|
||||
tv->tv_sec = time(NULL);
|
||||
tv->tv_usec = 0;
|
||||
return(0);
|
||||
}
|
||||
#endif
|
||||
|
||||
/* ***************************************************** */
|
||||
|
||||
int gettimeofday(struct timeval *tv, struct timezone *tz) {
|
||||
FILETIME ft;
|
||||
LARGE_INTEGER li;
|
||||
|
||||
Reference in New Issue
Block a user