static gboolean update_device_lists(FormatDialog* dialog) { if(dialog->hal_drive_list) { format_volume_list_free(dialog->hal_drive_list); dialog->hal_drive_list = NULL; } dialog->hal_drive_list = build_volume_list(dialog->hal_context, FORMATVOLUMETYPE_DRIVE, dialog->icon_cache, 22, 22); if(!dialog->hal_drive_list) { show_error_dialog(dialog->toplevel, _("Cannot get list of disks"), _("Make sure the HAL daemon is running and configured correctly")); return FALSE; } if(dialog->hal_volume_list) { format_volume_list_free(dialog->hal_volume_list); dialog->hal_volume_list = NULL; } dialog->hal_volume_list = build_volume_list(dialog->hal_context, FORMATVOLUMETYPE_VOLUME, dialog->icon_cache, 22, 22); if(!dialog->hal_volume_list) { show_error_dialog(dialog->toplevel, _("Cannot get list of partitions"), _("Make sure the HAL daemon is running and configured correctly")); return FALSE; } return TRUE; }
/* Test database status: database exists, correct tables, correct version */ static GdaConnection * sql_get_tested_connection (const gchar *dsn_name, const gchar *host, const gchar *db_name, GdaClient *client, PlannerPlugin *plugin) { GdaConnection *conn = NULL; gboolean success; gchar *str; GError *error; conn = gda_client_open_connection (client, dsn_name, NULL, NULL, 0, &error); if (conn == NULL) { if (!create_database (dsn_name, host, db_name, plugin)) { str = g_strdup_printf (_("Connection to database '%s@%s' failed."), db_name, host); show_error_dialog (plugin, str); conn = NULL; } else { conn = gda_client_open_connection (client, dsn_name, NULL, NULL, 0, &error); } } if (conn != NULL) { success = sql_execute_command (conn, "SET TIME ZONE 'UTC'"); if (!success) { g_warning ("SET TIME ZONE command failed: %s.", sql_get_last_error (conn)); goto out; } if (!check_database_tables (conn, plugin)) { str = g_strdup_printf (_("Test to tables in database '%s' failed."), db_name); show_error_dialog (plugin, str); g_free (str); goto out; } } /* g_object_unref (client); */ return conn; out: if (conn) { gda_connection_close (conn); } return NULL; }
/* An application is valid if: * * 1) The file exists * 2) The user has permissions to run the file */ static gboolean check_application (GtkAppChooserDialog *self, GAppInfo **app_out) { const char *command; char *path = NULL; char **argv = NULL; int argc; GError *error = NULL; gint retval = TRUE; GAppInfo *info; command = NULL; info = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (self->priv->app_chooser_widget)); command = g_app_info_get_executable (info); g_shell_parse_argv (command, &argc, &argv, &error); if (error) { show_error_dialog (_("Could not run application"), error->message, GTK_WINDOW (self)); g_error_free (error); retval = FALSE; goto cleanup; } path = g_find_program_in_path (argv[0]); if (!path) { char *error_message; error_message = g_strdup_printf (_("Could not find '%s'"), argv[0]); show_error_dialog (_("Could not find application"), error_message, GTK_WINDOW (self)); g_free (error_message); retval = FALSE; goto cleanup; } *app_out = info; cleanup: g_strfreev (argv); g_free (path); return retval; }
bool GodotSharpEditor::_create_project_solution() { EditorProgress pr("create_csharp_solution", "Generating solution...", 2); pr.step("Generating C# project..."); String path = OS::get_singleton()->get_resource_dir(); String name = ProjectSettings::get_singleton()->get("application/config/name"); if (name.empty()) { name = "UnnamedProject"; } String guid = CSharpProject::generate_game_project(path, name); if (guid.length()) { NETSolution solution(name); if (!solution.set_path(path)) { show_error_dialog("Failed to create solution."); return false; } Vector<String> extra_configs; extra_configs.push_back("Tools"); solution.add_new_project(name, guid, extra_configs); Error sln_error = solution.save(); if (sln_error != OK) { show_error_dialog("Failed to save solution."); return false; } if (!GodotSharpBuilds::make_api_sln(GodotSharpBuilds::API_CORE)) return false; if (!GodotSharpBuilds::make_api_sln(GodotSharpBuilds::API_EDITOR)) return false; pr.step("Done"); // Here, after all calls to progress_task_step call_deferred("_remove_create_sln_menu_option"); } else { show_error_dialog("Failed to create C# project."); } return true; }
static void software_button_clicked_cb (GtkButton *button, GtkAppChooserDialog *self) { GSubprocess *process; GError *error = NULL; gchar *option; if (self->priv->content_type) option = g_strconcat ("--search=", self->priv->content_type, NULL); else option = g_strdup ("--mode=overview"); process = g_subprocess_new (0, &error, "gnome-software", option, NULL); if (!process) { show_error_dialog (_("Failed to start GNOME Software"), error->message, GTK_WINDOW (self)); g_error_free (error); } else g_object_unref (process); g_free (option); }
uintptr_t object_alloc(int size, int tag) { uintptr_t *ret; if(tag == FLOAT_TAG) ret = GC_MALLOC(sizeof(double)); else ret = GC_MALLOC(size * sizeof(OBJECT_PTR)); if(!ret) { if(!console_mode && !single_expression_mode && !pipe_mode) { char buf[MAX_STRING_LENGTH]; memset(buf, '\0', MAX_STRING_LENGTH); int len=0; len += sprintf(buf, "Unable to allocate memory\n"); show_error_dialog(buf); } else printf("Unable to allocate memory\n"); cleanup(); exit(1); } assert(is_valid_object((OBJECT_PTR)((uintptr_t)ret+tag))); return (uintptr_t)ret; }
static void on_realm_joined (GObject *source, GAsyncResult *result, gpointer user_data) { UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data); GError *error = NULL; um_realm_join_finish (self->selected_realm, result, &error); /* Yay, joined the domain, register the user locally */ if (error == NULL) { g_debug ("Joining realm completed successfully"); enterprise_permit_user_login (self); /* Credential failure while joining domain, prompt for admin creds */ } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN) || g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) { g_debug ("Joining realm failed due to credentials"); join_show_prompt (self, error); /* Other failure */ } else { show_error_dialog (self, _("Failed to join domain"), error); g_message ("Failed to join the domain: %s", error->message); finish_action (self); g_error_free (error); } g_object_unref (self); }
static void on_join_login (GObject *source, GAsyncResult *result, gpointer user_data) { UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data); GError *error = NULL; GBytes *creds; um_realm_login_finish (result, &creds, &error); /* Logged in as admin successfully, use creds to join domain */ if (error == NULL) { if (!um_realm_join_as_admin (self->selected_realm, gtk_entry_get_text (self->join_name), gtk_entry_get_text (self->join_password), creds, self->cancellable, on_realm_joined, g_object_ref (self))) { show_error_dialog (self, _("No supported way to authenticate with this domain"), NULL); g_message ("Authenticating as admin is not supported by the realm"); finish_action (self); } g_bytes_unref (creds); /* Couldn't login as admin, show prompt again */ } else { join_show_prompt (self, error); g_message ("Couldn't log in as admin to join domain: %s", error->message); g_error_free (error); } g_object_unref (self); }
static gboolean spawn_synaptic (GtkWindow *window, const gchar *path, gint *child_pid) { gchar **argv; GError *error = NULL; gboolean retval = TRUE; gint i = 0; argv = g_new0 (gchar*, 6); argv[i++] = g_find_program_in_path ("gksudo"); argv[i++] = g_strdup ("--desktop"); argv[i++] = g_strdup ("/usr/share/applications/synaptic.desktop"); argv[i++] = g_strdup ("--disable-grab"); argv[i++] = get_synaptic_command_line (window, path); argv[i++] = NULL; if (!gdk_spawn_on_screen (gtk_window_get_screen (window), NULL, argv, NULL, G_SPAWN_SEARCH_PATH | G_SPAWN_DO_NOT_REAP_CHILD, NULL, NULL, child_pid, &error)) { show_error_dialog (window, (error) ? error->message : ""); g_error_free (error); retval = FALSE; } g_strfreev (argv); return retval; }
static void on_register_user (GObject *source, GAsyncResult *result, gpointer user_data) { UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data); GError *error = NULL; UmUser *user = NULL; um_user_manager_cache_user_finish (UM_USER_MANAGER (source), result, &user, &error); /* This is where we're finally done */ if (error == NULL) { g_debug ("Successfully cached remote user: %s", um_user_get_user_name (user)); finish_action (self); complete_dialog (self, user); } else { show_error_dialog (self, _("Failed to register account"), error); g_message ("Couldn't cache user account: %s", error->message); finish_action (self); g_error_free (error); } }
static void search_for_mimetype_ready_cb (GObject *source, GAsyncResult *res, gpointer user_data) { GtkAppChooserOnline *online = GTK_APP_CHOOSER_ONLINE (source); GtkAppChooserDialog *self = user_data; GError *error = NULL; gdk_threads_enter (); _gtk_app_chooser_online_search_for_mimetype_finish (online, res, &error); if (error != NULL) { show_error_dialog (_("Failed to look for applications online"), error->message, GTK_WINDOW (self)); g_error_free (error); } else { gtk_app_chooser_refresh (GTK_APP_CHOOSER (self->priv->app_chooser_widget)); } gdk_threads_leave (); }
static void on_join_login (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); GError *error = NULL; GBytes *creds; um_realm_login_finish (priv->realm, result, &creds, &error); /* Logged in as admin successfully, use creds to join domain */ if (error == NULL) { if (!um_realm_join_as_admin (priv->realm, gtk_entry_get_text (GTK_ENTRY (priv->join_name)), gtk_entry_get_text (GTK_ENTRY (priv->join_password)), creds, NULL, on_realm_joined, page)) { show_error_dialog (page, _("No supported way to authenticate with this domain"), NULL); g_message ("Authenticating as admin is not supported by the realm"); } g_bytes_unref (creds); /* Couldn't login as admin, show prompt again */ } else { join_show_prompt (page, error); g_message ("Couldn't log in as admin to join domain: %s", error->message); g_error_free (error); } }
static void on_realm_joined (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); GError *error = NULL; um_realm_join_finish (priv->realm, result, &error); /* Yay, joined the domain, register the user locally */ if (error == NULL) { g_debug ("Joining realm completed successfully"); enterprise_permit_user_login (page, priv->realm); /* Credential failure while joining domain, prompt for admin creds */ } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN) || g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD) || g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_HOSTNAME)) { g_debug ("Joining realm failed due to credentials or host name"); join_show_prompt (page, error); /* Other failure */ } else { show_error_dialog (page, _("Failed to join domain"), error); g_message ("Failed to join the domain: %s", error->message); apply_complete (page, FALSE); } g_clear_error (&error); }
static void on_realm_login (GObject *source, GAsyncResult *result, gpointer user_data) { UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data); GError *error = NULL; GBytes *creds; um_realm_login_finish (result, &creds, &error); if (error == NULL) { /* Already joined to the domain, just register this user */ if (um_realm_is_configured (self->selected_realm)) { g_debug ("Already joined to this realm"); enterprise_permit_user_login (self); /* Join the domain, try using the user's creds */ } else if (!um_realm_join_as_user (self->selected_realm, gtk_entry_get_text (self->enterprise_login), gtk_entry_get_text (self->enterprise_password), creds, self->cancellable, on_realm_joined, g_object_ref (self))) { /* If we can't do user auth, try to authenticate as admin */ g_debug ("Cannot join with user credentials"); join_show_prompt (self, NULL); } g_bytes_unref (creds); /* A problem with the user's login name or password */ } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN)) { g_debug ("Problem with the user's login: %s", error->message); set_entry_validation_error (self->enterprise_login, error->message); finish_action (self); gtk_widget_grab_focus (GTK_WIDGET (self->enterprise_login)); } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) { g_debug ("Problem with the user's password: %s", error->message); set_entry_validation_error (self->enterprise_password, error->message); finish_action (self); gtk_widget_grab_focus (GTK_WIDGET (self->enterprise_password)); /* Other login failure */ } else { g_dbus_error_strip_remote_error (error); show_error_dialog (self, _("Failed to log into domain"), error); g_message ("Couldn't log in as user: %s", error->message); finish_action (self); } g_clear_error (&error); g_object_unref (self); }
/** * gdict_show_error_dialog: * @widget: the widget that emits the error * @title: the primary error message * @message: the secondary error message or %NULL * * Creates and shows an error dialog bound to @widget. * * Since: 1.0 */ void _gdict_show_error_dialog (GtkWidget *widget, const gchar *title, const gchar *detail) { g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (title != NULL); show_error_dialog (get_toplevel_window (widget), title, detail); }
static FormatVolume* write_partition_table(FormatDialog* dialog, FormatVolume* vol, const char* fs) { FormatVolume* ret = NULL; char* drive_udi = g_strdup(libhal_drive_get_udi(vol->drive)); /* Write out a new table */ GError* err = NULL; /* FIXME: Somehow, we need to decide what kind of table to write */ if(!write_partition_table_for_device(vol->drive, PART_TYPE_MSDOS, &err)) { show_error_dialog(dialog->toplevel, _("Error formatting disk"), err->message); g_error_free(err); goto out; } /* Set the partition type */ int msdos_type = get_part_type_from_fs(fs); if( !set_partition_type(vol->drive, 0 /* Always first partition */, msdos_type) ) { show_error_dialog(dialog->toplevel, _("Error formatting disk"), _("Couldn't set partition type on drive")); goto out; } /* Find the partition attached to our drive */ if(!update_device_lists(dialog)) goto out; GSList* iter; for(iter = dialog->hal_volume_list; iter != NULL; iter = g_slist_next(iter)) { FormatVolume* vol = iter->data; if(!strcmp(vol->drive_udi, drive_udi)) break; } if(iter == NULL) { show_error_dialog(dialog->toplevel, _("Error formatting disk"), _("Can't find new partition after formatting. Try again")); goto out; } ret = iter->data; out: return ret; }
void on_help_button_clicked (GtkWidget *w, gpointer user_data) { GError *error = NULL; gnome_help_display_desktop_on_screen (NULL, "gformat", "gformat", "usage", gtk_widget_get_screen (w), &error); if (error) { show_error_dialog (gtk_widget_get_toplevel(w), _("Could not display help for the disk formatter."), error->message); g_error_free (error); } }
static void check_wireless (WirelessApplet *applet) { struct stat sbuf; if (stat ("/proc/net/wireless", &sbuf) != 0) { gtk_tooltips_set_tip (applet->tips, GTK_WIDGET (applet), _("No Wireless Devices"), NULL); show_error_dialog (_("There doesn't seem to be any wireless devices configured on your system.\nPlease verify your configuration if you think this is incorrect.")); } }
/** * gdict_show_gerror_dialog: * @widget: the widget that emits the error * @title: the primary error message * @error: a #GError * * Creates and shows an error dialog bound to @widget, using @error * to fill the secondary text of the message dialog with the error * message. Also takes care of freeing @error. * * Since: 1.0 */ void _gdict_show_gerror_dialog (GtkWidget *widget, const gchar *title, GError *error) { g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (title != NULL); g_return_if_fail (error != NULL); show_error_dialog (get_toplevel_window (widget), title, error->message); g_error_free (error); }
static void launch_mate_disk (const gchar *device_file) { gchar *command_line; GError *error; command_line = g_strdup_printf ("mate_disk --show-volume \"%s\"", device_file); error = NULL; if (!g_spawn_command_line_async (command_line, &error)) { show_error_dialog (NULL, _("Error launching Disk Utility"), error->message); g_error_free (error); } g_free (command_line); }
void load_keybind( gmpv_handle *ctx, const gchar *config_path, gboolean notify_propexp ) { gboolean propexp; ctx->keybind_list = keybind_parse_config_with_defaults(config_path, &propexp); if(notify_propexp && propexp) { const gchar *msg = _( "Keybindings that require Property " "Expansion are not supported and have " "been ignored." ); show_error_dialog(ctx, NULL, msg); } }
static gboolean find_app (GtkWindow *window, const gchar *app) { gchar *path; path = g_find_program_in_path (app); if(!path) { show_error_dialog (window, _("The necessary applications to install" " the package could not be found.")); return FALSE; } g_free (path); return TRUE; }
void Logger::log_handler(const gchar * log_domain, GLogLevelFlags log_level, const gchar *message, gpointer user_data) { std::stringstream buf; if(log_domain && log_domain[0]) buf << "(" << log_domain << ") "; if(log_level & G_LOG_LEVEL_ERROR) buf << "[error] "; else if(log_level & G_LOG_LEVEL_CRITICAL) buf << "[critical] "; else if(log_level & G_LOG_LEVEL_WARNING) buf << "[warning] "; else if(log_level & G_LOG_LEVEL_MESSAGE) buf << "[message] "; else if(log_level & G_LOG_LEVEL_INFO) buf << "[info] "; else if(log_level & G_LOG_LEVEL_DEBUG) buf << "[debug] "; if(message) buf << message; buf << "\n"; if(is_do_log_message(log_level, logger->console_message_level)) { std::cout << buf.str(); #ifdef ENABLE_LOG_WINDOW gLogWindow.append(buf.str().c_str()); #endif } if(is_do_log_message(log_level, logger->log_message_level) && logger->h_log_file) { fputs(buf.str().c_str(), logger->h_log_file); logger->start_flush_log_timer(); } // the application will be aborted short after this message if(log_level & G_LOG_FLAG_FATAL) { if(logger->h_log_file) fflush(logger->h_log_file); // make the fault loud and clear for the user show_error_dialog(buf.str().c_str()); } }
static void on_permit_user_login (GObject *source, GAsyncResult *result, gpointer user_data) { UmAccountDialog *self = UM_ACCOUNT_DIALOG (user_data); UmRealmCommon *common; UmUserManager *manager; GError *error = NULL; gchar *login; common = UM_REALM_COMMON (source); um_realm_common_call_change_login_policy_finish (common, result, &error); if (error == NULL) { /* * Now tell the account service about this user. The account service * should also lookup information about this via the realm and make * sure all that is functional. */ manager = um_user_manager_ref_default (); login = um_realm_calculate_login (common, gtk_entry_get_text (self->enterprise_login)); g_return_if_fail (login != NULL); g_debug ("Caching remote user: %s", login); um_user_manager_cache_user (manager, login, self->cancellable, on_register_user, g_object_ref (self), g_object_unref); g_free (login); g_object_unref (manager); } else { show_error_dialog (self, _("Failed to register account"), error); g_message ("Couldn't permit logins on account: %s", error->message); finish_action (self); } g_object_unref (self); }
void raise_error(char *err_str) { if(!console_mode && !single_expression_mode && !pipe_mode) { show_error_dialog(err_str); #ifdef INTERPRETER_MODE debug_mode = true; debug_continuation = create_current_continuation(); debug_env = reg_current_env; reg_next_expression = NIL; debug_execution_stack = reg_current_stack; create_debug_window(DEFAULT_DEBUG_WINDOW_POSX, DEFAULT_DEBUG_WINDOW_POSY, DEFAULT_DEBUG_WINDOW_WIDTH, DEFAULT_DEBUG_WINDOW_HEIGHT); #endif } else fprintf(stdout, "%s\n", err_str); //to stay commented out till we are //able to prpvide a meaningful backtrace //fprintf(stdout, "Begin backtrace\n"); //print_backtrace(); //fprintf(stdout, "End backtrace\n"); #ifdef INTERPRETER_MODE reg_accumulator = NIL; reg_current_value_rib = NIL; reg_next_expression = NIL; #endif in_error = true; exception_object = cons(get_symbol_object("EXCEPTION"), get_string_object(err_str)); }
static void on_permit_user_login (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); UmRealmCommon *common; GError *error = NULL; gchar *login; common = UM_REALM_COMMON (source); um_realm_common_call_change_login_policy_finish (common, result, &error); if (error == NULL) { /* * Now tell the account service about this user. The account service * should also lookup information about this via the realm and make * sure all that is functional. */ login = um_realm_calculate_login (common, gtk_entry_get_text (GTK_ENTRY (priv->login))); g_return_if_fail (login != NULL); g_debug ("Caching remote user: %s", login); priv->act_user = act_user_manager_cache_user (priv->act_client, login, NULL); g_signal_emit (page, signals[USER_CACHED], 0, priv->act_user, gtk_entry_get_text (GTK_ENTRY (priv->password))); apply_complete (page, TRUE); g_free (login); } else { show_error_dialog (page, _("Failed to register account"), error); g_message ("Couldn't permit logins on account: %s", error->message); g_error_free (error); apply_complete (page, FALSE); } }
static void create_user_done (UmUserManager *manager, GAsyncResult *res, UmAccountDialog *self) { UmUser *user; GError *error; finish_action (self); /* Note that user is returned without an extra reference */ error = NULL; if (!um_user_manager_create_user_finish (manager, res, &user, &error)) { g_debug ("Failed to create user: %s", error->message); if (!g_error_matches (error, UM_USER_MANAGER_ERROR, UM_USER_MANAGER_ERROR_PERMISSION_DENIED)) show_error_dialog (self, _("Failed to add account"), error); g_error_free (error); gtk_widget_grab_focus (self->local_name); } else { g_debug ("Created user: %s", um_user_get_user_name (user)); complete_dialog (self, user); } }
static void on_realm_login (GObject *source, GAsyncResult *result, gpointer user_data) { GisAccountPageEnterprise *page = user_data; GisAccountPageEnterprisePrivate *priv = gis_account_page_enterprise_get_instance_private (page); GError *error = NULL; GBytes *creds = NULL; um_realm_login_finish (priv->realm, result, &creds, &error); /* * User login is valid, but cannot authenticate right now (eg: user needs * to change password at next login etc.) */ if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_CANNOT_AUTH)) { g_clear_error (&error); creds = NULL; } if (error == NULL) { /* Already joined to the domain, just register this user */ if (um_realm_is_configured (priv->realm)) { g_debug ("Already joined to this realm"); enterprise_permit_user_login (page, priv->realm); /* Join the domain, try using the user's creds */ } else if (creds == NULL || !um_realm_join_as_user (priv->realm, gtk_entry_get_text (GTK_ENTRY (priv->login)), gtk_entry_get_text (GTK_ENTRY (priv->password)), creds, priv->cancellable, on_realm_joined, page)) { /* If we can't do user auth, try to authenticate as admin */ g_debug ("Cannot join with user credentials"); join_show_prompt (page, error); } g_bytes_unref (creds); /* A problem with the user's login name or password */ } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_LOGIN)) { g_debug ("Problem with the user's login: %s", error->message); set_entry_validation_error (GTK_ENTRY (priv->login), error->message); gtk_widget_grab_focus (priv->login); apply_complete (page, FALSE); } else if (g_error_matches (error, UM_REALM_ERROR, UM_REALM_ERROR_BAD_PASSWORD)) { g_debug ("Problem with the user's password: %s", error->message); set_entry_validation_error (GTK_ENTRY (priv->password), error->message); gtk_widget_grab_focus (priv->password); apply_complete (page, FALSE); /* Other login failure */ } else { show_error_dialog (page, _("Failed to log into domain"), error); g_message ("Couldn't log in as user: %s", error->message); apply_complete (page, FALSE); } g_clear_error (&error); }
int main (int argc, char *argv[]) { int ret; GError *error; MduPool *pool; MduDevice *device; MduDevice *device_to_unmount; MduDevice *device_to_mount; MduPresentable *volume; gchar *volume_name; gchar *confirmation_secondary; GtkWidget *dialog; gint response; gchar *fs_type; gchar *fs_label; gboolean encrypt; gchar *passphrase; gboolean save_passphrase_in_keyring; gboolean save_passphrase_in_keyring_session; GMainLoop *loop; GVolumeMonitor *gvolume_monitor; GList *l; GList *gvolumes; GVolume *gvolume; GMount *gmount; gboolean take_ownership; FormatData *format_data; MduPresentable *toplevel; gchar *drive_name; gchar *format_desc; gchar *formatting_desc; gchar *size_str; gint grace_timeout_id; ret = 1; pool = NULL; device = NULL; device_to_unmount = NULL; device_to_mount = NULL; volume = NULL; volume_name = NULL; confirmation_secondary = NULL; dialog = NULL; fs_type = NULL; fs_label = NULL; passphrase = NULL; loop = NULL; volume = NULL; gmount = NULL; gvolume_monitor = NULL; gvolumes = NULL; gvolume = NULL; gmount = NULL; format_data = NULL; toplevel = NULL; drive_name = NULL; format_desc = NULL; formatting_desc = NULL; size_str = NULL; #if !GLIB_CHECK_VERSION (2, 32, 0) g_thread_init (NULL); #endif /* Initialize gettext support */ bindtextdomain (GETTEXT_PACKAGE, MATELOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain (GETTEXT_PACKAGE); /* Initialize gtk */ error = NULL; if (! gtk_init_with_args (&argc, &argv, NULL, entries, GETTEXT_PACKAGE, &error)) { g_printerr ("Could not parse arguments: %s\n", error->message); g_error_free (error); goto out; } loop = g_main_loop_new (NULL, FALSE); g_set_prgname ("mdu-format-tool"); g_set_application_name (_("Mate Disk Utility formatting tool")); if (device_file == NULL) { g_printerr ("Incorrect usage. Try --help.\n"); goto out; } pool = mdu_pool_new (); if (pool == NULL) { g_warning ("Unable to get device pool"); goto out; } device = mdu_pool_get_by_device_file (pool, device_file); if (device == NULL) { g_printerr ("No device for %s\n", device_file); goto out; } /* if the user specified a luks device, find the slave backing device */ if (mdu_device_is_luks_cleartext (device)) { const gchar *slave; slave = mdu_device_luks_cleartext_get_slave (device); g_object_ref (device); device = mdu_pool_get_by_object_path (pool, slave); /* don't support LUKS in LUKS... */ g_assert (!mdu_device_is_luks_cleartext (device)); } volume = mdu_pool_get_volume_by_device (pool, device); if (volume == NULL) { g_printerr ("%s is not a volume\n", device_file); goto out; } volume_name = mdu_presentable_get_name (volume); toplevel = mdu_presentable_get_toplevel (MDU_PRESENTABLE (volume)); if (toplevel != NULL && MDU_IS_DRIVE (toplevel)) { drive_name = mdu_presentable_get_name (toplevel); } size_str = mdu_util_get_size_for_display (mdu_device_get_size (device), FALSE, FALSE); if (drive_name != NULL) { if (mdu_device_is_partition (device)) { /* Translators: First argument is the partition number, second argument is the drive name, * third argument is the size (e.g. 10 GB) */ format_desc = g_strdup_printf (_("Format partition %d of %s (%s)"), mdu_device_partition_get_number (device), drive_name, size_str); /* Translators: First argument is the partition number, second argument is the drive name, * third argument is the size (e.g. 10 GB) */ formatting_desc = g_strdup_printf (_("Formatting partition %d of %s (%s)"), mdu_device_partition_get_number (device), drive_name, size_str); } else { /* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */ format_desc = g_strdup_printf (_("Format %s (%s)"), drive_name, size_str); /* Translators: First argument is the drive name, second argument is the size (e.g. 10 GB) */ formatting_desc = g_strdup_printf (_("Formatting %s (%s)"), drive_name, size_str); } } else { /* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */ format_desc = g_strdup_printf (_("Format %s Volume (%s)"), size_str, mdu_device_get_device_file (device)); /* Translators: First argument is the size (e.g. 10 GB), second is the device (e.g. /dev/md0) */ formatting_desc = g_strdup_printf (_("Formatting %s Volume (%s)"), size_str, mdu_device_get_device_file (device)); } dialog = mdu_format_dialog_new (NULL, /* no parent window */ volume, MDU_FORMAT_DIALOG_FLAGS_SIMPLE | MDU_FORMAT_DIALOG_FLAGS_DISK_UTILITY_BUTTON); gtk_window_set_title (GTK_WINDOW (dialog), format_desc); gtk_window_set_icon_name (GTK_WINDOW (dialog), "caja-mdu"); gtk_widget_show_all (dialog); response = gtk_dialog_run (GTK_DIALOG (dialog)); switch (response) { case GTK_RESPONSE_OK: break; case GTK_RESPONSE_ACCEPT: gtk_widget_destroy (dialog); dialog = NULL; launch_mate_disk (device_file); goto out; default: /* explicit fallthrough */ case GTK_RESPONSE_CANCEL: goto out; } fs_type = mdu_format_dialog_get_fs_type (MDU_FORMAT_DIALOG (dialog)); fs_label = mdu_format_dialog_get_fs_label (MDU_FORMAT_DIALOG (dialog)); encrypt = mdu_format_dialog_get_encrypt (MDU_FORMAT_DIALOG (dialog)); gtk_widget_destroy (dialog); dialog = NULL; /* Ask for passphrase if needed */ passphrase = NULL; save_passphrase_in_keyring = FALSE; save_passphrase_in_keyring_session = FALSE; if (encrypt) { passphrase = mdu_util_dialog_ask_for_new_secret (NULL, &save_passphrase_in_keyring, &save_passphrase_in_keyring_session); if (passphrase == NULL) goto out; } take_ownership = (g_strcmp0 (fs_type, "vfat") != 0); format_data = g_new0 (FormatData, 1); format_data->loop = loop; format_data->error = NULL; dialog = mdu_format_progress_dialog_new (NULL, device, _("Preparing...")); gtk_window_set_title (GTK_WINDOW (dialog), formatting_desc); gtk_widget_show_all (dialog); g_signal_connect (dialog, "response", G_CALLBACK (on_progress_dialog_response), format_data); /* first a small 2.5 sec window to allow the user to cancel before initiating */ grace_timeout_id = g_timeout_add (2500, on_grace_timeout, format_data); g_main_loop_run (loop); g_source_remove (grace_timeout_id); if (format_data->error != NULL && format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_CANCELLED) { /* cancelled already, we are done */ goto out; } /* then unmount the mount if needed; we use GIO for this to handle tearing * down LUKS; first determine the device to unmount */ if (mdu_device_is_luks (device)) { const gchar *holder; holder = mdu_device_luks_get_holder (device); device_to_unmount = mdu_pool_get_by_object_path (pool, holder); } else { device_to_unmount = g_object_ref (device); } g_assert (device_to_unmount != NULL); gvolume_monitor = g_volume_monitor_get (); gvolumes = g_volume_monitor_get_volumes (gvolume_monitor); for (l = gvolumes; l != NULL; l = l->next) { GVolume *v = G_VOLUME (l->data); if (g_strcmp0 (g_volume_get_identifier (v, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE), mdu_device_get_device_file (device_to_unmount)) == 0) { gvolume = g_object_ref (v); break; } } if (gvolume != NULL) { gmount = g_volume_get_mount (gvolume); if (gmount != NULL) { GMountOperation *mount_op; mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Unmounting...")); mount_op = gtk_mount_operation_new (GTK_WINDOW (dialog)); g_mount_unmount_with_operation (gmount, G_MOUNT_UNMOUNT_NONE, mount_op, NULL, unmount_cb, format_data); g_object_unref (mount_op); g_main_loop_run (format_data->loop); if (format_data->error != NULL) { if (!(format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_FAILED_HANDLED)) { gchar *primary; primary = g_strdup_printf (_("Unable to format '%s'"), volume_name); show_error_dialog (NULL, primary, format_data->error->message); g_free (primary); } g_error_free (format_data->error); goto out; } } } /* and now, kick off the operation */ mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Formatting...")); mdu_device_op_filesystem_create (device, fs_type, fs_label, passphrase, take_ownership, fs_create_cb, format_data); again: g_main_loop_run (loop); if (format_data->error != NULL) { gtk_widget_destroy (dialog); dialog = NULL; if (format_data->error->domain == G_IO_ERROR && format_data->error->code == G_IO_ERROR_CANCELLED) { mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Cancelling...")); /* cancel the job; no callback since op_filesystem_create will return an error */ mdu_device_op_cancel_job (device, NULL, NULL); goto again; } else { show_error_dialog (NULL, _("Error formatting volume"), format_data->error->message); g_error_free (format_data->error); } goto out; } /* ugh, DeviceKit-disks bug - spin around in the mainloop for some time to ensure we * have gotten all changes */ mdu_format_progress_dialog_set_text (MDU_FORMAT_PROGRESS_DIALOG (dialog), _("Mounting volume...")); g_timeout_add (1500, on_hack_timeout, loop); g_main_loop_run (loop); /* OK, peachy, now mount the volume and open a window */ if (passphrase != NULL) { const gchar *cleartext_objpath; g_assert (mdu_device_is_luks (device)); cleartext_objpath = mdu_device_luks_get_holder (device); device_to_mount = mdu_pool_get_by_object_path (pool, cleartext_objpath); } else { device_to_mount = g_object_ref (device); } mdu_device_op_filesystem_mount (device_to_mount, NULL, fs_mount_cb, format_data); g_main_loop_run (loop); gtk_widget_destroy (dialog); dialog = NULL; if (format_data->error != NULL) { show_error_dialog (NULL, _("Error mounting device"), format_data->error->message); g_error_free (format_data->error); goto out; } /* open file manager */ launch_file_manager (format_data->mount_point); g_free (format_data->mount_point); /* save passphrase in keyring if requested */ if (passphrase != NULL && (save_passphrase_in_keyring || save_passphrase_in_keyring_session)) { if (!mdu_util_save_secret (device, passphrase, save_passphrase_in_keyring_session)) { show_error_dialog (NULL, _("Error storing passphrase in keyring"), ""); goto out; } } ret = 0; out: if (toplevel != NULL) g_object_unref (toplevel); g_free (drive_name); g_free (size_str); g_free (format_desc); g_free (formatting_desc); if (gmount != NULL) g_object_unref (gmount); if (gvolume != NULL) g_object_unref (gvolume); g_list_foreach (gvolumes, (GFunc) g_object_unref, NULL); if (gvolume_monitor != NULL) g_object_unref (gvolume_monitor); g_free (confirmation_secondary); g_free (volume_name); g_free (passphrase); g_free (fs_type); g_free (fs_label); g_free (device_file); if (loop != NULL) g_main_loop_unref (loop); if (dialog != NULL) gtk_widget_destroy (dialog); if (volume != NULL) g_object_unref (volume); if (device != NULL) g_object_unref (device); if (device_to_unmount != NULL) g_object_unref (device_to_unmount); if (device_to_mount != NULL) g_object_unref (device_to_mount); if (pool != NULL) g_object_unref (pool); if (format_data != NULL) g_free (format_data); return ret; }
void show_import_request_dialog(FRONTEND * fe) { /* import dialog -> dialog (OK, cancel), filename entry & browse */ GtkWidget *dlg; GtkEntry *filename_entry; GtkButton *browse_button; GtkBox *box; int status; gint result; dlg = gtk_dialog_new_with_buttons("Import Request", GTK_WINDOW(fe->mainWindow), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL); box = GTK_BOX(gtk_hbox_new(0, 5)); gtk_box_pack_start(box, gtk_label_new("Import from"), FALSE, FALSE, 0); filename_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(filename_entry), FALSE, FALSE, 0); browse_button = GTK_BUTTON(gtk_button_new_with_mnemonic("_Browse...")); gtk_box_pack_start(box, GTK_WIDGET(browse_button), FALSE, FALSE, 0); g_signal_connect(G_OBJECT(browse_button), "clicked", G_CALLBACK(on_browse_button_clicked), dlg); g_object_set_data_full(G_OBJECT(browse_button), "entry", filename_entry, NULL); /* don't ref the entry -- same lifetime */ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dlg)->vbox), GTK_WIDGET(box), FALSE, FALSE, 0); gtk_widget_show_all(GTK_WIDGET(GTK_DIALOG(dlg)->vbox)); result = gtk_dialog_run(GTK_DIALOG(dlg)); if (result == GTK_RESPONSE_ACCEPT) { CRYPT_CERTIFICATE request; gchar *filename; filename = g_filename_from_utf8(gtk_entry_get_text(filename_entry), -1, NULL, NULL, NULL); if (filename != NULL) { void *data; int data_len; data = lmz_file_read_full(filename, &data_len); if (data != NULL) { status = cryptImportCert(data, data_len, CRYPT_UNUSED, &request); if (cryptStatusOK(status)) { int id; status = lmz_ca_add_request(fe->db, request, &id); if (!cryptStatusOK(status)) { show_error_dialog(NULL, "error adding request to db (cl err %d)", status); } else { /* yay, it worked */ GtkTreeView *mainwin_req_tv, *mainwin_cert_tv; mainwin_req_tv = GTK_TREE_VIEW(g_object_get_data (G_OBJECT(fe->mainWindow), "request-list")); mainwin_cert_tv = GTK_TREE_VIEW(g_object_get_data (G_OBJECT(fe->mainWindow), "certificate-list")); refresh_request_tree_view(mainwin_req_tv, fe); refresh_cert_tree_view(mainwin_cert_tv, fe); } cryptDestroyCert(request); } else { show_error_dialog(NULL, "error importing request (cl err %d)", status); } free(data); } else { show_error_dialog(NULL, "error reading file"); } g_free(filename); } else { } } gtk_widget_destroy(dlg); }