Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
#include "gui.h"
static GtkWidget *rules_window = NULL;
static GtkWidget *rules_list_box = NULL;
static GtkWidget *btn_select_all_header = NULL;
static void refresh_rules_ui();
void free_rule_data(RuleData *rule) {
if (!rule) return;
g_free(rule->name);
g_free(rule->process_name);
g_free(rule->target_hosts);
g_free(rule->target_ports);
g_free(rule->proxy_name);
g_free(rule);
}
static GtkWindow *parent_window() {
return GTK_WINDOW(rules_window ? rules_window : window);
}
// position in the library list, rules it rejected (id 0) are not in it
static int lib_index_of(RuleData *rule) {
int idx = 0;
for (GList *l = g_rules_list; l != NULL && l->data != rule; l = l->next)
if (((RuleData *)l->data)->id != 0) idx++;
return idx;
}
static uint32_t rule_proxy_id(RuleAction action, const char *proxy_name) {
return action == RULE_ACTION_PROXY ? resolve_proxy_id(proxy_name) : 0;
}
void apply_rules_to_lib() {
int n = 1;
for (GList *l = g_rules_list; l != NULL; l = l->next, n++) {
RuleData *r = (RuleData *)l->data;
char err[256] = "";
r->id = ProxyBridge_AddRule(r->process_name, r->target_hosts, r->target_ports, r->protocol, r->action,
rule_proxy_id(r->action, r->proxy_name), err, sizeof(err));
if (r->id == 0) {
gui_log("Rule #%d (%s) not loaded: %s", n, r->process_name, err[0] ? err : "rejected");
continue;
}
if (r->localhost && r->action == RULE_ACTION_PROXY) ProxyBridge_SetRuleLocalhost(r->id, true);
if (!r->enabled) ProxyBridge_DisableRule(r->id);
}
}
static void on_rule_delete(GtkWidget *widget, gpointer data) {
RuleData *rule = (RuleData *)data;
if (rule->id != 0) ProxyBridge_DeleteRule(rule->id);
g_rules_list = g_list_remove(g_rules_list, rule);
free_rule_data(rule);
save_config();
refresh_rules_ui();
}
static void on_rule_toggle(GtkToggleButton *btn, gpointer data) {
RuleData *rule = (RuleData *)data;
rule->enabled = gtk_toggle_button_get_active(btn);
if (rule->id != 0) {
if (rule->enabled) ProxyBridge_EnableRule(rule->id);
else ProxyBridge_DisableRule(rule->id);
}
save_config();
}
static void on_rule_move(RuleData *rule, int dir) {
GList *link = g_list_find(g_rules_list, rule);
GList *other = link ? (dir < 0 ? link->prev : link->next) : NULL;
if (!other) return;
// swap payloads so the list head stays valid
link->data = other->data;
other->data = rule;
if (rule->id != 0 && !ProxyBridge_MoveRule(rule->id, lib_index_of(rule)))
gui_log("Could not reorder rule %u in the engine", rule->id);
save_config();
refresh_rules_ui();
}
static void on_rule_move_up(GtkWidget *widget, gpointer data) { on_rule_move((RuleData *)data, -1); }
static void on_rule_move_down(GtkWidget *widget, gpointer data) { on_rule_move((RuleData *)data, 1); }
static void on_browse_clicked(GtkWidget *widget, gpointer data) {
GtkWidget *dialog = gtk_file_chooser_dialog_new("Select Application", NULL, GTK_FILE_CHOOSER_ACTION_OPEN,
"_Cancel", GTK_RESPONSE_CANCEL, "_Select", GTK_RESPONSE_ACCEPT, NULL);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
if (filename) {
char *base = g_path_get_basename(filename);
gtk_entry_set_text(GTK_ENTRY(data), base);
g_free(base);
g_free(filename);
}
}
gtk_widget_destroy(dialog);
}
// The Action combo lists: 0 Direct, 1 Block, then one entry per proxy (g_proxies_list order). A rule whose proxy no longer
// exists (or a PROXY rule in a profile without any proxy) gets one extra entry at the end that keeps it as it is.
enum { ACT_DIRECT_IDX = 0, ACT_BLOCK_IDX = 1, ACT_FIRST_PROXY_IDX = 2 };
static void on_action_changed(GtkComboBox *combo, gpointer data) {
gtk_widget_set_sensitive(GTK_WIDGET(data), gtk_combo_box_get_active(combo) >= ACT_FIRST_PROXY_IDX);
}
// the proxy a PROXY rule uses: the one it names, else the profile's default proxy
static ProxyData *rule_effective_proxy(const RuleData *r) {
ProxyData *p = r->proxy_name && *r->proxy_name ? find_proxy_by_name(r->proxy_name) : NULL;
if (!p && (!r->proxy_name || !*r->proxy_name)) p = find_proxy_by_name(g_default_proxy);
if (!p && (!r->proxy_name || !*r->proxy_name) && g_proxies_list) p = g_proxies_list->data;
return p;
}
static void set_str(char **dst, const char *src) {
g_free(*dst);
*dst = g_strdup(src);
}
// returns the saved rule, NULL while the engine rejects it (err filled)
static RuleData *save_rule(RuleData *rule, const char *name, const char *proc, const char *hosts, const char *ports,
RuleProtocol proto, RuleAction action, const char *proxy_name, bool localhost, char *err, size_t err_size) {
if (!ProxyBridge_ValidateRule(proc, hosts, ports, err, err_size)) return NULL;
uint32_t pid = rule_proxy_id(action, proxy_name);
if (rule && rule->id != 0) {
if (!ProxyBridge_EditRule(rule->id, proc, hosts, ports, proto, action, pid, err, err_size)) return NULL;
} else {
// new rule, or one the engine rejected at load time
uint32_t id = ProxyBridge_AddRule(proc, hosts, ports, proto, action, pid, err, err_size);
if (id == 0) return NULL;
if (rule && !rule->enabled) ProxyBridge_DisableRule(id);
if (!rule) {
rule = g_malloc0(sizeof(RuleData));
rule->enabled = true;
g_rules_list = g_list_append(g_rules_list, rule);
}
rule->id = id;
ProxyBridge_MoveRule(id, lib_index_of(rule));
}
localhost = localhost && action == RULE_ACTION_PROXY;
ProxyBridge_SetRuleLocalhost(rule->id, localhost);
rule->localhost = localhost;
set_str(&rule->name, name);
set_str(&rule->process_name, proc);
set_str(&rule->target_hosts, hosts);
set_str(&rule->target_ports, ports);
set_str(&rule->proxy_name, proxy_name);
rule->protocol = proto;
rule->action = action;
return rule;
}
static void open_rule_dialog(RuleData *rule) {
GtkWidget *dialog = gtk_dialog_new_with_buttons(rule ? "Edit Rule" : "Add Rule", parent_window(),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
"Cancel", GTK_RESPONSE_CANCEL, "Save", GTK_RESPONSE_ACCEPT, NULL);
gtk_window_set_default_size(GTK_WINDOW(dialog), 500, 400);
gtk_widget_set_name(dialog, "dlg_rule");
GtkWidget *grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(grid), 8);
gtk_grid_set_column_spacing(GTK_GRID(grid), 10);
gtk_container_set_border_width(GTK_CONTAINER(grid), 15);
GtkWidget *proc_entry = gtk_entry_new();
GtkWidget *browse_btn = gtk_button_new_with_label("Browse...");
g_signal_connect(browse_btn, "clicked", G_CALLBACK(on_browse_clicked), proc_entry);
GtkWidget *proc_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5);
gtk_box_pack_start(GTK_BOX(proc_box), proc_entry, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(proc_box), browse_btn, FALSE, FALSE, 0);
// Target Host: multiline for long lists. Line breaks are only for readability and are stripped before
// the text reaches the engine; ';' stays the separator.
GtkWidget *host_view = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(host_view), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_accepts_tab(GTK_TEXT_VIEW(host_view), FALSE);
GtkWidget *host_entry = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(host_entry), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(host_entry), GTK_SHADOW_IN);
gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(host_entry), 90);
gtk_container_add(GTK_CONTAINER(host_entry), host_view);
GtkWidget *port_entry = gtk_entry_new();
GtkWidget *proto_combo = combo_new("TCP", "UDP", "BOTH", NULL);
GtkWidget *action_combo = combo_new("Direct", "Block", NULL);
int nproxies = 0, action_sel = ACT_DIRECT_IDX, extra_idx = -1;
for (GList *l = g_proxies_list; l != NULL; l = l->next, nproxies++) {
char *label = g_strdup_printf("Proxy: %s", ((ProxyData *)l->data)->name);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(action_combo), label);
g_free(label);
}
if (!rule || rule->action == RULE_ACTION_PROXY) {
ProxyData *eff = rule ? rule_effective_proxy(rule) : NULL;
if (!rule && g_proxies_list) eff = find_proxy_by_name(g_default_proxy) ? find_proxy_by_name(g_default_proxy) : g_proxies_list->data;
int at = eff ? g_list_index(g_proxies_list, eff) : -1;
if (at >= 0) {
action_sel = ACT_FIRST_PROXY_IDX + at;
} else if (rule) { // names a proxy that is gone, or the profile has none: keep the rule visible
char *label = rule->proxy_name && *rule->proxy_name ? g_strdup_printf("Proxy: %s (not found)", rule->proxy_name) : g_strdup("Proxy: (no proxy configured)");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(action_combo), label);
g_free(label);
extra_idx = ACT_FIRST_PROXY_IDX + nproxies;
action_sel = extra_idx;
}
} else {
action_sel = rule->action == RULE_ACTION_BLOCK ? ACT_BLOCK_IDX : ACT_DIRECT_IDX;
}
gtk_entry_set_text(GTK_ENTRY(proc_entry), rule ? rule->process_name : "");
{
char *shown = list_format(rule && rule->target_hosts && *rule->target_hosts ? rule->target_hosts : "*");
gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(host_view)), shown, -1);
g_free(shown);
}
gtk_entry_set_text(GTK_ENTRY(port_entry), rule ? rule->target_ports : "*");
gtk_combo_box_set_active(GTK_COMBO_BOX(proto_combo), rule ? (int)rule->protocol : RULE_PROTOCOL_BOTH);
gtk_combo_box_set_active(GTK_COMBO_BOX(action_combo), action_sel);
GtkWidget *name_entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(name_entry), 127);
gtk_entry_set_text(GTK_ENTRY(name_entry), rule && rule->name ? rule->name : "");
GtkWidget *localhost_check = gtk_check_button_new_with_label("Also proxy localhost traffic (127.0.0.0/8 and ::1)");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(localhost_check), rule && rule->localhost);
g_signal_connect(action_combo, "changed", G_CALLBACK(on_action_changed), localhost_check);
GtkWidget *err_label = hint_label("");
// names let the UI test find the widgets
gtk_widget_set_name(name_entry, "rule_name"); gtk_widget_set_name(proc_entry, "rule_process"); gtk_widget_set_name(host_view, "rule_hosts");
gtk_widget_set_name(port_entry, "rule_ports"); gtk_widget_set_name(proto_combo, "rule_proto"); gtk_widget_set_name(action_combo, "rule_action");
gtk_widget_set_name(localhost_check, "rule_localhost"); gtk_widget_set_name(err_label, "rule_error");
grid_row(grid, 0, "Name:", name_entry);
grid_row(grid, 1, "Process Name:", proc_box);
gtk_grid_attach(GTK_GRID(grid), hint_label("Example: firefox; chrome; /usr/bin/wget"), 1, 2, 1, 1);
grid_row(grid, 3, "Target Host:", host_entry);
gtk_grid_attach(GTK_GRID(grid), hint_label("Example: 192.168.1.*; 10.0.0.0/8; 10.0.0.1-10.0.0.50; github.com; *.github.com; * (domains are matched via DNS answers). Long lists are fine; line breaks are for readability only, separate entries with ;"), 1, 4, 1, 1);
grid_row(grid, 5, "Target Port:", port_entry);
gtk_grid_attach(GTK_GRID(grid), hint_label("Example: 80; 443; 8000-8080; *"), 1, 6, 1, 1);
grid_row(grid, 7, "Protocol:", proto_combo);
grid_row(grid, 8, "Action:", action_combo);
gtk_grid_attach(GTK_GRID(grid), localhost_check, 1, 9, 1, 1);
gtk_grid_attach(GTK_GRID(grid), hint_label("Without this, a proxied rule leaves connections to this computer (localhost) direct. DNS to a local resolver is never proxied."), 1, 10, 1, 1);
gtk_grid_attach(GTK_GRID(grid), err_label, 0, 11, 2, 1);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), grid);
gtk_widget_show_all(dialog);
on_action_changed(GTK_COMBO_BOX(action_combo), localhost_check);
bool saved = false;
while (!saved && gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
int proto = gtk_combo_box_get_active(GTK_COMBO_BOX(proto_combo));
int sel = gtk_combo_box_get_active(GTK_COMBO_BOX(action_combo));
RuleAction action = sel == ACT_BLOCK_IDX ? RULE_ACTION_BLOCK : sel == ACT_DIRECT_IDX || sel < 0 ? RULE_ACTION_DIRECT : RULE_ACTION_PROXY;
const char *proxy_name = NULL;
if (action == RULE_ACTION_PROXY) {
ProxyData *pd = sel == extra_idx ? NULL : g_list_nth_data(g_proxies_list, sel - ACT_FIRST_PROXY_IDX);
proxy_name = pd ? pd->name : rule ? rule->proxy_name : NULL;
}
char err[256] = "";
GtkTextBuffer *hbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(host_view));
GtkTextIter hs, he;
gtk_text_buffer_get_bounds(hbuf, &hs, &he);
char *raw_hosts = gtk_text_buffer_get_text(hbuf, &hs, &he, FALSE);
char *clean_hosts = list_normalize(raw_hosts);
g_free(raw_hosts);
saved = save_rule(rule, gtk_entry_get_text(GTK_ENTRY(name_entry)), gtk_entry_get_text(GTK_ENTRY(proc_entry)), clean_hosts,
gtk_entry_get_text(GTK_ENTRY(port_entry)), proto < 0 ? RULE_PROTOCOL_BOTH : (RuleProtocol)proto,
action, proxy_name,
gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(localhost_check)), err, sizeof(err)) != NULL;
g_free(clean_hosts);
if (saved) {
save_config();
refresh_rules_ui();
} else {
set_error_label(err_label, err[0] ? err : "Invalid rule.");
}
}
gtk_widget_destroy(dialog);
}
static void on_rule_edit(GtkWidget *widget, gpointer data) {
open_rule_dialog((RuleData *)data);
}
static void on_rule_add_clicked(GtkWidget *widget, gpointer data) {
open_rule_dialog(NULL);
}
static bool all_rules_selected() {
if (!g_rules_list) return false;
for (GList *l = g_rules_list; l != NULL; l = l->next)
if (!((RuleData *)l->data)->selected) return false;
return true;
}
static void update_select_all_label() {
if (btn_select_all_header)
gtk_button_set_label(GTK_BUTTON(btn_select_all_header), all_rules_selected() ? "Deselect All" : "Select All");
}
static void on_rule_select_toggle(GtkToggleButton *btn, gpointer data) {
((RuleData *)data)->selected = gtk_toggle_button_get_active(btn);
update_select_all_label();
}
static void on_rule_export_clicked(GtkWidget *widget, gpointer data) {
bool any_selected = false;
for (GList *l = g_rules_list; l != NULL; l = l->next) any_selected |= ((RuleData *)l->data)->selected;
if (!any_selected) {
show_message(parent_window(), GTK_MESSAGE_WARNING, "Please select at least one rule to export.");
return;
}
GtkWidget *dialog = gtk_file_chooser_dialog_new("Export Rules", parent_window(), GTK_FILE_CHOOSER_ACTION_SAVE,
"_Cancel", GTK_RESPONSE_CANCEL, "_Save", GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "proxy_rules.json");
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
char *json = rules_to_json(g_rules_list, true);
GError *err = NULL;
if (filename && g_file_set_contents(filename, json, -1, &err))
show_message(parent_window(), GTK_MESSAGE_INFO, "Rules exported successfully.");
else
show_message(parent_window(), GTK_MESSAGE_ERROR, "Could not write %s: %s", filename ? filename : "file", err ? err->message : "unknown error");
if (err) g_error_free(err);
g_free(json);
g_free(filename);
}
gtk_widget_destroy(dialog);
}
typedef struct {
int imported, failed;
GString *fail_msg;
} ImportCtx;
static void import_rule_cb(const RuleData *r, int index, void *ud) {
ImportCtx *ctx = (ImportCtx *)ud;
char err[256] = "";
// unknown proxy name -> default proxy
ProxyData *px = r->action == RULE_ACTION_PROXY ? find_proxy_by_name(r->proxy_name) : NULL;
uint32_t id = r->process_name ? ProxyBridge_AddRule(r->process_name, r->target_hosts, r->target_ports, r->protocol,
r->action, px ? px->id : 0, err, sizeof(err)) : 0;
if (id == 0) {
ctx->failed++;
if (ctx->fail_msg->len < 3000)
g_string_append_printf(ctx->fail_msg, "Rule #%d (%s): %s\n", index, r->process_name ? r->process_name : "?",
!r->process_name ? "missing processNames" : err[0] ? err : "rejected");
return;
}
if (r->localhost && r->action == RULE_ACTION_PROXY) ProxyBridge_SetRuleLocalhost(id, true);
if (!r->enabled) ProxyBridge_DisableRule(id);
RuleData *nd = g_malloc0(sizeof(RuleData));
nd->id = id;
nd->name = g_strdup(r->name ? r->name : "");
nd->localhost = r->localhost && r->action == RULE_ACTION_PROXY;
nd->process_name = g_strdup(r->process_name);
nd->target_hosts = g_strdup(r->target_hosts);
nd->target_ports = g_strdup(r->target_ports);
nd->protocol = r->protocol;
nd->action = r->action;
nd->enabled = r->enabled;
nd->proxy_name = px ? g_strdup(px->name) : NULL;
g_rules_list = g_list_append(g_rules_list, nd);
ctx->imported++;
}
static void on_rule_import_clicked(GtkWidget *widget, gpointer data) {
GtkWidget *dialog = gtk_file_chooser_dialog_new("Import Rules", parent_window(), GTK_FILE_CHOOSER_ACTION_OPEN,
"_Cancel", GTK_RESPONSE_CANCEL, "_Open", GTK_RESPONSE_ACCEPT, NULL);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
char *content = NULL;
if (filename && g_file_get_contents(filename, &content, NULL, NULL)) {
ImportCtx ctx = {0, 0, g_string_new("")};
rules_from_json(content, import_rule_cb, &ctx);
g_free(content);
if (ctx.imported > 0) { save_config(); refresh_rules_ui(); }
if (ctx.failed > 0)
show_message(parent_window(), GTK_MESSAGE_WARNING, "Imported %d rules, %d failed validation and were skipped:\n\n%s",
ctx.imported, ctx.failed, ctx.fail_msg->str);
else if (ctx.imported > 0)
show_message(parent_window(), GTK_MESSAGE_INFO, "Imported %d rules.", ctx.imported);
else
show_message(parent_window(), GTK_MESSAGE_WARNING, "No rules found in the file.");
g_string_free(ctx.fail_msg, TRUE);
} else {
show_message(parent_window(), GTK_MESSAGE_ERROR, "Could not read the selected file.");
}
g_free(filename);
}
gtk_widget_destroy(dialog);
}
static void on_bulk_delete_clicked(GtkWidget *widget, gpointer data) {
GList *l = g_rules_list;
while (l != NULL) {
GList *next = l->next;
RuleData *rule = (RuleData *)l->data;
if (rule->selected) {
if (rule->id != 0) ProxyBridge_DeleteRule(rule->id);
g_rules_list = g_list_delete_link(g_rules_list, l);
free_rule_data(rule);
}
l = next;
}
save_config();
refresh_rules_ui();
}
static void on_select_all_clicked(GtkWidget *widget, gpointer data) {
bool new_state = !all_rules_selected();
for (GList *l = g_rules_list; l != NULL; l = l->next) ((RuleData *)l->data)->selected = new_state;
refresh_rules_ui();
}
static GtkWidget *header_label(const char *text, bool expand) {
GtkWidget *l = gtk_label_new(text);
gtk_widget_set_halign(l, GTK_ALIGN_START);
gtk_widget_set_hexpand(l, expand);
return l;
}
static GtkWidget *cell_label(const char *text) {
GtkWidget *l = header_label(text, false);
gtk_label_set_ellipsize(GTK_LABEL(l), PANGO_ELLIPSIZE_END);
return l;
}
static GtkWidget *small_button(GtkWidget *box, const char *label, const char *tip, bool sensitive, GCallback cb, gpointer data) {
GtkWidget *b = gtk_button_new_with_label(label);
if (tip) gtk_widget_set_tooltip_text(b, tip);
gtk_widget_set_sensitive(b, sensitive);
g_signal_connect(b, "clicked", cb, data);
gtk_box_pack_start(GTK_BOX(box), b, FALSE, FALSE, 0);
return b;
}
static GtkWidget *check_cell(GtkWidget *grid, int row, int col, bool active, GCallback cb, gpointer data) {
GtkWidget *c = gtk_check_button_new();
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(c), active);
g_signal_connect(c, "toggled", cb, data);
gtk_grid_attach(GTK_GRID(grid), c, col, row, 1, 1);
return c;
}
static void refresh_rules_ui() {
if (!rules_list_box) return;
GList *children = gtk_container_get_children(GTK_CONTAINER(rules_list_box));
for (GList *c = children; c != NULL; c = c->next) gtk_widget_destroy(GTK_WIDGET(c->data));
g_list_free(children);
update_select_all_label();
GtkWidget *grid = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(grid), 10);
gtk_grid_set_column_spacing(GTK_GRID(grid), 15);
gtk_container_add(GTK_CONTAINER(rules_list_box), grid);
const char *heads[] = {" ", "Enable", "Actions", "SR", "Name", "Process", "Target Hosts", "Protocol", "Action"};
for (int c = 0; c < 9; c++)
gtk_grid_attach(GTK_GRID(grid), header_label(heads[c], c == 5 || c == 6), c, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), 0, 1, 9, 1);
const char *proto_strs[] = {"TCP", "UDP", "BOTH"};
const char *action_strs[] = {"Proxy", "Direct", "Block"};
const char *action_class[] = {"success", "info", "warning"};
int row = 2, sr = 1;
for (GList *l = g_rules_list; l != NULL; l = l->next, row += 2) {
RuleData *r = (RuleData *)l->data;
char nm[48];
snprintf(nm, sizeof nm, "rule_select_%d", sr);
gtk_widget_set_name(check_cell(grid, row, 0, r->selected, G_CALLBACK(on_rule_select_toggle), r), nm);
snprintf(nm, sizeof nm, "rule_enable_%d", sr);
gtk_widget_set_name(check_cell(grid, row, 1, r->enabled, G_CALLBACK(on_rule_toggle), r), nm);
// list position is the priority, first match wins
GtkWidget *act_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
char bn[48];
snprintf(bn, sizeof bn, "rule_edit_%d", sr);
gtk_widget_set_name(small_button(act_box, "Edit", NULL, true, G_CALLBACK(on_rule_edit), r), bn);
snprintf(bn, sizeof bn, "rule_delete_%d", sr);
gtk_widget_set_name(small_button(act_box, "Delete", NULL, true, G_CALLBACK(on_rule_delete), r), bn);
snprintf(bn, sizeof bn, "rule_up_%d", sr);
gtk_widget_set_name(small_button(act_box, "▲", "Move up (higher priority)", l->prev != NULL, G_CALLBACK(on_rule_move_up), r), bn);
snprintf(bn, sizeof bn, "rule_down_%d", sr);
gtk_widget_set_name(small_button(act_box, "▼", "Move down (lower priority)", l->next != NULL, G_CALLBACK(on_rule_move_down), r), bn);
gtk_grid_attach(GTK_GRID(grid), act_box, 2, row, 1, 1);
char sr_str[16];
snprintf(sr_str, sizeof(sr_str), "%d", sr++);
gtk_grid_attach(GTK_GRID(grid), gtk_label_new(sr_str), 3, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), cell_label(r->name && *r->name ? r->name : "-"), 4, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), cell_label(r->process_name), 5, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), cell_label(r->target_hosts), 6, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), gtk_label_new(proto_strs[r->protocol <= RULE_PROTOCOL_BOTH ? r->protocol : RULE_PROTOCOL_BOTH]), 7, row, 1, 1);
int a = r->action <= RULE_ACTION_BLOCK ? r->action : RULE_ACTION_PROXY;
// like the Windows app: a proxied rule shows which proxy it uses
char *act_text;
if (a == RULE_ACTION_PROXY) {
ProxyData *px = rule_effective_proxy(r);
act_text = g_strdup_printf("Proxy: %s%s", px ? px->name : r->proxy_name && *r->proxy_name ? r->proxy_name : "(none)", r->localhost ? " (+localhost)" : "");
} else {
act_text = g_strdup(action_strs[a]);
}
GtkWidget *l_act = gtk_label_new(act_text);
g_free(act_text);
gtk_style_context_add_class(gtk_widget_get_style_context(l_act), action_class[a]);
gtk_grid_attach(GTK_GRID(grid), l_act, 8, row, 1, 1);
gtk_grid_attach(GTK_GRID(grid), gtk_separator_new(GTK_ORIENTATION_HORIZONTAL), 0, row + 1, 9, 1);
}
gtk_widget_show_all(rules_list_box);
}
void refresh_rules_window() {
refresh_rules_ui();
}
static void on_rules_window_destroy(GtkWidget *widget, gpointer data) {
rules_window = NULL;
rules_list_box = NULL;
btn_select_all_header = NULL;
}
void on_proxy_rules_clicked(GtkWidget *widget, gpointer data) {
if (rules_window) {
gtk_window_present(GTK_WINDOW(rules_window));
return;
}
rules_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_name(rules_window, "win_rules");
g_signal_connect(rules_window, "destroy", G_CALLBACK(on_rules_window_destroy), NULL);
gtk_window_set_title(GTK_WINDOW(rules_window), "Process Rules");
gtk_window_set_default_size(GTK_WINDOW(rules_window), 1000, 500);
gtk_window_set_transient_for(GTK_WINDOW(rules_window), GTK_WINDOW(window));
GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 10);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 20);
gtk_container_add(GTK_CONTAINER(rules_window), vbox);
GtkWidget *header_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
GtkWidget *title = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(title), "<span size='x-large' weight='bold'>Process Rules</span>");
gtk_box_pack_start(GTK_BOX(header_box), title, FALSE, FALSE, 0);
GtkWidget *spacer = gtk_label_new("");
gtk_box_pack_start(GTK_BOX(header_box), spacer, TRUE, TRUE, 0);
btn_select_all_header = gtk_button_new_with_label("Select All");
GtkWidget *add_btn = gtk_button_new_with_label("+ Add Rule");
GtkWidget *del_btn = gtk_button_new_with_label("Delete Selected");
GtkWidget *import_btn = gtk_button_new_with_label("Import");
GtkWidget *export_btn = gtk_button_new_with_label("Export");
gtk_widget_set_name(add_btn, "rules_add"); gtk_widget_set_name(btn_select_all_header, "rules_select_all"); gtk_widget_set_name(del_btn, "rules_delete_selected");
gtk_widget_set_name(import_btn, "rules_import"); gtk_widget_set_name(export_btn, "rules_export");
g_signal_connect(add_btn, "clicked", G_CALLBACK(on_rule_add_clicked), NULL);
g_signal_connect(btn_select_all_header, "clicked", G_CALLBACK(on_select_all_clicked), NULL);
g_signal_connect(del_btn, "clicked", G_CALLBACK(on_bulk_delete_clicked), NULL);
g_signal_connect(import_btn, "clicked", G_CALLBACK(on_rule_import_clicked), NULL);
g_signal_connect(export_btn, "clicked", G_CALLBACK(on_rule_export_clicked), NULL);
GtkWidget *right[] = {add_btn, btn_select_all_header, del_btn, export_btn, import_btn};
for (int i = 0; i < 5; i++) gtk_box_pack_end(GTK_BOX(header_box), right[i], FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(vbox), header_box, FALSE, FALSE, 0);
GtkWidget *scrolled = gtk_scrolled_window_new(NULL, NULL);
rules_list_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_widget_set_name(rules_list_box, "rules_list");
gtk_container_add(GTK_CONTAINER(scrolled), rules_list_box);
gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0);
refresh_rules_ui();
gtk_widget_show_all(rules_window);
}