gfwleak/tango-tsg-service-chaining-engine
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

TSG-13684 tsg-service-chaining-engine使用VLAN封装Packet并执行Traffic Mirroring

Browse Source
This commit is contained in:
luwenpeng
2023-10-18 10:08:10 +08:00
parent 18561bc4fe
commit 0753e8018c
57 changed files with 1784 additions and 1175 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
common/src/ctrl_packet.cpp → common/src/control_packet.cpp
View File

@@ -6,7 +6,7 @@
#include "log.h"
#include "mpack.h"
#include "utils.h"
#include "ctrl_packet.h"
#include "control_packet.h"
const char *session_state_to_string(enum session_state state)
{
@@ -25,15 +25,12 @@ const char *session_state_to_string(enum session_state state)
}
}
void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler)
{
memset(handler, 0, sizeof(struct ctrl_pkt_parser));
}
// return 0 : success
// return -1 : error
int ctrl_packet_parser_mpack(struct ctrl_pkt_parser *handler, const char *data, size_t length)
int control_packet_parse(struct control_packet *handler, const char *data, size_t length)
{
memset(handler, 0, sizeof(struct control_packet));
mpack_tree_t tree;
mpack_node_t root;
mpack_node_t temp;
@@ -174,139 +171,7 @@ error_out:
return -1;
}
// return 0 : success
// return -1 : error
int ctrl_packet_parser_cjson(struct ctrl_pkt_parser *handler, const char *data, size_t length)
{
int iter = 0;
cJSON *item = NULL;
cJSON *elem = NULL;
cJSON *json = NULL;
json = cJSON_Parse(data);
if (json == NULL)
{
LOG_ERROR("%s: unexpected control packet: (invalid json format) %s", LOG_TAG_CTRLPKT, data);
return -1;
}
// tsync
item = cJSON_GetObjectItem(json, "tsync");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid tsync format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
memcpy(handler->tsync, item->valuestring, MIN(sizeof(handler->tsync), strlen(item->valuestring)));
// session_id
item = cJSON_GetObjectItem(json, "session_id");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid session_id format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
handler->session_id = atoll(item->valuestring);
// state
item = cJSON_GetObjectItem(json, "state");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid state format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
if (strcasecmp(item->valuestring, "opening") == 0)
{
handler->state = SESSION_STATE_OPENING;
}
else if (strcasecmp(item->valuestring, "active") == 0)
{
handler->state = SESSION_STATE_ACTIVE;
}
else if (strcasecmp(item->valuestring, "closing") == 0)
{
handler->state = SESSION_STATE_CLOSING;
}
else if (strcasecmp(item->valuestring, "resetall") == 0)
{
handler->state = SESSION_STATE_RESETALL;
}
else
{
LOG_ERROR("%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
if (handler->state != SESSION_STATE_ACTIVE)
{
goto success_out;
}
// method
item = cJSON_GetObjectItem(json, "method");
if (!item || !cJSON_IsString(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid method format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
memcpy(handler->method, item->valuestring, MIN(sizeof(handler->method), strlen(item->valuestring)));
if (strcasecmp(item->valuestring, "policy_update") != 0)
{
LOG_ERROR("%s: unexpected control packet: (invalid method value) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
// params
item = cJSON_GetObjectItem(json, "params");
if (!item || !cJSON_IsObject(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid params format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
item = cJSON_GetObjectItem(item, "service_chaining");
if (!item || !cJSON_IsArray(item) || !cJSON_GetArraySize(item))
{
LOG_ERROR("%s: unexpected control packet: (invalid service_chaining format) %s", LOG_TAG_CTRLPKT, data);
goto error_out;
}
handler->rule_id_num = MIN(cJSON_GetArraySize(item), (int)(sizeof(handler->rule_ids) / sizeof(handler->rule_ids[0])));
cJSON_ArrayForEach(elem, item)
{
if (!cJSON_IsNumber(elem))
{
LOG_ERROR("%s: unexpected control packet: (invalid service_chaining value) %s", LOG_TAG_POLICY, data);
continue;
}
handler->rule_ids[iter] = elem->valueint;
iter++;
if (iter == handler->rule_id_num)
{
break;
}
}
success_out:
cJSON_Delete(json);
return 0;
error_out:
cJSON_Delete(json);
return -1;
}
// return 0 : success
// return -1 : error
int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length)
{
// return ctrl_packet_parser_cjson(handler, data, length);
return ctrl_packet_parser_mpack(handler, data, length);
}
void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler)
void control_packet_dump(struct control_packet *handler)
{
if (handler)
{

287
common/src/raw_packet.cpp → common/src/data_packet.cpp
View File

@@ -14,18 +14,12 @@
#include "utils.h"
#include "uthash.h"
#include "addr_tuple4.h"
#include "raw_packet.h"
#include "data_packet.h"
/******************************************************************************
* Struct
******************************************************************************/
enum parse_status
{
PARSE_STATUS_CONTINUE,
PARSE_STATUS_STOP
};
struct vlan_hdr
{
uint16_t vlan_cfi;
@@ -66,8 +60,7 @@ struct gtp_hdr
* Static API
******************************************************************************/
static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset);
static enum parse_status raw_packet_parser_status(struct raw_pkt_parser *handler, const void *data, enum layer_type this_type);
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);
@@ -77,44 +70,38 @@ static const char *layer_type2str(enum layer_type this_type);
static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph);
// parser protocol
static const void *parse_ether(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type);
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);
static const void *parse_tcp(struct data_packet *handler, const void *data, size_t length);
static const void *parse_udp(struct data_packet *handler, const void *data, size_t length);
static const void *parse_pppoe_ses(struct data_packet *handler, const void *data, size_t length);
static const void *parse_vxlan(struct data_packet *handler, const void *data, size_t length);
static const void *parse_vlan8021q(struct data_packet *handler, const void *data, size_t length);
static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, size_t length);
static const void *parse_mpls(struct data_packet *handler, const void *data, size_t length);
/******************************************************************************
* Public API
******************************************************************************/
void raw_packet_parser_init(struct raw_pkt_parser *handler, uint64_t pkt_trace_id, enum layer_type expect_type, uint16_t expect_results_num)
{
memset(handler, 0, sizeof(struct raw_pkt_parser));
handler->expect_type = expect_type;
handler->results.layers_used = 0;
handler->results.layers_size = MIN(expect_results_num, (sizeof(handler->results.layers) / sizeof(handler->results.layers[0])));
handler->ptr_pkt_start = NULL;
handler->pkt_trace_id = pkt_trace_id;
}
// return most inner payload
const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length)
const void *data_packet_parse(struct data_packet *handler, const void *data, size_t length, uint64_t trace_id)
{
handler->ptr_pkt_start = data;
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->data_ptr = data;
handler->trace_id = trace_id;
// TESTED
return parse_ether(handler, data, length, LAYER_TYPE_ETHER);
return parse_ether(handler, data, length);
}
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_innermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
@@ -128,7 +115,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most inner tuple4, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
// first get L4 layer
if (type & LAYER_TYPE_L4)
@@ -147,13 +134,13 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
if (l3_layer_result)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + l3_layer_result->offset;
l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
}
if (l4_layer_result)
{
l4_layer_data = (const char *)handler->ptr_pkt_start + l4_layer_result->offset;
l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
}
@@ -169,7 +156,7 @@ int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, stru
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_outermost_tuple4(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
const char *l4_layer_data = NULL;
@@ -183,7 +170,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most outer tuple4, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
// first get L3 layer
if (type & LAYER_TYPE_L3)
@@ -202,13 +189,13 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
if (l3_layer_result)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + l3_layer_result->offset;
l3_layer_data = (const char *)handler->data_ptr + l3_layer_result->offset;
set_addr_tuple4(l3_layer_data, l3_layer_result->type, addr);
}
if (l4_layer_result)
{
l4_layer_data = (const char *)handler->ptr_pkt_start + l4_layer_result->offset;
l4_layer_data = (const char *)handler->data_ptr + l4_layer_result->offset;
set_addr_tuple4(l4_layer_data, l4_layer_result->type, addr);
}
@@ -224,7 +211,7 @@ int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, stru
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_innermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
@@ -235,10 +222,10 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most inner address, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
if (type & LAYER_TYPE_L3)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
l3_layer_data = (const char *)handler->data_ptr + layer->offset;
set_addr_tuple4(l3_layer_data, type, addr);
return 0;
}
@@ -249,7 +236,7 @@ int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, str
// return 0 : success
// return -1 : error
int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr)
int data_packet_get_outermost_address(struct data_packet *handler, struct addr_tuple4 *addr)
{
const char *l3_layer_data = NULL;
struct layer_results *results = &handler->results;
@@ -260,10 +247,10 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
const struct layer_result *layer = &results->layers[i];
enum layer_type type = layer->type;
LOG_DEBUG("%s: find most outer address, pkt_trace_id: %lu, layer[%d/%d]: %s", LOG_TAG_RAWPKT, handler->pkt_trace_id, i, results->layers_size, layer_type2str(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));
if (type & LAYER_TYPE_L3)
{
l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset;
l3_layer_data = (const char *)handler->data_ptr + layer->offset;
set_addr_tuple4(l3_layer_data, type, addr);
return 0;
}
@@ -272,7 +259,7 @@ int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, str
return -1;
}
uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_i2e)
uint64_t data_packet_get_hash(struct data_packet *handler, enum ldbc_method method, int dir_is_i2e)
{
uint64_t temp = 0;
uint64_t hash_value = 1;
@@ -294,12 +281,12 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
return hash_value;
}
if (raw_packet_parser_get_most_inner_address(handler, &inner_addr) == -1)
if (data_packet_get_innermost_address(handler, &inner_addr) == -1)
{
return hash_value;
}
if (raw_packet_parser_get_most_outer_address(handler, &outer_addr) == -1)
if (data_packet_get_outermost_address(handler, &outer_addr) == -1)
{
return hash_value;
}
@@ -392,8 +379,8 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
char *inner_addr_str = addr_tuple4_to_str(&inner_addr);
char *outer_addr_str = addr_tuple4_to_str(&outer_addr);
LOG_DEBUG("%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_TAG_RAWPKT, handler->pkt_trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
LOG_DEBUG("%s: trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu",
LOG_TAG_RAWPKT, handler->trace_id, outer_addr_str, inner_addr_str, dir_is_i2e, ldbc_method_to_string(method), hash_value);
free(inner_addr_str);
free(outer_addr_str);
@@ -406,7 +393,7 @@ uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum l
// return 0 : success
// return -ENOMEM : error
static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_type type, uint16_t offset)
static int data_packet_push_layer(struct data_packet *handler, enum layer_type type, uint16_t offset)
{
struct layer_results *result = &handler->results;
@@ -422,30 +409,6 @@ static int raw_packet_parser_push(struct raw_pkt_parser *handler, enum layer_typ
return 0;
}
// return PARSE_STATUS_CONTINUE
// return PARSE_STATUS_STOP
static enum parse_status raw_packet_parser_status(struct raw_pkt_parser *handler, const void *data, enum layer_type this_type)
{
/*
* only when this_type & handler->expect_type is true,
* the information of the current layer will be recorded in results.
*/
if (!(this_type & handler->expect_type))
{
return PARSE_STATUS_CONTINUE;
}
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->ptr_pkt_start);
if (raw_packet_parser_push(handler, this_type, offset) < 0)
{
return PARSE_STATUS_STOP;
}
else
{
return PARSE_STATUS_CONTINUE;
}
}
static const char *ldbc_method_to_string(enum ldbc_method ldbc_method)
{
switch (ldbc_method)
@@ -583,15 +546,16 @@ static uint16_t parse_gtphdr_len(const struct gtp_hdr *gtph)
return (char *)p_ext_hdr - (char *)gtph;
}
static const void *parse_ether(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_ether(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct ethhdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_ETHER));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_ETHER, offset) < 0)
{
return data;
}
@@ -602,40 +566,41 @@ static const void *parse_ether(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case ETH_P_8021Q:
case ETH_P_8021AD:
// TESTED
return parse_vlan8021q(handler, data_next_layer, data_next_length, LAYER_TYPE_VLAN);
return parse_vlan8021q(handler, data_next_layer, data_next_length);
case ETH_P_IP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case ETH_P_IPV6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
case ETH_P_PPP_SES:
// TODO
return parse_pppoe_ses(handler, data_next_layer, data_next_length, LAYER_TYPE_PPPOE);
return parse_pppoe_ses(handler, data_next_layer, data_next_length);
case ETH_P_MPLS_UC:
// TESTED
return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
return parse_mpls(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_ipv4(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct ip))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV4));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_IPV4, offset) < 0)
{
return data;
}
@@ -646,36 +611,37 @@ static const void *parse_ipv4(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case IPPROTO_TCP:
// TESTED
return parse_tcp(handler, data_next_layer, data_next_length, LAYER_TYPE_TCP);
return parse_tcp(handler, data_next_layer, data_next_length);
case IPPROTO_UDP:
// TESTED
return parse_udp(handler, data_next_layer, data_next_length, LAYER_TYPE_UDP);
return parse_udp(handler, data_next_layer, data_next_length);
case IPPROTO_IPIP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case IPPROTO_IPV6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_ipv6(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct ip6_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_IPV6));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_IPV6, offset) < 0)
{
return data;
}
@@ -686,36 +652,37 @@ static const void *parse_ipv6(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case IPPROTO_TCP:
// TESTED
return parse_tcp(handler, data_next_layer, data_next_length, LAYER_TYPE_TCP);
return parse_tcp(handler, data_next_layer, data_next_length);
case IPPROTO_UDP:
// TESTED
return parse_udp(handler, data_next_layer, data_next_length, LAYER_TYPE_UDP);
return parse_udp(handler, data_next_layer, data_next_length);
case IPPROTO_IPIP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case IPPROTO_IPV6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_tcp(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct tcphdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_TCP));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_TCP, offset) < 0)
{
return data;
}
@@ -725,20 +692,21 @@ static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, s
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
return data_next_layer;
}
static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_udp(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct udp_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_UDP));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_UDP, offset) < 0)
{
return data;
}
@@ -748,31 +716,32 @@ static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, s
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (ntohs(hdr->uh_dport))
{
// VXLAN_DPORT
case 4789:
// TESTED
return parse_vxlan(handler, data_next_layer, data_next_length, LAYER_TYPE_G_VXLAN);
return parse_vxlan(handler, data_next_layer, data_next_length);
// GTP1U_PORT
case 2152:
// TESTED
return parse_gtpv1_u(handler, data_next_layer, data_next_length, LAYER_TYPE_GTPV1_U);
return parse_gtpv1_u(handler, data_next_layer, data_next_length);
default:
return data_next_layer;
}
}
static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_pppoe_ses(struct data_packet *handler, const void *data, size_t length)
{
if (length < 8)
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_PPPOE));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_PPPOE, offset) < 0)
{
return data;
}
@@ -782,32 +751,33 @@ static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *d
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
// PPPOE_TYPE_IPV4
case 0x2100:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
// PPPOE_TYPE_IPV6
case 0x5700:
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_vxlan(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct vxlan_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_G_VXLAN));
return NULL;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_G_VXLAN, offset) < 0)
{
return data;
}
@@ -817,20 +787,21 @@ static const void *parse_vxlan(struct raw_pkt_parser *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: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
return parse_ether(handler, data_next_layer, data_next_length);
}
static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_vlan8021q(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct vlan_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_VLAN));
return NULL;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_VLAN, offset) < 0)
{
return data;
}
@@ -841,35 +812,35 @@ static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *d
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case ETH_P_8021Q:
// TESTED
return parse_vlan8021q(handler, data_next_layer, data_next_length, LAYER_TYPE_VLAN);
return parse_vlan8021q(handler, data_next_layer, data_next_length);
case ETH_P_IP:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case ETH_P_IPV6:
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
case ETH_P_PPP_SES:
// TESTED
return parse_pppoe_ses(handler, data_next_layer, data_next_length, LAYER_TYPE_PPPOE);
return parse_pppoe_ses(handler, data_next_layer, data_next_length);
case ETH_P_MPLS_UC:
// TODO
return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
return parse_mpls(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_gtpv1_u(struct data_packet *handler, const void *data, size_t length)
{
if (length < sizeof(struct gtp_hdr))
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_GTPV1_U));
return NULL;
}
@@ -879,7 +850,8 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_GTPV1_U, offset) < 0)
{
return data;
}
@@ -888,30 +860,31 @@ static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *dat
const void *data_next_layer = (const char *)data + hdr_len;
size_t data_next_length = length - hdr_len;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
switch (next_proto)
{
case 4:
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
case 6:
// TESTED
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
default:
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, stop parse next protocol %d", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), next_proto);
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);
return data_next_layer;
}
}
static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type)
static const void *parse_mpls(struct data_packet *handler, const void *data, size_t length)
{
if (length < 4)
{
LOG_ERROR("%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type));
LOG_ERROR("%s: trace_id: %lu, %s, err: data not enough", LOG_TAG_RAWPKT, handler->trace_id, layer_type2str(LAYER_TYPE_MPLS));
return data;
}
if (raw_packet_parser_status(handler, data, this_type) == PARSE_STATUS_STOP)
uint16_t offset = (uintptr_t)data - (uintptr_t)(handler->data_ptr);
if (data_packet_push_layer(handler, LAYER_TYPE_MPLS, offset) < 0)
{
return data;
}
@@ -961,33 +934,33 @@ static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data,
data_next_layer = (const char *)data_next_layer + 4;
data_next_length = data_next_length - 4;
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
return parse_ether(handler, data_next_layer, data_next_length);
}
else if (ip_version == 4)
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4);
return parse_ipv4(handler, data_next_layer, data_next_length);
}
else if (ip_version == 6)
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TODO
return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6);
return parse_ipv6(handler, data_next_layer, data_next_length);
}
else
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TODO
return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER);
return parse_ether(handler, data_next_layer, data_next_length);
}
}
else
{
LOG_DEBUG("%s: pkt_trace_id: %lu, this_layer: %s, payload_len: [%lu/%lu]", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type), data_next_length, length);
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);
// TESTED
return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS);
return parse_mpls(handler, data_next_layer, data_next_length);
}
}

18
common/src/utils.cpp
View File

@@ -12,17 +12,17 @@
#include "log.h"
/******************************************************************************
* fixed_num_array
* mutable_array
******************************************************************************/
void fixed_num_array_init(struct fixed_num_array *array)
void mutable_array_init(struct mutable_array *array)
{
memset(array, 0, sizeof(fixed_num_array));
memset(array, 0, sizeof(mutable_array));
array->num = 0;
array->size = sizeof(array->elems) / sizeof(array->elems[0]);
}
void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem)
void mutable_array_add_elem(struct mutable_array *array, uint64_t elem)
{
if (array->num < array->size)
{
@@ -35,7 +35,7 @@ void fixed_num_array_add_elem(struct fixed_num_array *array, uint64_t elem)
}
}
void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem)
void mutable_array_del_elem(struct mutable_array *array, uint64_t elem)
{
for (int i = 0; i < array->num; i++)
{
@@ -51,7 +51,7 @@ void fixed_num_array_del_elem(struct fixed_num_array *array, uint64_t elem)
}
}
int fixed_num_array_is_full(struct fixed_num_array *array)
int mutable_array_is_full(struct mutable_array *array)
{
if (array->num == array->size)
{
@@ -63,7 +63,7 @@ int fixed_num_array_is_full(struct fixed_num_array *array)
}
}
int fixed_num_array_count_elem(struct fixed_num_array *array)
int mutable_array_count_elem(struct mutable_array *array)
{
if (array)
{
@@ -75,7 +75,7 @@ int fixed_num_array_count_elem(struct fixed_num_array *array)
}
}
int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem)
int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem)
{
for (int i = 0; i < array->num; i++)
{
@@ -88,7 +88,7 @@ int fixed_num_array_exist_elem(struct fixed_num_array *array, uint64_t elem)
return 0;
}
int fixed_num_array_index_elem(struct fixed_num_array *array, int index)
int mutable_array_index_elem(struct mutable_array *array, int index)
{
if (index >= array->num)
{