Skip to content

Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic

feat(linux/gui): event pipeline, status bar, async start/stop, leak fixes

anof-cyber3552375d97e8
diff --git a/Linux/gui/gui.h b/Linux/gui/gui.h
index 653f671..edb7cd9 100644
--- a/Linux/gui/gui.h
+++ b/Linux/gui/gui.h
@@ -11,15 +11,6 @@
#include <sys/stat.h>
#include "ProxyBridge.h"
-typedef struct {
- char *process_name;
- uint32_t pid;
- char *dest_ip;
- uint16_t dest_port;
- char *proxy_info;
- char *timestamp;
-} ConnectionData;
-
typedef struct {
uint32_t id; // library id, 0 = not registered
char *name; // unique key, rules and config refer to it
@@ -58,6 +49,11 @@ extern GtkTextBuffer *log_buffer;
extern GtkWidget *status_bar;
extern guint status_context_id;
+// avoids libc strto*/atoi, glibc 2.38 redirects them to symbols old systems lack
+static inline long parse_long(const char *s) {
+ return s ? (long)g_ascii_strtoll(s, NULL, 10) : 0;
+}
+
extern GList *g_profiles;
extern char *g_active_profile;
extern GList *g_proxies_list; // working copy of the active profile
@@ -66,10 +62,7 @@ extern GList *g_rules_list;
extern bool g_chk_logging;
extern bool g_chk_dns;
-long safe_strtol(const char *nptr);
void show_message(GtkWindow *parent, GtkMessageType type, const char *format, ...);
-void trim_buffer_lines(GtkTextBuffer *buffer, int max_lines);
-char *get_current_time_str();
GtkWidget *combo_new(const char *first, ...) G_GNUC_NULL_TERMINATED;
GtkWidget *hint_label(const char *text);
void set_error_label(GtkWidget *label, const char *msg);
@@ -103,6 +96,11 @@ void refresh_rules_window();
void gui_log(const char *format, ...);
void lib_log_callback(const char *message);
void lib_connection_callback(const char *process_name, uint32_t pid, const char *dest_ip, uint16_t dest_port, const char *proxy_info);
+void gui_logs_init();
+void gui_logs_stop_timers();
+void gui_logs_free();
+uint64_t gui_conn_event_count();
+void on_pause_conn_toggled(GtkToggleButton *button, gpointer user_data);
void on_search_conn_changed(GtkSearchEntry *entry, gpointer user_data);
void on_search_log_changed(GtkSearchEntry *entry, gpointer user_data);
void on_clear_conn_clicked(GtkButton *button, gpointer user_data);
diff --git a/Linux/gui/gui_config.c b/Linux/gui/gui_config.c
index 75896f3..e70d63e 100644
--- a/Linux/gui/gui_config.c
+++ b/Linux/gui/gui_config.c
@@ -239,10 +239,10 @@ static ProxyData *parse_proxy_line(char *line) {
while (n < 6 && (tok = strsep(&line, "|")) != NULL) fields[n++] = tok;
if (n < 4) return NULL;
- int port = atoi(fields[3]);
+ int port = parse_long(fields[3]);
ProxyData *px = g_malloc0(sizeof(ProxyData));
px->name = unesc(fields[0]);
- px->type = proxy_type_from_int(atoi(fields[1]));
+ px->type = proxy_type_from_int(parse_long(fields[1]));
px->host = unesc(fields[2]);
px->port = (port >= 1 && port <= 65535) ? (uint16_t)port : 0;
px->username = unesc(n > 4 ? fields[4] : "");
@@ -256,9 +256,9 @@ static RuleData *parse_rule_line(char *line) {
int idx = 0;
while ((tok = strsep(&line, "|")) != NULL) {
switch (idx++) {
- case 1: rule->protocol = atoi(tok); break;
- case 2: rule->action = atoi(tok); break;
- case 3: rule->enabled = atoi(tok); break;
+ case 1: rule->protocol = parse_long(tok); break;
+ case 2: rule->action = parse_long(tok); break;
+ case 3: rule->enabled = parse_long(tok); break;
case 4: rule->process_name = g_strdup(tok); break;
case 5: rule->target_hosts = g_strdup(tok); break;
case 6: rule->target_ports = g_strdup(tok); break;
@@ -328,13 +328,13 @@ void load_config() {
}
else if (section != 1) continue;
else if (strcmp(line, "ip") == 0) g_strlcpy(old_ip, val, sizeof(old_ip));
- else if (strcmp(line, "port") == 0) old_port = atoi(val);
- else if (strcmp(line, "type") == 0) old_type = atoi(val);
+ else if (strcmp(line, "port") == 0) old_port = parse_long(val);
+ else if (strcmp(line, "type") == 0) old_type = parse_long(val);
else if (strcmp(line, "user") == 0) g_strlcpy(old_user, val, sizeof(old_user));
else if (strcmp(line, "pass") == 0) g_strlcpy(old_pass, val, sizeof(old_pass));
else if (strcmp(line, "activeProfile") == 0) { g_free(saved_active); saved_active = unesc(val); }
- else if (strcmp(line, "logging") == 0) g_chk_logging = atoi(val);
- else if (strcmp(line, "dns") == 0) g_chk_dns = atoi(val);
+ else if (strcmp(line, "logging") == 0) g_chk_logging = parse_long(val);
+ else if (strcmp(line, "dns") == 0) g_chk_dns = parse_long(val);
}
else if (section == 3 && cur) {
ProxyData *px = parse_proxy_line(line);
diff --git a/Linux/gui/gui_events.c b/Linux/gui/gui_events.c
new file mode 100644
index 0000000..80500e2
--- /dev/null
+++ b/Linux/gui/gui_events.c
@@ -0,0 +1,84 @@
+#include "gui_events.h"
+#include <pthread.h>
+#include <stdlib.h>
+#include <string.h>
+
+struct EventRing {
+ pthread_mutex_t lock;
+ char *slots;
+ uint16_t *lens;
+ size_t cap, slot_size, head, count;
+ uint64_t pushed, delivered, dropped, dropped_pending;
+};
+
+EventRing *event_ring_new(size_t capacity, size_t slot_size) {
+ if (capacity == 0 || slot_size < 2 || slot_size > UINT16_MAX) return NULL;
+ EventRing *r = calloc(1, sizeof(*r));
+ if (!r) return NULL;
+ r->slots = malloc(capacity * slot_size);
+ r->lens = calloc(capacity, sizeof(uint16_t));
+ if (!r->slots || !r->lens) {
+ free(r->slots);
+ free(r->lens);
+ free(r);
+ return NULL;
+ }
+ r->cap = capacity;
+ r->slot_size = slot_size;
+ pthread_mutex_init(&r->lock, NULL);
+ return r;
+}
+
+void event_ring_free(EventRing *r) {
+ if (!r) return;
+ pthread_mutex_destroy(&r->lock);
+ free(r->slots);
+ free(r->lens);
+ free(r);
+}
+
+void event_ring_push(EventRing *r, const char *text) {
+ size_t len = text ? strnlen(text, r->slot_size - 1) : 0;
+ pthread_mutex_lock(&r->lock);
+ if (r->count == r->cap) {
+ r->head = (r->head + 1) % r->cap;
+ r->count--;
+ r->dropped++;
+ r->dropped_pending++;
+ }
+ size_t idx = (r->head + r->count) % r->cap;
+ memcpy(r->slots + idx * r->slot_size, text, len);
+ r->lens[idx] = (uint16_t)len;
+ r->count++;
+ r->pushed++;
+ pthread_mutex_unlock(&r->lock);
+}
+
+size_t event_ring_drain(EventRing *r, char *out, size_t out_size, size_t max_events, uint64_t *dropped) {
+ size_t n = 0, used = 0;
+ pthread_mutex_lock(&r->lock);
+ while (n < max_events && r->count > 0) {
+ size_t len = r->lens[r->head];
+ if (used + len + 2 > out_size) break;
+ memcpy(out + used, r->slots + r->head * r->slot_size, len);
+ used += len;
+ out[used++] = '\n';
+ r->head = (r->head + 1) % r->cap;
+ r->count--;
+ r->delivered++;
+ n++;
+ }
+ if (dropped) *dropped = r->dropped_pending;
+ r->dropped_pending = 0;
+ pthread_mutex_unlock(&r->lock);
+ if (out_size) out[used] = '\0';
+ return n;
+}
+
+void event_ring_stats(EventRing *r, uint64_t *pushed, uint64_t *delivered, uint64_t *dropped) {
+ pthread_mutex_lock(&r->lock);
+ if (pushed) *pushed = r->pushed;
+ if (delivered) *delivered = r->delivered;
+ if (dropped) *dropped = r->dropped;
+ pthread_mutex_unlock(&r->lock);
+}
diff --git a/Linux/gui/gui_events.h b/Linux/gui/gui_events.h
new file mode 100644
index 0000000..65a1e74
--- /dev/null
+++ b/Linux/gui/gui_events.h
@@ -0,0 +1,21 @@
+#ifndef PROXYBRIDGE_GUI_EVENTS_H
+#define PROXYBRIDGE_GUI_EVENTS_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct EventRing EventRing;
+
+EventRing *event_ring_new(size_t capacity, size_t slot_size);
+void event_ring_free(EventRing *r);
+
+// any thread; text is truncated to slot_size - 1, the oldest event is dropped when full
+void event_ring_push(EventRing *r, const char *text);
+
+// moves events into out as "text\n" lines (NUL terminated), stops at max_events or when out is full.
+// *dropped receives the number of events dropped since the previous drain
+size_t event_ring_drain(EventRing *r, char *out, size_t out_size, size_t max_events, uint64_t *dropped);
+
+void event_ring_stats(EventRing *r, uint64_t *pushed, uint64_t *delivered, uint64_t *dropped);
+
+#endif
diff --git a/Linux/gui/gui_logs.c b/Linux/gui/gui_logs.c
index b4d8055..4771e26 100644
--- a/Linux/gui/gui_logs.c
+++ b/Linux/gui/gui_logs.c
@@ -1,17 +1,35 @@
#include "gui.h"
+#include "gui_events.h"
+#include <time.h>
-#define MAX_LINES 100
+#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
-static void filter_text_view(GtkTextBuffer *buffer, const char *text) {
- if (!buffer) return;
+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;
+static guint drain_source = 0;
- GtkTextIter start, end;
- gtk_text_buffer_get_bounds(buffer, &start, &end);
- gtk_text_buffer_remove_tag_by_name(buffer, "hidden", &start, &end);
- if (!text || !*text) return;
+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;
- char *lower_search = g_utf8_strdown(text, -1);
- GtkTextIter line_start = start;
while (!gtk_text_iter_is_end(&line_start)) {
GtkTextIter line_end = line_start;
if (!gtk_text_iter_ends_line(&line_end))
@@ -28,15 +46,20 @@ static void filter_text_view(GtkTextBuffer *buffer, const char *text) {
g_free(line_text);
gtk_text_iter_forward_line(&line_start);
}
- g_free(lower_search);
+}
+
+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) {
- filter_text_view(conn_buffer, gtk_entry_get_text(GTK_ENTRY(entry)));
+ set_filter(&conn_view, gtk_entry_get_text(GTK_ENTRY(entry)));
}
void on_search_log_changed(GtkSearchEntry *entry, gpointer user_data) {
- filter_text_view(log_buffer, gtk_entry_get_text(GTK_ENTRY(entry)));
+ set_filter(&log_view, gtk_entry_get_text(GTK_ENTRY(entry)));
}
void on_clear_conn_clicked(GtkButton *button, gpointer user_data) {
@@ -47,61 +70,114 @@ void on_clear_log_clicked(GtkButton *button, gpointer user_data) {
if (log_buffer) gtk_text_buffer_set_text(log_buffer, "", 0);
}
-// library strings are not guaranteed utf8
-static void append_line(GtkTextBuffer *buffer, char *line) {
- if (buffer) {
- if (!g_utf8_validate(line, -1, NULL)) {
- char *fixed = g_utf8_make_valid(line, -1);
- g_free(line);
- line = fixed;
- }
- GtkTextIter end;
- gtk_text_buffer_get_end_iter(buffer, &end);
- gtk_text_buffer_insert(buffer, &end, line, -1);
- trim_buffer_lines(buffer, MAX_LINES);
+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 excess = gtk_text_buffer_get_line_count(buffer) - 1 - 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);
}
- g_free(line);
}
-static gboolean update_log_gui(gpointer user_data) {
- char *time_str = get_current_time_str();
- append_line(log_buffer, g_strdup_printf("%s %s\n", time_str, (char *)user_data));
- g_free(time_str);
- g_free(user_data);
- return FALSE;
+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 update_connection_gui_append(gpointer user_data) {
- ConnectionData *d = (ConnectionData *)user_data;
- append_line(conn_buffer, g_strdup_printf("%s %s (PID:%u) -> %s:%u via %s\n",
- d->timestamp, d->process_name, d->pid, d->dest_ip, d->dest_port, d->proxy_info));
- g_free(d->process_name);
- g_free(d->dest_ip);
- g_free(d->proxy_info);
- g_free(d->timestamp);
- g_free(d);
- return FALSE;
+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;
+}
+
+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) {
- g_idle_add(update_log_gui, g_strdup(message ? 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);
- char *msg = g_strdup_vprintf(format, args);
+ g_vsnprintf(msg, sizeof(msg), format, args);
va_end(args);
- g_idle_add(update_log_gui, msg);
+ lib_log_callback(msg);
}
void lib_connection_callback(const char *process_name, uint32_t pid, const char *dest_ip, uint16_t dest_port, const char *proxy_info) {
- ConnectionData *data = g_malloc0(sizeof(ConnectionData));
- data->process_name = g_strdup(process_name ? process_name : "");
- data->pid = pid;
- data->dest_ip = g_strdup(dest_ip ? dest_ip : "");
- data->dest_port = dest_port;
- data->proxy_info = g_strdup(proxy_info ? proxy_info : "");
- data->timestamp = get_current_time_str();
- g_idle_add(update_connection_gui_append, data);
+ push_line(&conn_view, "%s (PID:%u) -> %s:%u via %s", process_name ? process_name : "", pid,
+ dest_ip ? dest_ip : "", dest_port, proxy_info ? proxy_info : "");
}
diff --git a/Linux/gui/gui_settings.c b/Linux/gui/gui_settings.c
index 22b11cb..a97d4f4 100644
--- a/Linux/gui/gui_settings.c
+++ b/Linux/gui/gui_settings.c
@@ -76,7 +76,7 @@ static bool confirm(GtkWindow *parent, const char *format, ...) {
static bool port_text_valid(const char *text, int *port_out) {
size_t n = strlen(text);
if (n == 0 || n > 5 || strspn(text, "0123456789") != n) return false;
- int p = atoi(text);
+ int p = (int)parse_long(text);
if (p < 1 || p > 65535) return false;
*port_out = p;
return true;
@@ -123,7 +123,7 @@ static void on_start_test_clicked(GtkWidget *widget, gpointer data) {
}
const char *t_host = gtk_entry_get_text(GTK_ENTRY(info->test_host));
- int t_port = (int)safe_strtol(gtk_entry_get_text(GTK_ENTRY(info->test_port)));
+ int t_port = (int)parse_long(gtk_entry_get_text(GTK_ENTRY(info->test_port)));
if (t_port <= 0 || t_port > 65535) t_port = 80;
gtk_text_buffer_set_text(info->output_buffer, "Testing connection... Please wait...", -1);
diff --git a/Linux/gui/gui_utils.c b/Linux/gui/gui_utils.c
index a8c50b5..1331496 100644
--- a/Linux/gui/gui_utils.c
+++ b/Linux/gui/gui_utils.c
@@ -1,9 +1,5 @@
#include "gui.h"
-long safe_strtol(const char *nptr) {
- return nptr ? strtol(nptr, NULL, 10) : 0;
-}
-
void show_message(GtkWindow *parent, GtkMessageType type, const char *format, ...) {
va_list args;
va_start(args, format);
@@ -17,23 +13,6 @@ void show_message(GtkWindow *parent, GtkMessageType type, const char *format, ..
g_free(msg);
}
-void trim_buffer_lines(GtkTextBuffer *buffer, int max_lines) {
- if (gtk_text_buffer_get_line_count(buffer) > max_lines) {
- GtkTextIter start, next;
- gtk_text_buffer_get_start_iter(buffer, &start);
- next = start;
- gtk_text_iter_forward_line(&next);
- gtk_text_buffer_delete(buffer, &start, &next);
- }
-}
-
-char *get_current_time_str() {
- GDateTime *now = g_date_time_new_now_local();
- char *s = g_date_time_format(now, "[%H:%M:%S]");
- g_date_time_unref(now);
- return s;
-}
-
GtkWidget *combo_new(const char *first, ...) {
GtkWidget *combo = gtk_combo_box_text_new();
va_list args;
diff --git a/Linux/gui/main.c b/Linux/gui/main.c
index f2b8cc8..0cfc867 100644
--- a/Linux/gui/main.c
+++ b/Linux/gui/main.c
@@ -8,8 +8,6 @@ GtkTextBuffer *log_buffer;
GtkWidget *status_bar;
guint status_context_id;
-static bool g_engine_running = false;
-
GList *g_rules_list = NULL;
bool g_chk_logging = true;
bool g_chk_dns = true;
@@ -211,7 +209,42 @@ static void on_about(GtkWidget *widget, gpointer data) {
gtk_widget_destroy(dialog);
}
-// signal handlers run in the main loop (g_unix_signal_add), so no library calls from a real signal context
+typedef enum { ENGINE_STOPPED, ENGINE_STARTING, ENGINE_RUNNING, ENGINE_STOPPING } EngineState;
+
+static EngineState engine_state = ENGINE_STOPPED;
+static GThread *engine_thread = NULL;
+static struct { bool start, ok; } engine_job;
+static GtkWidget *status_info;
+static GtkWidget *start_item, *stop_item;
+static guint status_source = 0;
+static uint64_t last_conn_count = 0;
+static unsigned conn_rate = 0;
+
+static void update_status_info() {
+ static const char *names[] = {"Stopped", "Starting...", "Running", "Stopping..."};
+ char *text = g_strdup_printf("Engine: %s | Profile: %s | Proxies: %u | Rules: %u | %u conn/s",
+ names[engine_state], g_active_profile, g_list_length(g_proxies_list),
+ g_list_length(g_rules_list), conn_rate);
+ gtk_label_set_text(GTK_LABEL(status_info), text);
+ g_free(text);
+ gtk_widget_set_sensitive(start_item, engine_state == ENGINE_STOPPED);
+ gtk_widget_set_sensitive(stop_item, engine_state == ENGINE_RUNNING);
+}
+
+static void set_engine_state(EngineState state) {
+ engine_state = state;
+ update_status_info();
+}
+
+static gboolean status_tick(gpointer data) {
+ uint64_t now = gui_conn_event_count();
+ conn_rate = (unsigned)(now - last_conn_count);
+ last_conn_count = now;
+ update_status_info();
+ return G_SOURCE_CONTINUE;
+}
+
+// runs in the main loop (g_unix_signal_add), so no library calls from a real signal context
static gboolean on_unix_signal(gpointer data) {
fprintf(stderr, "\nSignal received. Stopping ProxyBridge...\n");
gtk_main_quit();
@@ -219,28 +252,63 @@ static gboolean on_unix_signal(gpointer data) {
}
static void on_window_destroy(GtkWidget *widget, gpointer data) {
- gtk_main_quit(); // engine is stopped once after gtk_main returns
+ if (status_source) g_source_remove(status_source);
+ status_source = 0;
+ gui_logs_stop_timers();
+ gtk_main_quit();
}
-static bool start_engine() {
- if (g_engine_running) return true;
- if (ProxyBridge_Start()) {
- g_engine_running = true;
- char *msg = g_strdup_printf("ProxyBridge Service Started (eBPF). Active profile: %s", g_active_profile);
- gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, msg);
- g_free(msg);
- return true;
+static gboolean engine_job_done(gpointer data) {
+ g_thread_join(engine_thread);
+ engine_thread = NULL;
+ if (!engine_job.start) {
+ set_engine_state(ENGINE_STOPPED);
+ gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, "ProxyBridge Service Stopped.");
+ } else if (engine_job.ok) {
+ set_engine_state(ENGINE_RUNNING);
+ gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, "ProxyBridge Service Started (eBPF).");
+ } else {
+ set_engine_state(ENGINE_STOPPED);
+ gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, "Failed to start ProxyBridge engine. See the Activity Logs tab.");
+ show_message(GTK_WINDOW(window), GTK_MESSAGE_ERROR,
+ "Failed to start the ProxyBridge engine.\n\n"
+ "Open the \"Activity Logs\" tab to see the reason.\n"
+ "The eBPF backend needs root, a kernel >= 5.11 with BTF and cgroup v2.");
}
- gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, "Failed to start ProxyBridge engine. See the Activity Logs tab.");
- show_message(GTK_WINDOW(window), GTK_MESSAGE_ERROR,
- "Failed to start the ProxyBridge engine.\n\n"
- "Open the \"Activity Logs\" tab to see the reason.\n"
- "The eBPF backend needs root, a kernel >= 5.11 with BTF and cgroup v2.");
- return false;
+ return G_SOURCE_REMOVE;
+}
+
+static gpointer engine_job_thread(gpointer data) {
+ engine_job.ok = engine_job.start ? ProxyBridge_Start() : ProxyBridge_Stop();
+ g_idle_add(engine_job_done, NULL);
+ return NULL;
+}
+
+// Start/Stop can take a second (BPF load, /proc scan), keep them off the UI thread
+static void engine_request(bool start) {
+ if (engine_thread || engine_state != (start ? ENGINE_STOPPED : ENGINE_RUNNING)) return;
+ engine_job.start = start;
+ set_engine_state(start ? ENGINE_STARTING : ENGINE_STOPPING);
+ engine_thread = g_thread_new("engine", engine_job_thread, NULL);
}
static void on_start_engine(GtkWidget *widget, gpointer data) {
- start_engine();
+ engine_request(true);
+}
+
+static void on_stop_engine(GtkWidget *widget, gpointer data) {
+ engine_request(false);
+}
+
+// exit path: wait for a pending job, then stop synchronously
+static void shutdown_engine() {
+ if (engine_thread) {
+ g_thread_join(engine_thread);
+ engine_thread = NULL;
+ engine_state = engine_job.start && engine_job.ok ? ENGINE_RUNNING : ENGINE_STOPPED;
+ }
+ if (engine_state == ENGINE_RUNNING) ProxyBridge_Stop();
+ engine_state = ENGINE_STOPPED;
}
static GtkWidget *add_menu_item(GtkWidget *menu, const char *label, GCallback cb) {
@@ -269,7 +337,7 @@ static GtkWidget *add_submenu(GtkWidget *menubar, const char *label) {
return menu;
}
-static GtkTextBuffer *add_text_tab(GtkWidget *notebook, const char *title, const char *placeholder, GCallback on_search, GCallback on_clear) {
+static GtkTextBuffer *add_text_tab(GtkWidget *notebook, const char *title, const char *placeholder, GCallback on_search, GCallback on_clear, GCallback on_pause) {
GtkWidget *tab = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_set_border_width(GTK_CONTAINER(tab), 5);
GtkWidget *toolbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
@@ -280,6 +348,11 @@ static GtkTextBuffer *add_text_tab(GtkWidget *notebook, const char *title, const
g_signal_connect(clear_btn, "clicked", on_clear, NULL);
gtk_box_pack_start(GTK_BOX(toolbar), search, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(toolbar), clear_btn, FALSE, FALSE, 0);
+ if (on_pause) {
+ GtkWidget *pause_btn = gtk_toggle_button_new_with_label("Pause");
+ g_signal_connect(pause_btn, "toggled", on_pause, NULL);
+ gtk_box_pack_start(GTK_BOX(toolbar), pause_btn, FALSE, FALSE, 0);
+ }
gtk_box_pack_start(GTK_BOX(tab), toolbar, FALSE, FALSE, 0);
GtkWidget *view = gtk_text_view_new();
@@ -326,7 +399,8 @@ int main(int argc, char *argv[]) {
add_check_item(proxy_menu, "Enable Traffic Logging", g_chk_logging, G_CALLBACK(on_log_traffic_toggled));
add_check_item(proxy_menu, "DNS via Proxy", g_chk_dns, G_CALLBACK(on_dns_proxy_toggled));
add_separator(proxy_menu);
- add_menu_item(proxy_menu, "Start Engine", G_CALLBACK(on_start_engine));
+ start_item = add_menu_item(proxy_menu, "Start Engine", G_CALLBACK(on_start_engine));
+ stop_item = add_menu_item(proxy_menu, "Stop Engine", G_CALLBACK(on_stop_engine));
add_menu_item(proxy_menu, "Exit", G_CALLBACK(on_window_destroy));
GtkWidget *about_menu = add_submenu(menubar, "About");
add_menu_item(about_menu, "About", G_CALLBACK(on_about));
@@ -335,12 +409,18 @@ int main(int argc, char *argv[]) {
GtkWidget *notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
- conn_buffer = add_text_tab(notebook, "Connections", "Search connections...", G_CALLBACK(on_search_conn_changed), G_CALLBACK(on_clear_conn_clicked));
- log_buffer = add_text_tab(notebook, "Activity Logs", "Search logs...", G_CALLBACK(on_search_log_changed), G_CALLBACK(on_clear_log_clicked));
+ conn_buffer = add_text_tab(notebook, "Connections", "Search connections...", G_CALLBACK(on_search_conn_changed), G_CALLBACK(on_clear_conn_clicked), G_CALLBACK(on_pause_conn_toggled));
+ log_buffer = add_text_tab(notebook, "Activity Logs", "Search logs...", G_CALLBACK(on_search_log_changed), G_CALLBACK(on_clear_log_clicked), NULL);
+ GtkWidget *status_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);
status_bar = gtk_statusbar_new();
status_context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar), "Status");
- gtk_box_pack_start(GTK_BOX(vbox), status_bar, FALSE, FALSE, 0);
+ status_info = gtk_label_new("");
+ gtk_widget_set_margin_end(status_info, 10);
+ gtk_box_pack_start(GTK_BOX(status_box), status_bar, TRUE, TRUE, 0);
+ gtk_box_pack_end(GTK_BOX(status_box), status_info, FALSE, FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), status_box, FALSE, FALSE, 0);
+ gui_logs_init();
ProxyBridge_SetLogCallback(lib_log_callback);
ProxyBridge_SetConnectionCallback(lib_connection_callback);
@@ -353,10 +433,13 @@ int main(int argc, char *argv[]) {
g_unix_signal_add(SIGTERM, on_unix_signal, NULL);
gtk_widget_show_all(window);
- start_engine();
+ update_status_info();
+ status_source = g_timeout_add_seconds(1, status_tick, NULL);
+ engine_request(true);
gtk_main();
- if (g_engine_running) ProxyBridge_Stop();
+ shutdown_engine();
+ gui_logs_free();
config_free_all();
return 0;
}
diff --git a/Linux/gui/tests/events_test.c b/Linux/gui/tests/events_test.c
new file mode 100644
index 0000000..f3736dc
--- /dev/null
+++ b/Linux/gui/tests/events_test.c
@@ -0,0 +1,106 @@
+// event ring: ordering, drop accounting, multi-producer stress (run under ASan and TSan too)
+#include "gui_events.h"
+#include <pthread.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#define PRODUCERS 8
+#define PER_PRODUCER 200000
+
+static int failures = 0;
+#define CHECK(c) do { if (!(c)) { printf("FAIL line %d: %s\n", __LINE__, #c); failures++; } } while (0)
+
+static EventRing *ring;
+
+static void *producer(void *arg) {
+ int id = (int)(intptr_t)arg;
+ char buf[64];
+ for (int i = 0; i < PER_PRODUCER; i++) {
+ snprintf(buf, sizeof(buf), "%d:%d", id, i);
+ event_ring_push(ring, buf);
+ }
+ return NULL;
+}
+
+// "id:seq" without strto*
+static int parse_event(const char *s, int *id, long *seq) {
+ int i = 0;
+ *id = 0;
+ for (; s[i] >= '0' && s[i] <= '9'; i++) *id = *id * 10 + (s[i] - '0');
+ if (s[i++] != ':') return 0;
+ *seq = 0;
+ for (; s[i] >= '0' && s[i] <= '9'; i++) *seq = *seq * 10 + (s[i] - '0');
+ return s[i] == '\n' || s[i] == '\0';
+}
+
+int main() {
+ // fifo + drop accounting on a tiny ring
+ EventRing *small = event_ring_new(4, 16);
+ char out[256];
+ uint64_t dropped = 0;
+ char buf[16];
+ for (int i = 0; i < 10; i++) { snprintf(buf, sizeof(buf), "e%d", i); event_ring_push(small, buf); }
+ CHECK(event_ring_drain(small, out, sizeof(out), 100, &dropped) == 4);
+ CHECK(dropped == 6 && strcmp(out, "e6\ne7\ne8\ne9\n") == 0);
+ CHECK(event_ring_drain(small, out, sizeof(out), 100, &dropped) == 0 && dropped == 0 && out[0] == '\0');
+ event_ring_push(small, "0123456789abcdefXYZ");
+ CHECK(event_ring_drain(small, out, sizeof(out), 100, &dropped) == 1 && strcmp(out, "0123456789abcde\n") == 0);
+ event_ring_push(small, "a"); event_ring_push(small, "b"); event_ring_push(small, "c");
+ CHECK(event_ring_drain(small, out, 6, 100, &dropped) == 2 && strcmp(out, "a\nb\n") == 0);
+ CHECK(event_ring_drain(small, out, sizeof(out), 1, &dropped) == 1 && strcmp(out, "c\n") == 0);
+ event_ring_free(small);
+ CHECK(event_ring_new(0, 8) == NULL);
+
+ // multi producer stress with a slow consumer
+ ring = event_ring_new(4096, 512);
+ pthread_t th[PRODUCERS];
+ for (long i = 0; i < PRODUCERS; i++) pthread_create(&th[i], NULL, producer, (void *)(intptr_t)i);
+
+ static char big[256 * 1024];
+ long last[PRODUCERS];
+ for (int i = 0; i < PRODUCERS; i++) last[i] = -1;
+ uint64_t delivered = 0, reported_dropped = 0;
+ int done = 0;
+ for (int round = 0; ; round++) {
+ uint64_t d = 0;
+ size_t n = event_ring_drain(ring, big, sizeof(big), 2000, &d);
+ reported_dropped += d;
+ delivered += n;
+ size_t seen = 0;
+ for (char *p = big; *p; ) {
+ char *nl = strchr(p, '\n');
+ int id = 0; long seq = 0;
+ CHECK(nl && parse_event(p, &id, &seq) && id >= 0 && id < PRODUCERS);
+ if (!nl || id < 0 || id >= PRODUCERS) break;
+ CHECK(seq > last[id]);
+ last[id] = seq;
+ seen++;
+ p = nl + 1;
+ }
+ CHECK(seen == n);
+ if (round % 4 == 0) usleep(1000);
+ if (!done) {
+ done = 1;
+ uint64_t pushed;
+ event_ring_stats(ring, &pushed, NULL, NULL);
+ done = pushed == (uint64_t)PRODUCERS * PER_PRODUCER;
+ } else if (n == 0) {
+ break;
+ }
+ }
+ for (int i = 0; i < PRODUCERS; i++) pthread_join(th[i], NULL);
+
+ uint64_t pushed, del, drop;
+ event_ring_stats(ring, &pushed, &del, &drop);
+ printf("pushed=%llu delivered=%llu dropped=%llu\n", (unsigned long long)pushed, (unsigned long long)del, (unsigned long long)drop);
+ CHECK(pushed == (uint64_t)PRODUCERS * PER_PRODUCER);
+ CHECK(pushed == del + drop);
+ CHECK(del == delivered);
+ CHECK(drop == reported_dropped);
+ event_ring_free(ring);
+
+ if (!failures) printf("events_test: all passed\n");
+ return failures ? 1 : 0;
+}
diff --git a/Linux/gui/tests/run_tests.sh b/Linux/gui/tests/run_tests.sh
index a950ef9..c09b9cf 100755
--- a/Linux/gui/tests/run_tests.sh
+++ b/Linux/gui/tests/run_tests.sh
@@ -11,3 +11,9 @@ gcc -O1 -I../src -I. -D_GNU_SOURCE $(pkg-config --cflags gtk+-3.0) tests/config_
"$OUT/config_plain"
ASAN_OPTIONS=detect_leaks=1 "$OUT/config_test"
ASAN_OPTIONS=detect_leaks=1 "$OUT/json_test"
+gcc -O2 -Wall -Wextra -I. tests/events_test.c gui_events.c -o "$OUT/events_plain" -pthread
+time "$OUT/events_plain"
+gcc -g -Wall -Wextra -fsanitize=address,undefined -I. tests/events_test.c gui_events.c -o "$OUT/events_asan" -pthread
+ASAN_OPTIONS=detect_leaks=1 "$OUT/events_asan"
+gcc -g -O1 -Wall -Wextra -fsanitize=thread -I. tests/events_test.c gui_events.c -o "$OUT/events_tsan" -pthread
+setarch "$(uname -m)" -R "$OUT/events_tsan"