Re: NessusClient: Planned improvements (monitor dialog)
"Jan-Oliver Wagner" <[email protected]> Sat, 7 Apr 2007 23:14:46 +0200
| Newsgroups | gmane.comp.security.nessus.devel |
|---|---|
| Message-ID | <[email protected]> |
--Boundary-00=_JnAGGAp2jZS27oX
Content-Type: text/plain;
charset="iso-8859-1"
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline
On Friday 06 April 2007 16:40, Renaud Deraison wrote:
> On Apr 5, 2007, at 12:40 AM, Jan-Oliver Wagner wrote:
> > in order to prevent double work or uncoordinated work,
> > I though I drop a note on what I am currently (slowly!)
> > working on:
> >
> > - Migrating monitor dialog to TreeView widget.
>
> [...]
>
> I'd like to see a sample of what this would look like before you
> commit anything in that regards. The current view is working properly
> so I'm not convinced at all for a need to change this view.
Attached is monitor_dialog.c where I implemented the new TreeView.
It is a test version where it is integrated into the dialog additionally
to the old style.
The width is currently determined by the old style. The widths of
the columns could be adjusted.
Attached also is a sample screenshot.
I have not yet applied real tree structures for the hosts, but
it is possible in principle.
Additionally the consumption of vertical
space is much lower and there is a percentage information for
the progress bars.
=46or the time being I implemented the "Stop" funtionality using
a toggle cell renderer, because this was just really quick and
simple.
Best
Jan
=2D-=20
Dr. Jan-Oliver Wagner Intevation GmbH
Amtsgericht Osnabr=FCck, HR B 18998 http://www.intevation.de/
Gesch=E4ftsf=FChrer: Frank Koormann, Bernhard Reiter, Dr. Jan-Oliver Wagner
--Boundary-00=_JnAGGAp2jZS27oX
Content-Type: image/png;
name="monitor-screenshot.png"
Content-Transfer-Encoding: base64
Content-Disposition: attachment;
filename="monitor-screenshot.png"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=
--Boundary-00=_JnAGGAp2jZS27oX
Content-Type: text/x-csrc;
charset="iso-8859-1";
name="monitor_dialog.c"
Content-Transfer-Encoding: 7bit
Content-Disposition: attachment;
filename="monitor_dialog.c"
/* Nessus
* Copyright (C) 1998 - 2001 Renaud Deraison
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2,
* as published by the Free Software Foundation
*
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
*
* In addition, as a special exception, Renaud Deraison
* gives permission to link the code of this program with any
* version of the OpenSSL library which is distributed under a
* license identical to that listed in the included COPYING.OpenSSL
* file, 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>
#ifdef USE_GTK
#include <gtk/gtk.h>
#include "backend.h"
#include "nessus_plugin.h"
#include "context.h"
#include "preferences.h"
#include "attack.h"
#include "comm.h"
#include "auth.h"
#include "parser.h"
#include "report.h"
#include "globals.h"
#include "error_dialog.h"
#include "xpm/computer.xpm"
#include "monitor_dialog.h"
#include "nessus_i18n.h"
#include "prefs_dialog/prefs_context.h"
#include "prefs_dialog/prefs_scope_tree.h"
static void monitor_input_callback(struct arglist *);
static void monitor_add_host(struct arglist *, char *, int);
static void monitor_stop_test(GtkWidget *, struct context *);
static void monitor_list_update(struct arglist *, char *, int);
static int monitor_stop_whole_test_destroy(void*, void*, struct arglist *);
static int monitor_stop_whole_test(GtkWidget * , struct arglist *);
static int
is_server_present(soc)
int soc;
{
fd_set rd;
struct timeval tv = {2,0};
int fd = nessus_get_socket_from_connection(soc);
if(fd < 0 || fd >= FD_SETSIZE)
{
fprintf(stderr, _("is_server_present: fd(%d) out of range\n"), fd);
return 0;
}
FD_ZERO(&rd);
FD_SET(fd, &rd);
if(select(fd+1, &rd, NULL, NULL, &tv) > 0)
{
int len = -1;
ioctl(fd, FIONREAD, &len);
if(!len){
return 0;
}
}
return 1;
}
/*
* Function called when the UI is idle, which checks
* whether the server sent us anything. We use this rather
* than the traditional gdk input watcher, because it
* works under Win32
*/
static int
idle_socket(struct arglist * ctrls)
{
fd_set rd;
struct timeval tv = {0,100};
int n, soc;
struct context * context = arg_get_value(ctrls, "CONTEXT");
if ( context == NULL ) return FALSE;
if(context->socket < 0)
{
fprintf(stderr, "idle_socket: context->socket=%d\n", context->socket);
return FALSE;
}
if ( stream_pending(context->socket) )
{
monitor_input_callback(ctrls);
return TRUE;
}
soc = nessus_get_socket_from_connection(context->socket);
if((soc < 0) || (soc >= FD_SETSIZE))
{
fprintf(stderr, _("idle_server: soc(%d) out of range\n"), soc);
return -1;
}
FD_ZERO(&rd);
FD_SET(soc, &rd);
n = select(soc+1, &rd, NULL, NULL, &tv);
if(FD_ISSET(soc, &rd)&& (n > 0))
monitor_input_callback(ctrls);
return TRUE;
}
/* column IDs of scanner TreeView Model */
enum {
COL_ICON,
COL_HOSTNAME,
COL_PORTSCAN,
COL_CHECKS,
NUM_COLS
};
static void
stop_toggled(cell, path_str, data)
GtkCellRendererToggle *cell;
gchar *path_str;
gpointer data;
{
GtkListStore * store = arg_get_value(data, "MON_STORE");
struct context * context = arg_get_value(data, "CONTEXT");
GtkTreeIter iter;
char * hostname;
gtk_tree_model_get_iter_from_string(GTK_TREE_MODEL(store), &iter, path_str);
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
COL_HOSTNAME, &hostname, -1);
network_printf(context->socket,
"CLIENT <|> STOP_ATTACK <|> %s <|> CLIENT\n", hostname);
}
/*
* monitor_dialog_setup
*
* This function draws the window which will
* show the attack status
*/
void
monitor_dialog_setup(char * victim, struct context * context)
{
struct arglist * ctrls = emalloc(sizeof(struct arglist));
GtkWindow* parent = arg_get_value(MainDialog, "CONTEXT");
GtkWidget * scrolled_window;
GtkWidget * w, * box;
char* window_title;
const char* host_name;
int tag;
int backend = backend_init(NULL);
/* Could not create a backend */
if( backend < 0 )
return;
arg_add_value(ctrls, "MONITOR_BACKEND", ARG_INT, -1, (void*)backend);
arg_add_value(ctrls, "PARENT", ARG_PTR, -1, parent);
arg_add_value(ctrls, "CONTEXT", ARG_PTR, -1, context);
context->action = CONTEXT_SCANNING;
prefs_context_update(context);
w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(w), 640,480);
/* TODO make the window non-modal
* This can be done when context is kept for all called functions */
#if 0
gtk_window_set_modal(GTK_WINDOW(w), FALSE);
gtk_window_set_transient_for(GTK_WINDOW(w), parent);
arg_set_value(MainDialog, "CONTEXT", -1, w);
#endif
gtk_widget_realize(w);
gtk_signal_connect(GTK_OBJECT(w), "delete_event",
(GtkSignalFunc)monitor_stop_whole_test_destroy,ctrls);
host_name = prefs_get_string(context, "nessusd_host");
if(host_name)window_title = emalloc(strlen(host_name) + 255);
else window_title = emalloc(255);
sprintf(window_title, _("Scanning network from %s"),
host_name?host_name:_("some host"));
gtk_window_set_title(GTK_WINDOW(w), window_title);
efree(&window_title);
gtk_container_border_width(GTK_CONTAINER(w), 10);
arg_add_value(ctrls, "WINDOW", ARG_PTR, -1, w);
gtk_widget_show(w);
box = gtk_vbox_new(FALSE,10);
gtk_container_add(GTK_CONTAINER(w), box);
gtk_widget_show(box);
{ /* XXX: This is part of the MVC version */
GtkListStore * store;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_border_width(GTK_CONTAINER(scrolled_window), 10);
gtk_box_pack_start(GTK_BOX(box), scrolled_window, TRUE, TRUE, 0);
store = gtk_list_store_new(NUM_COLS, GDK_TYPE_PIXBUF,
G_TYPE_STRING, GTK_TYPE_INT, GTK_TYPE_INT);
arg_add_value(ctrls, "MON_STORE", ARG_PTR, -1, store);
w = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
/* The Icon column */
renderer = gtk_cell_renderer_pixbuf_new();
column = gtk_tree_view_column_new_with_attributes (NULL,
renderer, "pixbuf", COL_ICON, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w), column);
/* The hostname column */
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes (_("Hostname"),
renderer, "text", COL_HOSTNAME, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w), column);
/* The port scan progress bar column */
renderer = gtk_cell_renderer_progress_new();
column = gtk_tree_view_column_new_with_attributes (_("Portscan"),
renderer, "value", COL_PORTSCAN, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w), column);
/* The checks progress bar column */
renderer = gtk_cell_renderer_progress_new();
column = gtk_tree_view_column_new_with_attributes (_("Checks"),
renderer, "value", COL_CHECKS, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (w), column);
/* The stop action as toggle */
renderer = gtk_cell_renderer_toggle_new();
g_signal_connect(renderer, "toggled", G_CALLBACK(stop_toggled), ctrls);
column = gtk_tree_view_column_new_with_attributes(_("Stop"), renderer,
NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW (w), column);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), w);
gtk_widget_show(w);
gtk_widget_show (scrolled_window);
}
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_border_width(GTK_CONTAINER(scrolled_window), 10);
gtk_box_pack_start(GTK_BOX(box), scrolled_window, TRUE, TRUE, 0);
w = gtk_list_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window), w);
gtk_widget_show(w);
gtk_widget_show (scrolled_window);
arg_add_value(ctrls, "LIST", ARG_PTR, -1, w);
tag = gtk_idle_add((GtkFunction)idle_socket, ctrls);
arg_add_value(ctrls, "TAG", ARG_INT, sizeof(int), (void*)tag);
w = gtk_button_new_with_label(_("Stop the whole test"));
gtk_signal_connect(GTK_OBJECT(w), "clicked",
(GtkSignalFunc)monitor_stop_whole_test,ctrls);
gtk_box_pack_start(GTK_BOX(box), w, FALSE, TRUE, 0);
gtk_widget_show(w);
if(!attack_host(victim, context))
{
gtk_widget_hide(arg_get_value(ctrls, "WINDOW"));
gtk_idle_remove(tag);
gtk_widget_destroy(arg_get_value(ctrls, "WINDOW"));
#if 0
arg_set_value(MainDialog, "CONTEXT", -1, parent);
#endif
prefs_context_update(context);
scopetreeview_connected_update(context);
}
}
/*
* monitor_list_update
*
* Updates the progress bars
*/
static void
monitor_list_update(ctrls,msg, short_status)
struct arglist * ctrls;
char * msg;
int short_status;
{
char * hostname;
char * action;
char* current = NULL;
int max;
gfloat gmax;
gfloat gcurrent;
GList * dlist;
GtkObject * item;
GtkWidget * gtkw;
char * list_hostname;
int flag = 0;
static harglst * hosts = NULL;
int v = 1;
if(!hosts)
{
hosts = harg_create(65000);
}
if(!short_status)
parse_nessusd_status(msg, &hostname, &action, ¤t, &max);
else
parse_nessusd_short_status(msg, &hostname, &action, ¤t, &max);
if(hostname)
{
v = harg_get_int(hosts, hostname);
if(!v){
harg_add_int(hosts, hostname, 1);
v = 1;
}
else
{
v++;
harg_set_int(hosts, hostname, v);
}
}
{ /* XXX: This is part of the MVC version */
GtkListStore * store = arg_get_value(ctrls, "MON_STORE");
GtkTreeIter iter;
int f = (atoi(current) * 100) / max;
if(f>=100)f=100;
if(f<=0)f=0;
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {
do {
gtk_tree_model_get (GTK_TREE_MODEL(store), &iter,
COL_HOSTNAME, &list_hostname, -1);
if(!list_hostname){
fprintf(stderr, _("Error ! Null hostname in the list\n"));
return;
}
if (!strcmp(list_hostname, hostname)) {
if( strcmp(action, "portscan") == 0 )
gtk_list_store_set(store, &iter, COL_PORTSCAN, f, -1);
else
gtk_list_store_set(store, &iter, COL_CHECKS, f, -1);
/* flag = 1; activate only if old progress below gets removed */
break;
}
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
}
}
gtkw = arg_get_value(ctrls, "LIST");
dlist = GTK_LIST(gtkw)->children;
while(dlist && !flag)
{
item = GTK_OBJECT(dlist->data);
list_hostname = gtk_object_get_data(item, "hostname");
if(!list_hostname){
fprintf(stderr, _("Error ! Null hostname in the list\n"));
/*exit(1);*/
return;
}
if(!strcmp(list_hostname, hostname))
{
GtkWidget * progress_bar;
gfloat f;
if( strcmp(action, "portscan") == 0 )
progress_bar = gtk_object_get_data(item, "progress_bar_portscan");
else
progress_bar = gtk_object_get_data(item, "progress_bar_attack");
gmax = max;
gcurrent = atoi(current);
f = (gcurrent/gmax);
if(f>=1.0)f=1.0;
if(f<=0.0)f=0.0;
gtk_progress_bar_update (GTK_PROGRESS_BAR(progress_bar), f);
flag = 1;
}
dlist = dlist->next;
}
if(!flag)
{
/* the host was not found, we must add one... */
monitor_add_host(ctrls, estrdup(hostname), atoi(current));
}
efree(&hostname);
efree(&action);
if(current)efree(¤t);
}
/*
* monitor_remove_host
*/
static void
monitor_remove_host(ctrls, host)
struct arglist * ctrls;
char * host;
{
GtkWidget * item;
GList * list = NULL;
item = gtk_object_get_data(GTK_OBJECT(arg_get_value(ctrls, "LIST")),host);
if(!item){
/*
* If this happens, then it's very likely that the server
* thinks the communication has been cut between the client
* and itself. Which is not a good thing.
*/
return;
}
if(item != (void*)-1)
{
list = g_list_append(list, item);
gtk_list_remove_items(GTK_LIST(arg_get_value(ctrls, "LIST")), list);
gtk_object_remove_data(GTK_OBJECT(arg_get_value(ctrls, "LIST")), host);
g_list_free(list);
}
{ /* XXX: This is part of the MVC version */
GtkListStore * store = arg_get_value(ctrls, "MON_STORE");
GtkTreeIter iter;
char * list_hostname;
if (gtk_tree_model_get_iter_first(GTK_TREE_MODEL(store), &iter)) {
do {
gtk_tree_model_get(GTK_TREE_MODEL(store), &iter,
COL_HOSTNAME, &list_hostname, -1);
if (!strcmp(list_hostname, host)) {
gtk_list_store_remove(store, &iter);
break;
}
} while (gtk_tree_model_iter_next(GTK_TREE_MODEL(store), &iter));
}
}
}
/*
* monitor_add_host
*
* this function adds a new hostname and progress bar in
* the monitor window
*/
void
monitor_add_host(ctrls,hostname,port)
struct arglist * ctrls;
char * hostname;
int port;
{
GtkWidget * progress_bar_portscan;
GtkWidget * progress_bar_attack;
GtkWidget * table;
GtkWidget * label;
GtkWidget * item;
GtkWidget * button;
GtkWidget * separator;
GtkWidget * box, * hbox;
GdkPixbuf *pixbuf;
GtkWidget *img;
GList * dlist;
GtkWidget * window = arg_get_value(ctrls,"WINDOW");
struct context * context = arg_get_value(ctrls, "CONTEXT");
item = gtk_list_item_new();
dlist = NULL;
table = gtk_table_new(4, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 15);
gtk_table_set_row_spacings(GTK_TABLE(table), 5);
gtk_container_add(GTK_CONTAINER(item), table);
hbox = gtk_hbox_new(FALSE,0);
gtk_widget_show(hbox);
gtk_table_attach_defaults(GTK_TABLE(table), hbox, 0,1,0,3);
/*
* Host name
*/
box = gtk_vbox_new(TRUE,0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 0);
if(F_show_pixmaps)
{
pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)computer_xpm);
img = gtk_image_new_from_pixbuf(pixbuf);
gtk_box_pack_start(GTK_BOX(box), img, FALSE, FALSE, 0);
gtk_widget_show(img);
}
label = gtk_label_new(hostname);
gtk_object_set_data(GTK_OBJECT(item), "label", label);
gtk_widget_set_usize(label, 150, 15);
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/*
* Portscan, Attack and Plugin labels
*/
box = gtk_vbox_new(TRUE, 0);
gtk_widget_show(box);
gtk_box_pack_end(GTK_BOX(hbox), box, FALSE, FALSE, 0);
label = gtk_label_new(_("Portscan:"));
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
label = gtk_label_new(_("Checks:"));
gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);
gtk_widget_show(label);
/*
* Progress bars
*/
box = gtk_vbox_new(FALSE,0);
gtk_table_attach_defaults(GTK_TABLE(table), box, 1,2,0,3);
gtk_widget_show(box);
progress_bar_portscan = gtk_progress_bar_new();
/*
gtk_table_attach_defaults(GTK_TABLE(table),progress_bar_portscan, 1,2,0,1);
*/
gtk_box_pack_start(GTK_BOX(box), progress_bar_portscan, TRUE, TRUE,0);
gtk_widget_show(progress_bar_portscan);
progress_bar_attack = gtk_progress_bar_new();
/*
gtk_table_attach_defaults(GTK_TABLE(table),progress_bar_attack, 1,2,1,2);
*/
gtk_box_pack_start(GTK_BOX(box), progress_bar_attack, TRUE, TRUE,0);
gtk_widget_show(progress_bar_attack);
/*
* Stop button
*/
box = gtk_vbox_new(TRUE,0);
gtk_table_attach_defaults(GTK_TABLE(table), box, 2,3,0,2);
gtk_widget_show(box);
button = gtk_button_new_with_label(_("Stop"));
gtk_signal_connect(GTK_OBJECT(button), "clicked",
(GtkSignalFunc)monitor_stop_test, context);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 0);
gtk_object_set_data(GTK_OBJECT(button), "hostname", hostname);
gtk_widget_show(button);
separator = gtk_hseparator_new();
gtk_table_attach_defaults(GTK_TABLE(table), separator, 0,3,3,4);
gtk_widget_show(separator);
gtk_object_set_data(GTK_OBJECT(item), "hostname", hostname);
gtk_object_set_data(GTK_OBJECT(item), "progress_bar_attack", progress_bar_attack);
gtk_object_set_data(GTK_OBJECT(item), "progress_bar_portscan", progress_bar_portscan);
gtk_widget_show(table);
gtk_widget_show(item);
dlist = g_list_append(dlist, item);
gtk_object_set_data(GTK_OBJECT(arg_get_value(ctrls, "LIST")), hostname,item);
gtk_list_append_items(GTK_LIST(arg_get_value(ctrls, "LIST")), dlist);
{ /* XXX: This is part of the MVC version */
GtkListStore * store = arg_get_value(ctrls, "MON_STORE");
GtkTreeIter iter;
GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data((const char **)computer_xpm);
gtk_list_store_append(store, &iter); /* Acquire an iterator */
gtk_list_store_set(store, &iter,
COL_ICON, pixbuf,
COL_HOSTNAME, hostname,
COL_PORTSCAN, 0,
COL_CHECKS, 0,
-1);
}
}
/*
* monitor_stop_test
*
* This function will stop the connection between
* nessusd and the client, and will report the results
* to the screen
*/
static int
monitor_stop_whole_test_destroy(a,b,ctrls)
void * a, * b;
struct arglist * ctrls;
{
return monitor_stop_whole_test(NULL, ctrls);
}
static int
monitor_stop_whole_test(w, ctrls)
GtkWidget * w;
struct arglist * ctrls;
{
int type = 0, n;
char * msg;
char buf[32768];
struct context * context;
GtkWindow* parent = arg_get_value(ctrls, "PARENT");
context = arg_get_value(ctrls, "CONTEXT");
network_printf(context->socket, "CLIENT <|> STOP_WHOLE_TEST <|> CLIENT\n");
gtk_idle_remove((int)arg_get_value(ctrls, "TAG"));
/*
* Read the data remaining...
*/
while(type != MSG_BYE)
{
buf[sizeof(buf) - 1] = '\0';
network_gets_raw(context->socket, buf, sizeof(buf) - 1);
if( buf[0] == '\0') {
break;
}
if ((n = strlen (buf)) && buf [n-1] == '\n') buf [n-1] = '\0';
msg = emalloc(strlen(buf)+1);
type = parse_server_message(context, buf, (int)arg_get_value(ctrls, "MONITOR_BACKEND"), msg);
efree(&msg);
}
context->action = CONTEXT_IDLE;
prefs_context_update(context);
gtk_widget_hide(arg_get_value(ctrls, "WINDOW"));
#if 0
arg_set_value(MainDialog, "CONTEXT", -1, parent);
#endif
report_save(context, (int)arg_get_value(ctrls, "MONITOR_BACKEND"), NULL);
return(FALSE);
}
/*
* monitor_input_callback
*
* This function is called whenever there is new
* data coming from the server.
*/
void
monitor_input_callback(ctrls)
struct arglist * ctrls;
{
GtkWindow* parent = arg_get_value(ctrls, "PARENT");
int finished = 0;
static char * buf = NULL;
static int bufsz = 0;
static char * msg = NULL;
int n, type = -1;
int interrupted = 0;
struct context * context = arg_get_value(ctrls, "CONTEXT");
if ( context == NULL ) return;
if ( buf == NULL )
{
bufsz = 1024 * 1024;
buf = emalloc( bufsz );
msg = emalloc( bufsz );
}
network_gets_raw( context->socket, buf, bufsz );
if ((n = strlen (buf)) && buf [n-1] == '\n') buf [n-1] = '\0';
if( buf[0] == '\0') {
if(!is_server_present(context->socket))
{
interrupted++;
goto scan_finished;
}
else return;
}
type = parse_server_message(context, buf, (int)arg_get_value(ctrls, "MONITOR_BACKEND"), msg);
switch(type)
{
case MSG_BYE :
network_printf(context->socket, "CLIENT <|> BYE <|> ACK\n");
finished = 1;
break;
case MSG_STAT2 :
monitor_list_update(ctrls,buf+2, 1);
break;
case MSG_STAT :
monitor_list_update(ctrls, msg, 0);
break;
case MSG_FINISHED :
monitor_remove_host(ctrls, msg);
break;
}
buf[0] = '\0';
msg[0] = '\0';
if(finished)
{
scan_finished :
gtk_widget_hide(arg_get_value(ctrls, "WINDOW"));
gtk_idle_remove((int)arg_get_value(ctrls, "TAG"));
gtk_widget_destroy(arg_get_value(ctrls, "WINDOW"));
#if 0
arg_set_value(MainDialog, "CONTEXT", -1, parent);
#endif
report_save(context, (int)arg_get_value(ctrls, "MONITOR_BACKEND"), NULL);
context->action = CONTEXT_IDLE;
prefs_context_update(context);
}
}
/*
* monitor_stop_test
*
* this function stops one test
*/
void
monitor_stop_test(GtkWidget * w,struct context * context)
{
char * hostname = gtk_object_get_data(GTK_OBJECT(w), "hostname");
network_printf(context->socket, "CLIENT <|> STOP_ATTACK <|> %s <|> CLIENT\n", hostname);
}
#endif
--Boundary-00=_JnAGGAp2jZS27oX
Content-Type: text/plain; charset="us-ascii"
MIME-Version: 1.0
Content-Transfer-Encoding: 7bit
Content-Disposition: inline
_______________________________________________
Nessus-devel mailing list
[email protected]
http://mail.nessus.org/mailman/listinfo/nessus-devel
--Boundary-00=_JnAGGAp2jZS27oX--