diff --git a/common/include/data_packet.h b/common/include/data_packet.h index e902b5e..85b64c2 100644 --- a/common/include/data_packet.h +++ b/common/include/data_packet.h @@ -60,28 +60,23 @@ struct layer_result enum layer_type type; }; -struct layer_results +struct data_packet { struct layer_result layers[16]; uint16_t layers_used; uint16_t layers_size; -}; - -struct data_packet -{ - struct layer_results results; const void *data_ptr; uint64_t trace_id; }; -// return most inner payload +// return innermost payload const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id); // return 0 : success // return -1 : error -int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr); -int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr); +int data_packet_get_innermost_four_tuple(struct data_packet *handler, struct four_tuple *addr); +int data_packet_get_outermost_four_tuple(struct data_packet *handler, struct four_tuple *addr); // return 0 : success // return -1 : error diff --git a/common/src/data_packet.cpp b/common/src/data_packet.cpp index 1142e25..5d19cff 100644 --- a/common/src/data_packet.cpp +++ b/common/src/data_packet.cpp @@ -60,16 +60,13 @@ struct gtp_hdr * Static API ******************************************************************************/ -static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset); - static const char *ldbc_method_to_string(enum ldbc_method ldbc_method); - -// parser utils -static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr); -static const char *layer_type2str(enum layer_type this_type); -static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph); +static const char *layer_type_to_string(enum layer_type this_type); +static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset); +static void populate_four_tuple_from_layer(const void *data, enum layer_type layer_type, struct four_tuple *addr); // parser protocol +static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph); static const void *parse_ether(struct data_packet *handler, const void *data, size_t length); static const void *parse_ipv4(struct data_packet *handler, const void *data, size_t length); static const void *parse_ipv6(struct data_packet *handler, const void *data, size_t length); @@ -85,13 +82,13 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz * Public API ******************************************************************************/ -// return most inner payload +// return innermost payload const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id) { memset(handler, 0, sizeof(struct data_packet)); - handler->results.layers_used = 0; - handler->results.layers_size = sizeof(handler->results.layers) / sizeof(handler->results.layers[0]); + handler->layers_used = 0; + handler->layers_size = sizeof(handler->layers) / sizeof(handler->layers[0]); handler->data_ptr = data; handler->trace_id = trace_id; @@ -101,21 +98,20 @@ const void *data_packet_parse(struct data_packet *handler, const void *data, siz // return 0 : success // return -1 : error -int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tuple *addr) +int data_packet_get_innermost_four_tuple(struct data_packet *handler, struct four_tuple *addr) { const char *l3_layer_data = NULL; const char *l4_layer_data = NULL; const struct layer_result *l3_layer_result = NULL; const struct layer_result *l4_layer_result = NULL; - struct layer_results *results = &handler->results; // search L4 layer and L3 layer in reverse order - for (int8_t i = results->layers_used - 1; i >= 0; i--) + for (int8_t i = handler->layers_used - 1; i >= 0; i--) { - const struct layer_result *layer = &results->layers[i]; + const struct layer_result *layer = &handler->layers[i]; enum layer_type type = layer->type; - LOG_DEBUG("%s: find most inner tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type)); + LOG_DEBUG("%s: find innermost tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type)); // first get L4 layer if (type & LAYER_TYPE_L4) @@ -135,13 +131,13 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tu if (l3_layer_result) { l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset; - set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr); + populate_four_tuple_from_layer(l3_layer_data, l3_layer_result->type, addr); } if (l4_layer_result) { l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset; - set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr); + populate_four_tuple_from_layer(l4_layer_data, l4_layer_result->type, addr); } if (l3_layer_result && l4_layer_result) @@ -156,21 +152,20 @@ int data_packet_get_innermost_tuple4(struct data_packet *handler, struct four_tu // return 0 : success // return -1 : error -int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tuple *addr) +int data_packet_get_outermost_four_tuple(struct data_packet *handler, struct four_tuple *addr) { const char *l3_layer_data = NULL; const char *l4_layer_data = NULL; const struct layer_result *l3_layer_result = NULL; const struct layer_result *l4_layer_result = NULL; - struct layer_results *results = &handler->results; // search L3 layer and L4 layer in order - for (int8_t i = 0; i <= results->layers_used - 1; i++) + for (int8_t i = 0; i <= handler->layers_used - 1; i++) { - const struct layer_result *layer = &results->layers[i]; + const struct layer_result *layer = &handler->layers[i]; enum layer_type type = layer->type; - LOG_DEBUG("%s: find most outer tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type)); + LOG_DEBUG("%s: find outermost tuple4, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type)); // first get L3 layer if (type & LAYER_TYPE_L3) @@ -190,13 +185,13 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tu if (l3_layer_result) { l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset; - set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr); + populate_four_tuple_from_layer(l3_layer_data, l3_layer_result->type, addr); } if (l4_layer_result) { l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset; - set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr); + populate_four_tuple_from_layer(l4_layer_data, l4_layer_result->type, addr); } if (l3_layer_result && l4_layer_result) @@ -214,19 +209,18 @@ int data_packet_get_outermost_tuple4(struct data_packet *handler, struct four_tu int data_packet_get_innermost_address(struct data_packet *handler, struct four_tuple *addr) { const char *l3_layer_data = NULL; - struct layer_results *results = &handler->results; // search L3 layer in reverse order - for (int8_t i = results->layers_used - 1; i >= 0; i--) + for (int8_t i = handler->layers_used - 1; i >= 0; i--) { - const struct layer_result *layer = &results->layers[i]; + const struct layer_result *layer = &handler->layers[i]; enum layer_type type = layer->type; - LOG_DEBUG("%s: find most inner address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type)); + LOG_DEBUG("%s: find innermost address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type)); if (type & LAYER_TYPE_L3) { l3_layer_data = (const char *)handler->data_ptr + layer->offset; - set_addr_tuple4(l3_layer_data, type, addr); + populate_four_tuple_from_layer(l3_layer_data, type, addr); return 0; } } @@ -239,19 +233,18 @@ int data_packet_get_innermost_address(struct data_packet *handler, struct four_t int data_packet_get_outermost_address(struct data_packet *handler, struct four_tuple *addr) { const char *l3_layer_data = NULL; - struct layer_results *results = &handler->results; // search L3 layer in order - for (int8_t i = 0; i <= results->layers_used - 1; i++) + for (int8_t i = 0; i <= handler->layers_used - 1; i++) { - const struct layer_result *layer = &results->layers[i]; + const struct layer_result *layer = &handler->layers[i]; enum layer_type type = layer->type; - LOG_DEBUG("%s: find most outer address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, results->layers_size, layer_type2str(type)); + LOG_DEBUG("%s: find outermost address, trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->trace_id, i, handler->layers_size, layer_type_to_string(type)); if (type & LAYER_TYPE_L3) { l3_layer_data = (const char *)handler->data_ptr + layer->offset; - set_addr_tuple4(l3_layer_data, type, addr); + populate_four_tuple_from_layer(l3_layer_data, type, addr); return 0; } } @@ -391,24 +384,6 @@ uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method meth * Private API ******************************************************************************/ -// return 0 : success -// return -ENOMEM : error -static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset) -{ - struct layer_results *result = &handler->results; - - if (result->layers_used >= result->layers_size) - { - return -ENOMEM; - } - - result->layers[result->layers_used].offset = offset; - result->layers[result->layers_used].type = type; - result->layers_used++; - - return 0; -} - static const char *ldbc_method_to_string(enum ldbc_method ldbc_method) { switch (ldbc_method) @@ -428,7 +403,54 @@ static const char *ldbc_method_to_string(enum ldbc_method ldbc_method) } } -static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct four_tuple *addr) +static const char *layer_type_to_string(enum layer_type this_type) +{ + switch (this_type) + { + case LAYER_TYPE_ETHER: + return "ETHER"; + case LAYER_TYPE_PPP: + return "PPP"; + case LAYER_TYPE_HDLC: + return "HDLC"; + case LAYER_TYPE_VLAN: + return "VLAN"; + case LAYER_TYPE_PPPOE: + return "PPPOE"; + case LAYER_TYPE_MPLS: + return "MPLS"; + case LAYER_TYPE_IPV4: + return "IPV4"; + case LAYER_TYPE_IPV6: + return "IPV6"; + case LAYER_TYPE_UDP: + return "UDP"; + case LAYER_TYPE_TCP: + return "TCP"; + case LAYER_TYPE_G_VXLAN: + return "G_VXLAN"; + case LAYER_TYPE_GTPV1_U: + return "GTPV1_U"; + default: + return "UNKNOWN"; + } +} + +static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset) +{ + if (handler->layers_used >= handler->layers_size) + { + return -ENOMEM; + } + + handler->layers[handler->layers_used].offset = offset; + handler->layers[handler->layers_used].type = type; + handler->layers_used++; + + return 0; +} + +static void populate_four_tuple_from_layer(const void *data, enum layer_type layer_type, struct four_tuple *addr) { const struct tcphdr *tcp_hdr = NULL; const struct udp_hdr *udp_hdr = NULL; @@ -464,39 +486,6 @@ static void set_addr_tuple4(const void *data, enum layer_type layer_type, struct } } -static const char *layer_type2str(enum layer_type this_type) -{ - switch (this_type) - { - case LAYER_TYPE_ETHER: - return "ETHER"; - case LAYER_TYPE_PPP: - return "PPP"; - case LAYER_TYPE_HDLC: - return "HDLC"; - case LAYER_TYPE_VLAN: - return "VLAN"; - case LAYER_TYPE_PPPOE: - return "PPPOE"; - case LAYER_TYPE_MPLS: - return "MPLS"; - case LAYER_TYPE_IPV4: - return "IPV4"; - case LAYER_TYPE_IPV6: - return "IPV6"; - case LAYER_TYPE_UDP: - return "UDP"; - case LAYER_TYPE_TCP: - return "TCP"; - case LAYER_TYPE_G_VXLAN: - return "G_VXLAN"; - case LAYER_TYPE_GTPV1_U: - return "GTPV1_U"; - default: - return "UNKNOWN"; - } -} - // FROM SAPP static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph) { @@ -550,7 +539,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si { if (length < sizeof(struct ethhdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER)); return data; } @@ -566,7 +555,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER), data_next_length, length); switch (next_proto) { case ETH_P_8021Q: @@ -586,7 +575,7 @@ static const void *parse_ether(struct data_packet *handler, const void *data, si // TESTED return parse_mpls(handler, data_next_layer, data_next_length); default: - LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER), next_proto); + LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_ETHER), next_proto); return data_next_layer; } } @@ -595,7 +584,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz { if (length < sizeof(struct ip)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4)); return data; } @@ -611,7 +600,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4), data_next_length, length); switch (next_proto) { case IPPROTO_TCP: @@ -627,7 +616,7 @@ static const void *parse_ipv4(struct data_packet *handler, const void *data, siz // TESTED return parse_ipv6(handler, data_next_layer, data_next_length); default: - LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4), next_proto); + LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV4), next_proto); return data_next_layer; } } @@ -636,7 +625,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz { if (length < sizeof(struct ip6_hdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6)); return data; } @@ -652,7 +641,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6), data_next_length, length); switch (next_proto) { case IPPROTO_TCP: @@ -668,7 +657,7 @@ static const void *parse_ipv6(struct data_packet *handler, const void *data, siz // TESTED return parse_ipv6(handler, data_next_layer, data_next_length); default: - LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6), next_proto); + LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_IPV6), next_proto); return data_next_layer; } } @@ -677,7 +666,7 @@ static const void *parse_tcp(struct data_packet *handler, const void *data, size { if (length < sizeof(struct tcphdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_TCP)); return data; } @@ -692,7 +681,7 @@ static const void *parse_tcp(struct data_packet *handler, const void *data, size const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_TCP), data_next_length, length); return data_next_layer; } @@ -701,7 +690,7 @@ static const void *parse_udp(struct data_packet *handler, const void *data, size { if (length < sizeof(struct udp_hdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_UDP)); return data; } @@ -716,7 +705,7 @@ static const void *parse_udp(struct data_packet *handler, const void *data, size const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_UDP), data_next_length, length); switch (ntohs(hdr->uh_dport)) { // VXLAN_DPORT @@ -736,7 +725,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data { if (length < 8) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE)); return data; } @@ -751,7 +740,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE), data_next_length, length); switch (next_proto) { // PPPOE_TYPE_IPV4 @@ -763,7 +752,7 @@ static const void *parse_pppoe_ses(struct data_packet *handler, const void *data // TODO return parse_ipv6(handler, data_next_layer, data_next_length); default: - LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE), next_proto); + LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_PPPOE), next_proto); return data_next_layer; } } @@ -772,7 +761,7 @@ static const void *parse_vxlan(struct data_packet *handler, const void *data, si { if (length < sizeof(struct vxlan_hdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_G_VXLAN)); return NULL; } @@ -787,7 +776,7 @@ static const void *parse_vxlan(struct data_packet *handler, const void *data, si const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_G_VXLAN), data_next_length, length); // TESTED return parse_ether(handler, data_next_layer, data_next_length); } @@ -796,7 +785,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data { if (length < sizeof(struct vlan_hdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN)); return NULL; } @@ -812,7 +801,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN), data_next_length, length); switch (next_proto) { case ETH_P_8021Q: @@ -831,7 +820,7 @@ static const void *parse_vlan8021q(struct data_packet *handler, const void *data // TODO return parse_mpls(handler, data_next_layer, data_next_length); default: - LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN), next_proto); + LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_VLAN), next_proto); return data_next_layer; } } @@ -840,7 +829,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, { if (length < sizeof(struct gtp_hdr)) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U)); return NULL; } @@ -860,7 +849,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, const void *data_next_layer = (const char *)data + hdr_len; size_t data_next_length = length - hdr_len; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U), data_next_length, length); switch (next_proto) { case 4: @@ -870,7 +859,7 @@ static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, // TESTED return parse_ipv6(handler, data_next_layer, data_next_length); default: - LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U), next_proto); + LOG_ERROR("%s: trace_id: %lu, %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_GTPV1_U), next_proto); return data_next_layer; } } @@ -879,7 +868,7 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz { if (length < 4) { - LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS)); + LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS)); return data; } @@ -934,32 +923,32 @@ static const void *parse_mpls(struct data_packet *handler, const void *data, siz data_next_layer = (const char *)data_next_layer + 4; data_next_length = data_next_length - 4; - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length); // TESTED return parse_ether(handler, data_next_layer, data_next_length); } else if (ip_version == 4) { - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length); // TESTED return parse_ipv4(handler, data_next_layer, data_next_length); } else if (ip_version == 6) { - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length); // TODO return parse_ipv6(handler, data_next_layer, data_next_length); } else { - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length); // TODO return parse_ether(handler, data_next_layer, data_next_length); } } else { - LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS), data_next_length, length); + LOG_DEBUG("%s: trace_id: %lu, %s->payload: [%lu/%lu]", LOG_TAG_RAWPKT, handler->trace_id, layer_type_to_string(LAYER_TYPE_MPLS), data_next_length, length); // TESTED return parse_mpls(handler, data_next_layer, data_next_length); } diff --git a/common/test/gtest_data_packet.cpp b/common/test/gtest_data_packet.cpp index bd34c57..133b357 100644 --- a/common/test/gtest_data_packet.cpp +++ b/common/test/gtest_data_packet.cpp @@ -90,8 +90,8 @@ TEST(DATA_PACKET, ETH_VLAN_VLAN_IP4_IP4_UDP) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "10.10.100.25 62367 10.10.101.2 17000"); @@ -220,8 +220,8 @@ TEST(DATA_PACKET, ETH_IP6_IP4_TCP_SSH) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "1.1.1.1 57639 2.2.2.2 22"); @@ -345,8 +345,8 @@ TEST(DATA_PACKET, ETH_VLAN_IP6_IP4_GRE_PPP_IP4_UDP_DNS) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "8.8.8.8 53 172.16.44.3 9879"); @@ -445,8 +445,8 @@ TEST(DATA_PACKET, ETH_IP4_IP6_TCP) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "2001:da8:200:900e:200:5efe:d24d:58a3 52556 2600:140e:6::1702:1058 80"); @@ -530,8 +530,8 @@ TEST(DATA_PACKET, ETH_IP6_IP6_UDP) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "dead::beef 30000 cafe::babe 13000"); @@ -622,8 +622,8 @@ TEST(DATA_PACKET, ETH_MPLS_IP4_TCP) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "119.40.37.65 61853 123.125.29.250 80"); @@ -719,8 +719,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_IP4_TCP) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "10.31.0.1 11001 10.34.0.1 23"); @@ -821,8 +821,8 @@ TEST(DATA_PACKET, ETH_VLAN_PPPOE_IP4_TCP) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "100.65.55.0 34532 91.185.14.33 443"); @@ -982,8 +982,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP6_TCP_TLS) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "2409:8c34:4400:700:0:4:0:3 443 2409:8934:5082:2100:ecad:e0e4:530a:c269 46582"); @@ -1150,8 +1150,8 @@ TEST(DATA_PACKET, ETH_IP6_UDP_GTP_IP4_TCP_TLS) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "10.49.115.138 50081 121.196.250.66 443"); @@ -1260,8 +1260,8 @@ TEST(DATA_PACKET, ETH_IP4_UDP_VXLAN_ETH_IP4_UDP_DNS) memset(&inner_addr, 0, sizeof(inner_addr)); memset(&outer_addr, 0, sizeof(outer_addr)); - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == 0); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == 0); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == 0); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == 0); inner_addr_str = four_tuple_to_string(&inner_addr); outer_addr_str = four_tuple_to_string(&outer_addr); EXPECT_STREQ(inner_addr_str, "192.168.11.193 65290 114.114.114.114 53"); @@ -1328,8 +1328,8 @@ TEST(DATA_PACKET, ETH_MPLS_MPLS_PWETHCW_ETH_ARP) struct four_tuple inner_addr; struct four_tuple outer_addr; - EXPECT_TRUE(data_packet_get_innermost_tuple4(&handler, &inner_addr) == -1); - EXPECT_TRUE(data_packet_get_outermost_tuple4(&handler, &outer_addr) == -1); + EXPECT_TRUE(data_packet_get_innermost_four_tuple(&handler, &inner_addr) == -1); + EXPECT_TRUE(data_packet_get_outermost_four_tuple(&handler, &outer_addr) == -1); EXPECT_TRUE(data_packet_get_innermost_address(&handler, &inner_addr) == -1); EXPECT_TRUE(data_packet_get_outermost_address(&handler, &outer_addr) == -1); diff --git a/platform/src/packet_io.cpp b/platform/src/packet_io.cpp index de85072..332d76e 100644 --- a/platform/src/packet_io.cpp +++ b/platform/src/packet_io.cpp @@ -356,7 +356,7 @@ static struct session_ctx *data_packet_search_session(struct session_table *tabl data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0); - data_packet_get_innermost_tuple4(&data_pkt, &inner_addr); + data_packet_get_innermost_four_tuple(&data_pkt, &inner_addr); four_tuple_reverse(&inner_addr, &reverse_addr); struct session_node *node = session_table_search_by_id(table, session_id); @@ -388,7 +388,7 @@ static struct session_ctx *inject_packet_search_session(struct session_table *ta data_packet_parse(&data_pkt, (const void *)raw_data, raw_len, 0); - data_packet_get_innermost_tuple4(&data_pkt, &inner_addr); + data_packet_get_innermost_four_tuple(&data_pkt, &inner_addr); struct session_node *node = session_table_search_by_addr(table, &inner_addr); if (node == NULL) @@ -916,7 +916,7 @@ static void handle_session_opening(struct metadata *meta, struct control_packet struct data_packet data_pkt; struct four_tuple inner_tuple4; const void *payload = data_packet_parse(&data_pkt, (const void *)meta->raw_data, meta->raw_len, meta->session_id); - data_packet_get_innermost_tuple4(&data_pkt, &inner_tuple4); + data_packet_get_innermost_four_tuple(&data_pkt, &inner_tuple4); uint16_t real_offset = (char *)payload - meta->raw_data; if (real_offset != meta->l7offset) {