prefs_report.c

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

/* $Id: prefs_report.c,v 1.1.1.1 2005/09/10 17:36:46 renaud Exp $
 *
 * Copyright (C) 2004 by Intevation GmbH
 * Author(s):
 * Jan-Oliver Wagner <[e-mail]> (2004)
 *
 * This program is free software under the GNU GPL (>=v2)
 * Read the file COPYING coming with the software for details.
 *
 * In addition, as a special exception, Intevation GmbH gives
 * permission to link the code of this program with the OpenSSL
 * library (or with modified versions of OpenSSL that use the same
 * license as OpenSSL), and distribute linked combinations including
 * the two. You must obey the GNU General Public License in all
 * respects for all of the code used other than OpenSSL. If you
 * modify this file, you may extend this exception to your version
 * of the file, but you are not obligated to do so. If you do not
 * wish to do so, delete this exception statement from your version.
 */

#include <includes.h>

#include <gtk/gtk.h>

#include "preferences.h"
#include "nessus_i18n.h"
#include "report_save.h"
#include "data_mining.h"
#include "xstuff.h"

#include "xpm/computer.xpm"
#include "xpm/network.xpm"
#include "xpm/warning_small.xpm"
#include "xpm/info_small.xpm"
#include "xpm/error_small.xpm"
#include "xpm/nothing.xpm"

#define n(x) (x ? x:"")

static GtkWidget * Lists[4];

typedef void (*func_fill_t)(struct arglist *, GtkWidget*);

/*
 * Our sort functions
 */

static int
cmp_hosts(a, b)
  char * a, * b;
{
  struct in_addr ia, ib;

  if(!a && !b)return 0;

  if(!a)
    return 1;
  if(!b)
    return -1;

  if(inet_aton(a, &ia) == 0)
    return strcmp(a, b);

  if(inet_aton(b, &ib) == 0)
  {
    return strcmp(a, b);
  }

  return -(ntohl(ia.s_addr) - ntohl(ib.s_addr));
}

static int
cmp_vulns(a, b)
  char * a, * b;
{
  int level_a, level_b;

  if(!a) 
    return -1;
  else if(!b)
    return 1;

  if(strstr(a, "Hole"))level_a = 3;
  else if(strstr(a, "Warning"))level_a = 2;
  else if(strstr(a, "Note"))level_a = 1;
  else level_a = 0;

  if(strstr(b, "Hole"))level_b = 3;
  else if(strstr(b, "Warning"))level_b = 2;
  else if(strstr(b, "Note"))level_b = 1;
  else level_b = 0;

  return level_a - level_b; 
}

/*
 * Utilities
 */

static void 
replace_data(obj, key, value)
  GtkObject* obj;
  char * key;
  char * value;
{
  char * old = gtk_object_get_data(obj, key);
  if(old)efree(&old);
  gtk_object_set_data(obj, key, value);
}

/*
 * Converts a multiple subset (with field AND severity) to 
 * a sorted, uniq'ed one.
 *
 * The function name is set to 'x' just to simplify its use 
 * throughout the code
 */
static struct subset *
x(subset)
  struct subset * subset;
{
  cmp_func_t cmps1[] = {cmp_hosts, cmp_vulns};
  cmp_func_t cmps2[] = {cmp_vulns};
  return subset_sort(
      subset_uniq(subset_sort(subset, 0, 1, cmps1), 0), 1, 1, cmps2);
}

/*
 * Initializers
 */

static char **
select_severity_pixmap(severity)
  char * severity;
{
  if(severity)
  {
    if(!strcmp(severity, "Security Note"))return info_small_xpm;
    else if(!strcmp(severity, "Security Warning"))return warning_small_xpm;
    else if(!strcmp(severity, "Security Hole")) return error_small_xpm;
  }
  return nothing_xpm;
} /* select_severity_pixmap */


/*
 * Update the label at the bottom of the report frame with
 * information about when the scan happened.
 */
void
prefs_report_update_timestamp(ctrls)
  struct arglist *ctrls;
{
  GtkWidget *scan_timestamps = arg_get_value(ctrls, "SCAN_TIMESTAMPS");
  int be = (int)arg_get_value(ctrls, "BE");
  char *str;

  if(be < 0)
    str = g_strdup("");
  else
  {
    struct subset *start_subset = query_backend(be,
	"SELECT date FROM timestamps WHERE type = 'scan_start'");
    struct subset *end_subset = query_backend(be,
	"SELECT date FROM timestamps WHERE type = 'scan_end'");
    char *start = NULL, *end = NULL;

    if(subset_size(start_subset))
      start = subset_value(start_subset);
    if(subset_size(end_subset))
      end = subset_value(end_subset);

    if(start && end)
      str = g_strdup_printf(_("Scan took place from %s to %s"), start, end);
    else if(start)
      str = g_strdup_printf(_("Scan started on %s"), start);
    else if(end)
      str = g_strdup_printf(_("Scan finished on %s"), end);
    else
      str = g_strdup_printf(_("Time of scan not available."));

    subset_free(start_subset);
    subset_free(end_subset);
  }
  gtk_label_set_text(GTK_LABEL(scan_timestamps), str);
  gtk_misc_set_alignment((GtkMisc *)scan_timestamps, 0, 1);
  g_free(str);
}

GtkWidget *
create_label(list, obj)
  GtkWidget * list;
  struct subset * obj;
{
  char * name = subset_nth_value(obj, 0);
  char * severity = subset_nth_value(obj, 1);
  GtkWidget *widget = gtk_list_item_new();
  GtkWidget * box = gtk_hbox_new(FALSE, 3);
  GtkWidget * hostname;
  GtkWidget *pixmap;
  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");
  char ** cat = NULL;
  char ** level;
 char * t;

  gtk_container_add(GTK_CONTAINER(widget), box);
  gtk_widget_show(box);

  if(!strcmp(sort_key, "host"))cat  = (char**)computer_xpm;
  else if(!strcmp(sort_key, "subnet"))cat = (char**)network_xpm;

  if(cat)
  {
    pixmap = make_pixmap(list, NULL, cat);
    gtk_box_pack_start(GTK_BOX(box), pixmap, FALSE, FALSE, 5);
    gtk_widget_show(pixmap);
  }

  if((level = select_severity_pixmap(severity)))
  {
    pixmap = make_pixmap(list, NULL, level);
    gtk_box_pack_start(GTK_BOX(box), pixmap, FALSE, FALSE, 5);
    gtk_widget_show(pixmap);
  }

  t = strchr(name, '\r');
  while(t != NULL)
  {
    t[0] = ' ';
    t = strchr(t + 1, '\r');
  }

  hostname = gtk_label_new(name);
  gtk_label_set_justify(GTK_LABEL(hostname), GTK_JUSTIFY_LEFT); 
  gtk_widget_show(hostname);
  gtk_box_pack_start(GTK_BOX(box), hostname, FALSE, FALSE, 5);
  gtk_widget_show(hostname);

  return widget;
}

static void
empty_list(list)
  GtkWidget * list;
{
  GList * items = GTK_LIST(list)->children;
  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");

  if(items)
  {
    while(items)
    {
      char * ptr = gtk_object_get_data(GTK_OBJECT(items->data), sort_key);
      gtk_object_remove_data(GTK_OBJECT(items->data), sort_key);
      efree(&ptr);
      items = items->next;
    }
  gtk_list_remove_items(GTK_LIST(list), GTK_LIST(list)->children);
  }
}

void
fill_list(list, subset)
  GtkWidget * list;
  struct subset * subset;
{
  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");
  struct subset * walk;
  GList * glist = NULL;

  walk = subset;
  while(walk)
  {
    GtkWidget * item = create_label(list, walk);
    glist = g_list_append(glist, item);
    gtk_widget_show(item);
    gtk_object_set_data(GTK_OBJECT(item), sort_key,
                        estrdup(subset_value(walk)));
    walk = subset_next(walk);
  }
  gtk_list_append_items(GTK_LIST(list), glist); 
  gtk_list_select_item(GTK_LIST(list), 0);
}

void
subnets_fill(ctrls, list)
  struct arglist * ctrls;
  GtkWidget * list;
{
  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");
  struct subset * subset;
  int be = (int)arg_get_value(ctrls, "BE");

  if (be < 0) return;

  subset = x(query_backend(be, "SELECT %s,severity FROM results", sort_key ));

  fill_list(list, subset);
  subset_free(subset);
}

static void
hosts_fill(ctrls, list)
  struct arglist * ctrls;
  GtkWidget * list;
{
  char * restriction_1_key = gtk_object_get_data(GTK_OBJECT(list),
                                                 "restriction_1_key");
  char * restriction_1_value = gtk_object_get_data(GTK_OBJECT(list),
                                                   "restriction_1_value"); 
  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");
  struct subset * subset;
  int be = (int)arg_get_value(ctrls, "BE");

  if (be < 0) return;

  subset = x(query_backend(be, "SELECT %s,severity FROM results WHERE %s = '%s'",
             sort_key, n(restriction_1_key), n(restriction_1_value)));

  fill_list(list, subset);
  subset_free(subset);
}

static void
ports_fill(ctrls, list)
  struct arglist * ctrls;
  GtkWidget * list;
{
  char * restriction_1_key = gtk_object_get_data(GTK_OBJECT(list),
                                                 "restriction_1_key");
  char * restriction_1_value = gtk_object_get_data(GTK_OBJECT(list),
                                                  "restriction_1_value"); 
  char * restriction_2_key = gtk_object_get_data(GTK_OBJECT(list),
                                                 "restriction_2_key");
  char * restriction_2_value = gtk_object_get_data(GTK_OBJECT(list),
                                                   "restriction_2_value"); 
  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");
  struct subset * subset;
  int be = (int)arg_get_value(ctrls, "BE");

  if (be < 0) return;

  subset = x(query_backend(be,
    "SELECT %s,severity FROM results WHERE %s = '%s'  AND %s = '%s'",
    sort_key, n(restriction_1_key), n(restriction_1_value),
    n(restriction_2_key), n(restriction_2_value)));

  fill_list(list, subset);
  subset_free(subset);
}

static void
severity_fill(ctrls, list)
  struct arglist * ctrls;
  GtkWidget * list;
{
  char * restriction_1_key = gtk_object_get_data(GTK_OBJECT(list),
                                                 "restriction_1_key");
  char * restriction_1_value = gtk_object_get_data(GTK_OBJECT(list),
                                                   "restriction_1_value"); 
  char * restriction_2_key = gtk_object_get_data(GTK_OBJECT(list),
                                                 "restriction_2_key");
  char * restriction_2_value = gtk_object_get_data(GTK_OBJECT(list),
                                                   "restriction_2_value");
  char * restriction_3_key = gtk_object_get_data(GTK_OBJECT(list),
                                                 "restriction_3_key");
  char * restriction_3_value = gtk_object_get_data(GTK_OBJECT(list),
                                                   "restriction_3_value");

  char * sort_key = gtk_object_get_data(GTK_OBJECT(list), "sort_key");
  struct subset * subset;
  int be = (int)arg_get_value(ctrls, "BE");

  if (be < 0) return;

  subset = x(query_backend(be,
    "SELECT %s,severity FROM results WHERE %s = '%s' AND %s = '%s' AND %s = '%s'",
    sort_key, n(restriction_1_key), n(restriction_1_value),