diff options
Diffstat (limited to 'sediff/open_policies_dialog.c')
| -rw-r--r-- | sediff/open_policies_dialog.c | 527 |
1 files changed, 527 insertions, 0 deletions
diff --git a/sediff/open_policies_dialog.c b/sediff/open_policies_dialog.c new file mode 100644 index 0000000..482b95f --- /dev/null +++ b/sediff/open_policies_dialog.c @@ -0,0 +1,527 @@ +/** + * @file + * Run the dialog to allow the user to open a policy. + * + * @author Jeremy A. Mowery jmowery@tresys.com + * @author Jason Tang jtang@tresys.com + * + * Copyright (C) 2007 Tresys Technology, LLC + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include <config.h> + +#include "open_policies_dialog.h" +#include "utilgui.h" + +#include <assert.h> +#include <errno.h> +#include <string.h> +#include <apol/util.h> +#include <glade/glade.h> + +struct open_policy_pane +{ + struct open_policy *op; + GtkRadioButton *monolithic_radio, *modular_radio; + GtkLabel *main_label; + + GtkHBox *bottom_hbox; + GtkListStore *module_store; + + GtkEntry *base_entry; + GtkButton *base_browse_button; + + GtkTreeView *module_view; + GtkButton *add_button, *remove_button, *import_button, *export_button; + char *last_module_path; +}; + +struct open_policy +{ + GladeXML *xml; + toplevel_t *top; + GtkDialog *dialog; + GtkButton *ok_button, *rundiff_button; + struct open_policy_pane pane[SEDIFFX_POLICY_NUM]; +}; + +enum module_columns +{ + PATH_COLUMN = 0, NAME_COLUMN, VERSION_COLUMN, NUM_COLUMNS +}; + +/** + * Sort columns in alphabetical order. + */ +static gint open_policy_sort(GtkTreeModel * model, GtkTreeIter * a, GtkTreeIter * b, gpointer user_data) +{ + GValue value_a = { 0 }, value_b = { + 0}; + const char *name_a, *name_b; + int retval, column_id = GPOINTER_TO_INT(user_data); + + gtk_tree_model_get_value(model, a, column_id, &value_a); + gtk_tree_model_get_value(model, b, column_id, &value_b); + name_a = g_value_get_string(&value_a); + name_b = g_value_get_string(&value_b); + retval = strcmp(name_a, name_b); + g_value_unset(&value_a); + g_value_unset(&value_b); + return retval; +} + +static void open_policy_init_pane(struct open_policy *op, sediffx_policy_e which, const char *suffix) +{ + struct open_policy_pane *pane = op->pane + which; + GString *s = g_string_new(NULL); + GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); + GtkTreeViewColumn *column; + GtkTreeSelection *selection; + + g_string_printf(s, "monolithic radio%s", suffix); + pane->monolithic_radio = GTK_RADIO_BUTTON(glade_xml_get_widget(op->xml, s->str)); + g_string_printf(s, "modular radio%s", suffix); + pane->modular_radio = GTK_RADIO_BUTTON(glade_xml_get_widget(op->xml, s->str)); + g_string_printf(s, "main filename label%s", suffix); + pane->main_label = GTK_LABEL(glade_xml_get_widget(op->xml, s->str)); + assert(pane->monolithic_radio != NULL && pane->modular_radio != NULL && pane->main_label != NULL); + + g_string_printf(s, "base entry%s", suffix); + pane->base_entry = GTK_ENTRY(glade_xml_get_widget(op->xml, s->str)); + g_string_printf(s, "base browse%s", suffix); + pane->base_browse_button = GTK_BUTTON(glade_xml_get_widget(op->xml, s->str)); + assert(pane->base_entry != NULL && pane->base_browse_button != NULL); + + g_string_printf(s, "hbox.3%s", suffix); + pane->bottom_hbox = GTK_HBOX(glade_xml_get_widget(op->xml, s->str)); + assert(pane->bottom_hbox != NULL); + + g_string_printf(s, "module view%s", suffix); + pane->module_view = GTK_TREE_VIEW(glade_xml_get_widget(op->xml, s->str)); + assert(pane->module_view != NULL); + pane->module_store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); + gtk_tree_view_set_model(pane->module_view, GTK_TREE_MODEL(pane->module_store)); + + g_string_printf(s, "module add button%s", suffix); + pane->add_button = GTK_BUTTON(glade_xml_get_widget(op->xml, s->str)); + g_string_printf(s, "module remove button%s", suffix); + pane->remove_button = GTK_BUTTON(glade_xml_get_widget(op->xml, s->str)); + g_string_printf(s, "module list import button%s", suffix); + pane->import_button = GTK_BUTTON(glade_xml_get_widget(op->xml, s->str)); + g_string_printf(s, "module list export button%s", suffix); + pane->export_button = GTK_BUTTON(glade_xml_get_widget(op->xml, s->str)); + assert(pane->add_button != NULL && pane->remove_button != NULL && + pane->import_button != NULL && pane->export_button != NULL); + + g_string_free(s, TRUE); + + selection = gtk_tree_view_get_selection(pane->module_view); + gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); + + column = gtk_tree_view_column_new_with_attributes("Module", renderer, "text", NAME_COLUMN, NULL); + gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN); + gtk_tree_view_column_set_resizable(column, TRUE); + gtk_tree_view_append_column(pane->module_view, column); + gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(pane->module_store), NAME_COLUMN, open_policy_sort, + (gpointer) NAME_COLUMN, NULL); + + column = gtk_tree_view_column_new_with_attributes("Version", renderer, "text", VERSION_COLUMN, NULL); + gtk_tree_view_column_set_sort_column_id(column, VERSION_COLUMN); + gtk_tree_view_column_set_resizable(column, TRUE); + gtk_tree_view_append_column(pane->module_view, column); + gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(pane->module_store), VERSION_COLUMN, open_policy_sort, + (gpointer) VERSION_COLUMN, NULL); + + column = gtk_tree_view_column_new_with_attributes("Path", renderer, "text", PATH_COLUMN, NULL); + gtk_tree_view_column_set_sort_column_id(column, PATH_COLUMN); + gtk_tree_view_column_set_resizable(column, TRUE); + gtk_tree_view_append_column(pane->module_view, column); + gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(pane->module_store), PATH_COLUMN, open_policy_sort, + (gpointer) PATH_COLUMN, NULL); + + gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(pane->module_store), NAME_COLUMN, GTK_SORT_ASCENDING); +} + +static void open_policy_init_widgets(struct open_policy *op) +{ + op->dialog = GTK_DIALOG(glade_xml_get_widget(op->xml, "PoliciesOpenWindow")); + assert(op->dialog != NULL); + gtk_window_set_transient_for(GTK_WINDOW(op->dialog), toplevel_get_window(op->top)); + op->ok_button = GTK_BUTTON(glade_xml_get_widget(op->xml, "ok button")); + op->rundiff_button = GTK_BUTTON(glade_xml_get_widget(op->xml, "rundiff button")); + assert(op->ok_button != NULL && op->rundiff_button != NULL); + + open_policy_init_pane(op, SEDIFFX_POLICY_ORIG, ""); + open_policy_init_pane(op, SEDIFFX_POLICY_MOD, " 1"); +} + +static void open_policy_on_policy_type_toggle(GtkToggleButton * widget, gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + /* clicking on the radio buttons emit two toggle signals, one for + * the original button and one for the new one. thus only need to + * handle half of all signals */ + if (!gtk_toggle_button_get_active(widget)) { + return; + } + char *prefix; + GString *s = g_string_new(NULL); + if (pane == &(pane->op->pane[SEDIFFX_POLICY_ORIG])) { + prefix = "Original"; + } else { + prefix = "Modified"; + } + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pane->monolithic_radio))) { + gtk_widget_set_sensitive(GTK_WIDGET(pane->bottom_hbox), FALSE); + g_string_printf(s, "<b>%s Policy Filename:</b>", prefix); + gtk_label_set_markup(pane->main_label, s->str); + } else { + gtk_widget_set_sensitive(GTK_WIDGET(pane->bottom_hbox), TRUE); + g_string_printf(s, "<b>%s Base Filename:</b>", prefix); + gtk_label_set_markup(pane->main_label, s->str); + } + g_string_free(s, TRUE); +} + +static void open_policy_on_entry_event_after(GtkWidget * widget __attribute__ ((unused)), GdkEvent * event + __attribute__ ((unused)), gpointer user_data) +{ + struct open_policy *op = (struct open_policy *)user_data; + gboolean sens_orig = FALSE, sens_mod = FALSE; + if (strcmp(gtk_entry_get_text(op->pane[SEDIFFX_POLICY_ORIG].base_entry), "") != 0) { + sens_orig = TRUE; + } + if (strcmp(gtk_entry_get_text(op->pane[SEDIFFX_POLICY_MOD].base_entry), "") != 0) { + sens_mod = TRUE; + } + gboolean sens = sens_orig && sens_mod; + gtk_widget_set_sensitive(GTK_WIDGET(op->pane[SEDIFFX_POLICY_ORIG].export_button), sens_orig); + gtk_widget_set_sensitive(GTK_WIDGET(op->pane[SEDIFFX_POLICY_MOD].export_button), sens_mod); + gtk_widget_set_sensitive(GTK_WIDGET(op->ok_button), sens); + gtk_widget_set_sensitive(GTK_WIDGET(op->rundiff_button), sens); +} + +static void open_policy_on_base_browse_click(GtkButton * button __attribute__ ((unused)), gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + const char *current_path = gtk_entry_get_text(pane->base_entry); + char *title; + apol_vector_t *paths; + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pane->monolithic_radio))) { + title = "Open Monolithic Policy"; + } else { + title = "Open Modular Policy"; + } + if (strcmp(current_path, "") == 0) { + current_path = NULL; + } + if ((paths = util_open_file(GTK_WINDOW(pane->op->dialog), title, current_path, 0)) == NULL) { + return; + } + gtk_entry_set_text(pane->base_entry, apol_vector_get_element(paths, 0)); + apol_vector_destroy(&paths); +} + +/** + * Attempt to load a module and retrieve its name and version. Upon + * success add an entry to the list store. + * + * @return 0 on success, < 0 on error. + */ +static int open_policy_load_module(struct open_policy *op, struct open_policy_pane *pane, const char *path) +{ + const char *module_name, *version_string; + int module_type; + qpol_module_t *module = NULL; + GtkTreeIter iter; + + /* check if modulue was already loaded */ + gboolean iter_valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pane->module_store), &iter); + while (iter_valid) { + char *s; + gtk_tree_model_get(GTK_TREE_MODEL(pane->module_store), &iter, PATH_COLUMN, &s, -1); + if (strcmp(s, path) == 0) { + toplevel_ERR(op->top, "Module %s was already added.", path); + return -1; + } + iter_valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(pane->module_store), &iter); + } + if ((qpol_module_create_from_file(path, &module)) < 0) { + toplevel_ERR(op->top, "Error opening module %s: %s", path, strerror(errno)); + return -1; + } + if (qpol_module_get_name(module, &module_name) < 0 || + qpol_module_get_version(module, &version_string) < 0 || qpol_module_get_type(module, &module_type) < 0) { + toplevel_ERR(op->top, "Error reading module %s: %s", path, strerror(errno)); + qpol_module_destroy(&module); + return -1; + } + if (module_type != QPOL_MODULE_OTHER) { + toplevel_ERR(op->top, "%s is not a loadable module.", path); + qpol_module_destroy(&module); + return -1; + } + gtk_list_store_append(pane->module_store, &iter); + gtk_list_store_set(pane->module_store, &iter, PATH_COLUMN, path, NAME_COLUMN, module_name, VERSION_COLUMN, version_string, + -1); + qpol_module_destroy(&module); + return 0; +} + +static void open_policy_on_add_click(GtkButton * button __attribute__ ((unused)), gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + apol_vector_t *paths; + const char *path = NULL, *prev_path; + size_t i; + if ((prev_path = pane->last_module_path) == NULL) { + prev_path = gtk_entry_get_text(pane->base_entry); + if (strcmp(prev_path, "") == 0) { + prev_path = NULL; + } + } + paths = util_open_file(GTK_WINDOW(pane->op->dialog), "Open Module", prev_path, 1); + if (paths == NULL) { + return; + } + int all_succeed = 1; + for (i = 0; i < apol_vector_get_size(paths); i++) { + path = apol_vector_get_element(paths, i); + if (open_policy_load_module(pane->op, pane, path) < 0) { + all_succeed = 0; + } + } + if (all_succeed) { + assert(path != NULL); + free(pane->last_module_path); + pane->last_module_path = strdup(path); + } + apol_vector_destroy(&paths); +} + +static void open_policy_on_remove_click(GtkButton * button __attribute__ ((unused)), gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + GtkTreeSelection *selection = gtk_tree_view_get_selection(pane->module_view); + GtkTreeIter iter; + char *path; + if (!gtk_tree_selection_get_selected(selection, NULL, &iter)) { + return; + } + gtk_tree_model_get(GTK_TREE_MODEL(pane->module_store), &iter, 0, &path, -1); + gtk_list_store_remove(pane->module_store, &iter); +} + +static void open_policy_on_import_click(GtkButton * button __attribute__ ((unused)), gpointer user_data); +static void open_policy_on_export_click(GtkButton * button __attribute__ ((unused)), gpointer user_data); + +static void open_policy_on_selection_change(GtkTreeSelection * selection, gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + gboolean sens = gtk_tree_selection_get_selected(selection, NULL, NULL); + gtk_widget_set_sensitive(GTK_WIDGET(pane->remove_button), sens); +} + +static void open_policy_init_signals(struct open_policy *op) +{ + sediffx_policy_e i; + for (i = SEDIFFX_POLICY_ORIG; i < SEDIFFX_POLICY_NUM; i++) { + struct open_policy_pane *pane = op->pane + i; + GtkTreeSelection *selection = gtk_tree_view_get_selection(pane->module_view); + g_signal_connect(pane->monolithic_radio, "toggled", G_CALLBACK(open_policy_on_policy_type_toggle), pane); + g_signal_connect(pane->modular_radio, "toggled", G_CALLBACK(open_policy_on_policy_type_toggle), pane); + g_signal_connect(pane->base_entry, "event-after", G_CALLBACK(open_policy_on_entry_event_after), op); + g_signal_connect(pane->base_browse_button, "clicked", G_CALLBACK(open_policy_on_base_browse_click), pane); + g_signal_connect(selection, "changed", G_CALLBACK(open_policy_on_selection_change), pane); + g_signal_connect(pane->add_button, "clicked", G_CALLBACK(open_policy_on_add_click), pane); + g_signal_connect(pane->remove_button, "clicked", G_CALLBACK(open_policy_on_remove_click), pane); + g_signal_connect(pane->import_button, "clicked", G_CALLBACK(open_policy_on_import_click), pane); + g_signal_connect(pane->export_button, "clicked", G_CALLBACK(open_policy_on_export_click), pane); + } +} + +static void open_policy_init_value(struct open_policy *op, const apol_policy_path_t * path, struct open_policy_pane *pane) +{ + apol_policy_path_type_e path_type = apol_policy_path_get_type(path); + const char *primary_path = apol_policy_path_get_primary(path); + gtk_entry_set_text(pane->base_entry, primary_path); + gtk_list_store_clear(pane->module_store); + if (path_type == APOL_POLICY_PATH_TYPE_MONOLITHIC) { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pane->monolithic_radio), TRUE); + } else if (path_type == APOL_POLICY_PATH_TYPE_MODULAR) { + const apol_vector_t *modules = apol_policy_path_get_modules(path); + size_t i; + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pane->modular_radio), TRUE); + for (i = 0; i < apol_vector_get_size(modules); i++) { + char *module_path = apol_vector_get_element(modules, i); + if (open_policy_load_module(op, pane, module_path) < 0) { + break; + } + } + } else { + /* should never get here */ + toplevel_ERR(pane->op->top, "Unknown policy path type %d.", path_type); + } +} + +static void open_policy_init_values(struct open_policy *op, const apol_policy_path_t * orig_path, + const apol_policy_path_t * mod_path) +{ + if (orig_path != NULL) { + open_policy_init_value(op, orig_path, op->pane + SEDIFFX_POLICY_ORIG); + } + if (mod_path != NULL) { + open_policy_init_value(op, mod_path, op->pane + SEDIFFX_POLICY_MOD); + } +} + +/** + * Build the policy path corresponding to the user's inputs on this + * dialog. + * + * @return path for the dialog, or NULL upon error. The caller must + * call apol_policy_path_destroy() afterwards. + */ +static apol_policy_path_t *open_policy_build_path(struct open_policy_pane *pane) +{ + const char *primary_path = gtk_entry_get_text(pane->base_entry); + apol_policy_path_type_e path_type = APOL_POLICY_PATH_TYPE_MONOLITHIC; + apol_vector_t *modules = NULL; + apol_policy_path_t *path = NULL; + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pane->modular_radio))) { + path_type = APOL_POLICY_PATH_TYPE_MODULAR; + GtkTreeIter iter; + if ((modules = apol_vector_create(free)) == NULL) { + toplevel_ERR(pane->op->top, "%s", strerror(errno)); + return NULL; + } + if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(pane->module_store), &iter)) { + do { + GValue value = { 0 }; + char *module_path; + gtk_tree_model_get_value(GTK_TREE_MODEL(pane->module_store), &iter, PATH_COLUMN, &value); + module_path = g_value_dup_string(&value); + g_value_unset(&value); + if (apol_vector_append(modules, module_path) < 0) { + toplevel_ERR(pane->op->top, "%s", strerror(errno)); + free(module_path); + apol_vector_destroy(&modules); + return NULL; + } + } while (gtk_tree_model_iter_next(GTK_TREE_MODEL(pane->module_store), &iter)); + } + } + path = apol_policy_path_create(path_type, primary_path, modules); + apol_vector_destroy(&modules); + if (path == NULL) { + toplevel_ERR(pane->op->top, "%s", strerror(errno)); + return NULL; + } + return path; +} + +static void open_policy_on_import_click(GtkButton * button __attribute__ ((unused)), gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + apol_vector_t *paths = NULL; + apol_policy_path_t *ppath = NULL; + const char *path = NULL, *prev_path; + if ((prev_path = pane->last_module_path) == NULL) { + prev_path = gtk_entry_get_text(pane->base_entry); + if (strcmp(prev_path, "") == 0) { + prev_path = NULL; + } + } + paths = util_open_file(GTK_WINDOW(pane->op->dialog), "Import Policy List", prev_path, 1); + if (paths == NULL) { + return; + } + path = apol_vector_get_element(paths, 0); + ppath = apol_policy_path_create_from_file(path); + if (ppath == NULL) { + toplevel_ERR(pane->op->top, "Error importing policy list %s: %s", path, strerror(errno)); + goto cleanup; + } + open_policy_init_value(pane->op, ppath, pane); + free(pane->last_module_path); + pane->last_module_path = strdup(path); + cleanup: + apol_vector_destroy(&paths); + apol_policy_path_destroy(&ppath); +} + +static void open_policy_on_export_click(GtkButton * button __attribute__ ((unused)), gpointer user_data) +{ + struct open_policy_pane *pane = (struct open_policy_pane *)user_data; + char *path = util_save_file(GTK_WINDOW(pane->op->dialog), "Export Policy List", NULL); + apol_policy_path_t *ppath = NULL; + if (path == NULL) { + return; + } + ppath = open_policy_build_path(pane); + if (ppath == NULL) { + goto cleanup; + } + if (apol_policy_path_to_file(ppath, path) < 0) { + toplevel_ERR(pane->op->top, "Error exporting policy list %s: %s", path, strerror(errno)); + } + cleanup: + g_free(path); + apol_policy_path_destroy(&ppath); +} + +void open_policies_dialog_run(toplevel_t * top, const apol_policy_path_t * orig_path, const apol_policy_path_t * mod_path) +{ + struct open_policy op; + gint response; + apol_policy_path_t *input[SEDIFFX_POLICY_NUM]; + + memset(&op, 0, sizeof(op)); + op.top = top; + op.xml = glade_xml_new(toplevel_get_glade_xml(top), "PoliciesOpenWindow", NULL); + op.pane[SEDIFFX_POLICY_ORIG].op = &op; + op.pane[SEDIFFX_POLICY_MOD].op = &op; + + open_policy_init_widgets(&op); + open_policy_init_signals(&op); + open_policy_init_values(&op, orig_path, mod_path); + open_policy_on_entry_event_after(NULL, NULL, &op); + + while (1) { + response = gtk_dialog_run(op.dialog); + if (response == GTK_RESPONSE_CANCEL || response == GTK_RESPONSE_DELETE_EVENT) { + break; + } + if ((input[SEDIFFX_POLICY_ORIG] = open_policy_build_path(&op.pane[SEDIFFX_POLICY_ORIG])) == NULL || + (input[SEDIFFX_POLICY_MOD] = open_policy_build_path(&op.pane[SEDIFFX_POLICY_MOD])) == NULL) { + continue; + } + if (toplevel_open_policies(op.top, input[SEDIFFX_POLICY_ORIG], input[SEDIFFX_POLICY_MOD]) == 0) { + break; + } + } + gtk_widget_destroy(GTK_WIDGET(op.dialog)); + free(op.pane[SEDIFFX_POLICY_ORIG].last_module_path); + free(op.pane[SEDIFFX_POLICY_MOD].last_module_path); + g_object_unref(op.pane[SEDIFFX_POLICY_ORIG].module_store); + g_object_unref(op.pane[SEDIFFX_POLICY_MOD].module_store); + + if (response == 0) { + /* Run Diff button was clicked */ + toplevel_run_diff(op.top); + } +} |