wizard_gtk.c

GNUnet是一个安全的点对点网络框架

  GNUNET_GC_get_configuration_value_string (editCfg, "FS", "QUOTA", "1024",
                                            &val);
  gtk_entry_set_text (GTK_ENTRY (entQuota), val);
  GNUNET_free (val);

  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkMigr),
                                GNUNET_GC_get_configuration_value_yesno
                                (editCfg, "FS", "ACTIVEMIGRATION",
                                 GNUNET_YES) == GNUNET_YES);

  if (GNUNET_configure_autostart
      (err_ctx, GNUNET_YES, GNUNET_YES, NULL, NULL, NULL, NULL))
    gtk_widget_set_sensitive (chkStart, TRUE);


  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkStart),
                                GNUNET_GC_get_configuration_value_yesno
                                (editCfg, "GNUNETD", "AUTOSTART",
                                 GNUNET_NO) == GNUNET_YES);

  if (doOpenEnhConfigurator)
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (chkEnh), 1);
  gtk_widget_show (curwnd);
}

void
do_destroy_widgetsetup_gtk (GtkButton * button, gpointer user_data)
{
  GtkWidget *msgSaveFailed = user_data;
  gtk_widget_destroy (msgSaveFailed);
}

static void
showErr (const char *prefix, const char *error)
{
  GtkWidget *dialog;
  char *err;

  err = GNUNET_malloc (strlen (prefix) + strlen (error) + 2);
  sprintf (err, "%s %s", prefix, error);

  dialog = gtk_message_dialog_new (NULL,
                                   GTK_DIALOG_MODAL,
                                   GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, err);
  GNUNET_free (err);
  gtk_dialog_run (GTK_DIALOG (dialog));
  gtk_widget_destroy (dialog);
}


static int
save_conf ()
{
  char *err;
  const char *prefix;

  if (GNUNET_GC_write_configuration (editCfg, cfg_fn))
    {
      prefix = _("Unable to save configuration file `%s':");

      err = GNUNET_malloc (strlen (cfg_fn) + strlen (prefix) + 1);
      sprintf (err, prefix, cfg_fn);
      showErr (err, STRERROR (errno));
      GNUNET_free (err);
      return GNUNET_SYSERR;
    }
  return GNUNET_OK;
}

void
on_abort_clickedsetup_gtk (GtkButton * button, gpointer user_data)
{
  GtkWidget *dialog;
  int ok, ret;

  ok = GNUNET_OK;

  dialog = gtk_message_dialog_new (NULL,
                                   GTK_DIALOG_MODAL,
                                   GTK_MESSAGE_QUESTION,
                                   GTK_BUTTONS_YES_NO,
                                   _
                                   ("Do you want to save the new configuration?"));
  ret = gtk_dialog_run (GTK_DIALOG (dialog));
  gtk_widget_destroy (dialog);
  switch (ret)
    {
    case GTK_RESPONSE_YES:
      ok = save_conf ();
      break;
    case GTK_RESPONSE_NO:
      ok = GNUNET_OK;
      break;
    case GTK_RESPONSE_CANCEL:
    default:
      ok = GNUNET_NO;
    }

  if (ok)
    {
      quit = 1;
      gtk_widget_destroy (curwnd);
    }
}

void
on_finish_clickedsetup_gtk (GtkButton * button, gpointer user_data)
{
  char *gup;
  char *bin;
  if (doAutoStart && (user_name != NULL))
    if (!GNUNET_GNS_wiz_create_group_user (group_name, user_name))
      {
#ifndef MINGW
        showErr (_("Unable to create user account:"), STRERROR (errno));
#endif
        return;
      }

  if (GNUNET_GNS_wiz_autostart_service (err_ctx, GNUNET_SERVICE_TYPE_GNUNETD,
                                        doAutoStart, user_name,
                                        group_name) != GNUNET_OK)
    {
#ifndef MINGW
      showErr (_("Unable to change startup process:"), STRERROR (errno));
#endif
    }

  if (GNUNET_OK != save_conf ())
    return;
  if (doUpdate)
    {
      bin = GNUNET_get_installation_path (GNUNET_IPK_BINDIR);
      gup = GNUNET_malloc (strlen (bin) + 30 + strlen (cfg_fn));
      strcpy (gup, bin);
      GNUNET_free (bin);
      strcat (gup, "/gnunet-update -c ");
      strcat (gup, cfg_fn);
      if (system (gup) != 0)
        showErr (_("Running gnunet-update failed.\n"
                   "This maybe due to insufficient permissions, please check your configuration.\n"
                   "Finally, run gnunet-update manually."), "");
      GNUNET_free (gup);
    }
  gtk_widget_destroy (curwnd);
}

void
on_updateFailedOK_clickedsetup_gtk (GtkButton * button, gpointer user_data)
{
  GtkWidget *dialog = user_data;
  gtk_widget_destroy (dialog);
}

void
on_entIP_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;

  ret = gtk_editable_get_chars (editable, 0, -1);
  GNUNET_GC_set_configuration_value_string (editCfg, err_ctx, "NETWORK", "IP",
                                            ret);
  g_free (ret);
}


void
on_entUp_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;

  ret = gtk_editable_get_chars (editable, 0, -1);
  GNUNET_GC_set_configuration_value_string (editCfg,
                                            err_ctx,
                                            "LOAD", "MAXNETUPBPSTOTAL", ret);
  g_free (ret);
}


void
on_entDown_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;

  ret = gtk_editable_get_chars (editable, 0, -1);
  GNUNET_GC_set_configuration_value_string (editCfg,
                                            err_ctx,
                                            "LOAD", "MAXNETDOWNBPSTOTAL",
                                            ret);
  g_free (ret);
}


void
on_radGNUnet_toggledsetup_gtk (GtkToggleButton * togglebutton,
                               gpointer user_data)
{
  GNUNET_GC_set_configuration_value_choice (editCfg,
                                            err_ctx,
                                            "LOAD",
                                            "BASICLIMITING",
                                            gtk_toggle_button_get_active
                                            (togglebutton) ? "YES" : "NO");
}


void
on_radShare_toggledsetup_gtk (GtkToggleButton * togglebutton,
                              gpointer user_data)
{
  GNUNET_GC_set_configuration_value_choice (editCfg,
                                            err_ctx,
                                            "LOAD",
                                            "BASICLIMITING",
                                            gtk_toggle_button_get_active
                                            (togglebutton) ? "NO" : "YES");
}


void
on_entCPU_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;
  int num;

  ret = gtk_editable_get_chars (editable, 0, -1);
  num = atoi (ret);
  GNUNET_GC_set_configuration_value_number (editCfg, err_ctx, "LOAD",
                                            "MAXCPULOAD", num);
  g_free (ret);
}

void
on_chkMigr_toggledsetup_gtk (GtkToggleButton * togglebutton,
                             gpointer user_data)
{
  GNUNET_GC_set_configuration_value_choice (editCfg,
                                            err_ctx,
                                            "FS",
                                            "ACTIVEMIGRATION",
                                            gtk_toggle_button_get_active
                                            (togglebutton) ? "YES" : "NO");
}

void
on_entQuota_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;

  ret = gtk_editable_get_chars (editable, 0, -1);
  GNUNET_GC_set_configuration_value_string (editCfg, err_ctx, "FS", "QUOTA",
                                            ret);
  g_free (ret);
}


void
on_chkStart_toggledsetup_gtk (GtkToggleButton * togglebutton,
                              gpointer user_data)
{
  doAutoStart = gtk_toggle_button_get_active (togglebutton);
  GNUNET_GC_set_configuration_value_choice (editCfg,
                                            err_ctx,
                                            "GNUNETD",
                                            "AUTOSTART",
                                            doAutoStart ? "YES" : "NO");
}


void
on_chkEnh_toggledsetup_gtk (GtkToggleButton * togglebutton,
                            gpointer user_data)
{
  doOpenEnhConfigurator = gtk_toggle_button_get_active (togglebutton);
}

void
on_chkUpdate_toggledsetup_gtk (GtkToggleButton * togglebutton,
                               gpointer user_data)
{
  doUpdate = gtk_toggle_button_get_active (togglebutton);
}

void
on_entUser_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;

  ret = gtk_editable_get_chars (editable, 0, -1);
  GNUNET_GE_ASSERT (err_ctx, ret != NULL);
  GNUNET_GC_set_configuration_value_string (editCfg, err_ctx, "GNUNETD",
                                            "USER", ret);
  GNUNET_free_non_null (user_name);
  if (strlen (ret) != 0)
    user_name = GNUNET_strdup (ret);
  else
    user_name = NULL;
  g_free (ret);

}

void
on_entGroup_changedsetup_gtk (GtkEditable * editable, gpointer user_data)
{
  gchar *ret;

  GNUNET_free_non_null (group_name);
  ret = gtk_editable_get_chars (editable, 0, -1);
  GNUNET_GE_ASSERT (err_ctx, ret != NULL);
  GNUNET_GC_set_configuration_value_string (editCfg,
                                            err_ctx, "GNUNETD", "GROUP", ret);
  if (strlen (ret) != 0)
    group_name = GNUNET_strdup (ret);
  else
    group_name = NULL;
  g_free (ret);
}

int
gtk_wizard_mainsetup_gtk (int argc,
                          char *const *argv,
                          struct GNUNET_PluginHandle *self,
                          struct GNUNET_GE_Context *ectx,
                          struct GNUNET_GC_Configuration *cfg,
                          struct GNUNET_GNS_Context *gns,
                          const char *filename, int is_daemon)
{
  GNUNET_GE_ASSERT (ectx, is_daemon);
  g_thread_init (NULL);
  gtk_init (&argc, (char ***) &argv);
#ifdef ENABLE_NLS
  bind_textdomain_codeset (PACKAGE, "UTF-8");   /* for gtk */
#endif
#ifdef WINDOWS
  FreeConsole ();
#endif

  editCfg = cfg;
  err_ctx = ectx;
  cfg_fn = filename;
  daemon_config = is_daemon;
  setLibrary (self);
  curwnd = get_xml ("assi_step1");
  gtk_widget_show (curwnd);
  gdk_threads_enter ();
  gtk_main ();
  gdk_threads_leave ();
  destroyMainXML ();
#if HAVE_GUILE
  if (doOpenEnhConfigurator)
    gconf_main_post_init (self, ectx, cfg, gns, filename, is_daemon);
#endif
  GNUNET_free_non_null (user_name);
  GNUNET_free_non_null (group_name);
  setLibrary (NULL);

  return 0;
}