Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
#include "gui.h"
#include "gui_events.h"
#include <time.h>
#include <pthread.h>
#define RING_CAPACITY 4096
#define SLOT_SIZE 512
#define DRAIN_MAX 2000
#define DRAIN_BUF_SIZE (256 * 1024)
#define DRAIN_INTERVAL_MS 100
#define CONN_HISTORY 2000
#define LOG_HISTORY 1000
#define AUTO_CLEAR_LINES 500 // a log is wiped once it grows past this, when auto-clear is on
typedef struct {
GtkTextBuffer **buffer;
EventRing *ring;
int max_lines;
char *filter; // lowercase, NULL = show all
bool paused;
} View;
static View conn_view = {&conn_buffer, NULL, CONN_HISTORY, NULL, false};
static View log_view = {&log_buffer, NULL, LOG_HISTORY, NULL, false};
static char *drain_buf = NULL;
// Connection-log filters. The library calls the connection callback from its own threads, so the copy has its own lock.
static pthread_mutex_t filter_mu = PTHREAD_MUTEX_INITIALIZER;
static struct pbp_filter *filters;
static size_t nfilters;
void gui_logs_set_filters(const struct pbp_filter *f, size_t n) {
struct pbp_filter *copy = calloc(n ? n : 1, sizeof *copy);
for (size_t i = 0; copy && i < n; i++) copy[i] = pbp_filter_dup(&f[i]);
pthread_mutex_lock(&filter_mu);
struct pbp_filter *old = filters;
size_t nold = nfilters;
filters = copy;
nfilters = copy ? n : 0;
pthread_mutex_unlock(&filter_mu);
for (size_t i = 0; i < nold; i++) pbp_filter_clear(&old[i]);
free(old);
}
static guint drain_source = 0;
static void filter_from_line(GtkTextBuffer *buffer, int first_line, const char *lower_search) {
GtkTextIter line_start, buf_end;
gtk_text_buffer_get_iter_at_line(buffer, &line_start, first_line);
gtk_text_buffer_get_end_iter(buffer, &buf_end);
gtk_text_buffer_remove_tag_by_name(buffer, "hidden", &line_start, &buf_end);
if (!lower_search) return;
while (!gtk_text_iter_is_end(&line_start)) {
GtkTextIter line_end = line_start;
if (!gtk_text_iter_ends_line(&line_end))
gtk_text_iter_forward_to_line_end(&line_end);
char *line_text = gtk_text_buffer_get_text(buffer, &line_start, &line_end, FALSE);
char *lower_line = g_utf8_strdown(line_text, -1);
if (!strstr(lower_line, lower_search)) {
GtkTextIter next_line = line_end;
gtk_text_iter_forward_char(&next_line);
gtk_text_buffer_apply_tag_by_name(buffer, "hidden", &line_start, &next_line);
}
g_free(lower_line);
g_free(line_text);
gtk_text_iter_forward_line(&line_start);
}
}
static void set_filter(View *v, const char *text) {
g_free(v->filter);
v->filter = (text && *text) ? g_utf8_strdown(text, -1) : NULL;
if (*v->buffer) filter_from_line(*v->buffer, 0, v->filter);
}
void on_search_conn_changed(GtkSearchEntry *entry, gpointer user_data) {
set_filter(&conn_view, gtk_entry_get_text(GTK_ENTRY(entry)));
}
void on_search_log_changed(GtkSearchEntry *entry, gpointer user_data) {
set_filter(&log_view, gtk_entry_get_text(GTK_ENTRY(entry)));
}
void on_clear_conn_clicked(GtkButton *button, gpointer user_data) {
if (conn_buffer) gtk_text_buffer_set_text(conn_buffer, "", 0);
}
void on_clear_log_clicked(GtkButton *button, gpointer user_data) {
if (log_buffer) gtk_text_buffer_set_text(log_buffer, "", 0);
}
void on_pause_conn_toggled(GtkToggleButton *button, gpointer user_data) {
conn_view.paused = gtk_toggle_button_get_active(button);
}
// one insert, one filter pass over the new lines and one trim per batch
static void append_batch(View *v, const char *text, uint64_t dropped) {
GtkTextBuffer *buffer = *v->buffer;
if (!buffer) return;
GString *batch = g_string_new(text);
if (dropped) g_string_append_printf(batch, "[%" G_GUINT64_FORMAT " events skipped]\n", dropped);
if (!g_utf8_validate(batch->str, -1, NULL)) {
char *fixed = g_utf8_make_valid(batch->str, -1);
g_string_assign(batch, fixed);
g_free(fixed);
}
GtkTextIter end;
gtk_text_buffer_get_end_iter(buffer, &end);
int first_line = gtk_text_iter_get_line(&end);
gtk_text_buffer_insert(buffer, &end, batch->str, (gint)batch->len);
g_string_free(batch, TRUE);
if (v->filter) filter_from_line(buffer, first_line, v->filter);
int lines = gtk_text_buffer_get_line_count(buffer) - 1;
if (g_chk_auto_clear && lines > AUTO_CLEAR_LINES) {
gtk_text_buffer_set_text(buffer, "", 0);
return;
}
int excess = lines - v->max_lines;
if (excess > 0) {
GtkTextIter start, cut;
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_iter_at_line(buffer, &cut, excess);
gtk_text_buffer_delete(buffer, &start, &cut);
}
}
static void drain_view(View *v) {
if (v->paused || !v->ring) return;
uint64_t dropped = 0;
size_t n = event_ring_drain(v->ring, drain_buf, DRAIN_BUF_SIZE, DRAIN_MAX, &dropped);
if (n || dropped) append_batch(v, drain_buf, dropped);
}
static gboolean drain_tick(gpointer user_data) {
drain_view(&conn_view);
drain_view(&log_view);
return G_SOURCE_CONTINUE;
}
void gui_logs_init() {
drain_buf = g_malloc(DRAIN_BUF_SIZE);
conn_view.ring = event_ring_new(RING_CAPACITY, SLOT_SIZE);
log_view.ring = event_ring_new(RING_CAPACITY, SLOT_SIZE);
drain_source = g_timeout_add(DRAIN_INTERVAL_MS, drain_tick, NULL);
}
void gui_logs_stop_timers() {
if (drain_source) g_source_remove(drain_source);
drain_source = 0;
}
// call after the engine stopped, library threads push into the rings until then
void gui_logs_free() {
gui_logs_stop_timers();
event_ring_free(conn_view.ring);
event_ring_free(log_view.ring);
conn_view.ring = log_view.ring = NULL;
g_free(conn_view.filter);
g_free(log_view.filter);
conn_view.filter = log_view.filter = NULL;
g_free(drain_buf);
drain_buf = NULL;
gui_logs_set_filters(NULL, 0);
}
uint64_t gui_conn_event_count() {
uint64_t pushed = 0;
if (conn_view.ring) event_ring_stats(conn_view.ring, &pushed, NULL, NULL);
return pushed;
}
static void push_line(View *v, const char *fmt, ...) G_GNUC_PRINTF(2, 3);
static void push_line(View *v, const char *fmt, ...) {
if (!v->ring) return;
char line[SLOT_SIZE];
time_t now = time(NULL);
struct tm tm_now;
size_t off = 0;
if (localtime_r(&now, &tm_now)) off = strftime(line, sizeof(line), "[%H:%M:%S] ", &tm_now);
va_list args;
va_start(args, fmt);
g_vsnprintf(line + off, sizeof(line) - off, fmt, args);
va_end(args);
event_ring_push(v->ring, line);
}
void lib_log_callback(const char *message) {
push_line(&log_view, "%s", message ? message : "");
}
void gui_log(const char *format, ...) {
char msg[SLOT_SIZE];
va_list args;
va_start(args, format);
g_vsnprintf(msg, sizeof(msg), format, args);
va_end(args);
lib_log_callback(msg);
}
void lib_connection_callback_ex(const char *process_name, uint32_t pid, const char *dest_ip, uint16_t dest_port, const char *protocol,
const char *proxy_info) {
const char *info = proxy_info ? proxy_info : "";
const char *action = strcmp(info, "DIRECT") == 0 ? "Direct" : strcmp(info, "BLOCK") == 0 ? "Blocked" : "Proxy";
char port[8];
snprintf(port, sizeof port, "%u", dest_port);
pthread_mutex_lock(&filter_mu);
bool show = pbp_filters_pass(filters, nfilters, process_name ? process_name : "", dest_ip ? dest_ip : "", port, protocol ? protocol : "", action);
pthread_mutex_unlock(&filter_mu);
if (!show) return;
// like the Windows app: a UDP flow is marked, a TCP connection is not
push_line(&conn_view, "%s (PID:%u) -> %s:%u via %s%s", process_name ? process_name : "", pid, dest_ip ? dest_ip : "", dest_port, info,
protocol && !strcmp(protocol, "UDP") ? " (UDP)" : "");
}