Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
added inital GUI
anof-cyber9b729f9bfd8e
diff --git a/Linux/build.sh b/Linux/build.shindex 868b8b4..ed07efc 100755--- a/Linux/build.sh+++ b/Linux/build.sh@@ -44,9 +44,27 @@ fiecho ""# Move binaries to output+echo "=== Building GUI ==="+cd "$SCRIPT_DIR"+rm -f ProxyBridgeGUI+if pkg-config --exists gtk+-3.0; then+ gcc -Wall -Wno-unused-parameter -O3 -Isrc -fstack-protector-strong -D_FORTIFY_SOURCE=2 -fPIE -Wformat -Wformat-security -Werror=format-security -fno-strict-overflow -fno-delete-null-pointer-checks -fwrapv -c gui/main.c -o gui_main.o $(pkg-config --cflags gtk+-3.0)+ gcc -o ProxyBridgeGUI gui_main.o -Lsrc -pie -Wl,-z,relro,-z,now -Wl,-z,noexecstack -s -Wl,-rpath,'$ORIGIN/.' -lproxybridge -lpthread $(pkg-config --libs gtk+-3.0) -export-dynamic+ rm -f gui_main.o+ echo "✓ GUI build successful"+else+ echo "⚠ GTK3 not found. Skipping GUI build."+ echo " Install with: sudo apt install libgtk-3-dev (Debian/Ubuntu/Mint)"+ echo " sudo dnf install gtk3-devel (Fedora)"+fi++echo ""echo "Moving binaries to output directory..."mv "$SCRIPT_DIR/src/libproxybridge.so" "$OUTPUT_DIR/"-mv ProxyBridge "$OUTPUT_DIR/"+mv "$SCRIPT_DIR/cli/ProxyBridge" "$OUTPUT_DIR/"+if [ -f ProxyBridgeGUI ]; then+ mv ProxyBridgeGUI "$OUTPUT_DIR/"+fiecho "✓ Binaries moved to output"echo ""diff --git a/Linux/gui/main.c b/Linux/gui/main.cindex 399f27b..afac9fa 100644--- a/Linux/gui/main.c+++ b/Linux/gui/main.c@@ -1,152 +1,614 @@-#include <stdio.h>-#include <stdlib.h>-#include <dlfcn.h>#include <gtk/gtk.h>-#include <unistd.h>-#include "proxybridge.h"-#include "main_window.h"--// Library handle-static void *lib_handle = NULL;--// Function pointers-uint32_t (*ProxyBridge_AddRule)(const char *, const char *, const char *, RuleProtocol, RuleAction) = NULL;-bool (*ProxyBridge_EnableRule)(uint32_t) = NULL;-bool (*ProxyBridge_DisableRule)(uint32_t) = NULL;-bool (*ProxyBridge_DeleteRule)(uint32_t) = NULL;-bool (*ProxyBridge_EditRule)(uint32_t, const char *, const char *, const char *, RuleProtocol, RuleAction) = NULL;-bool (*ProxyBridge_SetProxyConfig)(ProxyType, const char *, uint16_t, const char *, const char *) = NULL;-void (*ProxyBridge_SetLogCallback)(LogCallback) = NULL;-void (*ProxyBridge_SetConnectionCallback)(ConnectionCallback) = NULL;-void (*ProxyBridge_SetTrafficLoggingEnabled)(bool) = NULL;-void (*ProxyBridge_SetDnsViaProxy)(bool) = NULL;-bool (*ProxyBridge_Start)(void) = NULL;-bool (*ProxyBridge_Stop)(void) = NULL;--// Callback handlers-static void log_callback(const char *message) {- add_activity_log(message);-}--static void connection_callback(const char *processName, uint32_t pid,- const char *destIp, uint16_t destPort,- const char *proxyInfo) {- char msg[512];- snprintf(msg, sizeof(msg), "%s (PID %u) → %s:%u via %s",- processName, pid, destIp, destPort, proxyInfo);- add_connection_log(msg);-}--bool load_proxybridge_library(void)-{- lib_handle = dlopen("libproxybridge.so", RTLD_LAZY);- if (!lib_handle) {- lib_handle = dlopen("/usr/local/lib/libproxybridge.so", RTLD_LAZY);- }-- if (!lib_handle) {- fprintf(stderr, "Failed to load libproxybridge.so: %s\n", dlerror());- return false;+#include <stdlib.h>+#include <stdio.h>+#include <string.h>+#include <time.h>+#include <pthread.h>+#include <signal.h>+#include "ProxyBridge.h"++// --- Global UI Widgets ---+static GtkWidget *window;+static GtkTextView *conn_view;+static GtkTextBuffer *conn_buffer;+static GtkTextView *log_view;+static GtkTextBuffer *log_buffer;+static GtkWidget *status_bar;+static guint status_context_id;++// --- Data Structures for thread-safe UI updates ---+typedef struct {+ char *process_name;+ uint32_t pid;+ char *dest_ip;+ uint16_t dest_port;+ char *proxy_info;+ char *timestamp;+} ConnectionData;++typedef struct {+ char *message;+} LogData;++typedef struct {+ GtkWidget *dialog;+ GtkWidget *ip_entry;+ GtkWidget *port_entry;+ GtkWidget *type_combo;+ GtkWidget *user_entry;+ GtkWidget *pass_entry;+ GtkWidget *test_host;+ GtkWidget *test_port;+ GtkTextBuffer *output_buffer;+ GtkWidget *test_btn;+} ConfigInfo;++// --- Config Globals (Defaults) ---+static char g_proxy_ip[256] = "";+static uint16_t g_proxy_port = 0;+static ProxyType g_proxy_type = PROXY_TYPE_SOCKS5;+static char g_proxy_user[256] = "";+static char g_proxy_pass[256] = "";++// --- Helper Functions ---++static char* get_current_time_str() {+ time_t rawtime;+ struct tm *timeinfo;+ char *buffer = malloc(32);+ time(&rawtime);+ timeinfo = localtime(&rawtime);+ strftime(buffer, 32, "[%H:%M:%S]", timeinfo);+ return buffer;+}++static void free_connection_data(ConnectionData *data) {+ if (data) {+ free(data->process_name);+ free(data->dest_ip);+ free(data->proxy_info);+ free(data->timestamp);+ free(data);}+}++// --- GTK Callbacks (Main Thread) ---++// Filter Function for TextView+static void filter_text_view(GtkTextBuffer *buffer, const char *text) {+ if (!buffer) return;- #define LOAD_SYMBOL(name) \- name = dlsym(lib_handle, #name); \- if (!name) { \- fprintf(stderr, "Failed to load symbol %s: %s\n", #name, dlerror()); \- dlclose(lib_handle); \- return false; \+ GtkTextIter start, end;+ gtk_text_buffer_get_bounds(buffer, &start, &end);+ gtk_text_buffer_remove_tag_by_name(buffer, "hidden", &start, &end);++ if (!text || strlen(text) == 0) return;++ 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))+ gtk_text_iter_forward_to_line_end(&line_end);++ char *line_text = gtk_text_buffer_get_text(buffer, &line_start, &line_end, FALSE);++ // Case-insensitive search+ char *lower_line = g_utf8_strdown(line_text, -1);+ char *lower_search = g_utf8_strdown(text, -1);++ if (!strstr(lower_line, lower_search)) {+ GtkTextIter next_line = line_end;+ gtk_text_iter_forward_char(&next_line); // include newline+ gtk_text_buffer_apply_tag_by_name(buffer, "hidden", &line_start, &next_line);}++ g_free(lower_line);+ g_free(lower_search);+ g_free(line_text);++ gtk_text_iter_forward_line(&line_start);+ }+}++static void on_search_conn_changed(GtkSearchEntry *entry, gpointer user_data) {+ const char *text = gtk_entry_get_text(GTK_ENTRY(entry));+ filter_text_view(conn_buffer, text);+}++static void on_search_log_changed(GtkSearchEntry *entry, gpointer user_data) {+ const char *text = gtk_entry_get_text(GTK_ENTRY(entry));+ filter_text_view(log_buffer, text);+}++static void on_clear_conn_clicked(GtkButton *button, gpointer user_data) {+ if (conn_buffer) gtk_text_buffer_set_text(conn_buffer, "", 0);+}++static void on_clear_log_clicked(GtkButton *button, gpointer user_data) {+ if (log_buffer) gtk_text_buffer_set_text(log_buffer, "", 0);+}++// Thread-safe idle callback for Log+static gboolean update_log_gui(gpointer user_data) {+ LogData *data = (LogData *)user_data;+ if (!data) return FALSE;++ GtkTextIter end;+ gtk_text_buffer_get_end_iter(log_buffer, &end);- LOAD_SYMBOL(ProxyBridge_AddRule);- LOAD_SYMBOL(ProxyBridge_EnableRule);- LOAD_SYMBOL(ProxyBridge_DisableRule);- LOAD_SYMBOL(ProxyBridge_DeleteRule);- LOAD_SYMBOL(ProxyBridge_EditRule);- LOAD_SYMBOL(ProxyBridge_SetProxyConfig);- LOAD_SYMBOL(ProxyBridge_SetLogCallback);- LOAD_SYMBOL(ProxyBridge_SetConnectionCallback);- LOAD_SYMBOL(ProxyBridge_SetTrafficLoggingEnabled);- LOAD_SYMBOL(ProxyBridge_SetDnsViaProxy);- LOAD_SYMBOL(ProxyBridge_Start);- LOAD_SYMBOL(ProxyBridge_Stop);-- #undef LOAD_SYMBOL-- // Set up callbacks- ProxyBridge_SetLogCallback(log_callback);- ProxyBridge_SetConnectionCallback(connection_callback);-- return true;-}--void unload_proxybridge_library(void)-{- if (lib_handle) {- // Stop proxy before unloading (critical cleanup)- if (ProxyBridge_Stop) {- ProxyBridge_Stop();- }- dlclose(lib_handle);- lib_handle = NULL;+ char full_msg[1200];+ snprintf(full_msg, sizeof(full_msg), "%s %s\n", get_current_time_str(), data->message);+ gtk_text_buffer_insert(log_buffer, &end, full_msg, -1);++ // Limit to 100 lines to prevent memory growth+ while (gtk_text_buffer_get_line_count(log_buffer) > 100) {+ GtkTextIter start, next;+ gtk_text_buffer_get_start_iter(log_buffer, &start);+ next = start;+ gtk_text_iter_forward_line(&next);+ gtk_text_buffer_delete(log_buffer, &start, &next);}++ free(data->message);+ free(data);+ return FALSE; // Remove source}-static gboolean check_root_privileges(void)-{- if (geteuid() != 0) {- GtkWidget *dialog = gtk_message_dialog_new(- NULL,- GTK_DIALOG_MODAL,- GTK_MESSAGE_ERROR,- GTK_BUTTONS_OK,- "ProxyBridge requires root privileges"- );- gtk_message_dialog_format_secondary_text(- GTK_MESSAGE_DIALOG(dialog),- "Please run with: sudo ./ProxyBridge-GUI"- );- gtk_dialog_run(GTK_DIALOG(dialog));- gtk_widget_destroy(dialog);- return FALSE;+// Thread-safe idle callback for Connection+static gboolean update_connection_gui_append(gpointer user_data) {+ ConnectionData *data = (ConnectionData *)user_data;+ if (!data) return FALSE;++ if (conn_buffer) {+ GtkTextIter end;+ gtk_text_buffer_get_end_iter(conn_buffer, &end);++ char line_buffer[1024];+ // Format: [Time] Process (PID) -> Target via ProxyInfo+ snprintf(line_buffer, sizeof(line_buffer), "%s %s (PID:%u) -> %s:%u via %s\n",+ data->timestamp, data->process_name, data->pid, data->dest_ip, data->dest_port, data->proxy_info);++ gtk_text_buffer_insert(conn_buffer, &end, line_buffer, -1);++ // Limit to 100 lines to prevent memory growth+ while (gtk_text_buffer_get_line_count(conn_buffer) > 100) {+ GtkTextIter start, next;+ gtk_text_buffer_get_start_iter(conn_buffer, &start);+ next = start;+ gtk_text_iter_forward_line(&next);+ gtk_text_buffer_delete(conn_buffer, &start, &next);+ }}- return TRUE;++ free_connection_data(data);+ return FALSE;}-int main(int argc, char *argv[])-{- gtk_init(&argc, &argv);++// --- Library Callbacks ---++static void lib_log_callback(const char *message) {+ LogData *data = malloc(sizeof(LogData));+ data->message = strdup(message);+ g_idle_add(update_log_gui, data);+}++static 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 = malloc(sizeof(ConnectionData));+ data->process_name = strdup(process_name);+ data->pid = pid;+ data->dest_ip = strdup(dest_ip);+ data->dest_port = dest_port;+ data->proxy_info = strdup(proxy_info);+ data->timestamp = get_current_time_str();+ g_idle_add(update_connection_gui_append, data);+}++// --- Settings Dialog ---++struct TestRunnerData {+ char *host;+ uint16_t port;+ ConfigInfo *ui_info;+};++// Better thread communication+typedef struct {+ char *result_text;+ GtkTextBuffer *buffer;+ GtkWidget *btn;+} TestResultData;++static gboolean on_test_done(gpointer user_data) {+ TestResultData *data = (TestResultData *)user_data;+ gtk_text_buffer_set_text(data->buffer, data->result_text, -1);+ gtk_widget_set_sensitive(data->btn, TRUE);- // Check root privileges- if (!check_root_privileges()) {- return 1;+ free(data->result_text);+ free(data);+ return FALSE;+}++static gpointer run_test_thread(gpointer user_data) {+ struct TestRunnerData *req = (struct TestRunnerData *)user_data;++ char *buffer = malloc(4096);+ memset(buffer, 0, 4096);++ // Check callback if needed, but TestConnection usually returns result in buffer+ ProxyBridge_TestConnection(req->host, req->port, buffer, 4096);++ TestResultData *res = malloc(sizeof(TestResultData));+ res->result_text = buffer;+ res->buffer = req->ui_info->output_buffer;+ res->btn = req->ui_info->test_btn;++ g_idle_add(on_test_done, res);++ free(req->host);+ free(req);+ return NULL;+}++static void on_start_test_clicked(GtkWidget *widget, gpointer data) {+ ConfigInfo *info = (ConfigInfo *)data;++ // 1. Validate Proxy Config+ const char *ip_text = gtk_entry_get_text(GTK_ENTRY(info->ip_entry));+ const char *port_text = gtk_entry_get_text(GTK_ENTRY(info->port_entry));++ if (!ip_text || strlen(ip_text) == 0 || strspn(port_text, "0123456789") != strlen(port_text) || strlen(port_text) == 0) {+ gtk_text_buffer_set_text(info->output_buffer, "Error: Invalid Proxy IP or Port.", -1);+ return;}- // Load ProxyBridge library- if (!load_proxybridge_library()) {- GtkWidget *dialog = gtk_message_dialog_new(- NULL,- GTK_DIALOG_MODAL,- GTK_MESSAGE_ERROR,- GTK_BUTTONS_OK,- "Failed to load ProxyBridge library"- );- gtk_message_dialog_format_secondary_text(- GTK_MESSAGE_DIALOG(dialog),- "Make sure libproxybridge.so is in /usr/local/lib/"- );+ // 2. Set Proxy Config+ ProxyType type = (gtk_combo_box_get_active(GTK_COMBO_BOX(info->type_combo)) == 0) ? PROXY_TYPE_HTTP : PROXY_TYPE_SOCKS5;+ int port = atoi(port_text);+ const char *user = gtk_entry_get_text(GTK_ENTRY(info->user_entry));+ const char *pass = gtk_entry_get_text(GTK_ENTRY(info->pass_entry));++ ProxyBridge_SetProxyConfig(type, ip_text, port, user, pass);++ // 3. Get Test Target+ const char *t_host = gtk_entry_get_text(GTK_ENTRY(info->test_host));+ const char *t_port_s = gtk_entry_get_text(GTK_ENTRY(info->test_port));++ if (!t_host || strlen(t_host) == 0) t_host = "google.com";+ int t_port = atoi(t_port_s);+ if (t_port <= 0) t_port = 80;++ // 4. Update UI+ gtk_text_buffer_set_text(info->output_buffer, "Testing connection... Please wait...", -1);+ gtk_widget_set_sensitive(info->test_btn, FALSE);++ // 5. Run Thread+ struct TestRunnerData *req = malloc(sizeof(struct TestRunnerData));+ req->host = strdup(t_host);+ req->port = t_port;+ req->ui_info = info;++ GThread *thread = g_thread_new("test_conn", run_test_thread, req);+ g_thread_unref(thread);+}++static void on_proxy_configure(GtkWidget *widget, gpointer data) {+ ConfigInfo info; // We will pass address to signals, careful about scope if dialog is non-modal? No, dialog_run is blocking.+ // Wait, on_start_test_clicked will be called while dialog_run is blocking main loop? Yes.+ // But info needs to persist. Stack allocation is fine because we don't leave this function until dialog closes.++ GtkWidget *content_area;+ GtkWidget *grid;+ // Removed local declarations that are now in struct ConfigInfo++ info.dialog = gtk_dialog_new_with_buttons("Proxy Settings",+ GTK_WINDOW(window),+ GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,+ "Cancel", GTK_RESPONSE_CANCEL,+ "Save", GTK_RESPONSE_ACCEPT,+ NULL);+ // Increase width for log+ gtk_window_set_default_size(GTK_WINDOW(info.dialog), 600, 500);++ content_area = gtk_dialog_get_content_area(GTK_DIALOG(info.dialog));+ grid = gtk_grid_new();+ gtk_grid_set_row_spacing(GTK_GRID(grid), 5);+ gtk_grid_set_column_spacing(GTK_GRID(grid), 10);+ gtk_container_set_border_width(GTK_CONTAINER(grid), 10);+ gtk_box_pack_start(GTK_BOX(content_area), grid, TRUE, TRUE, 0);++ // Type+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Type:"), 0, 0, 1, 1);+ info.type_combo = gtk_combo_box_text_new();+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(info.type_combo), "HTTP");+ gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(info.type_combo), "SOCKS5");+ gtk_combo_box_set_active(GTK_COMBO_BOX(info.type_combo), g_proxy_type == PROXY_TYPE_HTTP ? 0 : 1);+ gtk_grid_attach(GTK_GRID(grid), info.type_combo, 1, 0, 3, 1); // Span 3++ // IP+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Host:"), 0, 1, 1, 1);+ info.ip_entry = gtk_entry_new();+ gtk_entry_set_text(GTK_ENTRY(info.ip_entry), g_proxy_ip);+ gtk_widget_set_hexpand(info.ip_entry, TRUE);+ gtk_grid_attach(GTK_GRID(grid), info.ip_entry, 1, 1, 3, 1);++ // Port+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Port:"), 0, 2, 1, 1);+ info.port_entry = gtk_entry_new();+ if (g_proxy_port != 0) {+ char port_str[8];+ sprintf(port_str, "%d", g_proxy_port);+ gtk_entry_set_text(GTK_ENTRY(info.port_entry), port_str);+ }+ gtk_grid_attach(GTK_GRID(grid), info.port_entry, 1, 2, 3, 1);++ // User+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Username:"), 0, 3, 1, 1);+ info.user_entry = gtk_entry_new();+ gtk_entry_set_text(GTK_ENTRY(info.user_entry), g_proxy_user);+ gtk_grid_attach(GTK_GRID(grid), info.user_entry, 1, 3, 3, 1);++ // Pass+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Password:"), 0, 4, 1, 1);+ info.pass_entry = gtk_entry_new();+ gtk_entry_set_visibility(GTK_ENTRY(info.pass_entry), FALSE);+ gtk_entry_set_text(GTK_ENTRY(info.pass_entry), g_proxy_pass);+ gtk_grid_attach(GTK_GRID(grid), info.pass_entry, 1, 4, 3, 1);++ // --- Test Section ---+ gtk_grid_attach(GTK_GRID(grid), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), 0, 5, 4, 1);++ GtkWidget *test_label = gtk_label_new("<b>Test Connection</b>");+ gtk_label_set_use_markup(GTK_LABEL(test_label), TRUE);+ gtk_widget_set_halign(test_label, GTK_ALIGN_START);+ gtk_grid_attach(GTK_GRID(grid), test_label, 0, 6, 4, 1);++ // Target Host+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Target:"), 0, 7, 1, 1);+ info.test_host = gtk_entry_new();+ gtk_entry_set_text(GTK_ENTRY(info.test_host), "google.com");+ gtk_grid_attach(GTK_GRID(grid), info.test_host, 1, 7, 1, 1);++ // Target Port+ gtk_grid_attach(GTK_GRID(grid), gtk_label_new("Port:"), 2, 7, 1, 1);+ info.test_port = gtk_entry_new();+ gtk_entry_set_text(GTK_ENTRY(info.test_port), "80");+ gtk_widget_set_size_request(info.test_port, 80, -1);+ gtk_grid_attach(GTK_GRID(grid), info.test_port, 3, 7, 1, 1);++ // Start Test Button+ info.test_btn = gtk_button_new_with_label("Start Test");+ g_signal_connect(info.test_btn, "clicked", G_CALLBACK(on_start_test_clicked), &info);+ gtk_grid_attach(GTK_GRID(grid), info.test_btn, 0, 8, 4, 1);++ // Output Log+ GtkWidget *out_scroll = gtk_scrolled_window_new(NULL, NULL);+ gtk_widget_set_size_request(out_scroll, -1, 150);+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(out_scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);++ GtkWidget *out_view = gtk_text_view_new();+ gtk_text_view_set_editable(GTK_TEXT_VIEW(out_view), FALSE);+ gtk_text_view_set_monospace(GTK_TEXT_VIEW(out_view), TRUE);+ info.output_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(out_view));++ gtk_container_add(GTK_CONTAINER(out_scroll), out_view);+ gtk_grid_attach(GTK_GRID(grid), out_scroll, 0, 9, 4, 1);+++ gtk_widget_show_all(info.dialog);++ while (TRUE) {+ if (gtk_dialog_run(GTK_DIALOG(info.dialog)) != GTK_RESPONSE_ACCEPT) break;++ // Validation+ const char *ip_text = gtk_entry_get_text(GTK_ENTRY(info.ip_entry));+ const char *port_text = gtk_entry_get_text(GTK_ENTRY(info.port_entry));++ if (!ip_text || strlen(ip_text) == 0) {+ GtkWidget *err = gtk_message_dialog_new(GTK_WINDOW(info.dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Host (IP/Domain) cannot be empty.");+ gtk_dialog_run(GTK_DIALOG(err));+ gtk_widget_destroy(err);+ continue;+ }++ if (strspn(port_text, "0123456789") != strlen(port_text) || strlen(port_text) == 0) {+ GtkWidget *err = gtk_message_dialog_new(GTK_WINDOW(info.dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Port must be a valid number.");+ gtk_dialog_run(GTK_DIALOG(err));+ gtk_widget_destroy(err);+ continue;+ }++ int p = atoi(port_text);+ if (p < 1 || p > 65535) {+ GtkWidget *err = gtk_message_dialog_new(GTK_WINDOW(info.dialog), GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, "Port must be between 1 and 65535.");+ gtk_dialog_run(GTK_DIALOG(err));+ gtk_widget_destroy(err);+ continue;+ }++ // Save+ g_proxy_type = (gtk_combo_box_get_active(GTK_COMBO_BOX(info.type_combo)) == 0) ? PROXY_TYPE_HTTP : PROXY_TYPE_SOCKS5;+ strncpy(g_proxy_ip, ip_text, sizeof(g_proxy_ip)-1);+ g_proxy_port = p;+ strncpy(g_proxy_user, gtk_entry_get_text(GTK_ENTRY(info.user_entry)), sizeof(g_proxy_user)-1);+ strncpy(g_proxy_pass, gtk_entry_get_text(GTK_ENTRY(info.pass_entry)), sizeof(g_proxy_pass)-1);++ ProxyBridge_SetProxyConfig(g_proxy_type, g_proxy_ip, g_proxy_port, g_proxy_user, g_proxy_pass);++ char status_msg[512];+ snprintf(status_msg, sizeof(status_msg), "Configuration updated: %s:%d", g_proxy_ip, g_proxy_port);+ gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, status_msg);+ break;+ }++ gtk_widget_destroy(info.dialog);+}++static void on_about(GtkWidget *widget, gpointer data) {+ GtkWidget *dialog = gtk_message_dialog_new(GTK_WINDOW(window),+ GTK_DIALOG_DESTROY_WITH_PARENT,+ GTK_MESSAGE_INFO,+ GTK_BUTTONS_OK,+ "ProxyBridge Linux GUI\nVersion 4.0-Beta\n\nHigh-performance zero-copy proxy client.");+ gtk_dialog_run(GTK_DIALOG(dialog));+ gtk_widget_destroy(dialog);+}++static void signal_handler(int sig) {+ fprintf(stderr, "\nSignal %d received. Stopping ProxyBridge...\n", sig);+ ProxyBridge_Stop();+ exit(sig);+}++static void on_window_destroy(GtkWidget *widget, gpointer data) {+ ProxyBridge_Stop();+ gtk_main_quit();+}++// --- Main Init ---++int main(int argc, char *argv[]) {+ signal(SIGINT, signal_handler);+ signal(SIGTERM, signal_handler);+ signal(SIGSEGV, signal_handler);++ // Only verify root if not argument --help or similar passed?+ // But GTK also takes args.+ // Simply check uid.+ if (getuid() != 0) {+ // Can't show GUI dialog easily without GTK init which might fail if no display.+ // Try init, then dialog.+ gtk_init(&argc, &argv);+ GtkWidget *dialog = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "ProxyBridge must be run as root (sudo).");gtk_dialog_run(GTK_DIALOG(dialog));- gtk_widget_destroy(dialog);return 1;}++ gtk_init(&argc, &argv);++ // Apply dark theme preference if available+ GtkSettings *settings = gtk_settings_get_default();+ if (settings) {+ g_object_set(settings, "gtk-application-prefer-dark-theme", TRUE, NULL);+ }++ window = gtk_window_new(GTK_WINDOW_TOPLEVEL);+ gtk_window_set_title(GTK_WINDOW(window), "ProxyBridge");+ gtk_window_set_default_size(GTK_WINDOW(window), 900, 600);+ g_signal_connect(window, "destroy", G_CALLBACK(on_window_destroy), NULL);++ GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);+ gtk_container_add(GTK_CONTAINER(window), vbox);++ // Menu Bar+ GtkWidget *menubar = gtk_menu_bar_new();- // Create main window- create_main_window();+ GtkWidget *proxy_menu_item = gtk_menu_item_new_with_label("Proxy");+ GtkWidget *proxy_menu = gtk_menu_new();+ GtkWidget *config_item = gtk_menu_item_new_with_label("Proxy Settings");+ GtkWidget *exit_item = gtk_menu_item_new_with_label("Exit");+ g_signal_connect(config_item, "activate", G_CALLBACK(on_proxy_configure), NULL);+ g_signal_connect(exit_item, "activate", G_CALLBACK(on_window_destroy), NULL);+ gtk_menu_shell_append(GTK_MENU_SHELL(proxy_menu), config_item);+ gtk_menu_shell_append(GTK_MENU_SHELL(proxy_menu), gtk_separator_menu_item_new());+ gtk_menu_shell_append(GTK_MENU_SHELL(proxy_menu), exit_item);+ gtk_menu_item_set_submenu(GTK_MENU_ITEM(proxy_menu_item), proxy_menu);- // Run GTK main loop- gtk_main();+ GtkWidget *about_menu_item = gtk_menu_item_new_with_label("About");+ g_signal_connect(about_menu_item, "activate", G_CALLBACK(on_about), NULL);++ gtk_menu_shell_append(GTK_MENU_SHELL(menubar), proxy_menu_item);+ gtk_menu_shell_append(GTK_MENU_SHELL(menubar), about_menu_item);+ gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);++ // Tabs+ GtkWidget *notebook = gtk_notebook_new();+ gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);++ // --- Tab 1: Connections ---+ GtkWidget *conn_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);+ gtk_container_set_border_width(GTK_CONTAINER(conn_vbox), 5);++ // Toolbar (Search + Clear)+ GtkWidget *conn_toolbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);++ GtkWidget *conn_search = gtk_search_entry_new();+ gtk_entry_set_placeholder_text(GTK_ENTRY(conn_search), "Search connections...");+ g_signal_connect(conn_search, "search-changed", G_CALLBACK(on_search_conn_changed), NULL);++ GtkWidget *conn_clear_btn = gtk_button_new_with_label("Clear Logs");+ g_signal_connect(conn_clear_btn, "clicked", G_CALLBACK(on_clear_conn_clicked), NULL);++ gtk_box_pack_start(GTK_BOX(conn_toolbar), conn_search, TRUE, TRUE, 0);+ gtk_box_pack_start(GTK_BOX(conn_toolbar), conn_clear_btn, FALSE, FALSE, 0);+ gtk_box_pack_start(GTK_BOX(conn_vbox), conn_toolbar, FALSE, FALSE, 0);++ // List View (Now Text View)+ conn_view = GTK_TEXT_VIEW(gtk_text_view_new());+ gtk_text_view_set_editable(conn_view, FALSE);+ gtk_text_view_set_cursor_visible(conn_view, FALSE);+ conn_buffer = gtk_text_view_get_buffer(conn_view);++ // Create tag for filtering+ gtk_text_buffer_create_tag(conn_buffer, "hidden", "invisible", TRUE, NULL);++ GtkWidget *scrolled_window = gtk_scrolled_window_new(NULL, NULL);+ gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(conn_view));+ gtk_box_pack_start(GTK_BOX(conn_vbox), scrolled_window, TRUE, TRUE, 0);++ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), conn_vbox, gtk_label_new("Connections"));++ // --- Tab 2: Activity Logs ---+ GtkWidget *log_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);+ gtk_container_set_border_width(GTK_CONTAINER(log_vbox), 5);++ // Toolbar (Search + Clear)+ GtkWidget *log_toolbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);++ GtkWidget *log_search = gtk_search_entry_new();+ gtk_entry_set_placeholder_text(GTK_ENTRY(log_search), "Search logs...");+ g_signal_connect(log_search, "search-changed", G_CALLBACK(on_search_log_changed), NULL);++ GtkWidget *log_clear_btn = gtk_button_new_with_label("Clear Logs");+ g_signal_connect(log_clear_btn, "clicked", G_CALLBACK(on_clear_log_clicked), NULL);++ gtk_box_pack_start(GTK_BOX(log_toolbar), log_search, TRUE, TRUE, 0);+ gtk_box_pack_start(GTK_BOX(log_toolbar), log_clear_btn, FALSE, FALSE, 0);+ gtk_box_pack_start(GTK_BOX(log_vbox), log_toolbar, FALSE, FALSE, 0);++ log_view = GTK_TEXT_VIEW(gtk_text_view_new());+ gtk_text_view_set_editable(log_view, FALSE);+ gtk_text_view_set_cursor_visible(log_view, FALSE);+ log_buffer = gtk_text_view_get_buffer(log_view);++ // Create tag for filtering+ gtk_text_buffer_create_tag(log_buffer, "hidden", "invisible", TRUE, NULL);- // Cleanup- unload_proxybridge_library();+ GtkWidget *log_scroll = gtk_scrolled_window_new(NULL, NULL);+ gtk_container_add(GTK_CONTAINER(log_scroll), GTK_WIDGET(log_view));+ gtk_box_pack_start(GTK_BOX(log_vbox), log_scroll, TRUE, TRUE, 0);++ gtk_notebook_append_page(GTK_NOTEBOOK(notebook), log_vbox, gtk_label_new("Activity Logs"));++ // Status Bar+ 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);++ // Initial Config+ ProxyBridge_SetLogCallback(lib_log_callback);+ ProxyBridge_SetConnectionCallback(lib_connection_callback);+ ProxyBridge_SetTrafficLoggingEnabled(true);+ // Start Proxy Engine+ if (ProxyBridge_Start()) {+ gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, "ProxyBridge Service Started. Please configure proxy settings.");+ } else {+ gtk_statusbar_push(GTK_STATUSBAR(status_bar), status_context_id, "Failed to start ProxyBridge engine.");+ }++ gtk_widget_show_all(window);+ gtk_main();+return 0;}