247 lines
10 KiB
C
247 lines
10 KiB
C
#include "etcp_dump.h"
|
|
#include "etcp.h"
|
|
#include "pkt_normalizer.h"
|
|
#include "../lib/ll_queue.h"
|
|
#include "../lib/memory_pool.h"
|
|
#include "../lib/socket_compat.h"
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#define DUMP_FP stdout
|
|
|
|
#define DUMP_LINE(fmt, ...) do { \
|
|
fprintf(DUMP_FP, " " fmt "\n", ##__VA_ARGS__); \
|
|
} while(0)
|
|
|
|
#define DUMP_HDR(fmt, ...) do { \
|
|
fprintf(DUMP_FP, fmt "\n", ##__VA_ARGS__); \
|
|
} while(0)
|
|
|
|
static void dump_queue(const char* name, struct ll_queue* q) {
|
|
if (!q) { DUMP_LINE("%-14s NULL", name); return; }
|
|
DUMP_LINE("%-14s %d pkts / %zu bytes", name, queue_entry_count(q), queue_total_bytes(q));
|
|
}
|
|
|
|
static void dump_pool(const char* name, struct memory_pool* pool) {
|
|
if (!pool) return;
|
|
size_t allocs, reuse;
|
|
memory_pool_get_stats(pool, &allocs, &reuse);
|
|
DUMP_LINE(" %-12s alloc=%zu reuse=%zu", name, allocs, reuse);
|
|
}
|
|
|
|
static void dump_link_timer(const char* name, void* timer) {
|
|
DUMP_LINE(" %-14s %s", name, timer ? "ACTIVE" : "free");
|
|
}
|
|
|
|
static const char* ip_to_str_buf(uint32_t ip, char* buf, size_t sz) {
|
|
uint8_t* b = (uint8_t*)&ip;
|
|
snprintf(buf, sz, "%u.%u.%u.%u", b[0], b[1], b[2], b[3]);
|
|
return buf;
|
|
}
|
|
|
|
static const char* sockaddr_to_str(const struct sockaddr_storage* addr, char* buf, size_t sz) {
|
|
if (!addr || addr->ss_family != AF_INET) { snprintf(buf, sz, "?"); return buf; }
|
|
const struct sockaddr_in* sin = (const struct sockaddr_in*)addr;
|
|
uint8_t* b = (uint8_t*)&sin->sin_addr.s_addr;
|
|
snprintf(buf, sz, "%u.%u.%u.%u:%u", b[0], b[1], b[2], b[3], ntohs(sin->sin_port));
|
|
return buf;
|
|
}
|
|
|
|
void etcp_dump_conn_state(struct ETCP_CONN* conn) {
|
|
if (!conn) { DUMP_HDR("etcp_dump_conn_state: NULL conn"); return; }
|
|
|
|
char addr_buf[32], nat_buf[32];
|
|
|
|
DUMP_HDR("=== ETCP CONN STATE [%s] ===", conn->log_name);
|
|
|
|
/* --- GENERAL --- */
|
|
DUMP_LINE("GENERAL: %s peer=0x%llx initialized=%d links_up=%d tx_state=%d session=0x%08x mtu=%d routing_ex=%d",
|
|
conn->name ? conn->name : "",
|
|
(unsigned long long)conn->peer_node_id, conn->initialized, conn->links_up,
|
|
conn->tx_state, conn->session_id, conn->mtu, conn->routing_exchange_active);
|
|
|
|
/* --- IDS --- */
|
|
DUMP_LINE("IDS: next_tx=%u last_rx=%u last_del=%u rx_ack_till=%u",
|
|
conn->next_tx_id, conn->last_rx_id, conn->last_delivered_id, conn->rx_ack_till);
|
|
|
|
/* --- RTT --- */
|
|
DUMP_LINE("RTT: last=%u avg10=%u avg100=%u jitter=%u",
|
|
conn->rtt_last, conn->rtt_avg_10, conn->rtt_avg_100, conn->jitter);
|
|
|
|
/* --- STATS --- */
|
|
DUMP_LINE("STATS: bytes_sent=%u retrans=%u reinit=%u reset=%u ack_pkts=%u",
|
|
conn->bytes_sent_total, conn->retransmissions_count,
|
|
conn->reinit_count, conn->reset_count, conn->ack_packets_count);
|
|
|
|
/* --- INFLIGHT --- */
|
|
DUMP_LINE("INFLIGHT: unacked=%u optimal=%u",
|
|
conn->unacked_bytes, conn->optimal_inflight);
|
|
|
|
/* --- ACK DEBUG --- */
|
|
DUMP_LINE("ACK_DEBUG: hit_inf=%u hit_sndq=%u miss=%u link_wait=%u rx_dup=%u tx_dup=%u",
|
|
conn->cnt_ack_hit_inf, conn->cnt_ack_hit_sndq, conn->cnt_ack_miss,
|
|
conn->cnt_link_wait, conn->rx_dup_count, conn->tx_dup_count);
|
|
|
|
/* --- DEBUG[8] --- */
|
|
DUMP_LINE("DEBUG: [0]=%u [1]=%u [2]=%u [3]=%u [4]=%u [5]=%u [6]=%u [7]=%u",
|
|
conn->debug[0], conn->debug[1], conn->debug[2], conn->debug[3],
|
|
conn->debug[4], conn->debug[5], conn->debug[6], conn->debug[7]);
|
|
|
|
/* --- TIMERS --- */
|
|
DUMP_LINE("TIMERS: retrans=%s ack_resp=%s",
|
|
conn->retrans_timer ? "ACTIVE" : "free",
|
|
conn->ack_resp_timer ? "ACTIVE" : "free");
|
|
|
|
/* --- QUEUES --- */
|
|
DUMP_HDR(" --- QUEUES ---");
|
|
dump_queue("input", conn->input_queue);
|
|
dump_queue("input_send_q", conn->input_send_q);
|
|
dump_queue("input_wait_ack", conn->input_wait_ack);
|
|
dump_queue("ack_q", conn->ack_q);
|
|
dump_queue("recv_q", conn->recv_q);
|
|
dump_queue("output", conn->output_queue);
|
|
|
|
/* --- NORMALIZER --- */
|
|
if (conn->normalizer) {
|
|
struct PKTNORM* pn = (struct PKTNORM*)conn->normalizer;
|
|
DUMP_HDR(" --- NORMALIZER ---");
|
|
DUMP_LINE("frag=%u data_ptr=%u/%u flush=%s pending=%s recvpart=%s",
|
|
pn->frag_size, pn->data_ptr, pn->data_size,
|
|
pn->flush_timer ? "ACTIVE" : "free",
|
|
pn->pending ? "ACTIVE" : "free",
|
|
pn->recvpart ? "ACTIVE" : "free");
|
|
dump_queue("pn-input", pn->input);
|
|
dump_queue("pn-output", pn->output);
|
|
DUMP_LINE("alloc_err=%u logic_err=%u in=%llu/%llu out=%llu/%llu",
|
|
pn->alloc_errors, pn->logic_errors,
|
|
(unsigned long long)pn->in_total_pkts, (unsigned long long)pn->in_total_bytes,
|
|
(unsigned long long)pn->out_total_pkts, (unsigned long long)pn->out_total_bytes);
|
|
} else {
|
|
DUMP_HDR(" --- NORMALIZER --- NULL");
|
|
}
|
|
|
|
/* --- POOLS --- */
|
|
DUMP_HDR(" --- POOLS ---");
|
|
dump_pool("inflight", conn->inflight_pool);
|
|
dump_pool("io", conn->io_pool);
|
|
if (conn->instance) {
|
|
dump_pool("data", conn->instance->data_pool);
|
|
dump_pool("ack", conn->instance->ack_pool);
|
|
dump_pool("pkt", conn->instance->pkt_pool);
|
|
}
|
|
|
|
/* --- LINKS --- */
|
|
int link_idx = 0;
|
|
struct ETCP_LINK* link = conn->links;
|
|
while (link) {
|
|
DUMP_HDR(" --- LINK %d ---", link_idx);
|
|
|
|
sockaddr_to_str(&link->remote_addr, addr_buf, sizeof(addr_buf));
|
|
|
|
/* basic link state */
|
|
DUMP_LINE("BASIC: id=%d/%d is_server=%d link_state=%d link_status=%d initialized=%d mtu=%d",
|
|
link->local_link_id, link->remote_link_id, link->is_server,
|
|
link->link_state, link->link_status, link->initialized, link->mtu);
|
|
DUMP_LINE("ADDR: remote=%s remote_sock=%d remote_type=%d remote_only_local=%d",
|
|
addr_buf, link->remote_socket_id, link->remote_type, link->remote_only_local);
|
|
|
|
/* keepalive */
|
|
DUMP_LINE("KA: recv=%d remote=%d sent=%u recv=%u interval=%u timeout=%u",
|
|
link->recv_keepalive, link->remote_keepalive,
|
|
link->keepalive_sent_count, link->keepalive_recv_count,
|
|
link->keepalive_interval, link->keepalive_timeout);
|
|
|
|
/* timers */
|
|
DUMP_LINE("TIMERS: init=%s(%u/%u) ka=%s shaper=%s burst=%s keepalive=%s",
|
|
link->init_timer ? "ACTIVE" : "free",
|
|
link->init_timeout, link->init_retry_count,
|
|
link->keepalive_timer ? "ACTIVE" : "free",
|
|
link->shaper_timer ? "ACTIVE" : "free",
|
|
link->burst_resp_timer ? "ACTIVE" : "free",
|
|
link->keepalive_sent_count > 0 ? "has_sent" : "idle");
|
|
|
|
/* inflight (BBR) */
|
|
DUMP_LINE("BBR: bytes=%u pkts=%u lim=%u mode=%d cycle=%d pacing=%u",
|
|
link->inflight_bytes, link->inflight_packets, link->inflight_lim_bytes,
|
|
link->bbr ? link->bbr->mode : -1,
|
|
link->bbr ? link->bbr->cycle_idx : -1,
|
|
link->bbr_pacing_rate);
|
|
|
|
/* rtt (BBR) */
|
|
DUMP_LINE("RTT: last=%u jitter=%u min_rtt_us=%u bw_lo=%u bw_hi=%u inflight_lo=%u inflight_hi=%u",
|
|
link->rtt_last, link->jitter,
|
|
link->bbr ? link->bbr->min_rtt_us : 0,
|
|
link->bbr ? link->bbr->bw_lo : 0,
|
|
link->bbr ? (link->bbr->bw_hi[0] > link->bbr->bw_hi[1] ? link->bbr->bw_hi[0] : link->bbr->bw_hi[1]) : 0,
|
|
link->bbr ? link->bbr->inflight_lo : 0,
|
|
link->bbr ? link->bbr->inflight_hi : 0);
|
|
|
|
/* tt/rt/bandwidth */
|
|
DUMP_LINE("TT/RT: tt=%u rt=%u recv_dt_tx=%u recv_dt_rx=%u bw=%u",
|
|
link->tt_last, link->rt_last,
|
|
link->recv_dt_avg_tx, link->recv_dt_avg_rx,
|
|
link->bandwidth);
|
|
|
|
/* errors */
|
|
DUMP_LINE("MTU: %u local=%u remote=%u", link->mtu, link->mtu_local, link->mtu_remote);
|
|
DUMP_LINE("ERRORS: enc=%zu dec=%zu snd=%zu rcv=%zu total_enc=%zu total_dec=%zu retrans=%u",
|
|
link->encrypt_errors, link->decrypt_errors,
|
|
link->send_errors, link->recv_errors,
|
|
link->total_encrypted, link->total_decrypted,
|
|
link->total_retransmissions);
|
|
|
|
/* nat */
|
|
ip_to_str_buf(link->nat_ip, nat_buf, sizeof(nat_buf));
|
|
DUMP_LINE("NAT: ip=%s:%u chg=%u hits=%u check=%d type=%d",
|
|
nat_buf, link->nat_port,
|
|
link->nat_changes_count, link->nat_hits_count,
|
|
link->nat_check_status, link->nat_type);
|
|
|
|
/* last recv */
|
|
DUMP_LINE("LAST_RECV: time=%llu ts=%u updated=%d",
|
|
(unsigned long long)link->last_recv_local_time,
|
|
link->last_recv_timestamp, link->last_recv_updated);
|
|
|
|
/* handshake */
|
|
DUMP_LINE("HANDSHAKE: min=%u max=%u", link->handshake_minsize, link->handshake_maxsize);
|
|
|
|
/* burst */
|
|
DUMP_LINE("BURST: active=%d id=%u seq=%u/%u last_tb=%llu resp=%s",
|
|
link->burst_active, link->burst_id,
|
|
link->burst_seq, link->burst_count,
|
|
(unsigned long long)link->burst_last_time_tb,
|
|
link->burst_resp_timer ? "ACTIVE" : "free");
|
|
|
|
/* shaper */
|
|
DUMP_LINE("SHAPER: load_tb=%llu sub=%llu state=%d",
|
|
(unsigned long long)link->shaper_load_time_tb,
|
|
(unsigned long long)link->shaper_sub_nanotime,
|
|
link->shaper_state);
|
|
|
|
link = link->next;
|
|
link_idx++;
|
|
}
|
|
if (link_idx == 0) DUMP_HDR(" --- NO LINKS ---");
|
|
|
|
DUMP_HDR("=== END [%s] ===", conn->log_name);
|
|
}
|
|
|
|
void etcp_dump_all_conns(struct UTUN_INSTANCE* instance) {
|
|
if (!instance) {
|
|
DUMP_HDR("etcp_dump_all_conns: NULL instance");
|
|
return;
|
|
}
|
|
DUMP_HDR("=== DUMP ALL CONNS for instance node=0x%llx ===",
|
|
(unsigned long long)instance->node_id);
|
|
struct ETCP_CONN* conn = instance->connections;
|
|
int idx = 0;
|
|
while (conn) {
|
|
DUMP_HDR("--- CONN %d ---", idx);
|
|
etcp_dump_conn_state(conn);
|
|
conn = conn->next;
|
|
idx++;
|
|
}
|
|
if (idx == 0) DUMP_HDR("--- NO CONNECTIONS ---");
|
|
DUMP_HDR("=== END DUMP ALL ===");
|
|
}
|