/* * HardInfo - Displays System Information * Copyright (C) 2003-2009 L. A. F. Pereira * * 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, version 2 or later. * * 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 "hardinfo.h" #include "iconcache.h" #include "syncmanager.h" #include #include #include #ifndef SOUP_CHECK_VERSION #define SOUP_CHECK_VERSION(a,b,c) 0 #endif typedef struct _SyncDialog SyncDialog; typedef struct _SyncNetArea SyncNetArea; typedef struct _SyncNetAction SyncNetAction; struct _SyncNetArea { GtkWidget *vbox; }; struct _SyncNetAction { SyncEntry *entry; GError *error; }; struct _SyncDialog { GtkWidget *dialog; GtkWidget *label; GtkWidget *button_sync; GtkWidget *button_cancel; GtkWidget *button_close; GtkWidget *button_priv_policy; GtkWidget *scroll_box; SyncNetArea *sna; gboolean flag_cancel : 1; }; static GSList *entries = NULL; static SoupSession *session = NULL; static GMainLoop *loop; static GQuark err_quark; //Note there are personal information involved and very old //linux systems does not work with HTTPS so use HTTP for now #define API_SERVER_URI "http://api.hardinfo2.org" #define LABEL_SYNC_DEFAULT \ _("Synchronize with Central Database\n" \ "The following information may be synchronized\n" \ "with the HardInfo central database.") #define LABEL_SYNC_SYNCING \ _("Synchronizing\n" \ "This may take some time.") static SyncDialog *sync_dialog_new(GtkWidget *parent); static void sync_dialog_destroy(SyncDialog *sd); static void sync_dialog_start_sync(SyncDialog *sd); static SyncNetArea *sync_dialog_netarea_new(void); static void sync_dialog_netarea_destroy(SyncNetArea *sna); static void sync_dialog_netarea_show(SyncDialog *sd); #if 0 static void sync_dialog_netarea_hide(SyncDialog * sd); #endif static void sync_dialog_netarea_start_actions(SyncDialog *sd, SyncNetAction *sna, gint n); #define SNA_ERROR(code, message, ...) \ if (!sna->error) { \ sna->error = g_error_new(err_quark, code, message, ##__VA_ARGS__); \ } gint sync_manager_count_entries(void) { return g_slist_length(entries); } void sync_manager_add_entry(SyncEntry *entry) { DEBUG("registering syncmanager entry ''%s''", entry->name); entry->selected = TRUE; entries = g_slist_append(entries, entry); } void sync_manager_clear_entries(void) { DEBUG("clearing syncmanager entries"); g_slist_free(entries); entries = NULL; } void sync_manager_show(GtkWidget *parent) { SyncDialog *sd = sync_dialog_new(parent); err_quark = g_quark_from_static_string("syncmanager"); if (gtk_dialog_run(GTK_DIALOG(sd->dialog)) == GTK_RESPONSE_ACCEPT) { shell_view_set_enabled(FALSE); shell_status_set_enabled(TRUE); shell_set_transient_dialog(GTK_WINDOW(sd->dialog)); sync_dialog_start_sync(sd); shell_set_transient_dialog(NULL); shell_status_set_enabled(FALSE); shell_view_set_enabled(TRUE); } sync_dialog_destroy(sd); } static gboolean _cancel_sync(GtkWidget *widget, gpointer data) { SyncDialog *sd = (SyncDialog *)data; if (session) { soup_session_abort(session); } sd->flag_cancel = TRUE; g_main_loop_quit(loop); gtk_widget_set_sensitive(widget, FALSE); return FALSE; } static SyncNetAction *sync_manager_get_selected_actions(gint *n) { gint i; GSList *entry; SyncNetAction *actions; actions = g_new0(SyncNetAction, g_slist_length(entries)); for (entry = entries, i = 0; entry; entry = entry->next) { SyncEntry *e = (SyncEntry *)entry->data; if (e->selected) { SyncNetAction sna = {.entry = e}; actions[i++] = sna; } } *n = i; return actions; } #if !SOUP_CHECK_VERSION(3,0,0) static SoupURI *sync_manager_get_proxy(void) { const gchar *conf; if (!(conf = g_getenv("HTTP_PROXY"))) { if (!(conf = g_getenv("http_proxy"))) { return NULL; } } return soup_uri_new(conf); } #endif static void ensure_soup_session(void) { if (!session) { #if SOUP_CHECK_VERSION(3,0,0) session = soup_session_new_with_options("timeout", 10, NULL); #else #if SOUP_CHECK_VERSION(2,42,0) SoupURI *proxy = sync_manager_get_proxy(); session = soup_session_new_with_options( SOUP_SESSION_TIMEOUT, 10, SOUP_SESSION_PROXY_URI, proxy, NULL); #else SoupURI *proxy = sync_manager_get_proxy(); session = soup_session_async_new_with_options( SOUP_SESSION_TIMEOUT, 10, SOUP_SESSION_PROXY_URI, proxy, NULL); #endif #endif } } static void sync_dialog_start_sync(SyncDialog *sd) { gint nactions; SyncNetAction *actions; ensure_soup_session(); loop = g_main_loop_new(NULL, FALSE); gtk_widget_hide(sd->button_sync); gtk_widget_hide(sd->button_priv_policy); sync_dialog_netarea_show(sd); g_signal_connect(G_OBJECT(sd->button_cancel), "clicked", (GCallback)_cancel_sync, sd); actions = sync_manager_get_selected_actions(&nactions); sync_dialog_netarea_start_actions(sd, actions, nactions); g_free(actions); if (sd->flag_cancel) { gtk_widget_hide(sd->button_cancel); gtk_widget_show(sd->button_close); /* wait for the user to close the dialog */ g_main_loop_run(loop); } g_main_loop_unref(loop); } #if SOUP_CHECK_VERSION(2,42,0) static void got_response(GObject *source, GAsyncResult *res, gpointer user_data) #else static void got_response(SoupSession *source, SoupMessage *res, gpointer user_data) #endif { SyncNetAction *sna = user_data; GInputStream *is; #if SOUP_CHECK_VERSION(2,42,0) #else const guint8 *buf=NULL; gsize len,datawritten; SoupBuffer *soupmsg=NULL; #endif #if SOUP_CHECK_VERSION(2,42,0) is = soup_session_send_finish(session, res, &sna->error); if (is == NULL) goto out; if (sna->error != NULL) goto out; #endif if (sna->entry->file_name != NULL) { //check for missing config dirs g_mkdir(g_get_user_config_dir(), 0766); g_mkdir(g_build_filename(g_get_user_config_dir(),"hardinfo2",NULL), 0766); // gchar *path = g_build_filename(g_get_user_config_dir(), "hardinfo2", sna->entry->file_name, NULL); GFile *file = g_file_new_for_path(path); GFileOutputStream *output = g_file_replace(file, NULL, FALSE, G_FILE_CREATE_REPLACE_DESTINATION, NULL, &sna->error); if (output != NULL) { #if SOUP_CHECK_VERSION(2,42,0) g_output_stream_splice(G_OUTPUT_STREAM(output), is, G_OUTPUT_STREAM_SPLICE_CLOSE_TARGET, NULL, &sna->error); #else soupmsg=soup_message_body_flatten(res->response_body); if(soupmsg){ soup_buffer_get_data(soupmsg,&buf,&len); DEBUG("got file with len: %u", (unsigned int)len); if(len>0){ g_output_stream_write_all(G_OUTPUT_STREAM(output),buf,len,&datawritten,NULL,&sna->error); soup_buffer_free(soupmsg); } } #endif } g_free(path); g_object_unref(file); } out: g_main_loop_quit(loop); #if SOUP_CHECK_VERSION(2,42,0) g_object_unref(is); #endif } static gboolean send_request_for_net_action(SyncNetAction *sna) { gchar *uri; SoupMessage *msg; guint response_code; uri = g_strdup_printf("%s/%s", API_SERVER_URI, sna->entry->file_name); if (sna->entry->generate_contents_for_upload == NULL) { msg = soup_message_new("GET", uri); } else { gsize size; gchar *contents = sna->entry->generate_contents_for_upload(&size); msg = soup_message_new("POST", uri); #if SOUP_CHECK_VERSION(3, 0, 0) GBytes *cont = g_bytes_new_static(contents,size); soup_message_set_request_body_from_bytes(msg, "application/octet-stream", cont); #else soup_message_set_request(msg, "application/octet-stream", SOUP_MEMORY_TAKE, contents, size); #endif } #if SOUP_CHECK_VERSION(3, 0, 0) soup_session_send_async(session, msg, G_PRIORITY_DEFAULT, NULL, got_response, sna); #else #if SOUP_CHECK_VERSION(2,42,0) soup_session_send_async(session, msg, NULL, got_response, sna); #else soup_session_queue_message(session, msg, got_response, sna); #endif #endif g_main_loop_run(loop); g_object_unref(msg); g_free(uri); if (sna->error != NULL) { DEBUG("Error while sending request: %s", sna->error->message); g_error_free(sna->error); sna->error = NULL; return FALSE; } return TRUE; } static void sync_dialog_netarea_start_actions(SyncDialog *sd, SyncNetAction sna[], gint n) { gint i; GtkWidget **labels; GtkWidget **status_labels; const gchar *done_str = "\342\234\223"; const gchar *error_str = "\342\234\227"; const gchar *curr_str = "\342\226\266"; const gchar *empty_str = "\302\240\302\240"; labels = g_new0(GtkWidget *, n); status_labels = g_new0(GtkWidget *, n); for (i = 0; i < n; i++) { GtkWidget *hbox; hbox = gtk_hbox_new(FALSE, 5); labels[i] = gtk_label_new(_(sna[i].entry->name)); status_labels[i] = gtk_label_new(empty_str); gtk_label_set_use_markup(GTK_LABEL(labels[i]), TRUE); gtk_label_set_use_markup(GTK_LABEL(status_labels[i]), TRUE); gtk_misc_set_alignment(GTK_MISC(labels[i]), 0.0, 0.5); gtk_misc_set_alignment(GTK_MISC(status_labels[i]), 1.0, 0.5); gtk_box_pack_start(GTK_BOX(hbox), status_labels[i], FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), labels[i], TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(sd->sna->vbox), hbox, FALSE, FALSE, 3); gtk_widget_show_all(hbox); } while (gtk_events_pending()) gtk_main_iteration(); for (i = 0; i < n; i++) { gchar *markup; if (sd->flag_cancel) { markup = g_strdup_printf("%s %s", _(sna[i].entry->name), _("(canceled)")); gtk_label_set_markup(GTK_LABEL(labels[i]), markup); g_free(markup); gtk_label_set_markup(GTK_LABEL(status_labels[i]), error_str); break; } markup = g_strdup_printf("%s", _(sna[i].entry->name)); gtk_label_set_markup(GTK_LABEL(labels[i]), markup); g_free(markup); gtk_label_set_markup(GTK_LABEL(status_labels[i]), curr_str); if (sna[i].entry && !send_request_for_net_action(&sna[i])) { markup = g_strdup_printf("%s %s", _(sna[i].entry->name), _("(failed)")); gtk_label_set_markup(GTK_LABEL(labels[i]), markup); g_free(markup); sd->flag_cancel = TRUE; gtk_label_set_markup(GTK_LABEL(status_labels[i]), error_str); if (sna[i].error) { if (sna[i].error->code != 1) { /* the user has not cancelled something... */ g_warning(_("Failed while performing \"%s\". Please file a " "bug report " "if this problem persists. (Use the " "Help\342\206\222Report" " bug option.)\n\nDetails: %s"), _(sna[i].entry->name), sna[i].error->message); } g_error_free(sna[i].error); } else { g_warning(_("Failed while performing \"%s\". Please file a bug " "report " "if this problem persists. (Use the " "Help\342\206\222Report" " bug option.)"), _(sna[i].entry->name)); } break; } gtk_label_set_markup(GTK_LABEL(status_labels[i]), done_str); gtk_label_set_markup(GTK_LABEL(labels[i]), _(sna[i].entry->name)); } g_free(labels); g_free(status_labels); } static SyncNetArea *sync_dialog_netarea_new(void) { SyncNetArea *sna = g_new0(SyncNetArea, 1); sna->vbox = gtk_vbox_new(FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(sna->vbox), 10); gtk_widget_show_all(sna->vbox); gtk_widget_hide(sna->vbox); return sna; } static void sync_dialog_netarea_destroy(SyncNetArea *sna) { g_return_if_fail(sna != NULL); g_free(sna); } static void sync_dialog_netarea_show(SyncDialog *sd) { g_return_if_fail(sd && sd->sna); gtk_widget_hide(GTK_WIDGET(sd->scroll_box)); gtk_widget_show(GTK_WIDGET(sd->sna->vbox)); gtk_label_set_markup(GTK_LABEL(sd->label), LABEL_SYNC_SYNCING); gtk_window_set_default_size(GTK_WINDOW(sd->dialog), 0, 0); gtk_window_reshow_with_initial_size(GTK_WINDOW(sd->dialog)); } static void sync_dialog_netarea_hide(SyncDialog *sd) { g_return_if_fail(sd && sd->sna); gtk_widget_show(GTK_WIDGET(sd->scroll_box)); gtk_widget_hide(GTK_WIDGET(sd->sna->vbox)); gtk_label_set_markup(GTK_LABEL(sd->label), LABEL_SYNC_DEFAULT); gtk_window_reshow_with_initial_size(GTK_WINDOW(sd->dialog)); } static void populate_store(GtkListStore *store) { GSList *entry; SyncEntry *e; gtk_list_store_clear(store); for (entry = entries; entry; entry = entry->next) { GtkTreeIter iter; e = (SyncEntry *)entry->data; e->selected = TRUE; gtk_list_store_append(store, &iter); gtk_list_store_set(store, &iter, 0, TRUE, 1, _(e->name), 2, e, -1); } } static void sel_toggle(GtkCellRendererToggle *cellrenderertoggle, gchar *path_str, GtkTreeModel *model) { GtkTreeIter iter; GtkTreePath *path = gtk_tree_path_new_from_string(path_str); SyncEntry *se; gboolean active; gtk_tree_model_get_iter(model, &iter, path); gtk_tree_model_get(model, &iter, 0, &active, 2, &se, -1); se->selected = !active; gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, se->selected, -1); gtk_tree_path_free(path); } static void close_clicked(void) { g_main_loop_quit(loop); } static SyncDialog *sync_dialog_new(GtkWidget *parent) { SyncDialog *sd; GtkWidget *dialog; GtkWidget *dialog1_vbox; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *dialog1_action_area; GtkWidget *button8; GtkWidget *button7; GtkWidget *button6; GtkWidget *priv_policy_btn; GtkWidget *label; GtkWidget *hbox; GtkTreeViewColumn *column; GtkTreeModel *model; GtkListStore *store; GtkCellRenderer *cr_text, *cr_toggle; sd = g_new0(SyncDialog, 1); sd->sna = sync_dialog_netarea_new(); dialog = gtk_dialog_new(); gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(parent)); gtk_window_set_title(GTK_WINDOW(dialog), _("Synchronize")); gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE); gtk_window_set_icon(GTK_WINDOW(dialog), icon_cache_get_pixbuf("syncmanager.png")); gtk_window_set_default_size(GTK_WINDOW(dialog), 420, 260); gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT); gtk_window_set_type_hint(GTK_WINDOW(dialog), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_container_set_border_width(GTK_CONTAINER(dialog), 5); #if GTK_CHECK_VERSION(2, 14, 0) dialog1_vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); #else dialog1_vbox = GTK_DIALOG(dialog)->vbox; #endif gtk_box_set_spacing(GTK_BOX(dialog1_vbox), 5); gtk_container_set_border_width(GTK_CONTAINER(dialog1_vbox), 4); gtk_widget_show(dialog1_vbox); #if GTK_CHECK_VERSION(3, 0, 0) hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); #else hbox = gtk_hbox_new(FALSE, 5); #endif gtk_box_pack_start(GTK_BOX(dialog1_vbox), hbox, FALSE, FALSE, 0); label = gtk_label_new(LABEL_SYNC_DEFAULT); gtk_label_set_line_wrap(GTK_LABEL(label), TRUE); gtk_label_set_use_markup(GTK_LABEL(label), TRUE); #if GTK_CHECK_VERSION(3, 0, 0) gtk_widget_set_valign(label, GTK_ALIGN_CENTER); #else gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5); #endif gtk_box_pack_start(GTK_BOX(hbox), icon_cache_get_image("syncmanager.png"), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, TRUE, 0); gtk_widget_show_all(hbox); gtk_box_pack_start(GTK_BOX(dialog1_vbox), sd->sna->vbox, TRUE, TRUE, 0); scrolledwindow2 = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow2); gtk_box_pack_start(GTK_BOX(dialog1_vbox), scrolledwindow2, TRUE, TRUE, 0); gtk_widget_set_size_request(scrolledwindow2, -1, 200); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolledwindow2), GTK_SHADOW_IN); store = gtk_list_store_new(3, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER); model = GTK_TREE_MODEL(store); treeview2 = gtk_tree_view_new_with_model(model); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview2), FALSE); gtk_widget_show(treeview2); gtk_container_add(GTK_CONTAINER(scrolledwindow2), treeview2); column = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(treeview2), column); cr_toggle = gtk_cell_renderer_toggle_new(); gtk_tree_view_column_pack_start(column, cr_toggle, FALSE); g_signal_connect(cr_toggle, "toggled", G_CALLBACK(sel_toggle), model); gtk_tree_view_column_add_attribute(column, cr_toggle, "active", 0); cr_text = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cr_text, TRUE); gtk_tree_view_column_add_attribute(column, cr_text, "markup", 1); populate_store(store); priv_policy_btn = gtk_link_button_new_with_label( "https://github.com/hardinfo2/hardinfo2?tab=readme-ov-file#privacy-policy", _("Privacy Policy")); gtk_widget_show(priv_policy_btn); gtk_box_pack_start(GTK_BOX(dialog1_vbox), priv_policy_btn, FALSE, FALSE, 0); #if GTK_CHECK_VERSION(2, 14, 0) dialog1_action_area = gtk_dialog_get_action_area(GTK_DIALOG(dialog)); #else dialog1_action_area = GTK_DIALOG(dialog)->action_area; #endif gtk_widget_show(dialog1_action_area); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog1_action_area), GTK_BUTTONBOX_END); button8 = gtk_button_new_with_mnemonic(_("_Cancel")); gtk_widget_show(button8); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button8, GTK_RESPONSE_CANCEL); #if GTK_CHECK_VERSION(2, 18, 0) gtk_widget_set_can_default(button8, TRUE); #else GTK_WIDGET_SET_FLAGS(button8, GTK_CAN_DEFAULT); #endif button7 = gtk_button_new_with_mnemonic(_("_Synchronize")); gtk_widget_show(button7); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button7, GTK_RESPONSE_ACCEPT); #if GTK_CHECK_VERSION(2, 18, 0) gtk_widget_set_can_default(button7, TRUE); #else GTK_WIDGET_SET_FLAGS(button7, GTK_CAN_DEFAULT); #endif button6 = gtk_button_new_from_stock(GTK_STOCK_CLOSE); g_signal_connect(G_OBJECT(button6), "clicked", (GCallback)close_clicked, NULL); gtk_dialog_add_action_widget(GTK_DIALOG(dialog), button6, GTK_RESPONSE_ACCEPT); #if GTK_CHECK_VERSION(2, 18, 0) gtk_widget_set_can_default(button6, TRUE); #else GTK_WIDGET_SET_FLAGS(button6, GTK_CAN_DEFAULT); #endif sd->dialog = dialog; sd->button_sync = button7; sd->button_cancel = button8; sd->button_close = button6; sd->button_priv_policy = priv_policy_btn; sd->scroll_box = scrolledwindow2; sd->label = label; return sd; } static void sync_dialog_destroy(SyncDialog *sd) { gtk_widget_destroy(sd->dialog); sync_dialog_netarea_destroy(sd->sna); g_free(sd); } static gboolean sync_one(gpointer data) { SyncNetAction *sna = data; if (sna->entry->generate_contents_for_upload) goto out; DEBUG("Syncronizing: %s", sna->entry->name); gchar *msg = g_strdup_printf(_("Synchronizing: %s"), _(sna->entry->name)); shell_status_update(msg); shell_status_pulse(); g_free(msg); send_request_for_net_action(sna); out: g_main_loop_unref(loop); idle_free(sna); return FALSE; } void sync_manager_update_on_startup(void) { GSList *entry; ensure_soup_session(); loop = g_main_loop_new(NULL, FALSE); for (entry = entries; entry; entry = entry->next) { SyncNetAction *action = g_new0(SyncNetAction, 1); action->entry = entry->data; loop = g_main_loop_ref(loop); g_idle_add(sync_one, action); } }