prefs_dialog.c

大国补丁后的nessus2.2.8的源代码

  t = arg_get_value(ctrls, "USER");

  gtkw = arg_get_value(t, "RULES");
  if(gtkw)
  {
    GtkWidget *item;
    GtkWidget *label;

    GList *dlist = NULL;
    GList *oldlist = (void *)arg_get_value(t, "RULES_DLIST");
    struct arglist *rules = arg_get_value(context->prefs, "RULES");

    if(oldlist)
      gtk_list_remove_items(GTK_LIST(gtkw), oldlist);

    while(rules && rules->next)
    {
      GtkWidget *box;

      if(strlen(rules->value))
      {
	item = gtk_list_item_new();
	gtk_object_set_data(GTK_OBJECT(item), "rule", rules->name);
	box = gtk_hbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(item), box);
	gtk_widget_show(box);
	label = gtk_label_new(rules->value);
	gtk_widget_show(label);
	gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
	dlist = g_list_append(dlist, item);
	rules = rules->next;
	gtk_widget_show(item);
      }
    }
    if(arg_get_value(t, "RULES_DLIST"))
      arg_set_value(t, "RULES_DLIST", -1, dlist);
    else
      arg_add_value(t, "RULES_DLIST", ARG_PTR, -1, dlist);
    gtk_list_append_items(GTK_LIST(gtkw), dlist);
  }

#ifdef ENABLE_SAVE_KB
  prefs_dialog_kb_set_prefs(arg_get_value(ctrls, "SAVE_KB"), context->prefs);
#endif
}


static void
prefs_dialog_set_tooltips(ctrls)
  struct arglist *ctrls;
{
  struct arglist *t;
  GtkTooltips *tooltips;
  GtkWidget *w;

  tooltips = gtk_tooltips_new();
  arg_add_value(ctrls, "TOOLTIPS", ARG_PTR, -1, tooltips);

  t = arg_get_value(ctrls, "PLUGINS");
  w = arg_get_value(t, "ENABLE_DEPS_AT_RUNTIME");
  gtk_tooltips_set_tip(tooltips, w, HLP_ENABLE_DEPS_AT_RUNTIME, "");

  w = arg_get_value(t, "SILENT_DEPS");
  gtk_tooltips_set_tip(tooltips, w, HLP_SILENT_DEPS, "");

  t = arg_get_value(ctrls, "TARGET");
  w = arg_get_value(t, "DNS_EXPAND");
  gtk_tooltips_set_tip(tooltips, w, HLP_HOST_EXPANSION_DNS, "");

  w = arg_get_value(t, "TARGET");
  gtk_tooltips_set_tip(tooltips, w, HLP_TARGET_PRIMARY_TARGET, "");

  w = arg_get_value(t, "READ_FROM_FILE");
  gtk_tooltips_set_tip(tooltips, w, HLP_TARGET_READ_FROM_FILE, "");


  t = arg_get_value(ctrls, "SCAN_OPTIONS");
  w = arg_get_value(t, "PING_HOSTS");
  gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_PING, "");
  w = arg_get_value(t, "OPTIMIZE_TEST");
  gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_OPTIMIZE, "");

  w = arg_get_value(t, "SAFE_CHECKS");
  gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_SAFE_CHECKS, "");

  w = arg_get_value(t, "USE_MAC_ADDR");
  gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_USE_MAC_ADDR, "");

  w = arg_get_value(t, "REVERSE_LOOKUP");
  gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_REVERSE_LOOKUP, "");
  w = arg_get_value(t, "PORT_RANGE");
  gtk_tooltips_set_tip(tooltips, w, HLP_SCAN_OPT_PORT_RANGE, "");
  w = arg_get_value(t, "UNSCANNED_CLOSED");
  gtk_tooltips_set_tip(tooltips, w, HLP_UNSCANNED_CLOSED, "");

  w = arg_get_value(t, "MAX_HOSTS");
  gtk_tooltips_set_tip(tooltips, w, HLP_MISC_MAX_HOSTS, "");
  w = arg_get_value(t, "MAX_CHECKS");
  gtk_tooltips_set_tip(tooltips, w, HLP_MISC_MAX_CHECKS, "");
  w = arg_get_value(t, "CGI_PATH");
  gtk_tooltips_set_tip(tooltips, w, HLP_CGI_PATH, "");
  t = arg_get_value(ctrls, "USER");
  gtk_tooltips_enable(tooltips);
}


void
prefs_dialog_apply(context, ctrls)
  struct context *context;
  struct arglist *ctrls;
{
  struct arglist *prefs;
  struct arglist *serv;
  struct arglist *t;
  char expansion[30];
  char *s;
  GtkWidget *gtkw;

  /* Save comment to preferences */
  store_comment(context, arg_get_value(ctrls, "COMMENT"));

  if(context->type == CONTEXT_TASK || context->type == CONTEXT_REPORT)
    return;

  /*
   * FIXME:
   * Only try to save values if GTK widgets were changed.
   * Otherwise prefs_dialog_set_defaults can't set default
   * values from server.
   */

  bzero(expansion, 30);
  prefs = context->prefs;
  serv = arg_get_value(prefs, "SERVER_PREFS");
  if(!serv)
  {
    serv = emalloc(sizeof(struct arglist));
    arg_add_value(prefs, "SERVER_PREFS", ARG_ARGLIST, -1, serv);
  }


  t = arg_get_value(ctrls, "PLUGINS");
  gtkw = arg_get_value(t, "ENABLE_DEPS_AT_RUNTIME");
  if(gtkw)
  {
    char *s;

    if(GTK_TOGGLE_BUTTON(gtkw)->active)
      s = estrdup("yes");
    else
      s = estrdup("no");

    if(arg_get_value(serv, "auto_enable_dependencies"))
      arg_set_value(serv, "auto_enable_dependencies", strlen(s), s);
    else
      arg_add_value(serv, "auto_enable_dependencies", ARG_STRING, strlen(s),
	  s);
  }
  gtkw = arg_get_value(t, "SILENT_DEPS");
  if(gtkw)
  {
    char *s;

    if(GTK_TOGGLE_BUTTON(gtkw)->active)
      s = estrdup("yes");
    else
      s = estrdup("no");

    if(arg_get_value(serv, "silent_dependencies"))
      arg_set_value(serv, "silent_dependencies", strlen(s), s);
    else
      arg_add_value(serv, "silent_dependencies", ARG_STRING, strlen(s), s);
  }




  /*
   * Host expansion
   */
  t = arg_get_value(ctrls, "TARGET");
  gtkw = arg_get_value(t, "DNS_EXPAND");
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strcat(expansion, "dns;");

  strcat(expansion, "ip;");

  if(!strlen(expansion))
    strncpy(expansion, "none;", 5);
  expansion[strlen(expansion) - 1] = 0;

  s = (char *)gtk_entry_get_text(GTK_ENTRY(arg_get_value(t, "TARGET")));
  prefs_set_string(context, "targets", s);

  s = emalloc(strlen(expansion) + 1);
  strncpy(s, expansion, strlen(expansion));

  if(arg_get_value(serv, "host_expansion"))
    arg_set_value(serv, "host_expansion", strlen(s), s);
  else
    arg_add_value(serv, "host_expansion", ARG_STRING, strlen(s), s);




  /*
   * Scan options
   */

  t = arg_get_value(ctrls, "SCAN_OPTIONS");
  gtkw = arg_get_value(t, "PING_HOSTS");
  s = emalloc(4);

  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strncpy(s, "yes", 3);
  else
    strncpy(s, "no", 4);

  if(arg_get_value(serv, "ping_hosts"))
    arg_set_value(serv, "ping_hosts", strlen(s), s);
  else
    arg_add_value(serv, "ping_hosts", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "REVERSE_LOOKUP");
  s = emalloc(4);
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strncpy(s, "yes", 3);
  else
    strncpy(s, "no", 4);

  if(arg_get_value(serv, "reverse_lookup"))
    arg_set_value(serv, "reverse_lookup", strlen(s), s);
  else
    arg_add_value(serv, "reverse_lookup", ARG_STRING, strlen(s), s);

  gtkw = arg_get_value(t, "OPTIMIZE_TEST");
  s = emalloc(4);
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strncpy(s, "yes", 3);
  else
    strncpy(s, "no", 4);

  if(arg_get_value(serv, "optimize_test"))
    arg_set_value(serv, "optimize_test", strlen(s), s);
  else
    arg_add_value(serv, "optimize_test", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "SAFE_CHECKS");
  s = emalloc(4);
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strncpy(s, "yes", 3);
  else
    strncpy(s, "no", 4);

  if(arg_get_value(serv, "safe_checks"))
    arg_set_value(serv, "safe_checks", strlen(s), s);
  else
    arg_add_value(serv, "safe_checks", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "USE_MAC_ADDR");
  s = emalloc(4);
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strncpy(s, "yes", 3);
  else
    strncpy(s, "no", 4);

  if(arg_get_value(serv, "use_mac_addr"))
    arg_set_value(serv, "use_mac_addr", strlen(s), s);
  else
    arg_add_value(serv, "use_mac_addr", ARG_STRING, strlen(s), s);


  t = arg_get_value(ctrls, "SCAN_OPTIONS");
  gtkw = arg_get_value(t, "PORT_RANGE");
  s = emalloc(strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))) + 1);
  strncpy(s, gtk_entry_get_text(GTK_ENTRY(gtkw)),
      strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))));

  if(arg_get_value(serv, "port_range"))
    arg_set_value(serv, "port_range", strlen(s), s);
  else
    arg_add_value(serv, "port_range", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "UNSCANNED_CLOSED");
  s = emalloc(4);
  if(GTK_TOGGLE_BUTTON(gtkw)->active)
    strncpy(s, "yes", 3);
  else
    strncpy(s, "no", 4);

  if(arg_get_value(serv, "unscanned_closed"))
    arg_set_value(serv, "unscanned_closed", strlen(s), s);
  else
    arg_add_value(serv, "unscanned_closed", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "MAX_HOSTS");

  s = emalloc(strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))) + 1);

  strncpy(s, gtk_entry_get_text(GTK_ENTRY(gtkw)),
      strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))));

  if(arg_get_value(serv, "max_hosts"))
    arg_set_value(serv, "max_hosts", strlen(s), s);
  else
    arg_add_value(serv, "max_hosts", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "MAX_CHECKS");

  s = emalloc(strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))) + 1);

  strncpy(s, gtk_entry_get_text(GTK_ENTRY(gtkw)),
      strlen(gtk_entry_get_text(GTK_ENTRY(gtkw))));

  if(arg_get_value(serv, "max_checks"))
    arg_set_value(serv, "max_checks", strlen(s), s);
  else
    arg_add_value(serv, "max_checks", ARG_STRING, strlen(s), s);


  gtkw = arg_get_value(t, "CGI_PATH");
  s = estrdup((char *)gtk_entry_get_text(GTK_ENTRY(gtkw)));


  if(arg_get_value(serv, "cgi_path"))
    arg_set_value(serv, "cgi_path", strlen(s), s);
  else
    arg_add_value(serv, "cgi_path", ARG_STRING, strlen(s), s);

#ifdef ENABLE_SAVE_KB
  t = arg_get_value(ctrls, "SAVE_KB");
  prefs_dialog_kb_get_prefs(context, t);
#endif


  /*
   * Client-side User Access Rules
   * Get them out of the USRER->RULES_TREE and push them into
   * context->prefs->CLIENTSIDE_USERRULES
   */
  t = arg_get_value(ctrls, "USER");
  gtkw = arg_get_value(t, "RULES_TREE");
  if (gtkw)
  {
    GtkTreeModel * store;
    GtkTreePath * path;
    GtkTreeIter iter;
    int n = 0;
    char * rule, * name = NULL;
    struct arglist * clientside_userrules;

    /* first of all, remove the old stuff */
    clientside_userrules = emalloc(sizeof(struct arglist));
    if (arg_get_value(prefs, "CLIENTSIDE_USERRULES"))
    {
      arg_free_all(arg_get_value(prefs, "CLIENTSIDE_USERRULES"));
      arg_set_value(prefs, "CLIENTSIDE_USERRULES", -1, clientside_userrules);
    } else
      arg_add_value(prefs, "CLIENTSIDE_USERRULES", ARG_ARGLIST, -1,
                    clientside_userrules);

    store = gtk_tree_view_get_model(GTK_TREE_VIEW(gtkw));

    /* go to the third entry */
    path = gtk_tree_path_new_from_string("2:0");
    if (gtk_tree_model_get_iter(store, &iter, path))
    {
      do {
        gtk_tree_model_get(store, &iter, 0, &rule, -1);

        name = emalloc(20);
        sprintf(name, "%d", n);
        arg_add_value(clientside_userrules, name, ARG_STRING,
                      strlen(rule), rule);
        n ++;
      } while (gtk_tree_model_iter_next(store, &iter));
    }
  }
}


/* XXX Warning:
 * saves to context->plugins and context->scanners,
 * NOT to context->prefs["PLUGINS_PREFS"]
 */
void
prefs_dialog_apply_plugin_prefs(plugins)
  struct nessus_plugin *plugins;
{
  while(plugins!= NULL )
  {
    struct arglist *pref;
    char *type;
    char *value;

    if((pref = plugins->plugin_prefs) != NULL )
      while(pref && pref->next)
      {
	if((type = (char *)arg_get_value(pref->value, "type")))
	{
	  if(!strcmp(type, PREF_ENTRY) ||
	      !strcmp(type, PREF_FILE) || !strcmp(type, PREF_PASSWORD))
	  {
	    GtkWidget *entry = arg_get_value(pref->value, "ENTRY");

	    if(entry)
	    {
	      value = (char *)gtk_entry_get_text(GTK_ENTRY(entry));
	      arg_set_value(pref->value, "value", strlen(value),
		  estrdup(value));
	    }
	  }
	  else if(!strcmp(type, PREF_CHECKBOX))
	  {
	    GtkWidget *button = arg_get_value(pref->value, "CHECKBOX");

	    if(button)
	    {
	      char *value =
		  GTK_TOGGLE_BUTTON(button)->active ? "yes" : "no";
	      arg_set_value(pref->value, "value", strlen(value),
		  estrdup(value));
	    }
	  }
	  else if(!strcmp(type, PREF_RADIO))
	  {
        GSList *list = NULL;
        char * value = NULL;

        list = arg_get_value(pref->value, "RADIOBUTTONS");

        if (list)
        {
          /* First pass: find the active entry */
          while (list)
          {
            GtkWidget *button = list->data;

            if (GTK_TOGGLE_BUTTON(button)->active)
            {
              value = estrdup(gtk_object_get_data(GTK_OBJECT(button), "name"));
              break;
            }
            list = list->next;
          }
          /* Second pass: find all other entries and append
           * them separated with ";" */
          list = arg_get_value(pref->value, "RADIOBUTTONS");
          while (list)
          {
            GtkWidget *button = list->data;

            if (! GTK_TOGGLE_BUTTON(button)->active)
            {
              char * v = gtk_object_get_data(GTK_OBJECT(button), "name");
              value = (char *) erealloc((void *)value, (size_t) (strlen(value) + strlen(";") + strlen(v) + 1));
              strcat(value, ";");
              strcat(value, v);
            }
            list = list->next;
          }
        }
        if(value)
          arg_set_value(pref->value, "value", strlen(value), value);
	  }
	}
	pref = pref->next;
      }
    plugins = plugins->next;
  }
}


int
prefs_dialog_execute(w, ctrls)
  GtkWidget *w;
  struct arglist *ctrls;
{
  struct context *context = context_by_type(Context, CONTEXT_SCOPE);
  char *hostname;

  prefs_context_update(context);
  prefs_dialog_apply(context, ctrls);
  prefs_dialog_apply_plugin_prefs(context->plugins);
  prefs_dialog_apply_plugin_prefs(context->scanners);
  context_sync_plugin_prefs(context);

  /*
   * Check for the errors
   */

  if(!prefs_dialog_auth_connection(context))
    return (0);

  /* if the target is a file, then translate it */
  hostname = target_translate(prefs_get_string(context, "targets"));

  if(hostname == NULL || hostname[0] == '\0')
  {
    show_error(_("You must enter the name of the primary target\n\
to attack in the 'target' section"));
    return (0);
  }

  monitor_dialog_setup(hostname, context);

  return (0);
}
#endif