diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index ebd99f6..4b4253d 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -4,8 +4,7 @@ src/tfe_pkt_util.cpp src/tfe_tcp_restore.cpp src/raw_socket.cpp src/packet_construct.cpp src/tap.cpp src/io_uring.cpp src/intercept_policy.cpp src/tfe_fieldstat.cpp src/tfe_addr_tuple4.cpp src/tfe_packet_io.cpp src/tfe_session_table.cpp - src/tfe_ctrl_packet.cpp src/tfe_raw_packet.cpp - src/tfe_mpack.cpp src/tfe_packet_io_fs.cpp src/mpack.cpp ) + src/tfe_ctrl_packet.cpp src/tfe_raw_packet.cpp src/tfe_packet_io_fs.cpp src/mpack.cpp ) target_include_directories(common PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include) target_include_directories(common PUBLIC ${CMAKE_CURRENT_LIST_DIR}/../bpf/) target_include_directories(common PRIVATE ${CMAKE_CURRENT_LIST_DIR}/../platform/include/internal) diff --git a/common/include/tfe_ctrl_packet.h b/common/include/tfe_ctrl_packet.h index fbdd277..162b142 100644 --- a/common/include/tfe_ctrl_packet.h +++ b/common/include/tfe_ctrl_packet.h @@ -39,8 +39,8 @@ void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler); // return 0 : success // return -1 : error -int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length); -void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler); +int ctrl_packet_parser_parse(void *ctx, const char* data, size_t length, void *logger); +void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler, void *logger); #ifdef __cpluscplus } diff --git a/common/include/tfe_mpack.h b/common/include/tfe_mpack.h deleted file mode 100644 index 299cbbf..0000000 --- a/common/include/tfe_mpack.h +++ /dev/null @@ -1,17 +0,0 @@ -#ifndef _TFE_MPACK_H -#define _TFE_MPACK_H - -#ifdef __cpluscplus -extern "C" -{ -#endif - -#include "tfe_cmsg.h" - -int parse_messagepack(const char* data, size_t length, void *ctx); - -#ifdef __cpluscplus -} -#endif - -#endif \ No newline at end of file diff --git a/common/include/tfe_packet_io.h b/common/include/tfe_packet_io.h index eaf1d74..23c3bde 100644 --- a/common/include/tfe_packet_io.h +++ b/common/include/tfe_packet_io.h @@ -33,14 +33,13 @@ struct packet_io_thread_ctx struct tap_ctx *tap_ctx; struct session_table *session_table; - struct sf_metrics *sf_metrics; struct packet_io *ref_io; - struct packet_io_fs *ret_fs_state; - struct policy_enforcer *ref_enforcer; struct tfe_proxy *ref_proxy; + struct packet_io_fs *ret_fs_state; struct acceptor_kni_v4 *ref_acceptor_ctx; + void *logger; int session_table_need_reset; }; @@ -80,10 +79,9 @@ struct acceptor_kni_v4 int proxy_sids; int sce_sids; int nr_worker_threads; - int cpu_affinity_mask[TFE_THREAD_MAX]; - cpu_set_t coremask; + struct packet_io *io; struct packet_io_fs *packet_io_fs; struct packet_io_thread_ctx work_threads[TFE_THREAD_MAX]; @@ -96,10 +94,10 @@ int is_enable_iouring(struct packet_io *handle); void tfe_tap_ctx_destory(struct tap_ctx *handler); struct tap_ctx *tfe_tap_ctx_create(void *ctx); -int packet_io_thread_init(struct packet_io *handle, struct packet_io_thread_ctx *thread_ctx); +int packet_io_thread_init(struct packet_io *handle, struct packet_io_thread_ctx *thread_ctx, void *logger); void packet_io_thread_wait(struct packet_io *handle, struct packet_io_thread_ctx *thread_ctx, int timeout_ms); void packet_io_destory(struct packet_io *handle); -struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask); +struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask, void *logger); int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, void *ctx); void handle_decryption_packet_from_tap(const char *data, int len, void *args); diff --git a/common/include/tfe_packet_io_fs.h b/common/include/tfe_packet_io_fs.h index e935f07..d05c992 100644 --- a/common/include/tfe_packet_io_fs.h +++ b/common/include/tfe_packet_io_fs.h @@ -18,23 +18,28 @@ struct throughput_metrics struct packet_io_fs { - struct throughput_metrics raw_pkt_rx; // 累计值 - struct throughput_metrics raw_pkt_tx; // 累计值 + struct throughput_metrics raw_pkt_rx; // 累计值 + struct throughput_metrics raw_pkt_tx; // 累计值 - struct throughput_metrics hit_policy; // 累计值 + struct throughput_metrics decrypt_tx; // 累计值 + struct throughput_metrics decrypt_rx; // 累计值 - struct throughput_metrics decrypt_tx; // 累计值 - struct throughput_metrics decrypt_rx; // 累计值 + struct throughput_metrics raw_bypass; // 累计值 + struct throughput_metrics decrypt_rxdrop; // 累计值 - struct throughput_metrics ctrl_pkt_rx; // 累计值 - struct throughput_metrics ctrl_pkt_tx; // 累计值 + struct throughput_metrics ctrl_pkt_rx; // 累计值 + struct throughput_metrics ctrl_pkt_tx; // 累计值 - struct throughput_metrics tap_pkt_rx; // 累计值 - struct throughput_metrics tap_pkt_tx; // 累计值 - struct throughput_metrics tap_c_pkt_rx; // 累计值 - struct throughput_metrics tap_c_pkt_tx; // 累计值 - struct throughput_metrics tap_s_pkt_rx; // 累计值 - struct throughput_metrics tap_s_pkt_tx; // 累计值 + struct throughput_metrics keepalived_pkt_rx; // 累计值 + struct throughput_metrics keepalived_pkt_tx; // 累计值 + + struct throughput_metrics tap_pkt_rx; // 累计值 + struct throughput_metrics tap_pkt_tx; // 累计值 + struct throughput_metrics tap_pkt_rxdrop; // 累计值 + struct throughput_metrics tap_c_pkt_rx; // 累计值 + struct throughput_metrics tap_c_pkt_tx; // 累计值 + struct throughput_metrics tap_s_pkt_rx; // 累计值 + struct throughput_metrics tap_s_pkt_tx; // 累计值 uint64_t ctrl_pkt_opening_num; // 累计值 uint64_t ctrl_pkt_active_num; // 累计值 @@ -42,14 +47,14 @@ struct packet_io_fs uint64_t ctrl_pkt_resetall_num; // 累计值 uint64_t ctrl_pkt_error_num; // 累计值 - uint64_t session_nums; // 瞬时值 - uint64_t send_log; // 瞬时值 + uint64_t session_num; // 瞬时值 + uint64_t session_log; // 瞬时值 screen_stat_handle_t fs_handle; int fs_id[128]; }; -struct packet_io_fs *packet_io_fs_create(); +struct packet_io_fs *packet_io_fs_create(const char *profile); void packet_io_fs_destory(struct packet_io_fs *handle); void packet_io_fs_dump(struct packet_io_fs *handle); diff --git a/common/include/tfe_raw_packet.h b/common/include/tfe_raw_packet.h index a360b71..91f75ff 100644 --- a/common/include/tfe_raw_packet.h +++ b/common/include/tfe_raw_packet.h @@ -78,19 +78,19 @@ struct raw_pkt_parser 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); // return most inner payload -const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length); +const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length, void *logger); // return 0 : success // return -1 : error -int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr); -int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr); +int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger); +int raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger); // return 0 : success // return -1 : error -int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr); -int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr); +int raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger); +int raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger); -uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_internal); +uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_internal, void *logger); #ifdef __cpluscplus } diff --git a/common/src/tfe_ctrl_packet.cpp b/common/src/tfe_ctrl_packet.cpp index 4ee7536..c535857 100644 --- a/common/src/tfe_ctrl_packet.cpp +++ b/common/src/tfe_ctrl_packet.cpp @@ -2,11 +2,314 @@ #include #include -#include "tfe_mpack.h" +#include "mpack.h" #include "tfe_cmsg.h" #include "tfe_utils.h" #include "tfe_ctrl_packet.h" +enum ctr_pkt_index +{ + INDEX_TSYNC = 0, + INDEX_SESSION_ID, + INDEX_STATE, + INDEX_METHOD, + INDEX_KEY_SCE, + INDEX_VALUE_SCE, + INDEX_KEY_SHAPER, + INDEX_VALUE_SHAPER, + INDEX_KEY_PROXY, + INDEX_VALUE_PROXY, + INDEX_MAX +}; + +enum { + MPACK_ARRAY_INIT, + MPACK_ARRAY_FQDN_IDS, + MPACK_ARRAY_SEQ_SIDS, + MPACK_ARRAY_ACK_SIDS, + MPACK_ARRAY_SEQ_ROUTE_CTX, + MPACK_ARRAY_ACK_ROUTE_CTX, +}; + +struct mpack_mmap_id2type +{ + int id; + enum tfe_cmsg_tlv_type type; + const char *str_name; + int size; + int array_index; +}mpack_table[] = { + {.id = 0, .type = TFE_CMSG_TCP_RESTORE_SEQ, .str_name = "TFE_CMSG_TCP_RESTORE_SEQ", .size = 4, .array_index = MPACK_ARRAY_INIT}, + {.id = 1, .type = TFE_CMSG_TCP_RESTORE_ACK, .str_name = "TFE_CMSG_TCP_RESTORE_ACK", .size = 4, .array_index = MPACK_ARRAY_INIT}, + {.id = 2, .type = TFE_CMSG_TCP_RESTORE_MSS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_CLIENT", .size = 2, .array_index = MPACK_ARRAY_INIT}, + {.id = 3, .type = TFE_CMSG_TCP_RESTORE_MSS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_SERVER", .size = 2, .array_index = MPACK_ARRAY_INIT}, + {.id = 4, .type = TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 5, .type = TFE_CMSG_TCP_RESTORE_WSACLE_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_SERVER", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 6, .type = TFE_CMSG_TCP_RESTORE_SACK_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_CLIENT", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 7, .type = TFE_CMSG_TCP_RESTORE_SACK_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_SERVER", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 8, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 9, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 10, .type = TFE_CMSG_TCP_RESTORE_PROTOCOL, .str_name = "TFE_CMSG_TCP_RESTORE_PROTOCOL", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 11, .type = TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT", .size = 2, .array_index = MPACK_ARRAY_INIT}, + {.id = 12, .type = TFE_CMSG_TCP_RESTORE_WINDOW_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_SERVER", .size = 2, .array_index = MPACK_ARRAY_INIT}, + {.id = 13, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL", .size = 4, .array_index = MPACK_ARRAY_INIT}, + {.id = 14, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL", .size = 4, .array_index = MPACK_ARRAY_INIT}, + {.id = 15, .type = TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR, .str_name = "TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR", .size = 1, .array_index = MPACK_ARRAY_INIT}, + {.id = 16, .type = TFE_CMSG_SRC_SUB_ID, .str_name = "TFE_CMSG_SRC_SUB_ID", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 17, .type = TFE_CMSG_DST_SUB_ID, .str_name = "TFE_CMSG_DST_SUB_ID", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 18, .type = TFE_CMSG_SRC_ASN, .str_name = "TFE_CMSG_SRC_ASN", .size = 64, .array_index = MPACK_ARRAY_INIT}, + {.id = 19, .type = TFE_CMSG_DST_ASN, .str_name = "TFE_CMSG_DST_ASN", .size = 64, .array_index = MPACK_ARRAY_INIT}, + {.id = 20, .type = TFE_CMSG_SRC_ORGANIZATION, .str_name = "TFE_CMSG_SRC_ORGANIZATION", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 21, .type = TFE_CMSG_DST_ORGANIZATION, .str_name = "TFE_CMSG_DST_ORGANIZATION", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 22, .type = TFE_CMSG_SRC_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_COUNTRY", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 23, .type = TFE_CMSG_DST_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_DST_IP_LOCATION_COUNTRY", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 24, .type = TFE_CMSG_SRC_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_SRC_IP_LOCATION_PROVINE", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 25, .type = TFE_CMSG_DST_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_DST_IP_LOCATION_PROVINE", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 26, .type = TFE_CMSG_SRC_IP_LOCATION_CITY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_CITY", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 27, .type = TFE_CMSG_DST_IP_LOCATION_CITY, .str_name = "TFE_CMSG_DST_IP_LOCATION_CITY", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 28, .type = TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 29, .type = TFE_CMSG_DST_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_DST_IP_LOCATION_SUBDIVISION", .size = 256, .array_index = MPACK_ARRAY_INIT}, + {.id = 30, .type = TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT, .str_name = "TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT", .size = 32, .array_index = MPACK_ARRAY_INIT}, + {.id = 31, .type = TFE_CMSG_FQDN_CAT_ID_VAL, .str_name = "TFE_CMSG_FQDN_CAT_ID_VAL", .size = 4, .array_index = MPACK_ARRAY_FQDN_IDS}, + {.id = 32, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_SEQ_SIDS", .size = 2, .array_index = MPACK_ARRAY_SEQ_SIDS}, + {.id = 33, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_ACK_SIDS", .size = 2, .array_index = MPACK_ARRAY_ACK_SIDS}, + {.id = 34, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_SEQ_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_SEQ_ROUTE_CTX}, + {.id = 35, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_ACK_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_ACK_ROUTE_CTX} +}; + +static int fqdn_id_set_cmsg(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index) +{ + uint32_t fqdn_val[8] = {0}; + + uint32_t array_cnt = mpack_node_array_length(node); + tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_NUM, (const unsigned char *)&array_cnt, sizeof(uint32_t)); + for (uint32_t i = 0; i < array_cnt; i++) { + fqdn_val[i] = mpack_node_u32(mpack_node_array_at(node, i)); + } + tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_VAL, (const unsigned char*)fqdn_val, array_cnt * sizeof(uint32_t)); + return 0; +} + +static int sids_array_parse_mpack(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index, int is_seq) +{ + struct sids *sid = is_seq ? &handler->seq_sids : &handler->ack_sids; + if (mpack_node_array_length(node) > MR_SID_LIST_MAXLEN) { + return -1; + } + + sid->num = mpack_node_array_length(node); + for (int i = 0; i < sid->num; i++) + { + sid->elems[i] = mpack_node_u16(mpack_node_array_at(node, i)); + } + return 0; +} + +static int route_ctx_parse_mpack(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index, int is_seq) +{ + struct route_ctx *ctx = is_seq ? &handler->seq_route_ctx : &handler->ack_route_ctx; + if (mpack_node_array_length(node) > 64) { + return -1; + } + + ctx->len = mpack_node_array_length(node); + for (int i = 0; i < ctx->len; i++) + { + ctx->data[i] = mpack_node_u8(mpack_node_array_at(node, i)); + } + return 0; +} + +static int proxy_parse_messagepack(mpack_node_t node, void *ctx, void *logger) +{ + int ret = 0; + uint64_t value = 0; + char cmsg_str[256] = {0}; + struct ctrl_pkt_parser *handler = (struct ctrl_pkt_parser *)ctx; + + if (mpack_node_is_nil(mpack_node_map_cstr(node, "rule_ids"))) + { + TFE_LOG_ERROR(logger, "%s: session %lu unexpected control packet: (rule_ids no found)", LOG_TAG_CTRLPKT, handler->session_id); + return -1; + } + handler->tfe_policy_id_num = mpack_node_array_length(mpack_node_map_cstr(node, "rule_ids")); + for (int i = 0; i < handler->tfe_policy_id_num; i++) { + handler->tfe_policy_ids[i] = mpack_node_u64(mpack_node_array_at(mpack_node_map_cstr(node, "rule_ids"), i)); + } + + if (handler->tfe_policy_id_num) { + tfe_cmsg_set(handler->cmsg, TFE_CMSG_POLICY_ID, (const unsigned char *)&handler->tfe_policy_ids[0], sizeof(uint64_t)); + } + + mpack_node_t tcp_handshake = mpack_node_map_cstr(node, "tcp_handshake"); + int cmsg_array_cnt = mpack_node_array_length(tcp_handshake); + for (int i = 0; i < cmsg_array_cnt; i++) { + mpack_node_t ptr = mpack_node_array_at(tcp_handshake, i); + + switch (mpack_node_type(ptr)) { + case mpack_type_uint: + value = mpack_node_u64(ptr); + tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)&value, mpack_table[i].size); + break; + case mpack_type_str: + snprintf(cmsg_str, sizeof(cmsg_str), mpack_node_str(ptr), mpack_node_strlen(ptr)); + tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)cmsg_str, mpack_node_strlen(ptr)); + break; + case mpack_type_nil: + break; + case mpack_type_array: + switch(mpack_table[i].array_index) + { + case MPACK_ARRAY_FQDN_IDS: + fqdn_id_set_cmsg(handler, ptr, i); + break; + case MPACK_ARRAY_SEQ_SIDS: + ret = sids_array_parse_mpack(handler, ptr, i, 1); + if (ret != 0) + return -1; + break; + case MPACK_ARRAY_ACK_SIDS: + ret = sids_array_parse_mpack(handler, ptr, i, 0); + if (ret != 0) + return -1; + break; + case MPACK_ARRAY_SEQ_ROUTE_CTX: + ret = route_ctx_parse_mpack(handler, ptr, i, 1); + if (ret != 0) + return -1; + break; + case MPACK_ARRAY_ACK_ROUTE_CTX: + ret = route_ctx_parse_mpack(handler, ptr, i, 0); + if (ret != 0) + return -1; + break; + default: + break; + } + break; + default: + break; + } + } + return 0; +} + +// return 0 : success +// return -1 : error +int ctrl_packet_parser_parse(void *ctx, const char* data, size_t length, void *logger) +{ + int ret = 0; + struct ctrl_pkt_parser *handler = (struct ctrl_pkt_parser *)ctx; + char buff[16] = {0}; + mpack_node_t params; + mpack_node_t sce_map; + mpack_node_t proxy_map; + mpack_tree_t tree; + mpack_tree_init_data(&tree, data, length); + mpack_tree_parse(&tree); + mpack_node_t root = mpack_tree_root(&tree); + if (mpack_node_is_nil(root)) + { + TFE_LOG_ERROR(logger, "%s: unexpected control packet: (invalid mpack format)", LOG_TAG_CTRLPKT); + goto error; + } + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "tsync"))) + { + TFE_LOG_ERROR(logger, "%s: unexpected control packet: (tsync no found)", LOG_TAG_CTRLPKT); + goto error; + } + mpack_node_copy_cstr(mpack_node_map_cstr(root, "tsync"), handler->tsync, sizeof(handler->tsync)); + if (strcmp(handler->tsync, "2.0") != 0) + { + TFE_LOG_ERROR(logger, "%s: unexpected control packet: (invalid tsync version) %s", LOG_TAG_CTRLPKT, handler->tsync); + goto error; + } + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "session_id"))) + { + TFE_LOG_ERROR(logger, "%s: unexpected control packet: (session_id no found)", LOG_TAG_CTRLPKT); + goto error; + } + handler->session_id = mpack_node_u64(mpack_node_map_cstr(root, "session_id")); + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "state"))) + { + TFE_LOG_ERROR(logger, "%s: session %lu unexpected control packet: (state no found)", LOG_TAG_CTRLPKT, handler->session_id); + goto error; + } + mpack_node_copy_cstr(mpack_node_map_cstr(root, "state"), buff, sizeof(buff)); + if (strncasecmp(buff, "opening", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_OPENING; + goto succ; + } + else if (strncasecmp(buff, "active", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_ACTIVE; + } + else if (strncasecmp(buff, "closing", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_CLOSING; + goto succ; + } + else if (strncasecmp(buff, "resetall", sizeof(buff)) == 0) + { + handler->state = SESSION_STATE_RESETALL; + goto succ; + } + else + { + TFE_LOG_DEBUG(logger, "%s: session %lu unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, handler->session_id, buff); + } + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "method"))) + { + TFE_LOG_ERROR(logger, "%s: session %lu unexpected control packet: (method no found)", LOG_TAG_CTRLPKT, handler->session_id); + goto error; + } + mpack_node_copy_cstr(mpack_node_map_cstr(root, "method"), handler->method, sizeof(handler->method)); + + if (mpack_node_is_nil(mpack_node_map_cstr(root, "params"))) + { + TFE_LOG_ERROR(logger, "%s: session %lu unexpected control packet: (params no found)", LOG_TAG_CTRLPKT, handler->session_id); + goto error; + } + params = mpack_node_map_cstr(root, "params"); + + if (!mpack_node_is_missing(mpack_node_map_str_optional(params, "sce", strlen("sce")))) + { + sce_map = mpack_node_map_cstr(params, "sce"); + if (mpack_node_is_nil(mpack_node_map_cstr(sce_map, "rule_ids"))) + { + TFE_LOG_ERROR(logger, "%s: session %lu unexpected control packet: (sce rule_ids no found)", LOG_TAG_CTRLPKT, handler->session_id); + goto error; + } + handler->sce_policy_id_num = mpack_node_array_length(mpack_node_map_cstr(sce_map, "rule_ids")); + for (int i = 0; i < handler->sce_policy_id_num; i++) { + handler->sce_policy_ids[i] = mpack_node_u64(mpack_node_array_at(mpack_node_map_cstr(sce_map, "rule_ids"), i)); + } + } + + if (mpack_node_is_missing(mpack_node_map_str_optional(params, "proxy", strlen("proxy")))) + { + TFE_LOG_ERROR(logger, "%s: session %lu unexpected control packet: (proxy no found)", LOG_TAG_CTRLPKT, handler->session_id); + goto error; + } + + proxy_map = mpack_node_map_cstr(params, "proxy"); + ret = proxy_parse_messagepack(proxy_map, handler, logger); + if (ret != 0) + goto error; + +succ: + mpack_tree_destroy(&tree); + return 0; +error: + mpack_tree_destroy(&tree); + return -1; +} + const char *session_state_to_string(enum session_state state) { switch (state) @@ -31,32 +334,25 @@ void ctrl_packet_parser_init(struct ctrl_pkt_parser *handler) tfe_cmsg_dup(handler->cmsg); } -// return 0 : success -// return -1 : error -int ctrl_packet_parser_parse(struct ctrl_pkt_parser *handler, const char *data, size_t length) -{ - return parse_messagepack(data, length, handler); -} - -void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler) +void ctrl_packet_parser_dump(struct ctrl_pkt_parser *handler, void *logger) { if (handler) { - TFE_LOG_INFO(g_default_logger, "%s: tsync : %s", LOG_TAG_POLICY, handler->tsync); - TFE_LOG_INFO(g_default_logger, "%s: session_id : %lu", LOG_TAG_POLICY, handler->session_id); - TFE_LOG_INFO(g_default_logger, "%s: state : %s", LOG_TAG_POLICY, session_state_to_string(handler->state)); - TFE_LOG_INFO(g_default_logger, "%s: method : %s", LOG_TAG_POLICY, handler->method); - TFE_LOG_INFO(g_default_logger, "%s: tfe policy_id_num : %d", LOG_TAG_POLICY, handler->tfe_policy_id_num); + TFE_LOG_INFO(logger, "%s: tsync : %s", LOG_TAG_POLICY, handler->tsync); + TFE_LOG_INFO(logger, "%s: session_id : %lu", LOG_TAG_POLICY, handler->session_id); + TFE_LOG_INFO(logger, "%s: state : %s", LOG_TAG_POLICY, session_state_to_string(handler->state)); + TFE_LOG_INFO(logger, "%s: method : %s", LOG_TAG_POLICY, handler->method); + TFE_LOG_INFO(logger, "%s: tfe policy_id_num : %d", LOG_TAG_POLICY, handler->tfe_policy_id_num); for (int i = 0; i < handler->tfe_policy_id_num; i++) { - TFE_LOG_INFO(g_default_logger, "%s: %d tfe policy_ids[%03lu]", LOG_TAG_POLICY, i, handler->tfe_policy_ids[i]); + TFE_LOG_INFO(logger, "%s: %d tfe policy_ids[%03lu]", LOG_TAG_POLICY, i, handler->tfe_policy_ids[i]); } - TFE_LOG_INFO(g_default_logger, "%s: sce policy_id_num : %d", LOG_TAG_POLICY, handler->sce_policy_id_num); + TFE_LOG_INFO(logger, "%s: sce policy_id_num : %d", LOG_TAG_POLICY, handler->sce_policy_id_num); - for (int i = 0; i < handler->tfe_policy_id_num; i++) + for (int i = 0; i < handler->sce_policy_id_num; i++) { - TFE_LOG_INFO(g_default_logger, "%s: %d sce policy_ids[%03lu]", LOG_TAG_POLICY, i, handler->sce_policy_ids[i]); + TFE_LOG_INFO(logger, "%s: %d sce policy_ids[%03lu]", LOG_TAG_POLICY, i, handler->sce_policy_ids[i]); } } } diff --git a/common/src/tfe_mpack.cpp b/common/src/tfe_mpack.cpp deleted file mode 100644 index 5844f52..0000000 --- a/common/src/tfe_mpack.cpp +++ /dev/null @@ -1,319 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#include "mpack.h" -#include "tfe_cmsg.h" -#include "tfe_utils.h" -#include "tfe_ctrl_packet.h" - -enum ctr_pkt_index -{ - INDEX_TSYNC = 0, - INDEX_SESSION_ID, - INDEX_STATE, - INDEX_METHOD, - INDEX_KEY_SCE, - INDEX_VALUE_SCE, - INDEX_KEY_SHAPER, - INDEX_VALUE_SHAPER, - INDEX_KEY_PROXY, - INDEX_VALUE_PROXY, - INDEX_MAX -}; - -enum { - MPACK_ARRAY_INIT, - MPACK_ARRAY_FQDN_IDS, - MPACK_ARRAY_SEQ_SIDS, - MPACK_ARRAY_ACK_SIDS, - MPACK_ARRAY_SEQ_ROUTE_CTX, - MPACK_ARRAY_ACK_ROUTE_CTX, -}; - -struct mpack_mmap_id2type -{ - int id; - enum tfe_cmsg_tlv_type type; - const char *str_name; - int size; - int array_index; -}mpack_table[] = { - {.id = 0, .type = TFE_CMSG_TCP_RESTORE_SEQ, .str_name = "TFE_CMSG_TCP_RESTORE_SEQ", .size = 4, .array_index = MPACK_ARRAY_INIT}, - {.id = 1, .type = TFE_CMSG_TCP_RESTORE_ACK, .str_name = "TFE_CMSG_TCP_RESTORE_ACK", .size = 4, .array_index = MPACK_ARRAY_INIT}, - {.id = 2, .type = TFE_CMSG_TCP_RESTORE_MSS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_CLIENT", .size = 2, .array_index = MPACK_ARRAY_INIT}, - {.id = 3, .type = TFE_CMSG_TCP_RESTORE_MSS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_MSS_SERVER", .size = 2, .array_index = MPACK_ARRAY_INIT}, - {.id = 4, .type = TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_CLIENT", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 5, .type = TFE_CMSG_TCP_RESTORE_WSACLE_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WSACLE_SERVER", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 6, .type = TFE_CMSG_TCP_RESTORE_SACK_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_CLIENT", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 7, .type = TFE_CMSG_TCP_RESTORE_SACK_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_SACK_SERVER", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 8, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 9, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 10, .type = TFE_CMSG_TCP_RESTORE_PROTOCOL, .str_name = "TFE_CMSG_TCP_RESTORE_PROTOCOL", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 11, .type = TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_CLIENT", .size = 2, .array_index = MPACK_ARRAY_INIT}, - {.id = 12, .type = TFE_CMSG_TCP_RESTORE_WINDOW_SERVER, .str_name = "TFE_CMSG_TCP_RESTORE_WINDOW_SERVER", .size = 2, .array_index = MPACK_ARRAY_INIT}, - {.id = 13, .type = TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_CLIENT_VAL", .size = 4, .array_index = MPACK_ARRAY_INIT}, - {.id = 14, .type = TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL, .str_name = "TFE_CMSG_TCP_RESTORE_TS_SERVER_VAL", .size = 4, .array_index = MPACK_ARRAY_INIT}, - {.id = 15, .type = TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR, .str_name = "TFE_CMSG_TCP_RESTORE_INFO_PACKET_CUR_DIR", .size = 1, .array_index = MPACK_ARRAY_INIT}, - {.id = 16, .type = TFE_CMSG_SRC_SUB_ID, .str_name = "TFE_CMSG_SRC_SUB_ID", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 17, .type = TFE_CMSG_DST_SUB_ID, .str_name = "TFE_CMSG_DST_SUB_ID", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 18, .type = TFE_CMSG_SRC_ASN, .str_name = "TFE_CMSG_SRC_ASN", .size = 64, .array_index = MPACK_ARRAY_INIT}, - {.id = 19, .type = TFE_CMSG_DST_ASN, .str_name = "TFE_CMSG_DST_ASN", .size = 64, .array_index = MPACK_ARRAY_INIT}, - {.id = 20, .type = TFE_CMSG_SRC_ORGANIZATION, .str_name = "TFE_CMSG_SRC_ORGANIZATION", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 21, .type = TFE_CMSG_DST_ORGANIZATION, .str_name = "TFE_CMSG_DST_ORGANIZATION", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 22, .type = TFE_CMSG_SRC_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_COUNTRY", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 23, .type = TFE_CMSG_DST_IP_LOCATION_COUNTRY, .str_name = "TFE_CMSG_DST_IP_LOCATION_COUNTRY", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 24, .type = TFE_CMSG_SRC_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_SRC_IP_LOCATION_PROVINE", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 25, .type = TFE_CMSG_DST_IP_LOCATION_PROVINE, .str_name = "TFE_CMSG_DST_IP_LOCATION_PROVINE", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 26, .type = TFE_CMSG_SRC_IP_LOCATION_CITY, .str_name = "TFE_CMSG_SRC_IP_LOCATION_CITY", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 27, .type = TFE_CMSG_DST_IP_LOCATION_CITY, .str_name = "TFE_CMSG_DST_IP_LOCATION_CITY", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 28, .type = TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_SRC_IP_LOCATION_SUBDIVISION", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 29, .type = TFE_CMSG_DST_IP_LOCATION_SUBDIVISION, .str_name = "TFE_CMSG_DST_IP_LOCATION_SUBDIVISION", .size = 256, .array_index = MPACK_ARRAY_INIT}, - {.id = 30, .type = TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT, .str_name = "TFE_CMSG_SSL_CLIENT_JA3_FINGERPRINT", .size = 32, .array_index = MPACK_ARRAY_INIT}, - {.id = 31, .type = TFE_CMSG_FQDN_CAT_ID_VAL, .str_name = "TFE_CMSG_FQDN_CAT_ID_VAL", .size = 4, .array_index = MPACK_ARRAY_FQDN_IDS}, - {.id = 32, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_SEQ_SIDS", .size = 2, .array_index = MPACK_ARRAY_SEQ_SIDS}, - {.id = 33, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_ACK_SIDS", .size = 2, .array_index = MPACK_ARRAY_ACK_SIDS}, - {.id = 34, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_SEQ_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_SEQ_ROUTE_CTX}, - {.id = 35, .type = TFE_CMSG_TLV_NR_MAX, .str_name = "TFE_ACK_ROUTE_CTX", .size = 1, .array_index = MPACK_ARRAY_ACK_ROUTE_CTX} -}; - -static int fqdn_id_set_cmsg(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index) -{ - uint32_t fqdn_val[8] = {0}; - - uint32_t array_cnt = mpack_node_array_length(node); - tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_NUM, (const unsigned char *)&array_cnt, sizeof(uint32_t)); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array fqdn_id num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, array_cnt); - for (uint32_t i = 0; i < array_cnt; i++) { - fqdn_val[i] = mpack_node_u32(mpack_node_array_at(node, i)); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array fqdn_id msgpack cmsg: [%s] -> [%lu]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[table_index].str_name, fqdn_val[i]); - } - tfe_cmsg_set(handler->cmsg, TFE_CMSG_FQDN_CAT_ID_VAL, (const unsigned char*)fqdn_val, array_cnt * sizeof(uint32_t)); - return 0; -} - -static int sids_array_parse_mpack(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index, int is_seq) -{ - struct sids *sid = is_seq ? &handler->seq_sids : &handler->ack_sids; - if (mpack_node_array_length(node) > MR_SID_LIST_MAXLEN) { - TFE_LOG_ERROR(g_default_logger, "%s: session: %lu sid[%ld] more than maxlen %d", LOG_TAG_CTRLPKT, handler->session_id, mpack_node_array_length(node), MR_SID_LIST_MAXLEN); - return -1; - } - - sid->num = mpack_node_array_length(node); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array sids num: [%d]", LOG_TAG_CTRLPKT, handler->session_id, sid->num); - for (int i = 0; i < sid->num; i++) - { - sid->elems[i] = mpack_node_u16(mpack_node_array_at(node, i)); - } - return 0; -} - -static int route_ctx_parse_mpack(struct ctrl_pkt_parser *handler, mpack_node_t node, int table_index, int is_seq) -{ - struct route_ctx *ctx = is_seq ? &handler->seq_route_ctx : &handler->ack_route_ctx; - if (mpack_node_array_length(node) > 64) { - TFE_LOG_ERROR(g_default_logger, "%s: session: %lu route ctx[%ld] more than maxlen 64", LOG_TAG_CTRLPKT, handler->session_id, mpack_node_array_length(node)); - return -1; - } - - ctx->len = mpack_node_array_length(node); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu array route ctx num: [%u]", LOG_TAG_CTRLPKT, handler->session_id, ctx->len); - for (int i = 0; i < ctx->len; i++) - { - ctx->data[i] = mpack_node_u8(mpack_node_array_at(node, i)); - } - return 0; -} - -static int proxy_parse_messagepack(mpack_node_t node, void *ctx) -{ - uint64_t value = 0; - struct ctrl_pkt_parser *handler = (struct ctrl_pkt_parser *)ctx; - - if (mpack_node_is_nil(mpack_node_map_cstr(node, "rule_ids"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (rule_ids no found)", LOG_TAG_CTRLPKT); - return -1; - } - handler->tfe_policy_id_num = mpack_node_array_length(mpack_node_map_cstr(node, "rule_ids")); - for (int i = 0; i < handler->tfe_policy_id_num; i++) { - handler->tfe_policy_ids[i] = mpack_node_u64(mpack_node_array_at(mpack_node_map_cstr(node, "rule_ids"), i)); - } - - if (handler->tfe_policy_id_num) { - tfe_cmsg_set(handler->cmsg, TFE_CMSG_POLICY_ID, (const unsigned char *)&handler->tfe_policy_ids[0], sizeof(uint64_t)); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu tfe policy id num: [%d]", LOG_TAG_CTRLPKT, handler->session_id, handler->tfe_policy_id_num); - for (int i = 0; i < handler->tfe_policy_id_num; i++) { - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu policy id:%lu ", LOG_TAG_CTRLPKT, handler->session_id, handler->tfe_policy_ids[i]); - } - } - - mpack_node_t tcp_handshake = mpack_node_map_cstr(node, "tcp_handshake"); - int cmsg_array_cnt = mpack_node_array_length(tcp_handshake); - for (int i = 0; i < cmsg_array_cnt; i++) { - mpack_node_t ptr = mpack_node_array_at(tcp_handshake, i); - - switch (mpack_node_type(ptr)) { - case mpack_type_uint: - value = mpack_node_u64(ptr); - tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)&value, mpack_table[i].size); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu interger msgpack cmsg: [%s] -> [%lu]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, value); - break; - case mpack_type_str: - tfe_cmsg_set(handler->cmsg, mpack_table[i].type, (const unsigned char *)mpack_node_str(ptr), mpack_node_strlen(ptr)); - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu string msgpack cmsg: [%s] -> [%s]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name, mpack_node_str(ptr)); - break; - case mpack_type_nil: - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu msgpack cmsg: [%s] -> [nil]", LOG_TAG_CTRLPKT, handler->session_id, mpack_table[i].str_name); - break; - case mpack_type_array: - switch(mpack_table[i].array_index) - { - case MPACK_ARRAY_FQDN_IDS: - fqdn_id_set_cmsg(handler, ptr, i); - break; - case MPACK_ARRAY_SEQ_SIDS: - sids_array_parse_mpack(handler, ptr, i, 1); - break; - case MPACK_ARRAY_ACK_SIDS: - sids_array_parse_mpack(handler, ptr, i, 0); - break; - case MPACK_ARRAY_SEQ_ROUTE_CTX: - route_ctx_parse_mpack(handler, ptr, i, 1); - break; - case MPACK_ARRAY_ACK_ROUTE_CTX: - route_ctx_parse_mpack(handler, ptr, i, 0); - break; - default: - break; - } - break; - default: - break; - } - } - return 0; -} - -int parse_messagepack(const char* data, size_t length, void *ctx) -{ - struct ctrl_pkt_parser *handler = (struct ctrl_pkt_parser *)ctx; - char buff[16] = {0}; - mpack_node_t params; - mpack_node_t sce_map; - mpack_node_t proxy_map; - mpack_tree_t tree; - mpack_tree_init_data(&tree, data, length); - mpack_tree_parse(&tree); - mpack_node_t root = mpack_tree_root(&tree); - if (mpack_node_is_nil(root)) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (invalid mpack format)", LOG_TAG_CTRLPKT); - goto error; - } - - if (mpack_node_is_nil(mpack_node_map_cstr(root, "tsync"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (tsync no found)", LOG_TAG_CTRLPKT); - goto error; - } - mpack_node_copy_cstr(mpack_node_map_cstr(root, "tsync"), handler->tsync, sizeof(handler->tsync)); - if (strcmp(handler->tsync, "2.0") != 0) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (invalid tsync version) %s", LOG_TAG_CTRLPKT, handler->tsync); - goto error; - } - - if (mpack_node_is_nil(mpack_node_map_cstr(root, "session_id"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (session_id no found)", LOG_TAG_CTRLPKT); - goto error; - } - handler->session_id = mpack_node_u64(mpack_node_map_cstr(root, "session_id")); - - - if (mpack_node_is_nil(mpack_node_map_cstr(root, "state"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (state no found)", LOG_TAG_CTRLPKT); - goto error; - } - mpack_node_copy_cstr(mpack_node_map_cstr(root, "state"), buff, sizeof(buff)); - if (strncasecmp(buff, "opening", sizeof(buff)) == 0) - { - handler->state = SESSION_STATE_OPENING; - goto succ; - } - else if (strncasecmp(buff, "active", sizeof(buff)) == 0) - { - handler->state = SESSION_STATE_ACTIVE; - } - else if (strncasecmp(buff, "closing", sizeof(buff)) == 0) - { - handler->state = SESSION_STATE_CLOSING; - goto succ; - } - else if (strncasecmp(buff, "resetall", sizeof(buff)) == 0) - { - handler->state = SESSION_STATE_RESETALL; - goto succ; - } - else - { - TFE_LOG_DEBUG(g_default_logger, "%s: unexpected control packet: (invalid state value) %s", LOG_TAG_CTRLPKT, buff); - } - - if (mpack_node_is_nil(mpack_node_map_cstr(root, "method"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (method no found)", LOG_TAG_CTRLPKT); - goto error; - } - mpack_node_copy_cstr(mpack_node_map_cstr(root, "method"), handler->method, sizeof(handler->method)); - - if (mpack_node_is_nil(mpack_node_map_cstr(root, "params"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (params no found)", LOG_TAG_CTRLPKT); - goto error; - } - params = mpack_node_map_cstr(root, "params"); - - if (!mpack_node_is_missing(mpack_node_map_str_optional(params, "sce", strlen("sce")))) - { - sce_map = mpack_node_map_cstr(params, "sce"); - if (mpack_node_is_nil(mpack_node_map_cstr(sce_map, "rule_ids"))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (sce rule_ids no found)", LOG_TAG_CTRLPKT); - goto error; - } - handler->sce_policy_id_num = mpack_node_array_length(mpack_node_map_cstr(sce_map, "rule_ids")); - for (int i = 0; i < handler->sce_policy_id_num; i++) { - handler->sce_policy_ids[i] = mpack_node_u64(mpack_node_array_at(mpack_node_map_cstr(sce_map, "rule_ids"), i)); - } - - if (handler->sce_policy_id_num) { - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu sce policy id num: [%d]", LOG_TAG_CTRLPKT, handler->session_id, handler->sce_policy_id_num); - for (int i = 0; i < handler->sce_policy_id_num; i++) { - TFE_LOG_DEBUG(g_default_logger, "%s: session: %lu policy id:%lu ", LOG_TAG_CTRLPKT, handler->session_id, handler->sce_policy_ids[i]); - } - } - } - - if (mpack_node_is_missing(mpack_node_map_str_optional(params, "proxy", strlen("proxy")))) - { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet: (proxy no found)", LOG_TAG_CTRLPKT); - goto error; - } - - proxy_map = mpack_node_map_cstr(params, "proxy"); - proxy_parse_messagepack(proxy_map, handler); - -succ: - mpack_tree_destroy(&tree); - return 0; -error: - mpack_tree_destroy(&tree); - return -1; -} diff --git a/common/src/tfe_packet_io.cpp b/common/src/tfe_packet_io.cpp index 766ea48..34bee10 100644 --- a/common/src/tfe_packet_io.cpp +++ b/common/src/tfe_packet_io.cpp @@ -184,12 +184,12 @@ static int is_downstream_keepalive_packet(marsio_buff_t *rx_buff) } } -static int tfe_tap_write_per_thread(int tap_fd, const char *data, int data_len, void *logger) +static int tap_write(int tap_fd, const char *data, int data_len, void *logger) { int ret = write(tap_fd, data, data_len); if (ret != data_len) { - TFE_LOG_ERROR(g_default_logger, "%s: need send %dB, only send %dB, aborting: %s", LOG_TAG_PKTIO, data_len, ret, strerror(errno)); + TFE_LOG_ERROR(logger, "%s: need send %dB, only send %dB, aborting: %s", LOG_TAG_PKTIO, data_len, ret, strerror(errno)); } return ret; @@ -456,7 +456,7 @@ static int fake_tcp_handshake(struct tfe_proxy *proxy, struct tcp_restore_info * return 0; } -static int overwrite_tcp_mss(struct tfe_cmsg *cmsg, struct tcp_restore_info *restore) +static int overwrite_tcp_mss(struct tfe_cmsg *cmsg, struct tcp_restore_info *restore, uint64_t session_id, void *logger) { int ret = 0; uint16_t size = 0; @@ -468,25 +468,25 @@ static int overwrite_tcp_mss(struct tfe_cmsg *cmsg, struct tcp_restore_info *res ret = tfe_cmsg_get_value(cmsg, TFE_CMSG_DOWNSTREAM_TCP_MSS_ENABLE, (unsigned char *)&client_side_mss_enable, sizeof(client_side_mss_enable), &size); if (ret < 0) { - TFE_LOG_ERROR(g_default_logger, "failed at fetch client side tcp mss from cmsg: %s", strerror(-ret)); + TFE_LOG_ERROR(logger, "%s: session %lu failed at fetch client side tcp mss from cmsg: %s", LOG_TAG_PKTIO, session_id, strerror(-ret)); return -1; } ret = tfe_cmsg_get_value(cmsg, TFE_CMSG_DOWNSTREAM_TCP_MSS_VALUE, (unsigned char *)&client_side_mss_value, sizeof(client_side_mss_value), &size); if (ret < 0) { - TFE_LOG_ERROR(g_default_logger, "failed at fetch client side tcp mss value from cmsg: %s", strerror(-ret)); + TFE_LOG_ERROR(logger, "%s: session %lu failed at fetch client side tcp mss value from cmsg: %s", LOG_TAG_PKTIO, session_id, strerror(-ret)); return -1; } ret = tfe_cmsg_get_value(cmsg, TFE_CMSG_UPSTREAM_TCP_MSS_ENABLE, (unsigned char *)&server_side_mss_enable, sizeof(server_side_mss_enable), &size); if (ret < 0) { - TFE_LOG_ERROR(g_default_logger, "failed at fetch server side tcp mss from cmsg: %s", strerror(-ret)); + TFE_LOG_ERROR(logger, "%s: session %lu failed at fetch server side tcp mss from cmsg: %s", LOG_TAG_PKTIO, session_id, strerror(-ret)); return -1; } ret = tfe_cmsg_get_value(cmsg, TFE_CMSG_UPSTREAM_TCP_MSS_VALUE, (unsigned char *)&server_side_mss_value, sizeof(server_side_mss_value), &size); if (ret < 0) { - TFE_LOG_ERROR(g_default_logger, "failed at fetch server side tcp mss value from cmsg: %s", strerror(-ret)); + TFE_LOG_ERROR(logger, "%s: session %lu failed at fetch server side tcp mss value from cmsg: %s", LOG_TAG_PKTIO, session_id, strerror(-ret)); return -1; } if (client_side_mss_enable) @@ -700,7 +700,7 @@ static int tcp_restore_set_from_pkg(struct addr_tuple4 *tuple4, struct tcp_resto // return 0 : success // return -1 : error -static int packet_io_config(const char *profile, struct config *config) +static int packet_io_config(const char *profile, struct config *config, void *logger) { int ret = 0; @@ -730,77 +730,77 @@ static int packet_io_config(const char *profile, struct config *config) char src_mac_addr[18] = {0}; ret = MESA_load_profile_string_nodef(profile, "PACKET_IO", "src_mac_addr", src_mac_addr, sizeof(src_mac_addr)); if(ret < 0){ - TFE_LOG_ERROR(g_default_logger, "%s: invalid src_mac_addr: src_mac_addr not set, profile = %s, section = PACKET_IO", LOG_TAG_PKTIO, profile); + TFE_LOG_ERROR(logger, "%s: invalid src_mac_addr: src_mac_addr not set, profile = %s, section = PACKET_IO", LOG_TAG_PKTIO, profile); return -1; } str_to_mac(src_mac_addr, config->src_mac); ret = get_mac_by_device_name(config->dev_tap, config->tap_mac); if (ret != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: invalid tap_name: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap); + TFE_LOG_ERROR(logger, "%s: invalid tap_name: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap); return -1; } ret = get_mac_by_device_name(config->dev_tap_c, config->tap_c_mac); if (ret != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: invalid device_client: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap_c); + TFE_LOG_ERROR(logger, "%s: invalid device_client: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap_c); return -1; } ret = get_mac_by_device_name(config->dev_tap_s, config->tap_s_mac); if (ret != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: invalid device_server: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap_s); + TFE_LOG_ERROR(logger, "%s: invalid device_server: unable get %s mac", LOG_TAG_PKTIO, config->dev_tap_s); return -1; } if (config->rx_burst_max > RX_BURST_MAX) { - TFE_LOG_ERROR(g_default_logger, "%s: invalid rx_burst_max, exceeds limit %d", LOG_TAG_PKTIO, RX_BURST_MAX); + TFE_LOG_ERROR(logger, "%s: invalid rx_burst_max, exceeds limit %d", LOG_TAG_PKTIO, RX_BURST_MAX); return -1; } if (strlen(config->app_symbol) == 0) { - TFE_LOG_ERROR(g_default_logger, "%s: invalid app_symbol in %s", LOG_TAG_PKTIO, profile); + TFE_LOG_ERROR(logger, "%s: invalid app_symbol in %s", LOG_TAG_PKTIO, profile); return -1; } if (strlen(config->dev_nf_interface) == 0) { - TFE_LOG_ERROR(g_default_logger, "%s: invalid dev_nf_interface in %s", LOG_TAG_PKTIO, profile); + TFE_LOG_ERROR(logger, "%s: invalid dev_nf_interface in %s", LOG_TAG_PKTIO, profile); return -1; } - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bypass_all_traffic : %d", LOG_TAG_PKTIO, config->bypass_all_traffic); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->rx_burst_max : %d", LOG_TAG_PKTIO, config->rx_burst_max); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->app_symbol : %s", LOG_TAG_PKTIO, config->app_symbol); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->dev_nf_interface : %s", LOG_TAG_PKTIO, config->dev_nf_interface); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_name : %s", LOG_TAG_PKTIO, config->tap_rps_mask); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_allow_mutilthread : %d", LOG_TAG_PKTIO, config->tap_allow_mutilthread); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bpf_obj : %s", LOG_TAG_PKTIO, config->bpf_obj); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bpf_debug_log : %d", LOG_TAG_PKTIO, config->bpf_debug_log); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->bpf_hash_mode : %d", LOG_TAG_PKTIO, config->bpf_hash_mode); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_rps_enable : %d", LOG_TAG_PKTIO, config->tap_rps_enable); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->tap_rps_mask : %s", LOG_TAG_PKTIO, config->tap_rps_mask); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->enable_iouring : %d", LOG_TAG_PKTIO, config->enable_iouring); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->enable_debuglog : %d", LOG_TAG_PKTIO, config->enable_debuglog); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->ring_size : %d", LOG_TAG_PKTIO, config->ring_size); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->buff_size : %d", LOG_TAG_PKTIO, config->buff_size); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->flags : %d", LOG_TAG_PKTIO, config->flags); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->sq_thread_idle : %d", LOG_TAG_PKTIO, config->sq_thread_idle); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->device_client : %s", LOG_TAG_PKTIO, config->dev_tap_c); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->device_server : %s", LOG_TAG_PKTIO, config->dev_tap_s); - TFE_LOG_DEBUG(g_default_logger, "%s: PACKET_IO->src_mac_addr : %s", LOG_TAG_PKTIO, src_mac_addr); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->bypass_all_traffic : %d", LOG_TAG_PKTIO, config->bypass_all_traffic); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->rx_burst_max : %d", LOG_TAG_PKTIO, config->rx_burst_max); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->app_symbol : %s", LOG_TAG_PKTIO, config->app_symbol); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->dev_nf_interface : %s", LOG_TAG_PKTIO, config->dev_nf_interface); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->tap_name : %s", LOG_TAG_PKTIO, config->tap_rps_mask); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->tap_allow_mutilthread : %d", LOG_TAG_PKTIO, config->tap_allow_mutilthread); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->bpf_obj : %s", LOG_TAG_PKTIO, config->bpf_obj); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->bpf_debug_log : %d", LOG_TAG_PKTIO, config->bpf_debug_log); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->bpf_hash_mode : %d", LOG_TAG_PKTIO, config->bpf_hash_mode); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->tap_rps_enable : %d", LOG_TAG_PKTIO, config->tap_rps_enable); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->tap_rps_mask : %s", LOG_TAG_PKTIO, config->tap_rps_mask); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->enable_iouring : %d", LOG_TAG_PKTIO, config->enable_iouring); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->enable_debuglog : %d", LOG_TAG_PKTIO, config->enable_debuglog); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->ring_size : %d", LOG_TAG_PKTIO, config->ring_size); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->buff_size : %d", LOG_TAG_PKTIO, config->buff_size); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->flags : %d", LOG_TAG_PKTIO, config->flags); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->sq_thread_idle : %d", LOG_TAG_PKTIO, config->sq_thread_idle); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->device_client : %s", LOG_TAG_PKTIO, config->dev_tap_c); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->device_server : %s", LOG_TAG_PKTIO, config->dev_tap_s); + TFE_LOG_DEBUG(logger, "%s: PACKET_IO->src_mac_addr : %s", LOG_TAG_PKTIO, src_mac_addr); return 0; } // return 0 : success // return -1 : error -static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) +static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta, void *logger) { memset(meta, 0, sizeof(struct metadata)); if (marsio_buff_get_metadata(rx_buff, MR_BUFF_SESSION_ID, &(meta->session_id), sizeof(meta->session_id)) <= 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get session_id from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get session_id from metadata", LOG_TAG_PKTIO); return -1; } @@ -808,7 +808,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) meta->raw_data = marsio_buff_mtod(rx_buff); if (meta->raw_data == NULL || meta->raw_len == 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get raw_data from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get raw_data from metadata", LOG_TAG_PKTIO); return -1; } @@ -816,7 +816,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) // 0: I2E if (marsio_buff_get_metadata(rx_buff, MR_BUFF_DIR, &(meta->is_e2i_dir), sizeof(meta->is_e2i_dir)) <= 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get buff_dir from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get buff_dir from metadata", LOG_TAG_PKTIO); return -1; } @@ -826,7 +826,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) // only control packet set MR_BUFF_PAYLOAD_OFFSET if (marsio_buff_get_metadata(rx_buff, MR_BUFF_PAYLOAD_OFFSET, &(meta->l7offset), sizeof(meta->l7offset)) <= 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get l7offset from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get l7offset from metadata", LOG_TAG_PKTIO); return -1; } } @@ -836,7 +836,7 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) uint16_t user_data = 0; if (marsio_buff_get_metadata(rx_buff, MR_BUFF_USER_0, &(user_data), sizeof(user_data)) <= 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get is_decrypted from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get is_decrypted from metadata", LOG_TAG_PKTIO); return -1; } if (user_data & TRAFFIC_IS_DECRYPTED) @@ -852,14 +852,14 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) meta->route_ctx.len = marsio_buff_get_metadata(rx_buff, MR_BUFF_ROUTE_CTX, meta->route_ctx.data, sizeof(meta->route_ctx.data)); if (meta->route_ctx.len <= 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get route_ctx from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get route_ctx from metadata", LOG_TAG_PKTIO); return -1; } meta->sids.num = marsio_buff_get_sid_list(rx_buff, meta->sids.elems, sizeof(meta->sids.elems) / sizeof(meta->sids.elems[0])); if (meta->sids.num < 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to get sid_list from metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to get sid_list from metadata", LOG_TAG_PKTIO); return -1; } @@ -868,13 +868,13 @@ static int packet_io_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta) // return 0 : success // return -1 : error -static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta) +static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta, void *logger) { if (meta->session_id) { if (marsio_buff_set_metadata(tx_buff, MR_BUFF_SESSION_ID, &(meta->session_id), sizeof(meta->session_id)) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set session_id for metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set session_id for metadata", LOG_TAG_PKTIO); return -1; } } @@ -884,7 +884,7 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta) marsio_buff_set_ctrlbuf(tx_buff); if (marsio_buff_set_metadata(tx_buff, MR_BUFF_PAYLOAD_OFFSET, &(meta->l7offset), sizeof(meta->l7offset)) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set l7offset for metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set l7offset for metadata", LOG_TAG_PKTIO); return -1; } } @@ -897,7 +897,7 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta) } if (marsio_buff_set_metadata(tx_buff, MR_BUFF_USER_0, &(user_data), sizeof(user_data)) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set is_decrypted for metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set is_decrypted for metadata", LOG_TAG_PKTIO); return -1; } } @@ -906,7 +906,7 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta) { if (marsio_buff_set_metadata(tx_buff, MR_BUFF_ROUTE_CTX, meta->route_ctx.data, meta->route_ctx.len) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set route_ctx for metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set route_ctx for metadata", LOG_TAG_PKTIO); return -1; } } @@ -915,7 +915,7 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta) { if (marsio_buff_set_sid_list(tx_buff, meta->sids.elems, meta->sids.num) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set sid_list for metadata", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set sid_list for metadata", LOG_TAG_PKTIO); return -1; } } @@ -923,9 +923,9 @@ static int packet_io_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta) return 0; } -static void packet_io_dump_metadata(marsio_buff_t *tx_buff, struct metadata *meta) +static void packet_io_dump_metadata(marsio_buff_t *tx_buff, struct metadata *meta, void *logger) { - TFE_LOG_DEBUG(g_default_logger, "%s: META={session_id: %lu, raw_len: %d, is_e2i_dir: %d, is_ctrl_pkt: %d, l7offset: %d, is_decrypted: %u, sids_num: %d}", LOG_TAG_PKTIO, meta->session_id, meta->raw_len, meta->is_e2i_dir, meta->is_ctrl_pkt, meta->l7offset, meta->is_decrypted, meta->sids.num); + TFE_LOG_DEBUG(logger, "%s: META={session_id: %lu, raw_len: %d, is_e2i_dir: %d, is_ctrl_pkt: %d, l7offset: %d, is_decrypted: %u, sids_num: %d}", LOG_TAG_PKTIO, meta->session_id, meta->raw_len, meta->is_e2i_dir, meta->is_ctrl_pkt, meta->l7offset, meta->is_decrypted, meta->sids.num); } /* @@ -948,9 +948,10 @@ static void send_event_log(struct session_ctx *s_ctx, int thread_seq, void *ctx) struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)ctx; struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io *packet_io = thread->ref_io; - + struct packet_io_fs *packet_io_fs = thread->ret_fs_state; marsio_buff_t *tx_buffs[1]; struct metadata meta = {0}; + void * logger = thread->logger; uint16_t length = 0; uint8_t ssl_intercept_status = 0; @@ -1059,8 +1060,8 @@ static void send_event_log(struct session_ctx *s_ctx, int thread_seq, void *ctx) meta.sids.num = 1; meta.sids.elems[0] = acceptor_ctx->firewall_sids; route_ctx_copy(&meta.route_ctx, &s_ctx->ctrl_meta->route_ctx); - packet_io_set_metadata(tx_buffs[0], &meta); - int nsend = marsio_buff_datalen(tx_buffs[0]); + packet_io_set_metadata(tx_buffs[0], &meta, logger); + ATOMIC_INC(&(packet_io_fs->session_log)); marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread_seq, tx_buffs, 1); if (data) @@ -1068,21 +1069,65 @@ static void send_event_log(struct session_ctx *s_ctx, int thread_seq, void *ctx) return; } +static void tcp_restore_info_dump(struct tcp_restore_info *info, uint64_t session_id, void *logger) +{ + char str_client_addr[64] = { 0 }; + char str_server_addr[64] = { 0 }; + + const struct tcp_restore_endpoint *client = &info->client; + const struct tcp_restore_endpoint *server = &info->server; + + assert(client->addr.ss_family == server->addr.ss_family); + + if (client->addr.ss_family == AF_INET) + { + struct sockaddr_in *sk_client = (struct sockaddr_in *)&client->addr; + struct sockaddr_in *sk_server = (struct sockaddr_in *)&server->addr; + uint16_t port_client = ntohs(sk_client->sin_port); + uint16_t port_server = ntohs(sk_server->sin_port); + + inet_ntop(AF_INET, &sk_client->sin_addr, str_client_addr, sizeof(str_client_addr)); + inet_ntop(AF_INET, &sk_server->sin_addr, str_server_addr, sizeof(str_client_addr)); + + TFE_LOG_DEBUG(logger, "restore_info session %lu %s:%hu %s:%hu: cur_dir=%u\n" + "\tclient={ addr=%s, port=%hu, seq:%u, ack:%u, ts_val:%u, mss=%u, window:%hu, wscale_perm=%u, wscale=%u, timestamp_perm=%u, sack_perm=%u }\n" + "\tserver={ addr=%s, port=%hu, seq:%u, ack:%u, ts_val:%u, mss=%u, window:%hu, wscale_perm=%u, wscale=%u, timestamp_perm=%u, sack_perm=%u }", + session_id, str_client_addr, port_client, str_server_addr, port_server, info->cur_dir, + str_client_addr, port_client, client->seq, client->ack, client->ts_val, client->mss, client->window, (client->wscale_perm ? 1 : 0), client->wscale, (client->timestamp_perm ? 1 : 0), (client->sack_perm ? 1 : 0), + str_server_addr, port_server, server->seq, server->ack, server->ts_val, server->mss, server->window, (server->wscale_perm ? 1 : 0), server->wscale, (server->timestamp_perm ? 1 : 0), (server->sack_perm ? 1 : 0)); + } + else if (client->addr.ss_family == AF_INET6) + { + struct sockaddr_in6 *sk_client = (struct sockaddr_in6 *)&client->addr; + struct sockaddr_in6 *sk_server = (struct sockaddr_in6 *)&server->addr; + uint16_t port_client = ntohs(sk_client->sin6_port); + uint16_t port_server = ntohs(sk_server->sin6_port); + + inet_ntop(AF_INET6, &sk_client->sin6_addr, str_client_addr, sizeof(str_client_addr)); + inet_ntop(AF_INET6, &sk_server->sin6_addr, str_server_addr, sizeof(str_client_addr)); + + TFE_LOG_DEBUG(logger, "restore_info session %lu %s:%hu %s:%hu: tcp_restore_info %p cur_dir=%u\n" + "\tclient={ addr=%s, port=%hu, seq:%u, ack:%u, ts_val:%u, mss=%u, window:%hu, wscale_perm=%u, wscale=%u, timestamp_perm=%u, sack_perm=%u }\n" + "\tserver={ addr=%s, port=%hu, seq:%u, ack:%u, ts_val:%u, mss=%u, window:%hu, wscale_perm=%u, wscale=%u, timestamp_perm=%u, sack_perm=%u }", + session_id, str_client_addr, port_client, str_server_addr, port_server, info, info->cur_dir, + str_client_addr, port_client, client->seq, client->ack, client->ts_val, client->mss, client->window, (client->wscale_perm ? 1 : 0), client->wscale, (client->timestamp_perm ? 1 : 0), (client->sack_perm ? 1 : 0), + str_server_addr, port_server, server->seq, server->ack, server->ts_val, server->mss, server->window, (server->wscale_perm ? 1 : 0), server->wscale, (server->timestamp_perm ? 1 : 0), (server->sack_perm ? 1 : 0)); + } +} + // return 0 : success // return -1 : error static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser *parser, int thread_seq, void *ctx) { - uint8_t *iptmp = NULL; int fd_downstream = 0; int fd_upstream = 0; int fd_fake_c = 0; int fd_fake_s = 0; uint16_t size = 0; - char *addr_str = NULL; unsigned int stream_common_direction; uint8_t stream_protocol_in_char = 0; - uint8_t enalbe_decrypted_traffic_steering = 0; + uint8_t enable_decrypted_traffic_steering = 0; struct ethhdr *ether_hdr = NULL; struct session_ctx *s_ctx = NULL; struct addr_tuple4 inner_tuple4; @@ -1090,22 +1135,21 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser memset(&inner_tuple4, 0, sizeof(inner_tuple4)); memset(&restore_info, 0, sizeof(restore_info)); - struct sockaddr_in *in_addr_client = (struct sockaddr_in *)&restore_info.client.addr; - struct sockaddr_in *in_addr_server = (struct sockaddr_in *)&restore_info.server.addr; - struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)ctx; struct packet_io *packet_io = thread->ref_io; + struct packet_io_fs *packet_io_fs = thread->ret_fs_state; + void * logger = thread->logger; struct raw_pkt_parser raw_parser; raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8); - const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len); + const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len, logger); if ((char *)payload - meta->raw_data != meta->l7offset) { uint16_t offset = (char *)payload - meta->raw_data; - TFE_LOG_ERROR(g_default_logger, "%s: incorrect dataoffset in the control zone of session %lu, offset:%u, l7offset:%u, payload:%p, raw_data:%p", LOG_TAG_PKTIO, meta->session_id, offset, meta->l7offset, payload, meta->raw_data); + TFE_LOG_ERROR(logger, "%s: incorrect dataoffset in the control zone of session %lu, offset:%u, l7offset:%u, payload:%p, raw_data:%p", LOG_TAG_PKTIO, meta->session_id, offset, meta->l7offset, payload, meta->raw_data); } - raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_tuple4); + raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_tuple4, logger); intercept_policy_enforce(thread->ref_proxy->int_ply_enforcer, parser->cmsg); tcp_policy_enforce(thread->ref_proxy->tcp_ply_enforcer, parser->cmsg); @@ -1116,51 +1160,17 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser tcp_restore_set_from_cmsg(parser->cmsg, &restore_info); tcp_restore_set_from_pkg(&inner_tuple4, &restore_info); - if (overwrite_tcp_mss(parser->cmsg, &restore_info)) + if (overwrite_tcp_mss(parser->cmsg, &restore_info, meta->session_id, logger)) { goto end; } + tcp_restore_info_dump(&restore_info, meta->session_id, logger); - iptmp = (uint8_t *)&in_addr_client->sin_addr.s_addr; // tcp repair C2S - addr_str = addr_tuple4_to_str(&inner_tuple4); - TFE_LOG_DEBUG(g_default_logger, "restore_info session %lu %s : client", meta->session_id, addr_str); - - TFE_LOG_DEBUG(g_default_logger, "\t addr:%d.%d.%d.%d", iptmp[0], iptmp[1], iptmp[2], iptmp[3]); - TFE_LOG_DEBUG(g_default_logger, "\t port:%u", in_addr_client->sin_port); - TFE_LOG_DEBUG(g_default_logger, "\t seq:%u", restore_info.client.seq); - TFE_LOG_DEBUG(g_default_logger, "\t ack:%u", restore_info.client.ack); - TFE_LOG_DEBUG(g_default_logger, "\t ts_val:%u", restore_info.client.ts_val); - TFE_LOG_DEBUG(g_default_logger, "\t mss:%u", restore_info.client.mss); - TFE_LOG_DEBUG(g_default_logger, "\t window:%u", restore_info.client.window); - TFE_LOG_DEBUG(g_default_logger, "\t wscale:%u", restore_info.client.wscale); - TFE_LOG_DEBUG(g_default_logger, "\t wscale_perm:%s", restore_info.client.wscale_perm > 0?"true":"false"); - TFE_LOG_DEBUG(g_default_logger, "\t timestamp_perm:%s", restore_info.client.timestamp_perm > 0?"true":"false"); - TFE_LOG_DEBUG(g_default_logger, "\t sack_perm:%s", restore_info.client.sack_perm > 0?"true":"false"); - - - iptmp = (uint8_t *)&in_addr_server->sin_addr.s_addr; - // tcp repair C2S - TFE_LOG_DEBUG(g_default_logger, "restore_info session %lu %s : server", meta->session_id, addr_str); - - TFE_LOG_DEBUG(g_default_logger, "\t addr:%d.%d.%d.%d", iptmp[0], iptmp[1], iptmp[2], iptmp[3]); - TFE_LOG_DEBUG(g_default_logger, "\t port:%u", in_addr_server->sin_port); - TFE_LOG_DEBUG(g_default_logger, "\t seq:%u", restore_info.server.seq); - TFE_LOG_DEBUG(g_default_logger, "\t ack:%u", restore_info.server.ack); - TFE_LOG_DEBUG(g_default_logger, "\t ts_val:%u", restore_info.server.ts_val); - TFE_LOG_DEBUG(g_default_logger, "\t mss:%u", restore_info.server.mss); - TFE_LOG_DEBUG(g_default_logger, "\t window:%u", restore_info.server.window); - TFE_LOG_DEBUG(g_default_logger, "\t wscale:%u", restore_info.server.wscale); - TFE_LOG_DEBUG(g_default_logger, "\t wscale_perm:%s", restore_info.server.wscale_perm > 0?"true":"false"); - TFE_LOG_DEBUG(g_default_logger, "\t timestamp_perm:%s", restore_info.server.timestamp_perm > 0?"true":"false"); - TFE_LOG_DEBUG(g_default_logger, "\t sack_perm:%s", restore_info.server.sack_perm > 0?"true":"false"); - - free(addr_str); - fd_upstream = tfe_tcp_restore_fd_create(&(restore_info.client), &(restore_info.server), packet_io->config.dev_tap, 0x65); if (fd_upstream < 0) { - TFE_LOG_ERROR(g_default_logger, "Failed at tcp_restore_fd_create(UPSTREAM)"); + TFE_LOG_ERROR(logger, "%s: session %lu Failed at tcp_restore_fd_create(UPSTREAM)", LOG_TAG_PKTIO, meta->session_id); goto end; } @@ -1168,40 +1178,40 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser fd_downstream = tfe_tcp_restore_fd_create(&(restore_info.server), &(restore_info.client), packet_io->config.dev_tap, 0x65); if (fd_downstream < 0) { - TFE_LOG_ERROR(g_default_logger, "Failed at tcp_restore_fd_create(DOWNSTREAM)"); + TFE_LOG_ERROR(logger, "%s: session %lu Failed at tcp_restore_fd_create(DOWNSTREAM)", LOG_TAG_PKTIO, meta->session_id); goto end; } tfe_cmsg_get_value(parser->cmsg, TFE_CMSG_TCP_RESTORE_PROTOCOL, (unsigned char *)&stream_protocol_in_char, sizeof(stream_protocol_in_char), &size); - tfe_cmsg_get_value(parser->cmsg, TFE_CMSG_TCP_DECRYPTED_TRAFFIC_STEERING, (unsigned char *)&enalbe_decrypted_traffic_steering, sizeof(enalbe_decrypted_traffic_steering), &size); + tfe_cmsg_get_value(parser->cmsg, TFE_CMSG_TCP_DECRYPTED_TRAFFIC_STEERING, (unsigned char *)&enable_decrypted_traffic_steering, sizeof(enable_decrypted_traffic_steering), &size); if ((STREAM_PROTO_PLAIN == (enum tfe_stream_proto)stream_protocol_in_char && thread->ref_proxy->traffic_steering_options.enable_steering_http) || (STREAM_PROTO_SSL == (enum tfe_stream_proto)stream_protocol_in_char && thread->ref_proxy->traffic_steering_options.enable_steering_ssl) || - enalbe_decrypted_traffic_steering == 1) + enable_decrypted_traffic_steering == 1) { if (fake_tcp_handshake(thread->ref_proxy, &restore_info) == -1) { - TFE_LOG_ERROR(g_default_logger, "session %lu Failed at fake_tcp_handshake()", meta->session_id); + TFE_LOG_ERROR(logger, "%s: session %lu Failed at fake_tcp_handshake()", LOG_TAG_PKTIO, meta->session_id); goto end; } fd_fake_c = tfe_tcp_restore_fd_create(&(restore_info.client), &(restore_info.server), thread->ref_proxy->traffic_steering_options.device_client, thread->ref_proxy->traffic_steering_options.so_mask_client); if (fd_fake_c < 0) { - TFE_LOG_ERROR(g_default_logger, "session %lu Failed at tcp_restore_fd_create(fd_fake_c)", meta->session_id); + TFE_LOG_ERROR(logger, "%s: session %lu Failed at tcp_restore_fd_create(fd_fake_c)", LOG_TAG_PKTIO, meta->session_id); goto end; } fd_fake_s = tfe_tcp_restore_fd_create(&(restore_info.server), &(restore_info.client), thread->ref_proxy->traffic_steering_options.device_server, thread->ref_proxy->traffic_steering_options.so_mask_server); if (fd_fake_s < 0) { - TFE_LOG_ERROR(g_default_logger, "session %lu Failed at tcp_restore_fd_create(fd_fake_s)", meta->session_id); + TFE_LOG_ERROR(logger, "%s: session %lu Failed at tcp_restore_fd_create(fd_fake_s)", LOG_TAG_PKTIO, meta->session_id); goto end; } } if (tfe_proxy_fds_accept(thread->ref_proxy, fd_downstream, fd_upstream, fd_fake_c, fd_fake_s, parser->cmsg) < 0) { - TFE_LOG_ERROR(g_default_logger, "session %lu Failed at tfe_proxy_fds_accept()", meta->session_id); + TFE_LOG_ERROR(logger, "%s: session %lu Failed at tfe_proxy_fds_accept()", LOG_TAG_PKTIO, meta->session_id); goto end; } @@ -1254,10 +1264,10 @@ static int handle_session_opening(struct metadata *meta, struct ctrl_pkt_parser route_ctx_copy(&s_ctx->raw_meta_e2i->route_ctx, &parser->ack_route_ctx); } - TFE_LOG_INFO(g_default_logger, "%s: session %lu %s active first", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->session_addr); + TFE_LOG_INFO(logger, "%s: session %lu %s active first", LOG_TAG_PKTIO, s_ctx->session_id, s_ctx->session_addr); session_table_insert(thread->session_table, s_ctx->session_id, &(s_ctx->c2s_info.tuple4), s_ctx, session_value_free_cb); - + ATOMIC_INC(&(packet_io_fs->session_num)); return 0; end: if (parser->cmsg) @@ -1285,13 +1295,16 @@ static int handle_session_active(struct metadata *meta, struct ctrl_pkt_parser * static int handle_session_closing(struct metadata *meta, struct ctrl_pkt_parser *parser, int thread_seq, void *ctx) { struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)ctx; + struct packet_io_fs *packet_io_fs = thread->ret_fs_state; + void * logger = thread->logger; struct session_node *node = session_table_search_by_id(thread->session_table, meta->session_id); if (node) { struct session_ctx *s_ctx = (struct session_ctx *)node->val_data; - TFE_LOG_INFO(g_default_logger, "%s: session %lu closing", LOG_TAG_PKTIO, s_ctx->session_id); + TFE_LOG_INFO(logger, "%s: session %lu closing", LOG_TAG_PKTIO, s_ctx->session_id); session_table_delete_by_id(thread->session_table, meta->session_id); + ATOMIC_DEC(&(packet_io_fs->session_num)); return 0; } @@ -1304,9 +1317,11 @@ static int handle_session_resetall(struct metadata *meta, struct ctrl_pkt_parser { struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)ctx; struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; + struct packet_io_fs *packet_io_fs = thread->ret_fs_state; + void * logger = thread->logger; - TFE_LOG_ERROR(g_default_logger, "%s: session %lu resetall: notification clears all session tables !!!", LOG_TAG_PKTIO, meta->session_id); - + TFE_LOG_ERROR(logger, "%s: session %lu resetall: notification clears all session tables !!!", LOG_TAG_PKTIO, meta->session_id); + ATOMIC_ZERO(&(packet_io_fs->session_num)); for (int i = 0; i < acceptor_ctx->nr_worker_threads; i++) { struct packet_io_thread_ctx *thread_ctx = &acceptor_ctx->work_threads[i]; @@ -1321,29 +1336,28 @@ static int handle_session_resetall(struct metadata *meta, struct ctrl_pkt_parser static int handle_control_packet(struct packet_io *handle, marsio_buff_t *rx_buff, int thread_seq, void *ctx) { struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)ctx; - struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io_fs *packet_io_fs = thread->ret_fs_state; + void * logger = thread->logger; struct metadata meta; - if (packet_io_get_metadata(rx_buff, &meta) == -1) + if (packet_io_get_metadata(rx_buff, &meta, logger) == -1) { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet, unable to get metadata", LOG_TAG_PKTIO); - packet_io_dump_metadata(rx_buff, &meta); + TFE_LOG_ERROR(logger, "%s: unexpected control packet, unable to get metadata\n\tMETA={session_id: %lu, raw_len: %d, is_e2i_dir: %d, is_ctrl_pkt: %d, l7offset: %d, is_decrypted: %u, sids_num: %d}", + LOG_TAG_PKTIO, meta.session_id, meta.raw_len, meta.is_e2i_dir, meta.is_ctrl_pkt, meta.l7offset, meta.is_decrypted, meta.sids.num); return -1; } struct ctrl_pkt_parser ctrl_parser; ctrl_packet_parser_init(&ctrl_parser); - if (ctrl_packet_parser_parse(&ctrl_parser, meta.raw_data + meta.l7offset, meta.raw_len - meta.l7offset) == -1) + if (ctrl_packet_parser_parse(&ctrl_parser, meta.raw_data + meta.l7offset, meta.raw_len - meta.l7offset, logger) == -1) { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet, unable to parse data", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unexpected control packet, metadata's session %lu unable to parse data", LOG_TAG_PKTIO, meta.session_id); return -1; } - ctrl_packet_parser_dump(&ctrl_parser); if (ctrl_parser.session_id != meta.session_id) { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected control packet, metadata's session %lu != control packet's session %lu", LOG_TAG_PKTIO, meta.session_id, ctrl_parser.session_id); + TFE_LOG_ERROR(logger, "%s: unexpected control packet, metadata's session %lu != control packet's session %lu", LOG_TAG_PKTIO, meta.session_id, ctrl_parser.session_id); return -1; } @@ -1376,17 +1390,18 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)ctx; struct packet_io *packet_io = thread->ref_io; struct packet_io_fs *packet_io_fs = thread->ret_fs_state; + void * logger = thread->logger; int raw_len = marsio_buff_datalen(rx_buff); char *raw_data = marsio_buff_mtod(rx_buff); - char *buff = NULL; - int buff_size = 0; struct metadata meta; - if (packet_io_get_metadata(rx_buff, &meta) == -1) + if (packet_io_get_metadata(rx_buff, &meta, logger) == -1) { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected raw packet, unable to get metadata, bypass !!!", LOG_TAG_PKTIO); - packet_io_dump_metadata(rx_buff, &meta); + TFE_LOG_ERROR(logger, "%s: unexpected control packet, unable to get metadata\n\tMETA={session_id: %lu, raw_len: %d, is_e2i_dir: %d, is_ctrl_pkt: %d, l7offset: %d, is_decrypted: %u, sids_num: %d}", + LOG_TAG_PKTIO, meta.session_id, meta.raw_len, meta.is_e2i_dir, meta.is_ctrl_pkt, meta.l7offset, meta.is_decrypted, meta.sids.num); + throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->raw_bypass, 1, raw_len); marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1); return -1; } @@ -1394,7 +1409,8 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx struct session_node *node = session_table_search_by_id(thread->session_table, meta.session_id); if (node == NULL) { - TFE_LOG_ERROR(g_default_logger, "%s: unexpected raw packet, unable to find session %lu from session table, bypass !!!", LOG_TAG_PKTIO, meta.session_id); + throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->raw_bypass, 1, raw_len); marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1); return -1; } @@ -1403,31 +1419,33 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx if (meta.is_decrypted) { + throughput_metrics_inc(&packet_io_fs->decrypt_rx, 1, raw_len); // c2s if (meta.is_e2i_dir == s_ctx->c2s_info.is_e2i_dir) { add_ether_header(raw_data, packet_io->config.tap_c_mac, packet_io->config.tap_s_mac); + throughput_metrics_inc(&packet_io_fs->tap_s_pkt_tx, 1, raw_len); if (packet_io->config.enable_iouring) { io_uring_submit_write_entry(thread->tap_ctx->io_uring_s, raw_data, raw_len); } else { - tfe_tap_write_per_thread(thread->tap_ctx->tap_s, raw_data, raw_len, g_default_logger); + tap_write(thread->tap_ctx->tap_s, raw_data, raw_len, logger); } - throughput_metrics_inc(&packet_io_fs->tap_s_pkt_tx, 1, raw_len); } // s2c else { add_ether_header(raw_data, packet_io->config.tap_s_mac, packet_io->config.tap_c_mac); + throughput_metrics_inc(&packet_io_fs->tap_c_pkt_tx, 1, raw_len); if (packet_io->config.enable_iouring) { io_uring_submit_write_entry(thread->tap_ctx->io_uring_c, raw_data, raw_len); } else { - tfe_tap_write_per_thread(thread->tap_ctx->tap_c, raw_data, raw_len, g_default_logger); + tap_write(thread->tap_ctx->tap_c, raw_data, raw_len, logger); } - throughput_metrics_inc(&packet_io_fs->tap_c_pkt_tx, 1, raw_len); } } else { + throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); if (meta.is_e2i_dir) { if (metadata_is_empty(s_ctx->raw_meta_e2i)) @@ -1444,20 +1462,13 @@ static int handle_raw_packet_from_nf(struct packet_io *handle, marsio_buff_t *rx } s_ctx->raw_meta_i2e->sids = meta.sids; } -#if 0 - struct raw_pkt_parser raw_parser; - raw_packet_parser_init(&raw_parser, meta->session_id, LAYER_TYPE_ALL, 8); - const void *payload = raw_packet_parser_parse(&raw_parser, (const void *)meta->raw_data, meta->raw_len); - buff_size = raw_len - ((char *)payload - meta->raw_data) + sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct tcphdr); - -#endif // send to tap0 add_ether_header(raw_data, packet_io->config.src_mac, packet_io->config.tap_mac); if (packet_io->config.enable_iouring) { io_uring_submit_write_entry(thread->tap_ctx->io_uring_fd, raw_data, raw_len); } else { - tfe_tap_write_per_thread(thread->tap_ctx->tap_fd, raw_data, raw_len, g_default_logger); + tap_write(thread->tap_ctx->tap_fd, raw_data, raw_len, logger); } throughput_metrics_inc(&packet_io_fs->tap_pkt_tx, 1, raw_len); @@ -1503,8 +1514,7 @@ struct tap_ctx *tfe_tap_ctx_create(void *ctx) { int ret = 0; struct packet_io_thread_ctx *thread_ctx = (struct packet_io_thread_ctx *)ctx; - struct acceptor_kni_v4 *acceptor_ctx = thread_ctx->ref_acceptor_ctx; - struct packet_io *packet_io = acceptor_ctx->io; + struct packet_io *packet_io = thread_ctx->ref_io; struct tap_ctx *tap_ctx = (struct tap_ctx *)calloc(1, sizeof(struct tap_ctx)); assert(tap_ctx != NULL); @@ -1560,11 +1570,11 @@ error_out: return NULL; } -int packet_io_thread_init(struct packet_io *handle, struct packet_io_thread_ctx *thread_ctx) +int packet_io_thread_init(struct packet_io *handle, struct packet_io_thread_ctx *thread_ctx, void *logger) { if (marsio_thread_init(handle->instance) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to init marsio thread %d", LOG_TAG_PKTIO, thread_ctx->thread_index); + TFE_LOG_ERROR(logger, "%s: unable to init marsio thread %d", LOG_TAG_PKTIO, thread_ctx->thread_index); return -1; } @@ -1611,14 +1621,14 @@ void packet_io_destory(struct packet_io *handle) } } -struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask) +struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_t *coremask, void *logger) { int opt = 1; struct packet_io *handle = (struct packet_io *)calloc(1, sizeof(struct packet_io)); assert(handle != NULL); handle->thread_num = thread_num; - if (packet_io_config(profile, &(handle->config)) != 0) + if (packet_io_config(profile, &(handle->config), logger) != 0) { goto error_out; } @@ -1632,32 +1642,32 @@ struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_ } } else if (thread_num > 1){ - TFE_LOG_ERROR(g_default_logger, "%s: under tap mode, when disable tap_allow_mutilthread, only support one work thread.", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: under tap mode, when disable tap_allow_mutilthread, only support one work thread.", LOG_TAG_PKTIO); goto error_out; } handle->instance = marsio_create(); if (handle->instance == NULL) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to create marsio instance", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to create marsio instance", LOG_TAG_PKTIO); goto error_out; } if (marsio_option_set(handle->instance, MARSIO_OPT_THREAD_MASK_IN_CPUSET, coremask, sizeof(cpu_set_t)) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set MARSIO_OPT_EXIT_WHEN_ERR option for marsio instance", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set MARSIO_OPT_EXIT_WHEN_ERR option for marsio instance", LOG_TAG_PKTIO); goto error_out; } if (marsio_option_set(handle->instance, MARSIO_OPT_EXIT_WHEN_ERR, &opt, sizeof(opt)) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to set MARSIO_OPT_EXIT_WHEN_ERR option for marsio instance", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to set MARSIO_OPT_EXIT_WHEN_ERR option for marsio instance", LOG_TAG_PKTIO); goto error_out; } if (marsio_init(handle->instance, handle->config.app_symbol) != 0) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to initialize marsio instance", LOG_TAG_PKTIO); + TFE_LOG_ERROR(logger, "%s: unable to initialize marsio instance", LOG_TAG_PKTIO); goto error_out; } @@ -1665,14 +1675,14 @@ struct packet_io *packet_io_create(const char *profile, int thread_num, cpu_set_ handle->dev_nf_interface.mr_dev = marsio_open_device(handle->instance, handle->config.dev_nf_interface, handle->thread_num, handle->thread_num); if (handle->dev_nf_interface.mr_dev == NULL) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface); + TFE_LOG_ERROR(logger, "%s: unable to open device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface); goto error_out; } handle->dev_nf_interface.mr_path = marsio_sendpath_create_by_vdev(handle->dev_nf_interface.mr_dev); if (handle->dev_nf_interface.mr_path == NULL) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface); + TFE_LOG_ERROR(logger, "%s: unable to create sendpath for device %s", LOG_TAG_PKTIO, handle->config.dev_nf_interface); goto error_out; } @@ -1703,6 +1713,9 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi for (int i = 0; i < nr_recv; i++) { int raw_len = marsio_buff_datalen(rx_buffs[i]); + throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->raw_pkt_tx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->raw_bypass, 1, raw_len); } marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, rx_buffs, nr_recv); @@ -1716,20 +1729,29 @@ int packet_io_polling_nf_interface(struct packet_io *handle, int thread_seq, voi if (is_downstream_keepalive_packet(rx_buff)) { + throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->raw_pkt_tx, 1, raw_len); + + throughput_metrics_inc(&packet_io_fs->keepalived_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->keepalived_pkt_tx, 1, raw_len); + marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1); continue; } if (marsio_buff_is_ctrlbuf(rx_buff)) { + throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->raw_pkt_tx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->ctrl_pkt_rx, 1, raw_len); + throughput_metrics_inc(&packet_io_fs->ctrl_pkt_tx, 1, raw_len); // all control packet need bypass handle_control_packet(handle, rx_buff, thread_seq, ctx); marsio_send_burst(handle->dev_nf_interface.mr_path, thread_seq, &rx_buff, 1); } else { - throughput_metrics_inc(&packet_io_fs->raw_pkt_rx, 1, raw_len); handle_raw_packet_from_nf(handle, rx_buff, thread_seq, ctx); } } @@ -1742,28 +1764,31 @@ void handle_decryption_packet_from_tap(const char *data, int len, void *args) struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)args; struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io *packet_io = thread->ref_io; - + struct packet_io_fs *packet_io_fs = thread->ret_fs_state; struct addr_tuple4 inner_addr; struct raw_pkt_parser raw_parser; + void * logger = thread->logger; + memset(&inner_addr, 0, sizeof(struct addr_tuple4)); raw_packet_parser_init(&raw_parser, 0, LAYER_TYPE_ALL, 8); - raw_packet_parser_parse(&raw_parser, (const void *)data, len); - raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr); + raw_packet_parser_parse(&raw_parser, (const void *)data, len, logger); + raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr, logger); + + throughput_metrics_inc(&packet_io_fs->decrypt_rx, 1, len); struct session_node *node = session_table_search_by_addr(thread->session_table, &inner_addr); - if (node == NULL) - { - char *addr_string = addr_tuple4_to_str(&inner_addr); - TFE_LOG_ERROR(g_default_logger, "%s: unexpected inject packet, unable to find session %s from session table, drop !!!", LOG_TAG_PKTIO, addr_string); - free(addr_string); + if (node == NULL) { + throughput_metrics_inc(&packet_io_fs->decrypt_rxdrop, 1, len); return; } + struct session_ctx *s_ctx = (struct session_ctx *)node->val_data; marsio_buff_t *tx_buffs[1]; int alloc_ret = marsio_buff_malloc_device(packet_io->dev_nf_interface.mr_dev, tx_buffs, 1, 0, thread->thread_index); if (alloc_ret < 0){ - TFE_LOG_ERROR(g_default_logger, "Failed at alloc marsio buffer, ret = %d, thread_seq = %d", + TFE_LOG_ERROR(logger, "Failed at alloc marsio buffer, ret = %d, thread_seq = %d", alloc_ret, thread->thread_index); + throughput_metrics_inc(&packet_io_fs->decrypt_rxdrop, 1, len); return; } @@ -1781,10 +1806,14 @@ void handle_decryption_packet_from_tap(const char *data, int len, void *args) meta.sids.elems[0] = acceptor_ctx->sce_sids; meta.sids.elems[1] = acceptor_ctx->proxy_sids; - if (memcmp(&inner_addr, &s_ctx->c2s_info.tuple4, sizeof(struct addr_tuple4)) == 0) + if (memcmp(&inner_addr, &s_ctx->c2s_info.tuple4, sizeof(struct addr_tuple4)) == 0) { meta.is_e2i_dir = s_ctx->c2s_info.is_e2i_dir; - else + throughput_metrics_inc(&packet_io_fs->tap_c_pkt_rx, 1, len); + } + else { meta.is_e2i_dir = s_ctx->s2c_info.is_e2i_dir; + throughput_metrics_inc(&packet_io_fs->tap_s_pkt_rx, 1, len); + } if (meta.is_e2i_dir) { @@ -1794,7 +1823,8 @@ void handle_decryption_packet_from_tap(const char *data, int len, void *args) { route_ctx_copy(&meta.route_ctx, &s_ctx->raw_meta_i2e->route_ctx); } - packet_io_set_metadata(tx_buffs[0], &meta); + packet_io_set_metadata(tx_buffs[0], &meta, logger); + throughput_metrics_inc(&packet_io_fs->decrypt_tx, 1, len); marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread->thread_index, tx_buffs, 1); } @@ -1803,30 +1833,32 @@ void handle_raw_packet_from_tap(const char *data, int len, void *args) char *src_mac = NULL; char *dst_mac = NULL; struct packet_io_thread_ctx *thread = (struct packet_io_thread_ctx *)args; - struct acceptor_kni_v4 *acceptor_ctx = thread->ref_acceptor_ctx; struct packet_io *packet_io = thread->ref_io; - + struct packet_io_fs *packet_io_fs = thread->ret_fs_state; struct addr_tuple4 inner_addr; struct raw_pkt_parser raw_parser; + void * logger = thread->logger; + memset(&inner_addr, 0, sizeof(struct addr_tuple4)); raw_packet_parser_init(&raw_parser, 0, LAYER_TYPE_ALL, 8); - raw_packet_parser_parse(&raw_parser, (const void *)data, len); - raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr); + raw_packet_parser_parse(&raw_parser, (const void *)data, len, logger); + raw_packet_parser_get_most_inner_tuple4(&raw_parser, &inner_addr, logger); + + throughput_metrics_inc(&packet_io_fs->tap_pkt_rx, 1, len); struct session_node *node = session_table_search_by_addr(thread->session_table, &inner_addr); - if (node == NULL) - { - char *addr_string = addr_tuple4_to_str(&inner_addr); - TFE_LOG_ERROR(g_default_logger, "%s: unexpected inject packet, unable to find session %s from session table, drop !!!", LOG_TAG_PKTIO, addr_string); - free(addr_string); + if (node == NULL) { + throughput_metrics_inc(&packet_io_fs->tap_pkt_rxdrop, 1, len); return; } + struct session_ctx *s_ctx = (struct session_ctx *)node->val_data; marsio_buff_t *tx_buffs[1]; int alloc_ret = marsio_buff_malloc_device(packet_io->dev_nf_interface.mr_dev, tx_buffs, 1, 0, thread->thread_index); if (alloc_ret < 0){ - TFE_LOG_ERROR(g_default_logger, "Failed at alloc marsio buffer, ret = %d, thread_seq = %d", + TFE_LOG_ERROR(logger, "Failed at alloc marsio buffer, ret = %d, thread_seq = %d", alloc_ret, thread->thread_index); + throughput_metrics_inc(&packet_io_fs->tap_pkt_rxdrop, 1, len); return; } @@ -1864,9 +1896,9 @@ void handle_raw_packet_from_tap(const char *data, int len, void *args) sids_copy(&meta.sids, &s_ctx->raw_meta_i2e->sids); route_ctx_copy(&meta.route_ctx, &s_ctx->raw_meta_i2e->route_ctx); } - - packet_io_set_metadata(tx_buffs[0], &meta); + packet_io_set_metadata(tx_buffs[0], &meta, logger); add_ether_header(dst, src_mac, dst_mac); + throughput_metrics_inc(&packet_io_fs->raw_pkt_tx, 1, len); marsio_send_burst(packet_io->dev_nf_interface.mr_path, thread->thread_index, tx_buffs, 1); } diff --git a/common/src/tfe_packet_io_fs.cpp b/common/src/tfe_packet_io_fs.cpp index 13469b2..0a31e8a 100644 --- a/common/src/tfe_packet_io_fs.cpp +++ b/common/src/tfe_packet_io_fs.cpp @@ -8,14 +8,9 @@ enum PACKET_IO_STAT_FIELD { - // hit block policy - STAT_HIT_POLICY_PKT, - STAT_HIT_POLICY_B, - // dev nf interface STAT_RAW_PKT_RX_PKT, STAT_RAW_PKT_RX_B, - STAT_RAW_PKT_TX_PKT, STAT_RAW_PKT_TX_B, @@ -24,16 +19,18 @@ enum PACKET_IO_STAT_FIELD STAT_DECRYPTED_RX_PKT, STAT_DECRYPTED_RX_B, - // control packet - STAT_CONTROL_RX_PKT, - STAT_CONTROL_RX_B, - STAT_CONTROL_TX_PKT, - STAT_CONTROL_TX_B, + STAT_RAW_PKT_BYPASS_PKT, + STAT_RAW_PKT_BYPASS_B, + + STAT_DECRYPT_RXDROP_PKT, + STAT_DECRYPT_RXDROP_B, STAT_TAP_RX_PKT, STAT_TAP_RX_B, STAT_TAP_TX_PKT, STAT_TAP_TX_B, + STAT_TAP_RXDROP_PKT, + STAT_TAP_RXDROP_B, STAT_TAP_C_RX_PKT, STAT_TAP_C_RX_B, @@ -45,14 +42,26 @@ enum PACKET_IO_STAT_FIELD STAT_TAP_S_TX_PKT, STAT_TAP_S_TX_B, + // keepalived packet + STAT_KEEPALIVED_RX_PKT, + STAT_KEEPALIVED_RX_B, + STAT_KEEPALIVED_TX_PKT, + STAT_KEEPALIVED_TX_B, + + // control packet + STAT_CONTROL_RX_PKT, + STAT_CONTROL_RX_B, + STAT_CONTROL_TX_PKT, + STAT_CONTROL_TX_B, + STAT_CTRL_PKT_OPENING, STAT_CTRL_PKT_ACTIVE, STAT_CTRL_PKT_CLOSING, STAT_CTRL_PKT_RESETALL, STAT_CTRL_PKT_ERROR, - // send log - STAT_SEND_LOG, + STAT_SESSION_NUM, + STAT_SESSION_LOG, // max STAT_MAX, @@ -60,14 +69,9 @@ enum PACKET_IO_STAT_FIELD static const char *stat_map[] = { - // hit policy - [STAT_HIT_POLICY_PKT] = "hit_policy_pkt", - [STAT_HIT_POLICY_B] = "hit_policy_B", - // dev nf interface [STAT_RAW_PKT_RX_PKT] = "raw_rx_pkt", [STAT_RAW_PKT_RX_B] = "raw_rx_B", - [STAT_RAW_PKT_TX_PKT] = "raw_tx_pkt", [STAT_RAW_PKT_TX_B] = "raw_tx_B", @@ -77,26 +81,44 @@ static const char *stat_map[] = [STAT_DECRYPTED_RX_PKT] = "decrypt_rx_pkt", [STAT_DECRYPTED_RX_B] = "decrypt_rx_B", - // control packet - [STAT_CONTROL_RX_PKT] = "ctrl_rx_pkt", - [STAT_CONTROL_RX_B] = "ctrl_rx_B", - [STAT_CONTROL_TX_PKT] = "ctrl_tx_pkt", - [STAT_CONTROL_TX_B] = "ctrl_tx_B", + [STAT_RAW_PKT_BYPASS_PKT] = "raw_bypass_pkt", + [STAT_RAW_PKT_BYPASS_B] = "raw_bypass_B", + + [STAT_DECRYPT_RXDROP_PKT] = "dec_rxdrop_pkt", + [STAT_DECRYPT_RXDROP_B] = "dec_rxdrop_B", // tap packet [STAT_TAP_RX_PKT] = "tap_rx_pkt", [STAT_TAP_RX_B] = "tap_rx_B", [STAT_TAP_TX_PKT] = "tap_tx_pkt", [STAT_TAP_TX_B] = "tap_tx_B", + [STAT_TAP_RXDROP_PKT] = "tap_rxdrop_pkt", + [STAT_TAP_RXDROP_B] = "tap_rxdrop_B", + + // tap_c packet [STAT_TAP_C_RX_PKT] = "tap_c_rx_pkt", [STAT_TAP_C_RX_B] = "tap_c_rx_B", [STAT_TAP_C_TX_PKT] = "tap_c_tx_pkt", [STAT_TAP_C_TX_B] = "tap_c_tx_B", + + // tap_s packet [STAT_TAP_S_RX_PKT] = "tap_s_rx_pkt", [STAT_TAP_S_RX_B] = "tap_s_rx_B", [STAT_TAP_S_TX_PKT] = "tap_s_tx_pkt", [STAT_TAP_S_TX_B] = "tap_s_tx_B", + // keepalived packet + [STAT_KEEPALIVED_RX_PKT] = "keep_rx_pkt", + [STAT_KEEPALIVED_RX_B] = "keep_rx_B", + [STAT_KEEPALIVED_TX_PKT] = "keep_tx_pkt", + [STAT_KEEPALIVED_TX_B] = "keep_tx_B", + + // control packet + [STAT_CONTROL_RX_PKT] = "ctrl_rx_pkt", + [STAT_CONTROL_RX_B] = "ctrl_rx_B", + [STAT_CONTROL_TX_PKT] = "ctrl_tx_pkt", + [STAT_CONTROL_TX_B] = "ctrl_tx_B", + [STAT_CTRL_PKT_OPENING] = "ctrl_pkt_open", [STAT_CTRL_PKT_ACTIVE] = "ctrl_pkt_avtive", [STAT_CTRL_PKT_CLOSING] = "ctrl_pkt_close", @@ -104,7 +126,8 @@ static const char *stat_map[] = [STAT_CTRL_PKT_ERROR] = "ctrl_pkt_error", // send log - [STAT_SEND_LOG] = "send_log", + [STAT_SESSION_NUM] = "session_num", + [STAT_SESSION_LOG] = "session_log", [STAT_MAX] = NULL }; @@ -119,21 +142,22 @@ void throughput_metrics_inc(struct throughput_metrics *iterm, uint64_t n_pkts, u __atomic_fetch_add(&iterm->n_pkts, n_pkts, __ATOMIC_RELAXED); } -struct packet_io_fs *packet_io_fs_create() +struct packet_io_fs *packet_io_fs_create(const char *profile) { - int value=0, i=0; + int value=0; const char* app_name="packet_io"; const char* fieldstat_output="log/packet_io.fs2"; struct packet_io_fs *handle = (struct packet_io_fs *)calloc(1, sizeof(struct packet_io_fs)); - handle->fs_handle=FS_create_handle(); - FS_set_para(handle->fs_handle, OUTPUT_DEVICE, fieldstat_output, strlen(fieldstat_output)+1); - value=1; - FS_set_para(handle->fs_handle, PRINT_MODE, &value, sizeof(value)); - value=0; - FS_set_para(handle->fs_handle, CREATE_THREAD, &value, sizeof(value)); FS_set_para(handle->fs_handle, APP_NAME, app_name, strlen(app_name)+1); + FS_set_para(handle->fs_handle, OUTPUT_DEVICE, fieldstat_output, strlen(fieldstat_output)+1); + value = 1; + FS_set_para(handle->fs_handle, OUTPUT_PROMETHEUS, &value, sizeof(value)); + value=1; + FS_set_para(handle->fs_handle, PRINT_MODE, &value, sizeof(value)); + value=0; + FS_set_para(handle->fs_handle, CREATE_THREAD, &value, sizeof(value)); for (int i = 0; i < STAT_MAX; i++) { @@ -147,7 +171,6 @@ void packet_io_fs_destory(struct packet_io_fs *handle) { if (handle) { - FS_library_destroy(); free(handle); handle = NULL; } @@ -157,49 +180,59 @@ void packet_io_fs_dump(struct packet_io_fs *handle) { if (handle == NULL) return; - FS_operate(handle->fs_handle, handle->fs_id[STAT_HIT_POLICY_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->hit_policy.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_HIT_POLICY_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->hit_policy.n_bytes), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_tx.n_pkts), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_tx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rx.n_pkts), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPTED_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rx.n_bytes), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_BYPASS_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_bypass.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_RAW_PKT_BYPASS_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->raw_bypass.n_bytes), 0, __ATOMIC_RELAXED)); + + FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPT_RXDROP_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rxdrop.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_DECRYPT_RXDROP_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->decrypt_rxdrop.n_bytes), 0, __ATOMIC_RELAXED)); + + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RXDROP_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rxdrop.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RXDROP_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rxdrop.n_bytes), 0, __ATOMIC_RELAXED)); + + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); + + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_s_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); + + // keepalived packet + FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_KEEPALIVED_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->keepalived_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); + // control packet FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CONTROL_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); - - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_C_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_c_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); - - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_RX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_RX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_rx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_TX_PKT], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_pkts), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_TAP_S_TX_B], 0, FS_OP_SET, __atomic_fetch_add(&(handle->tap_pkt_tx.n_bytes), 0, __ATOMIC_RELAXED)); - FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_OPENING], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_opening_num), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_ACTIVE], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_active_num), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_CLOSING], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_closing_num), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_RESETALL], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_resetall_num), 0, __ATOMIC_RELAXED)); FS_operate(handle->fs_handle, handle->fs_id[STAT_CTRL_PKT_ERROR], 0, FS_OP_SET, __atomic_fetch_add(&(handle->ctrl_pkt_error_num), 0, __ATOMIC_RELAXED)); - // send log - FS_operate(handle->fs_handle, handle->fs_id[STAT_SEND_LOG], 0, FS_OP_SET, __atomic_fetch_add(&(handle->send_log), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_SESSION_NUM], 0, FS_OP_SET, __atomic_fetch_add(&(handle->session_num), 0, __ATOMIC_RELAXED)); + FS_operate(handle->fs_handle, handle->fs_id[STAT_SESSION_LOG], 0, FS_OP_SET, __atomic_fetch_add(&(handle->session_log), 0, __ATOMIC_RELAXED)); + FS_passive_output(handle->fs_handle); } diff --git a/common/src/tfe_raw_packet.cpp b/common/src/tfe_raw_packet.cpp index a407669..97d67a6 100644 --- a/common/src/tfe_raw_packet.cpp +++ b/common/src/tfe_raw_packet.cpp @@ -76,16 +76,16 @@ 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_ipv4(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_ipv6(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_tcp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_udp(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_pppoe_ses(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_vxlan(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_vlan8021q(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_gtpv1_u(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); +static const void *parse_mpls(struct raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger); /****************************************************************************** * Public API @@ -103,17 +103,17 @@ void raw_packet_parser_init(struct raw_pkt_parser *handler, uint64_t pkt_trace_i } // return most inner payload -const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length) +const void *raw_packet_parser_parse(struct raw_pkt_parser *handler, const void *data, size_t length, void *logger) { handler->ptr_pkt_start = data; // TESTED - return parse_ether(handler, data, length, LAYER_TYPE_ETHER); + return parse_ether(handler, data, length, LAYER_TYPE_ETHER, logger); } // return 0 : success // return -1 : error -int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr) +int raw_packet_parser_get_most_inner_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger) { const char *l3_layer_data = NULL; const char *l4_layer_data = NULL; @@ -127,7 +127,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; - TFE_LOG_DEBUG(g_default_logger, "%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)); + TFE_LOG_DEBUG(logger, "%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)); // first get L4 layer if (type & LAYER_TYPE_L4) @@ -168,7 +168,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 raw_packet_parser_get_most_outer_tuple4(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger) { const char *l3_layer_data = NULL; const char *l4_layer_data = NULL; @@ -182,7 +182,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; - TFE_LOG_DEBUG(g_default_logger, "%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)); + TFE_LOG_DEBUG(logger, "%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)); // first get L3 layer if (type & LAYER_TYPE_L3) @@ -223,7 +223,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 raw_packet_parser_get_most_inner_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger) { const char *l3_layer_data = NULL; struct layer_results *results = &handler->results; @@ -234,7 +234,7 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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)); + TFE_LOG_DEBUG(logger, "%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)); if (type & LAYER_TYPE_L3) { l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset; @@ -248,7 +248,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 raw_packet_parser_get_most_outer_address(struct raw_pkt_parser *handler, struct addr_tuple4 *addr, void *logger) { const char *l3_layer_data = NULL; struct layer_results *results = &handler->results; @@ -259,7 +259,7 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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)); + TFE_LOG_DEBUG(logger, "%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)); if (type & LAYER_TYPE_L3) { l3_layer_data = (const char *)handler->ptr_pkt_start + layer->offset; @@ -271,7 +271,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_internal) +uint64_t raw_packet_parser_get_hash_value(struct raw_pkt_parser *handler, enum ldbc_method method, int dir_is_internal, void *logger) { uint64_t temp = 0; uint64_t hash_value = 1; @@ -293,12 +293,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 (raw_packet_parser_get_most_inner_address(handler, &inner_addr, logger) == -1) { return hash_value; } - if (raw_packet_parser_get_most_outer_address(handler, &outer_addr) == -1) + if (raw_packet_parser_get_most_outer_address(handler, &outer_addr, logger) == -1) { return hash_value; } @@ -391,7 +391,7 @@ 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); - TFE_LOG_DEBUG(g_default_logger, "%s: pkt_trace_id: %lu, outer_addr: %s, inner_addr: %s, is_internal: %d, hash_method: %s, hash_value: %lu", + TFE_LOG_DEBUG(logger, "%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_internal, ldbc_method_to_string(method), hash_value); free(inner_addr_str); free(outer_addr_str); @@ -582,11 +582,11 @@ 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct ethhdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -601,38 +601,38 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_VLAN, logger); case ETH_P_8021AD: // TODO - return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER); + return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER, logger); 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, LAYER_TYPE_IPV4, logger); 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, LAYER_TYPE_IPV6, logger); 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, LAYER_TYPE_PPPOE, logger); 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, LAYER_TYPE_MPLS, logger); default: - TFE_LOG_ERROR(g_default_logger, "%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); + TFE_LOG_ERROR(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct ip)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -647,32 +647,32 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_TCP, logger); 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, LAYER_TYPE_UDP, logger); 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, LAYER_TYPE_IPV4, logger); 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, LAYER_TYPE_IPV6, logger); default: - TFE_LOG_ERROR(g_default_logger, "%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); + TFE_LOG_ERROR(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct ip6_hdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -687,32 +687,32 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_TCP, logger); 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, LAYER_TYPE_UDP, logger); 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, LAYER_TYPE_IPV4, logger); 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, LAYER_TYPE_IPV6, logger); default: - TFE_LOG_ERROR(g_default_logger, "%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); + TFE_LOG_ERROR(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct tcphdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -726,16 +726,16 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct udp_hdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -749,27 +749,27 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_G_VXLAN, logger); // 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, LAYER_TYPE_GTPV1_U, logger); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < 8) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -783,28 +783,28 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_IPV4, logger); // 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, LAYER_TYPE_IPV6, logger); default: - TFE_LOG_ERROR(g_default_logger, "%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); + TFE_LOG_ERROR(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct vxlan_hdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return NULL; } @@ -818,16 +818,16 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); // TESTED - return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER); + return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER, logger); } -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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct vlan_hdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return NULL; } @@ -842,35 +842,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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_VLAN, logger); 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, LAYER_TYPE_IPV4, logger); 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, LAYER_TYPE_IPV6, logger); 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, LAYER_TYPE_PPPOE, logger); 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, LAYER_TYPE_MPLS, logger); default: - TFE_LOG_ERROR(g_default_logger, "%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); + TFE_LOG_ERROR(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < sizeof(struct gtp_hdr)) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return NULL; } @@ -889,26 +889,26 @@ 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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); 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, LAYER_TYPE_IPV4, logger); 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, LAYER_TYPE_IPV6, logger); default: - TFE_LOG_ERROR(g_default_logger, "%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); + TFE_LOG_ERROR(logger, "%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); 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 raw_pkt_parser *handler, const void *data, size_t length, enum layer_type this_type, void *logger) { if (length < 4) { - TFE_LOG_ERROR(g_default_logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); + TFE_LOG_ERROR(logger, "%s: pkt_trace_id: %lu, this_layer: %s, err: data not enough", LOG_TAG_RAWPKT, handler->pkt_trace_id, layer_type2str(this_type)); return data; } @@ -962,33 +962,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; - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); // TESTED - return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER); + return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER, logger); } else if (ip_version == 4) { - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); // TESTED - return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4); + return parse_ipv4(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV4, logger); } else if (ip_version == 6) { - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); // TODO - return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6); + return parse_ipv6(handler, data_next_layer, data_next_length, LAYER_TYPE_IPV6, logger); } else { - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); // TODO - return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER); + return parse_ether(handler, data_next_layer, data_next_length, LAYER_TYPE_ETHER, logger); } } else { - TFE_LOG_DEBUG(g_default_logger, "%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); + TFE_LOG_DEBUG(logger, "%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); // TESTED - return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS); + return parse_mpls(handler, data_next_layer, data_next_length, LAYER_TYPE_MPLS, logger); } } \ No newline at end of file diff --git a/common/src/tfe_session_table.cpp b/common/src/tfe_session_table.cpp index 985a149..90eb5af 100644 --- a/common/src/tfe_session_table.cpp +++ b/common/src/tfe_session_table.cpp @@ -3,6 +3,8 @@ #include "tfe_session_table.h" #include +extern void * g_packet_io_logger; + struct session_table { struct session_node *root_by_id; @@ -90,7 +92,7 @@ int session_table_insert(struct session_table *table, uint64_t session_id, const HASH_FIND(hh1, table->root_by_id, &session_id, sizeof(session_id), temp); if (temp) { - TFE_LOG_DEBUG(g_default_logger, "%s: insert: key %lu exists", LOG_TAG_STABLE, session_id); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: insert: key %lu exists", LOG_TAG_STABLE, session_id); return -1; } @@ -105,7 +107,7 @@ int session_table_insert(struct session_table *table, uint64_t session_id, const HASH_ADD(hh1, table->root_by_id, session_id, sizeof(temp->session_id), temp); HASH_ADD(hh2, table->root_by_addr, session_addr, sizeof(temp->session_addr), temp); - TFE_LOG_DEBUG(g_default_logger, "%s: insert: key %lu success", LOG_TAG_STABLE, session_id); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: insert: key %lu success", LOG_TAG_STABLE, session_id); table->session_node_count++; return 0; @@ -117,7 +119,7 @@ int session_table_delete_by_id(struct session_table *table, uint64_t session_id) HASH_FIND(hh1, table->root_by_id, &session_id, sizeof(session_id), temp); if (!temp) { - TFE_LOG_DEBUG(g_default_logger, "%s: delete: key %lu not exists", LOG_TAG_STABLE, session_id); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: delete: key %lu not exists", LOG_TAG_STABLE, session_id); return -1; } @@ -133,7 +135,7 @@ int session_table_delete_by_id(struct session_table *table, uint64_t session_id) free(temp); temp = NULL; - TFE_LOG_DEBUG(g_default_logger, "%s: delete: key %lu success", LOG_TAG_STABLE, session_id); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: delete: key %lu success", LOG_TAG_STABLE, session_id); table->session_node_count--; return 0; @@ -151,7 +153,7 @@ int session_table_delete_by_addr(struct session_table *table, const struct addr_ HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct addr_tuple4), temp); if (!temp) { - TFE_LOG_DEBUG(g_default_logger, "%s: delete: key %s not exists", LOG_TAG_STABLE, addr_str); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: delete: key %s not exists", LOG_TAG_STABLE, addr_str); free(addr_str); return -1; } @@ -169,7 +171,7 @@ int session_table_delete_by_addr(struct session_table *table, const struct addr_ free(temp); temp = NULL; - TFE_LOG_DEBUG(g_default_logger, "%s: delete: key %s success", LOG_TAG_STABLE, addr_str); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: delete: key %s success", LOG_TAG_STABLE, addr_str); free(addr_str); addr_str = NULL; table->session_node_count--; @@ -183,11 +185,11 @@ struct session_node *session_table_search_by_id(struct session_table *table, uin HASH_FIND(hh1, table->root_by_id, &session_id, sizeof(session_id), temp); if (!temp) { - TFE_LOG_DEBUG(g_default_logger, "%s: search: key %lu not exists", LOG_TAG_STABLE, session_id); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: search: key %lu not exists", LOG_TAG_STABLE, session_id); return NULL; } - TFE_LOG_DEBUG(g_default_logger, "%s: search: key %lu success", LOG_TAG_STABLE, session_id); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: search: key %lu success", LOG_TAG_STABLE, session_id); return temp; } @@ -204,14 +206,14 @@ struct session_node *session_table_search_by_addr(struct session_table *table, c HASH_FIND(hh2, table->root_by_addr, &reverse_addr, sizeof(struct addr_tuple4), temp); if (!temp) { - TFE_LOG_DEBUG(g_default_logger, "%s: search: key %s not exists", LOG_TAG_STABLE, addr_str); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: search: key %s not exists", LOG_TAG_STABLE, addr_str); free(addr_str); addr_str = NULL; return NULL; } } - TFE_LOG_DEBUG(g_default_logger, "%s: search: key %s success", LOG_TAG_STABLE, addr_str); + TFE_LOG_DEBUG(g_packet_io_logger, "%s: search: key %s success", LOG_TAG_STABLE, addr_str); free(addr_str); addr_str = NULL; diff --git a/common/test/test_mpack.cpp b/common/test/test_mpack.cpp index 65fdc93..4eecf3b 100644 --- a/common/test/test_mpack.cpp +++ b/common/test/test_mpack.cpp @@ -6,7 +6,6 @@ // TEST(MPACK, PARSE) // { // struct ctrl_pkt_parser handler; -// parse_messagepack(); // } int main(int argc, char **argv) diff --git a/conf/tfe/zlog.conf b/conf/tfe/zlog.conf index e671d19..5b95a46 100644 --- a/conf/tfe/zlog.conf +++ b/conf/tfe/zlog.conf @@ -18,3 +18,4 @@ http.DEBUG "./log/http.log.%d(%F)"; http2.DEBUG "./log/http2.log.%d(%F)"; doh.DEBUG "./log/doh_pxy.log.%d(%F)"; tsg_http.DEBUG "./log/tsg_http_pxy.log.%d(%F)"; +packet_io.DEBUG "./log/packet_io.log.%d(%F)"; diff --git a/platform/include/internal/acceptor_kni_v4.h b/platform/include/internal/acceptor_kni_v4.h index 3cf02ba..2545a3c 100644 --- a/platform/include/internal/acceptor_kni_v4.h +++ b/platform/include/internal/acceptor_kni_v4.h @@ -2,5 +2,5 @@ struct tfe_proxy; -struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const char *profile, void *logger); +struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const char *profile); void acceptor_kni_v4_destroy(); diff --git a/platform/src/acceptor_kni_v4.cpp b/platform/src/acceptor_kni_v4.cpp index 080760c..401060f 100644 --- a/platform/src/acceptor_kni_v4.cpp +++ b/platform/src/acceptor_kni_v4.cpp @@ -21,34 +21,35 @@ #include "tfe_session_table.h" -static int tfe_tap_read_per_thread(int tap_fd, char *buff, int buff_size, void *logger) +void * g_packet_io_logger = NULL; + +static int tap_read(int tap_fd, char *buff, int buff_size, void *logger) { int ret = read(tap_fd, buff, buff_size); if (ret < 0) { if (errno != EWOULDBLOCK && errno != EAGAIN) { - TFE_LOG_ERROR(g_default_logger, "%s: unable to read data from tapfd %d, aborting: %s", LOG_TAG_PKTIO, tap_fd, strerror(errno)); + TFE_LOG_ERROR(logger, "%s: unable to read data from tapfd %d, aborting: %s", LOG_TAG_PKTIO, tap_fd, strerror(errno)); } } return ret; } -void acceptor_ctx_destory(struct acceptor_kni_v4 * ctx) +void acceptor_kni_v4_destroy(struct acceptor_kni_v4 *ctx) { if (ctx) { packet_io_destory(ctx->io); packet_io_fs_destory(ctx->packet_io_fs); - free(ctx); ctx = NULL; } return; } -struct acceptor_kni_v4 *acceptor_ctx_create(const char *profile) +struct acceptor_kni_v4 *acceptor_ctx_create(const char *profile, void *logger) { struct acceptor_kni_v4 *ctx = ALLOC(struct acceptor_kni_v4, 1); @@ -66,13 +67,13 @@ struct acceptor_kni_v4 *acceptor_ctx_create(const char *profile) CPU_SET(cpu_id, &ctx->coremask); } - ctx->io = packet_io_create(profile, ctx->nr_worker_threads, &ctx->coremask); + ctx->io = packet_io_create(profile, ctx->nr_worker_threads, &ctx->coremask, logger); if (ctx->io == NULL) { goto error_out; } - ctx->packet_io_fs = packet_io_fs_create(); + ctx->packet_io_fs = packet_io_fs_create(profile); if (ctx->packet_io_fs == NULL) { goto error_out; @@ -81,7 +82,7 @@ struct acceptor_kni_v4 *acceptor_ctx_create(const char *profile) return ctx; error_out: - acceptor_ctx_destory(ctx); + acceptor_kni_v4_destroy(ctx); return NULL; } @@ -89,18 +90,19 @@ static void *worker_thread_cycle(void *arg) { struct packet_io_thread_ctx *thread_ctx = (struct packet_io_thread_ctx *)arg; struct packet_io *handle = thread_ctx->ref_io; + void * logger = thread_ctx->logger; int pkg_len = 0; - char thread_name[16]; + char thread_name[32]; int n_pkt_recv_from_nf = 0; int n_pkt_recv_from_tap = 0; int n_pkt_recv_from_tap_c = 0; int n_pkt_recv_from_tap_s = 0; - snprintf(thread_name, sizeof(thread_name), "kni:worker-%d", thread_ctx->thread_index); + snprintf(thread_name, sizeof(thread_name), "packet-io:worker-%d", thread_ctx->thread_index); prctl(PR_SET_NAME, (unsigned long long)thread_name, NULL, NULL, NULL); - if (packet_io_thread_init(handle, thread_ctx) != 0) + if (packet_io_thread_init(handle, thread_ctx, logger) != 0) { goto error_out; } @@ -115,7 +117,7 @@ static void *worker_thread_cycle(void *arg) thread_ctx->tap_ctx->buff = ALLOC(char, thread_ctx->tap_ctx->buff_size); } - TFE_LOG_INFO(g_default_logger, "%s: worker thread %d is running", "LOG_TAG_KNI", thread_ctx->thread_index); + TFE_LOG_INFO(logger, "%s: worker thread %d is running", "LOG_TAG_KNI", thread_ctx->thread_index); while(1) { n_pkt_recv_from_nf = packet_io_polling_nf_interface(handle, thread_ctx->thread_index, thread_ctx); @@ -125,22 +127,21 @@ static void *worker_thread_cycle(void *arg) n_pkt_recv_from_tap_s = io_uring_peek_ready_entrys(thread_ctx->tap_ctx->io_uring_s); } else { - if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_fd, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) + if ((pkg_len = tap_read(thread_ctx->tap_ctx->tap_fd, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, logger)) > 0) { handle_raw_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); } - if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_c, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) + if ((pkg_len = tap_read(thread_ctx->tap_ctx->tap_c, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, logger)) > 0) { handle_decryption_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); } - if ((pkg_len = tfe_tap_read_per_thread(thread_ctx->tap_ctx->tap_s, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, g_default_logger)) > 0) + if ((pkg_len = tap_read(thread_ctx->tap_ctx->tap_s, thread_ctx->tap_ctx->buff, thread_ctx->tap_ctx->buff_size, logger)) > 0) { handle_decryption_packet_from_tap(thread_ctx->tap_ctx->buff, pkg_len, thread_ctx); } } - if (n_pkt_recv_from_nf == 0 && n_pkt_recv_from_tap == 0 && n_pkt_recv_from_tap_c == 0 && n_pkt_recv_from_tap_s == 0) { @@ -155,25 +156,18 @@ static void *worker_thread_cycle(void *arg) } error_out: - TFE_LOG_ERROR(g_default_logger, "%s: worker thread %d exiting", LOG_TAG_SCE, thread_ctx->thread_index); + TFE_LOG_ERROR(logger, "%s: worker thread %d exiting", LOG_TAG_SCE, thread_ctx->thread_index); return (void *)NULL; } -void acceptor_kni_v4_destroy(struct acceptor_kni_v4 *ctx) +struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const char *profile) { - if (ctx) - { - packet_io_destory(ctx->io); + void *packet_io_logger = NULL; + packet_io_logger = MESA_create_runtime_log_handle("packet_io", RLOG_LV_DEBUG); + assert(packet_io_logger != NULL); - free(ctx); - ctx = NULL; - } - return; -} - -struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const char *profile, void *logger) -{ - struct acceptor_kni_v4 *acceptor_ctx = acceptor_ctx_create(profile); + g_packet_io_logger = packet_io_logger; + struct acceptor_kni_v4 *acceptor_ctx = acceptor_ctx_create(profile, packet_io_logger); if (acceptor_ctx == NULL) goto error_out; @@ -181,6 +175,7 @@ struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const ch for (int i = 0; i < acceptor_ctx->nr_worker_threads; i++) { acceptor_ctx->work_threads[i].tid = 0; acceptor_ctx->work_threads[i].thread_index = i; + acceptor_ctx->work_threads[i].ref_io = acceptor_ctx->io; acceptor_ctx->work_threads[i].ref_acceptor_ctx = acceptor_ctx; acceptor_ctx->work_threads[i].tap_ctx = tfe_tap_ctx_create(&acceptor_ctx->work_threads[i]); @@ -188,10 +183,9 @@ struct acceptor_kni_v4 *acceptor_kni_v4_create(struct tfe_proxy *proxy, const ch goto error_out; acceptor_ctx->work_threads[i].session_table = session_table_create(); - acceptor_ctx->work_threads[i].ref_io = acceptor_ctx->io; acceptor_ctx->work_threads[i].ref_proxy = proxy; acceptor_ctx->work_threads[i].ret_fs_state = acceptor_ctx->packet_io_fs; - acceptor_ctx->work_threads[i].ref_acceptor_ctx = acceptor_ctx; + acceptor_ctx->work_threads[i].logger = packet_io_logger; acceptor_ctx->work_threads[i].session_table_need_reset = 0; } diff --git a/platform/src/proxy.cpp b/platform/src/proxy.cpp index aafd246..8f3904c 100644 --- a/platform/src/proxy.cpp +++ b/platform/src/proxy.cpp @@ -564,7 +564,7 @@ void tfe_proxy_acceptor_init(struct tfe_proxy * proxy, const char * profile) if (proxy->en_kni_v4_acceptor) { - g_default_proxy->kni_v4_acceptor = acceptor_kni_v4_create(g_default_proxy, profile, g_default_logger); + g_default_proxy->kni_v4_acceptor = acceptor_kni_v4_create(g_default_proxy, profile); CHECK_OR_EXIT(g_default_proxy->kni_v4_acceptor, "Failed at init KNIv4 acceptor. Exit. "); }