diff options
Diffstat (limited to 'shell/syncmanager.c')
| -rw-r--r-- | shell/syncmanager.c | 734 |
1 files changed, 734 insertions, 0 deletions
diff --git a/shell/syncmanager.c b/shell/syncmanager.c new file mode 100644 index 00000000..0f08cf87 --- /dev/null +++ b/shell/syncmanager.c @@ -0,0 +1,734 @@ +/* + * HardInfo - Displays System Information + * Copyright (C) 2003-2009 L. A. F. Pereira <l@tia.mat.br> + * + * 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 <libsoup/soup.h> + +#include <stdarg.h> +#include <string.h> + +#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 \ + _("<big><b>Synchronize with Central Database</b></big>\n" \ + "The following information may be synchronized\n" \ + "with the HardInfo central database.") +#define LABEL_SYNC_SYNCING \ + _("<big><b>Synchronizing</b></big>\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</s> <i>%s</i>", + _(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("<b>%s</b>", _(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("<b><s>%s</s></b> <i>%s</i>", + _(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); + } +} |