HTTP: rework state machine (#1966)

The goal if to correlate the right request-response pair, exporting
metadata from only one transaction (for example, the right url & return
state pair)

As a nice side effect, the code should be much cleaner, but that is a
matter of taste.

Two differences respect to the previous code:
* as it happens in the CI, if in the flow there are only one response
(before) and one request (after), only the metadata of the response are
saved/exported
* for performance reasons, we don't call `ndpi_parse_packet_line_info()`
anymore for ALL packets triggering the HTTP dissector, but only for the
packets that we already know belong to an HTTP flow. This is the reason
for the changes in RTSP/SOAP/... code
This commit is contained in:
Ivan Nardi
2023-05-16 16:01:55 +02:00
committed by GitHub
parent 8c224b464f
commit 4e186f6bfb
19 changed files with 296 additions and 305 deletions
+1 -4
View File
@@ -741,7 +741,7 @@ struct ndpi_flow_tcp_struct {
u_int32_t usenet_stage:2;
/* NDPI_PROTOCOL_HTTP */
u_int32_t http_stage:2;
u_int32_t http_stage:3;
/* NDPI_PROTOCOL_GNUTELLA */
u_int32_t gnutella_stage:2; // 0 - 2
@@ -1581,9 +1581,6 @@ struct ndpi_flow_struct {
u_int8_t bittorrent_stage; // can be 0 - 255
u_int8_t bt_check_performed : 1;
/* NDPI_PROTOCOL_HTTP */
u_int8_t http_detected:1;
/* NDPI_PROTOCOL_RTSP */
u_int8_t rtsprdt_stage:2;
-14
View File
@@ -7232,20 +7232,6 @@ void ndpi_parse_single_packet_line(struct ndpi_detection_module_struct *ndpi_str
packet->http_response.ptr = &packet->line[0].ptr[NDPI_STATICSTRING_LEN("HTTP/1.1 ")];
packet->http_response.len = packet->line[0].len - NDPI_STATICSTRING_LEN("HTTP/1.1 ");
packet->http_num_headers++;
/* Set server HTTP response code */
if(packet->payload_packet_len >= 12) {
char buf[4];
/* Set server HTTP response code */
strncpy(buf, (char *) &packet->payload[9], 3);
buf[3] = '\0';
flow->http.response_status_code = atoi(buf);
/* https://en.wikipedia.org/wiki/List_of_HTTP_status_codes */
if((flow->http.response_status_code < 100) || (flow->http.response_status_code > 509))
flow->http.response_status_code = 0; /* Out of range */
}
}
if((packet->parsed_lines == 0) && (packet->line[0].len > 0)) {
+10
View File
@@ -59,6 +59,10 @@ static void ndpi_search_gnutella(struct ndpi_detection_module_struct *ndpi_struc
/* this case works asymmetrically */
if (packet->payload_packet_len > 17 && memcmp(packet->payload, "GNUTELLA CONNECT/", 17) == 0) {
ndpi_int_gnutella_add_connection(ndpi_struct, flow, NDPI_CONFIDENCE_DPI);
/* Extract some metadata HTTP-like */
ndpi_parse_packet_line_info(ndpi_struct, flow);
if(packet->user_agent_line.ptr != NULL)
ndpi_user_agent_set(flow, packet->user_agent_line.ptr, packet->user_agent_line.len);
return;
}
@@ -73,6 +77,9 @@ static void ndpi_search_gnutella(struct ndpi_detection_module_struct *ndpi_struc
|| (packet->line[c].len > 36 && memcmp(packet->line[c].ptr,
"Content-Type: application/x-gnutella-", 37) == 0)) {
ndpi_int_gnutella_add_connection(ndpi_struct, flow, NDPI_CONFIDENCE_DPI);
/* Extract some metadata HTTP-like */
if(packet->user_agent_line.ptr != NULL)
ndpi_user_agent_set(flow, packet->user_agent_line.ptr, packet->user_agent_line.len);
return;
}
}
@@ -84,6 +91,9 @@ static void ndpi_search_gnutella(struct ndpi_detection_module_struct *ndpi_struc
|| (packet->accept_line.ptr != NULL && packet->accept_line.len > 24
&& memcmp(packet->accept_line.ptr, "application n/x-gnutella", 24) == 0)) {
ndpi_int_gnutella_add_connection(ndpi_struct, flow, NDPI_CONFIDENCE_DPI);
/* Extract some metadata HTTP-like */
if(packet->user_agent_line.ptr != NULL)
ndpi_user_agent_set(flow, packet->user_agent_line.ptr, packet->user_agent_line.len);
}
}
+233 -240
View File
@@ -113,14 +113,8 @@ static int ndpi_search_http_tcp_again(struct ndpi_detection_module_struct *ndpi_
printf("=> %s()\n", __FUNCTION__);
#endif
if((flow->host_server_name[0] != '\0')
&& (flow->http.response_status_code != 0)
) {
/* stop extra processing */
if(flow->initial_binary_bytes_len) ndpi_analyze_content_signature(ndpi_struct, flow);
flow->extra_packets_func = NULL; /* We're good now */
return(0);
if(flow->extra_packets_func == NULL) {
return(0); /* We're good now */
}
/* Possibly more processing */
@@ -287,8 +281,6 @@ static ndpi_protocol_category_t ndpi_http_check_content(struct ndpi_detection_mo
}
}
}
ndpi_validate_http_content(ndpi_struct, flow);
}
}
@@ -344,42 +336,23 @@ static ndpi_protocol_category_t ndpi_http_check_content(struct ndpi_detection_mo
static void ndpi_int_http_add_connection(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow,
u_int16_t http_protocol) {
u_int16_t master_protocol;
u_int16_t master_protocol) {
#ifdef HTTP_DEBUG
printf("=> %s()\n", __FUNCTION__);
#endif
master_protocol = NDPI_PROTOCOL_HTTP;
if(flow->detected_protocol_stack[1] != NDPI_PROTOCOL_UNKNOWN)
master_protocol = flow->detected_protocol_stack[1];
else if(flow->detected_protocol_stack[0] == NDPI_PROTOCOL_HTTP_CONNECT ||
flow->detected_protocol_stack[0] == NDPI_PROTOCOL_HTTP_PROXY)
master_protocol = flow->detected_protocol_stack[0];
/* Update the classification only if we don't already have master + app;
for example don't change the protocols if we have already detected a
sub-protocol via the (content-matched) subprotocols logic (i.e.
MPEGDASH, SOAP, ....) */
if(flow->detected_protocol_stack[1] == 0)
ndpi_set_detected_protocol(ndpi_struct, flow, http_protocol,
master_protocol,
NDPI_CONFIDENCE_DPI);
if(flow->detected_protocol_stack[1] == NDPI_PROTOCOL_UNKNOWN) {
NDPI_LOG_DBG2(ndpi_struct, "Master: %d\n", master_protocol);
ndpi_set_detected_protocol(ndpi_struct, flow, NDPI_PROTOCOL_UNKNOWN,
master_protocol, NDPI_CONFIDENCE_DPI);
}
flow->max_extra_packets_to_check = 8;
flow->extra_packets_func = ndpi_search_http_tcp_again;
flow->http_detected = 1;
switch(flow->detected_protocol_stack[1]) {
case NDPI_PROTOCOL_HTTP_CONNECT:
case NDPI_PROTOCOL_HTTP_PROXY:
if(flow->detected_protocol_stack[0] == NDPI_PROTOCOL_HTTP) {
flow->detected_protocol_stack[0] = flow->detected_protocol_stack[1];
flow->detected_protocol_stack[1] = NDPI_PROTOCOL_UNKNOWN;
}
break;
}
}
/* ************************************************************* */
@@ -684,10 +657,12 @@ void http_process_user_agent(struct ndpi_detection_module_struct *ndpi_struct,
}
}
if(ndpi_user_agent_set(flow, ua_ptr, ua_ptr_len) != NULL)
if(ndpi_user_agent_set(flow, ua_ptr, ua_ptr_len) != NULL) {
ndpi_unset_risk(ndpi_struct, flow, NDPI_HTTP_SUSPICIOUS_USER_AGENT);
ndpi_check_user_agent(ndpi_struct, flow, flow->http.user_agent, ua_ptr_len);
else
} else {
NDPI_LOG_DBG2(ndpi_struct, "Could not set HTTP user agent (already set?)\n");
}
NDPI_LOG_DBG2(ndpi_struct, "User Agent Type line found %.*s\n",
ua_ptr_len, ua_ptr);
@@ -952,10 +927,6 @@ static void check_content_type_and_change_protocol(struct ndpi_detection_module_
if(flow->guessed_protocol_id == NDPI_PROTOCOL_UNKNOWN)
flow->guessed_protocol_id = NDPI_PROTOCOL_HTTP;
if(ndpi_get_http_method(ndpi_struct, flow) != NDPI_HTTP_METHOD_UNKNOWN) {
ndpi_int_http_add_connection(ndpi_struct, flow, flow->detected_protocol_stack[0]);
}
ndpi_check_http_header(ndpi_struct, flow);
}
@@ -1195,233 +1166,248 @@ static void parse_response_code(struct ndpi_detection_module_struct *ndpi_struct
}
}
/*************************************************************************************************/
static int is_request(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow) {
struct ndpi_packet_struct *packet = &ndpi_struct->packet;
u_int16_t filename_start;
filename_start = http_request_url_offset(ndpi_struct, flow);
/* This check is required as RTSP is pretty similiar to HTTP */
if(filename_start > 0 &&
strncasecmp((const char *)packet->payload + filename_start,
"rtsp://", ndpi_min(7, packet->payload_packet_len - filename_start)) == 0)
return 0;
return filename_start;
}
static int is_response(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow) {
struct ndpi_packet_struct *packet = &ndpi_struct->packet;
if(packet->payload_packet_len >= 7 &&
strncasecmp((const char *)packet->payload, "HTTP/1.", 7) == 0)
return 1;
return 0;
}
static void process_request(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow,
u_int16_t filename_start) {
struct ndpi_packet_struct *packet = &ndpi_struct->packet;
u_int16_t master_protocol;
ndpi_parse_packet_line_info(ndpi_struct, flow);
master_protocol = NDPI_PROTOCOL_HTTP;
if(packet->parsed_lines == 0 ||
!(packet->line[0].len >= (9 + filename_start) &&
strncasecmp((const char *)&packet->line[0].ptr[packet->line[0].len - 9], " HTTP/1.", 8) == 0)) {
NDPI_LOG_DBG2(ndpi_struct, "Request with an incomplete or invalid first line\n");
/* Since we don't save data across different packets, we will never have
the complete url: we can't check for HTTP_PROXY */
if(filename_start == 8 &&
strncasecmp((const char *)packet->payload, "CONNECT ", 8) == 0) {
master_protocol = NDPI_PROTOCOL_HTTP_CONNECT;
}
} else {
/* First line is complete (example: "GET / HTTP/1.1"): extract url */
packet->http_url_name.ptr = &packet->payload[filename_start];
packet->http_url_name.len = packet->line[0].len - (filename_start + 9);
packet->http_method.ptr = packet->line[0].ptr;
packet->http_method.len = filename_start - 1;
/* Set the HTTP requested version: 0=HTTP/1.0 and 1=HTTP/1.1 */
if(memcmp(&packet->line[0].ptr[packet->line[0].len - 1], "1", 1) == 0)
flow->http.request_version = 1;
else
flow->http.request_version = 0;
if(packet->http_url_name.len > 7 &&
!strncasecmp((const char*) packet->http_url_name.ptr, "http://", 7)) {
master_protocol = NDPI_PROTOCOL_HTTP_PROXY;
}
if(filename_start == 8 &&
strncasecmp((const char *)packet->payload, "CONNECT ", 8) == 0) {
master_protocol = NDPI_PROTOCOL_HTTP_CONNECT;
}
}
ndpi_int_http_add_connection(ndpi_struct, flow, master_protocol);
check_content_type_and_change_protocol(ndpi_struct, flow);
if(flow->http.user_agent == NULL ||
flow->http.user_agent[0] == '\0') {
ndpi_set_risk(ndpi_struct, flow, NDPI_HTTP_SUSPICIOUS_USER_AGENT, "Empty or missing User-Agent");
}
}
static void process_response(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow) {
ndpi_parse_packet_line_info(ndpi_struct, flow);
parse_response_code(ndpi_struct, flow);
check_content_type_and_change_protocol(ndpi_struct, flow);
ndpi_validate_http_content(ndpi_struct, flow);
}
static void reset(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow) {
NDPI_LOG_DBG2(ndpi_struct, "Reset status and risks\n");
/* Reset everthing in flow->http.
TODO: Could we be smarter? Probably some info don't change across
different req-res transactions... */
flow->http.method = 0;
flow->http.request_version = 0;
flow->http.response_status_code = 0;
if(flow->http.url) {
ndpi_free(flow->http.url);
flow->http.url = NULL;
}
if(flow->http.content_type) {
ndpi_free(flow->http.content_type);
flow->http.content_type = NULL;
}
if(flow->http.request_content_type) {
ndpi_free(flow->http.request_content_type);
flow->http.request_content_type = NULL;
}
if(flow->http.user_agent) {
ndpi_free(flow->http.user_agent);
flow->http.user_agent = NULL;
}
if(flow->http.server) {
ndpi_free(flow->http.server);
flow->http.server = NULL;
}
if(flow->http.detected_os) {
ndpi_free(flow->http.detected_os);
flow->http.detected_os = NULL;
}
if(flow->http.nat_ip) {
ndpi_free(flow->http.nat_ip);
flow->http.nat_ip = NULL;
}
/* Reset flow risks. We should reset only those risks triggered by
the previous HTTP response... */
/* TODO */
ndpi_unset_risk(ndpi_struct, flow, NDPI_BINARY_APPLICATION_TRANSFER);
ndpi_unset_risk(ndpi_struct, flow, NDPI_HTTP_SUSPICIOUS_CONTENT);
ndpi_unset_risk(ndpi_struct, flow, NDPI_POSSIBLE_EXPLOIT);
ndpi_unset_risk(ndpi_struct, flow, NDPI_HTTP_SUSPICIOUS_USER_AGENT);
ndpi_unset_risk(ndpi_struct, flow, NDPI_HTTP_CRAWLER_BOT);
ndpi_unset_risk(ndpi_struct, flow, NDPI_NUMERIC_IP_HOST);
ndpi_unset_risk(ndpi_struct, flow, NDPI_URL_POSSIBLE_RCE_INJECTION);
ndpi_unset_risk(ndpi_struct, flow, NDPI_HTTP_OBSOLETE_SERVER);
ndpi_unset_risk(ndpi_struct, flow, NDPI_CLEAR_TEXT_CREDENTIALS);
ndpi_unset_risk(ndpi_struct, flow, NDPI_INVALID_CHARACTERS);
ndpi_unset_risk(ndpi_struct, flow, NDPI_HTTP_SUSPICIOUS_HEADER);
ndpi_unset_risk(ndpi_struct, flow, NDPI_ERROR_CODE_DETECTED);
ndpi_unset_risk(ndpi_struct, flow, NDPI_MALFORMED_PACKET);
}
static void ndpi_check_http_tcp(struct ndpi_detection_module_struct *ndpi_struct,
struct ndpi_flow_struct *flow) {
struct ndpi_packet_struct *packet = &ndpi_struct->packet;
u_int16_t filename_start; /* the filename in the request method line, e.g., "GET filename_start..."*/
u_int16_t filename_start;
packet->packet_lines_parsed_complete = 0;
NDPI_LOG_DBG(ndpi_struct, "http_stage %d dir %d req/res %d/%d\n",
flow->l4.tcp.http_stage, packet->packet_direction,
is_request(ndpi_struct, flow), is_response(ndpi_struct, flow));
if(packet->http_check_content && (packet->payload_packet_len > 0)) {
ndpi_http_check_human_redeable_content(ndpi_struct, flow, packet->payload, packet->payload_packet_len);
packet->http_check_content = 0; /* One packet is enough */
}
/* Check if we so far detected the protocol in the request or not. */
if(flow->l4.tcp.http_stage == 0) {
/* Expected a request */
flow->http_detected = 0;
NDPI_LOG_DBG2(ndpi_struct, "HTTP stage %d: \n", flow->l4.tcp.http_stage);
filename_start = http_request_url_offset(ndpi_struct, flow);
if(filename_start == 0) { /* not a regular request. In the HTTP first stage, may be a truncated flow or other protocols */
NDPI_LOG_DBG2(ndpi_struct, "Filename HTTP not found, we look for possible truncate flow..\n");
if(packet->payload_packet_len >= 7 && strncasecmp((const char *)packet->payload, "HTTP/1.", 7) == 0) {
NDPI_LOG_INFO(ndpi_struct, "found HTTP response\n");
parse_response_code(ndpi_struct, flow);
if(flow->flow_payload) {
char *endl;
flow->flow_payload[flow->flow_payload_len] = '\0';
if((endl = strrchr(flow->flow_payload, '\r')) == NULL)
endl = strrchr(flow->flow_payload, '\n');
if(endl != NULL) {
endl[0] = '\0';
flow->flow_payload_len = endl - flow->flow_payload;
}
}
ndpi_parse_packet_line_info(ndpi_struct, flow);
check_content_type_and_change_protocol(ndpi_struct, flow);
ndpi_validate_http_content(ndpi_struct, flow);
if(flow->l4.tcp.http_stage == 0) { /* Start: waiting for (the beginning of) a request */
filename_start = is_request(ndpi_struct, flow);
if(filename_start == 0) {
/* Flow starting with a response? */
if(is_response(ndpi_struct, flow)) {
NDPI_LOG_DBG2(ndpi_struct, "Response where a request were expected\n");
/* This is tricky. Two opposing goals:
1) We want to correctly match request with response!! -> Skip this response
and keep looking for a request.
2) We want to support asymmetric detection
Trade-off:
a) set HTTP as master (it is a guess; we can't know it from the reply only)
b) process the response(s) and save the metadata
c) look for a request. If we found it, reset everything (master,
classification and metadata!) */
ndpi_int_http_add_connection(ndpi_struct, flow, NDPI_PROTOCOL_HTTP);
process_response(ndpi_struct, flow);
flow->l4.tcp.http_stage = packet->packet_direction + 3; // packet_direction 0: stage 3, packet_direction 1: stage 4
return;
}
/* try to get some additional request header info even if the packet may not be HTTP */
ndpi_parse_packet_line_info(ndpi_struct, flow);
if(packet->http_num_headers > 0) {
check_content_type_and_change_protocol(ndpi_struct, flow);
return;
}
/* The first pkt is neither a request nor a response -> no http */
NDPI_LOG_DBG2(ndpi_struct, "Neither req nor response -> exclude\n");
NDPI_EXCLUDE_PROTO(ndpi_struct, flow);
return;
} else {
/* This check is required as RTSP is pretty similiar to HTTP (prevent false-positives). */
if (strncasecmp((const char *)packet->payload + filename_start,
"rtsp://", ndpi_min(7, packet->payload_packet_len - filename_start)) == 0)
{
NDPI_EXCLUDE_PROTO(ndpi_struct, flow);
return;
} else {
ndpi_int_http_add_connection(ndpi_struct, flow, NDPI_PROTOCOL_HTTP);
}
}
NDPI_LOG_DBG2(ndpi_struct, "Request where expected\n");
NDPI_LOG_DBG2(ndpi_struct,
"Filename HTTP found: %d, we look for line info..\n", filename_start);
process_request(ndpi_struct, flow, filename_start);
ndpi_parse_packet_line_info(ndpi_struct, flow);
/* Wait for the response */
flow->l4.tcp.http_stage = packet->packet_direction + 1; // packet_direction 0: stage 1, packet_direction 1: stage 2
if(packet->parsed_lines <= 1) {
NDPI_LOG_DBG2(ndpi_struct,
"Found just one line, we will look further for the next packet...\n");
return;
} else if(flow->l4.tcp.http_stage == 1 || flow->l4.tcp.http_stage == 2) {
/* Found a request, looking for the response */
/* Encode the direction of the packet in the stage, so we will know when we need to look for the response packet. */
flow->l4.tcp.http_stage = packet->packet_direction + 1; // packet_direction 0: stage 1, packet_direction 1: stage 2
return;
}
NDPI_LOG_DBG2(ndpi_struct,
"Found more than one line, we look further for the next packet...\n");
if(packet->line[0].len >= (9 + filename_start)
&& strncasecmp((const char *)&packet->line[0].ptr[packet->line[0].len - 9], " HTTP/1.", 8) == 0) {
/* Request line complete. Ex. "GET / HTTP/1.1" */
packet->http_url_name.ptr = &packet->payload[filename_start];
packet->http_url_name.len = packet->line[0].len - (filename_start + 9);
packet->http_method.ptr = packet->line[0].ptr;
packet->http_method.len = filename_start - 1;
// Set the HTTP requested version: 0=HTTP/1.0 and 1=HTTP/1.1
if(memcmp(&packet->line[0].ptr[packet->line[0].len - 1], "1", 1) == 0)
flow->http.request_version = 1;
else
flow->http.request_version = 0;
if((packet->http_url_name.len > 7)
&& (!strncasecmp((const char*) packet->http_url_name.ptr, "http://", 7))) {
NDPI_LOG_INFO(ndpi_struct, "found HTTP_PROXY\n");
ndpi_set_detected_protocol(ndpi_struct, flow, NDPI_PROTOCOL_UNKNOWN, NDPI_PROTOCOL_HTTP_PROXY, NDPI_CONFIDENCE_DPI);
check_content_type_and_change_protocol(ndpi_struct, flow);
flow->http_detected = 1;
flow->l4.tcp.http_stage = packet->packet_direction + 1; // packet_direction 0: stage 1, packet_direction 1: stage 2
if(flow->l4.tcp.http_stage - packet->packet_direction == 1) {
/* Another pkt from the same direction (probably another fragment of the request)
Keep lookng for the response */
NDPI_LOG_DBG2(ndpi_struct, "Another piece of request\n");
filename_start = is_request(ndpi_struct, flow);
if(filename_start > 0) {
/* Probably a new, separated request (asymmetric flow or missing pkts?).
What should we do? We definitely don't want to mix data from different
requests. The easiest (but costly) idea is to reset the state and
process it (i.e. we keep the metadata of the last request that we
have processed) */
reset(ndpi_struct, flow);
process_request(ndpi_struct, flow, filename_start);
return;
}
if(filename_start == 8 && (strncasecmp((const char *)packet->payload, "CONNECT ", 8) == 0)) {
NDPI_LOG_INFO(ndpi_struct, "found HTTP_CONNECT\n");
ndpi_set_detected_protocol(ndpi_struct, flow, NDPI_PROTOCOL_UNKNOWN, NDPI_PROTOCOL_HTTP_CONNECT, NDPI_CONFIDENCE_DPI);
check_content_type_and_change_protocol(ndpi_struct, flow);
flow->http_detected = 1;
flow->l4.tcp.http_stage = packet->packet_direction + 1; // packet_direction 0: stage 1, packet_direction 1: stage 2
return;
}
NDPI_LOG_DBG2(ndpi_struct,
"HTTP START Found, we will look for sub-protocols (content and host)...\n");
if(packet->host_line.ptr != NULL) {
/**
nDPI is pretty scrupulous about HTTP so it waits until the
HTTP response is received just to check that it conforms
with the HTTP specs. However this might be a waste of time as
in 99.99% of the cases is like that.
*/
/* if(!flow->http_detected) */ {
u_int proto = flow->detected_protocol_stack[1] ? flow->detected_protocol_stack[1] : flow->detected_protocol_stack[0];
if(proto == NDPI_PROTOCOL_UNKNOWN) proto = NDPI_PROTOCOL_HTTP;
ndpi_int_http_add_connection(ndpi_struct, flow, proto);
flow->http_detected = 1;
NDPI_LOG_DBG2(ndpi_struct,
"HTTP START Found, we will look further for the response...\n");
flow->l4.tcp.http_stage = packet->packet_direction + 1; // packet_direction 0: stage 1, packet_direction 1: stage 2
check_content_type_and_change_protocol(ndpi_struct, flow);
}
return;
}
}
check_content_type_and_change_protocol(ndpi_struct, flow);
NDPI_EXCLUDE_PROTO(ndpi_struct, flow);
} else if((flow->l4.tcp.http_stage == 1) || (flow->l4.tcp.http_stage == 2)) {
NDPI_LOG_DBG2(ndpi_struct, "HTTP stage %u: \n", flow->l4.tcp.http_stage);
/**
At first check, if this is for sure a response packet
(in another direction. If not, if HTTP is detected do nothing now and return,
otherwise check the second packet for the HTTP request
*/
if((flow->l4.tcp.http_stage - packet->packet_direction) == 1) { /* Expected a response package */
NDPI_LOG_DBG2(ndpi_struct,
" SECOND PAYLOAD TRAFFIC FROM CLIENT, FIRST PACKET MIGHT HAVE BEEN HTTP...UNKNOWN TRAFFIC, HERE FOR HTTP again.. \n");
ndpi_parse_packet_line_info(ndpi_struct, flow);
if(packet->parsed_lines <= 1) {
/* wait some packets in case request is split over more than 2 packets */
if(flow->packet_counter < 5) {
NDPI_LOG_DBG2(ndpi_struct, "line still not finished, search next packet\n");
return;
} else {
/* stop parsing here */
NDPI_LOG_DBG2(ndpi_struct, "exclude HTTP: PACKET DOES NOT HAVE A LINE STRUCTURE\n");
NDPI_EXCLUDE_PROTO(ndpi_struct, flow);
return;
}
}
/* The previous pkt was a valid HTTP request and this one is in the same direction:
splitted request? Try to extract more metadata */
if(flow->http_detected) {
check_content_type_and_change_protocol(ndpi_struct, flow);
}
// http://www.slideshare.net/DSPIP/rtsp-analysis-wireshark
if(!flow->http_detected
&& packet->line[0].len >= 9
&& strncasecmp((const char *)&packet->line[0].ptr[packet->line[0].len - 9], " HTTP/1.", 8) == 0) {
NDPI_LOG_INFO(ndpi_struct, "found HTTP\n");
ndpi_int_http_add_connection(ndpi_struct, flow, NDPI_PROTOCOL_HTTP);
check_content_type_and_change_protocol(ndpi_struct, flow);
NDPI_LOG_DBG2(ndpi_struct,
"HTTP START Found in 2. packet, we will look further for the response....\n");
flow->http_detected = 1;
}
check_content_type_and_change_protocol(ndpi_struct, flow);
return;
} else if(is_response(ndpi_struct, flow)) {
NDPI_LOG_DBG2(ndpi_struct, "Response where expected\n");
process_response(ndpi_struct, flow);
flow->l4.tcp.http_stage = 0;
} else {
NDPI_LOG_DBG2(ndpi_struct, "The msg from the server doesn't look like a response...\n");
/* TODO */
}
} else if(flow->l4.tcp.http_stage == 3 || flow->l4.tcp.http_stage == 4) {
/* Found a response but we want a request */
/**
This is a packet in another direction. Check if we find the proper response.
We have received a response for a previously identified partial HTTP request
*/
/* response without headers
* TODO: Shouldn't it be below ndpi_parse_packet_line_info, line ~825 ?
*/
if((packet->parsed_lines == 1) && (packet->packet_direction == 1 /* server -> client */)) {
/* In Apache if you do "GET /\n\n" the response comes without any header */
NDPI_LOG_INFO(ndpi_struct, "found HTTP. (apache)\n");
ndpi_int_http_add_connection(ndpi_struct, flow, NDPI_PROTOCOL_HTTP);
if(flow->l4.tcp.http_stage - packet->packet_direction == 3) {
/* Another pkt from the same direction (probably another fragment of the response)
Keep lookng for the request */
NDPI_LOG_DBG2(ndpi_struct, "Another piece of response\n");
if(is_response(ndpi_struct, flow)) {
/* See the comment above about how we handle consecutive requests/responses */
reset(ndpi_struct, flow);
process_response(ndpi_struct, flow);
return;
}
ndpi_parse_packet_line_info(ndpi_struct, flow);
check_content_type_and_change_protocol(ndpi_struct, flow);
return;
}
parse_response_code(ndpi_struct, flow);
/* Parse packet line and we look for the subprotocols */
ndpi_parse_packet_line_info(ndpi_struct, flow);
check_content_type_and_change_protocol(ndpi_struct, flow);
ndpi_validate_http_content(ndpi_struct, flow);
NDPI_LOG_DBG2(ndpi_struct, "Found a request. We need to reset the state!\n");
reset(ndpi_struct, flow);
flow->l4.tcp.http_stage = 0;
return;
return ndpi_check_http_tcp(ndpi_struct, flow);
}
}
@@ -1437,6 +1423,13 @@ static void ndpi_search_http_tcp(struct ndpi_detection_module_struct *ndpi_struc
NDPI_LOG_DBG(ndpi_struct, "search HTTP\n");
ndpi_check_http_tcp(ndpi_struct, flow);
if(flow->host_server_name[0] != '\0'&&
flow->http.response_status_code != 0) {
flow->extra_packets_func = NULL; /* We're good now */
if(flow->initial_binary_bytes_len) ndpi_analyze_content_signature(ndpi_struct, flow);
}
}
/* ********************************* */
+5
View File
@@ -55,6 +55,11 @@ static void ndpi_search_rtsp_tcp_udp(struct ndpi_detection_module_struct *ndpi_s
LINE_ENDS(packet->content_line, "application/x-rtsp-tunnelled") != 0))
{
ndpi_int_rtsp_add_connection(ndpi_struct, flow);
/* Extract some metadata HTTP-like */
if(packet->user_agent_line.ptr != NULL)
ndpi_user_agent_set(flow, packet->user_agent_line.ptr, packet->user_agent_line.len);
return;
}