/*

  *  ClamdTOP

  *

  *  Copyright (C) 2013-2019 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
  *  Copyright (C) 2008-2013 Sourcefire, Inc.

  *
  *  Authors: Török Edvin
  *
  *  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., 51 Franklin Street, Fifth Floor, Boston,
  *  MA 02110-1301, USA.
  */

 #define _GNU_SOURCE
 #define __EXTENSIONS
 #define GCC_PRINTF
 #define GCC_SCANF

 
 #ifdef HAVE_CONFIG_H
 #include "clamav-config.h"
 #endif
 

 #ifdef HAVE_STDINT_H
 #include <stdint.h>
 #endif
 

 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>

 #include CURSES_INCLUDE

 #include <time.h>
 #include <ctype.h>
 #include <signal.h>

 #ifdef _WIN32
 #include <windows.h>
 #include <winsock2.h>
 /* this is not correct, perhaps winsock errors are not mapped on errno */
 #define herror perror
 #else

 #include <netdb.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/un.h>

 #endif

 #include <sys/time.h>

 #include <assert.h>

 #include <errno.h>

 #include "libclamav/clamav.h"

 #include "shared/optparser.h"
 #include "shared/misc.h"
 

 /* Types, prototypes and globals*/
 typedef struct connection {
 	int sd;

 	char *remote;

 	int tcp;
 	struct timeval tv_conn;
 	char *version;

 	int line;

 } conn_t;
 
 struct global_stats {
 	struct task *tasks;
 	ssize_t n;
 	struct stats *all_stats;
 	size_t num_clamd;
 	conn_t *conn;
 };
 
 struct stats {
 	const char *remote;
 	char *engine_version;
 	char *db_version;
 	struct tm db_time;
 	const char *version;

 	int stats_unsupp;

 	uint8_t conn_hr, conn_min, conn_sec;
 	/* threads - primary */
 	unsigned prim_live, prim_idle, prim_max;
 	/* threads - sum */
 	unsigned live, idle, max;
 	/* queue */
 	unsigned biggest_queue, current_q;
 	double mem;/* in megabytes */
 	unsigned long lheapu, lmmapu, ltotalu, ltotalf, lreleasable, lpoolu, lpoolt;
 	unsigned pools_cnt;
 };
 
 static void cleanup(void);
 static int send_string_noreconn(conn_t *conn, const char *cmd);
 static void send_string(conn_t *conn, const char *cmd);

 static int read_version(conn_t *conn);

 char *get_ip(const char *ip);
 char *get_port(const char *ip);
 char *make_ip(const char *host, const char *port);

 enum exit_reason {

         FAIL_CMDLINE=1,
 	FAIL_INITIAL_CONN,

 	OUT_OF_MEMORY,
 	RECONNECT_FAIL,
 	SIGINT_REASON
 };
 
 static void exit_program(enum exit_reason reason, const char *func, unsigned line);

 #if __GNUC__ >= 3

 #define EXIT_PROGRAM(r) exit_program(r, __PRETTY_FUNCTION__, __LINE__);

 #else
 #define EXIT_PROGRAM(r) exit_program(r, "<unknown>", __LINE__);
 #endif

 #define OOM_CHECK(p) do { if (!p) EXIT_PROGRAM(OUT_OF_MEMORY); } while (0)
 
 

 static struct global_stats global;
 static int curses_inited = 1;
 static int maxystats=0;

 static int detail_selected = -1;
 

 static int detail_exists(void)

 {
 	return global.num_clamd != 1;
 }
 
 static int detail_is_selected(int idx)
 {
 	if (!detail_exists()) {
 		assert(idx == 0);
 		return 1;
 	}
 	return idx == detail_selected;
 }
 
 

 /* ---------------------- NCurses routines -----------------*/

 enum colors {
 	header_color=1,
 	version_color,

 	error_color,

 	value_color,
 	descr_color,

 	selected_color,

 	queue_header_color,
 	activ_color,
 	dim_color,
 	red_color,
 };
 
 #define UPDATE_INTERVAL 2
 #define MIN_INTERVAL 1
 
 /* the default color of the terminal in ncurses */
 #define DEFAULT_COLOR -1
 
 #define VALUE_ATTR A_BOLD | COLOR_PAIR(value_color)
 #define DESCR_ATTR COLOR_PAIR(descr_color)

 #define ERROR_ATTR A_BOLD | COLOR_PAIR(error_color)

 
 static WINDOW *header_window = NULL;
 static WINDOW *stats_head_window = NULL;
 static WINDOW *stats_window = NULL;
 static WINDOW *status_bar_window = NULL;
 static WINDOW *mem_window = NULL;
 
 static const char *status_bar_keys[10];
 static unsigned maxy=0, maxx=0;
 static char *queue_header = NULL;

 static char *clamd_header = NULL;
 

 #define CMDHEAD " COMMAND        QUEUEDSINCE   FILE"
 #define CMDHEAD2 " # COMMAND     QUEUEDSINCE   FILE"

 
 /*
  * CLAMD - which local/remote clamd this is
  * CONNTIM - since when we are connected (TODO: zeroed at reconnect)
  * QUEUE   - no of items in queue (total)
  * MAXQUEUE - max no of items in queue observed
  * LIVETHR - sum of live threads
  * IDLETHR - sum of idle threads
  */
 #define SUMHEAD "NO CONNTIME LIV IDL QUEUE  MAXQ   MEM HOST           ENGINE DBVER DBTIME"

 
 static void resize(void)
 {
 	char *p;
 	unsigned new_maxy, new_maxx;
 	getmaxyx(stdscr, new_maxy, new_maxx);
 	if(new_maxy == maxy && new_maxx == maxx)
 		return;
 	maxx = new_maxx;
 	maxy = new_maxy;
 	free(queue_header);

 	free(clamd_header);

 	queue_header = malloc(maxx + 1);

 	OOM_CHECK(queue_header);

 	clamd_header = malloc(maxx + 1);

 	OOM_CHECK(clamd_header);

 	assert(clamd_header && queue_header);

 	strncpy(queue_header, global.num_clamd>1 ? CMDHEAD2 : CMDHEAD, maxx);
 	strncpy(clamd_header, SUMHEAD, maxx);

 	queue_header[maxx] = '\0';

 	clamd_header[maxx] = '\0';

 	p = queue_header + strlen(queue_header);
 	while(p < queue_header+maxx)
 		*p++ = ' ';

 	p = clamd_header + strlen(clamd_header);
 	while(p < clamd_header+maxx)
 		*p++ = ' ';

 }
 
 static void rm_windows(void)
 {
 	if(header_window) {
 		delwin(header_window);
 		header_window = NULL;
 	}
 	if(mem_window) {
 		delwin(mem_window);
 		mem_window = NULL;
 	}
 	if(stats_window) {
 		delwin(stats_window);
 		stats_window = NULL;
 	}
 	if(stats_head_window) {
 		delwin(stats_head_window);
 		stats_head_window = NULL;
 	}
 	if(status_bar_window) {
 		delwin(status_bar_window);
 		status_bar_window = NULL;
 	}
 }
 
 

 static void init_windows(int num_clamd)

 {
 	resize();
 
 	rm_windows();

 	/* non-overlapping windows */

 	header_window = subwin(stdscr, 1, maxx, 0, 0);

 	stats_head_window = subwin(stdscr, num_clamd+1, maxx, 1, 0);
 	maxystats = maxy-num_clamd-3;
 	stats_window = subwin(stdscr, maxystats, maxx, num_clamd+2, 0);
 	status_bar_window = subwin(stdscr, 1, maxx, maxy-1, 0);
 	/* memwindow overlaps, used only in details mode */

 	mem_window = derwin(stats_window, 6, 41, 1, maxx-41);

 	touchwin(stdscr);
 	werase(stdscr);
 	refresh();
 	memset(status_bar_keys, 0, sizeof(status_bar_keys));

 	status_bar_keys[0] = "H - help";

 	status_bar_keys[1] = "Q - quit";

 	status_bar_keys[2] = "R - reset maximums";
 	if (num_clamd > 1) {
 		status_bar_keys[3] = "^ - previous clamd";
 		status_bar_keys[4] = "v - next clamd";
 	}

 }
 

 static void init_ncurses(int num_clamd, int use_default)

 {

 	int default_bg = use_default ? DEFAULT_COLOR : COLOR_BLACK;
 	int default_fg = use_default ? DEFAULT_COLOR : COLOR_WHITE;

 	initscr();

 	curses_inited = 1;
 

 	start_color();
 	keypad(stdscr, TRUE);	/* enable keyboard mapping */
 	nonl();			/* tell curses not to do NL->CR/NL on output */
 	halfdelay(UPDATE_INTERVAL*10); /* timeout of 2s when waiting for input*/
 	noecho();		/* dont echo input */
 	curs_set(0);		/* turn off cursor */

 	if (use_default)
 	    use_default_colors();

 
 	init_pair(header_color, COLOR_BLACK, COLOR_WHITE);

 	init_pair(version_color, default_fg, default_bg);

 	init_pair(error_color, COLOR_WHITE, COLOR_RED);

 	init_pair(value_color, COLOR_GREEN, default_bg);
 	init_pair(descr_color, COLOR_CYAN, default_bg);

 	init_pair(selected_color, COLOR_BLACK, COLOR_CYAN);

 	init_pair(queue_header_color, COLOR_BLACK, COLOR_GREEN);

 	init_pair(activ_color, COLOR_MAGENTA, default_bg);
 	init_pair(dim_color, COLOR_GREEN, default_bg);
 	init_pair(red_color, COLOR_RED, default_bg);

 	init_windows(num_clamd);

 }
 
 static void win_start(WINDOW *win, enum colors col)
 {
 	wattrset(win, COLOR_PAIR(col));
 	wbkgd(win, COLOR_PAIR(col));
 	werase(win);
 }
 
 
 static void  print_colored(WINDOW *win, const char *p)
 {
 	while(*p) {
 		wattron(win, DESCR_ATTR);
 		while(*p && !isdigit(*p))
 			waddch(win, *p++);
 		wattroff(win, DESCR_ATTR);
 		wattron(win, VALUE_ATTR);
 		while(*p && isdigit(*p))
 			waddch(win, *p++);
 		wattroff(win, VALUE_ATTR);
 	}
 }
 
 static void header(void)
 {
 	size_t i, x=0;
 	time_t t;
 

 	win_start(header_window, header_color);

 	mvwprintw(header_window, 0, 0, "  ClamdTOP version %s   ", get_version());

 	time(&t);
 	wprintw(header_window, "%s", ctime(&t));
 	wrefresh(header_window);
 

 /*	win_start(version_window, version_color);

 	mvwprintw(version_window, 0, 0, "Connected to: ");
 	print_colored(version_window, clamd_version ? clamd_version : "Unknown");

 	wrefresh(version_window);*/

 
 	werase(status_bar_window);
 	for(i=0;i<sizeof(status_bar_keys)/sizeof(status_bar_keys[0]);i++) {

 		const char *s = status_bar_keys[i];
 		if(!s)

 			continue;
 		wattron(status_bar_window, A_REVERSE);

 		if (s[0] == '^') {
 			mvwaddch(status_bar_window, 0, x, ACS_UARROW);
 			s++;
 			x++;
 		} else if (s[0] == 'v') {
 			mvwaddch(status_bar_window, 0, x, ACS_DARROW);
 			s++;
 			x++;
 		}
 		mvwprintw(status_bar_window, 0, x,  "%s",s);

 		wattroff(status_bar_window, A_REVERSE);
 		x += strlen(status_bar_keys[i]) + 1;
 	}
 	wrefresh(status_bar_window);
 }
 
 static void show_bar(WINDOW *win, size_t i, unsigned live, unsigned idle,
 		unsigned max, int blink)
 {

 	int y,x,z = 0;

 	unsigned len  = 39;

 	unsigned start = 1;

 	unsigned activ = max ? ((live-idle)*(len - start - 2) + (max/2)) / max : 0;
 	unsigned dim   = max ? idle*(len - start - 2) / max : 0;

 	unsigned rem = len - activ - dim - start-2;

 	assert(activ + 2 < len && activ+dim + 2 < len && activ+dim+rem + 2 < len && "Invalid values");

 	mvwaddch(win, i, start, '[' | A_BOLD);
 	wattron(win, A_BOLD | COLOR_PAIR(activ_color));
 	for(i=0;i<activ;i++)
 		waddch(win, '|');
 	wattroff(win, A_BOLD | COLOR_PAIR(activ_color));
 	wattron(win, A_DIM | COLOR_PAIR(dim_color));
 	for(i=0;i<dim;i++)
 		waddch(win, '|');
 	wattroff(win, A_DIM | COLOR_PAIR(dim_color));
 	for(i=0;i<rem;i++)
 		waddch(win, ' ');
 	waddch(win, ']' | A_BOLD);
 	if(blink) {
 		getyx(win, y, x);

 		if ((x < 0) || (y < 0)) {
 			return; /* if getyx() failed, nevermind the blinking */
 		}

 		if (x >= 2) {

 			z = x - 2;
 		}

 		mvwaddch(win, y, z, '>' | A_BLINK | COLOR_PAIR(red_color));

 		move(y, z);

 	}
 }
 

 /* --------------------- Error handling ---------------------*/
 static int normal_exit = 0;
 static const char *exit_reason = NULL;
 static const char *exit_func = NULL;
 static unsigned exit_line = 0;
 
 static void cleanup(void)
 {
 	unsigned i;
 	if (curses_inited) {

 		if (status_bar_window) {
 			werase(status_bar_window);
 			wrefresh(status_bar_window);
 		}

 		rm_windows();
 		endwin();
 	}
 	curses_inited = 0;
 	for (i=0;i<global.num_clamd;i++) {

 		if (global.conn[i].sd && global.conn[i].sd != -1) {

 			send_string_noreconn(&global.conn[i], "nEND\n");

 			close(global.conn[i].sd);
 		}

 		free(global.conn[i].version);

 		free(global.conn[i].remote);

 	}
 	free(global.all_stats);
 	free(global.conn);
 	free(queue_header);
 	free(clamd_header);
 	if(!normal_exit) {
 		fprintf(stderr, "Abnormal program termination");
 	        if (exit_reason) fprintf(stderr, ": %s",exit_reason);
 		if (exit_func) fprintf(stderr, " in %s", exit_func);
 		if (exit_line) fprintf(stderr, " at line %u", exit_line);
 		fputc('\n',stderr);
 	}
 }
 

 #ifdef __GNUC__
 #define __noreturn __attribute__((noreturn))
 #else
 #define __noreturn
 #endif

 static void __noreturn exit_program(enum exit_reason reason, const char *func, unsigned line)

 {
 	switch(reason) {

 		case FAIL_CMDLINE:
 			exit_reason = "Invalid command-line arguments";
 			break;

 		case FAIL_INITIAL_CONN:
 			exit_reason = "Unable to connect to all clamds";
 			break;
 		case OUT_OF_MEMORY:
 			exit_reason = "Out of memory";
 			break;
 		case RECONNECT_FAIL:
 			exit_reason = "Failed to reconnect to clamd after connection was lost";
 			break;

 		case SIGINT_REASON:
 			exit_reason = "User interrupt";
 			break;

 		default:
 			exit_reason = "Unknown";
 			break;
 	}
 	exit_func = func;
 	exit_line = line;
 	exit(reason);
 }
 

 struct task {
 	char *line;
 	double tim;

 	int clamd_no;

 };
 
 static int tasks_compare(const void *a, const void *b)
 {
 	const struct task *ta = a;
 	const struct task *tb = b;
 	if(ta->tim < tb->tim)
 		return 1;
 	if(ta->tim > tb->tim)
 		return -1;
 	return 0;
 }
 

 /* ----------- Socket routines ----------------------- */

 #ifdef __GNUC__
 static void print_con_info(conn_t *conn, const char *fmt, ...) __attribute__((format(printf, 2, 3)));
 #endif

 static void print_con_info(conn_t *conn, const char *fmt, ...)

 {
 	va_list ap;
 	va_start(ap, fmt);

 	if (stats_head_window) {

 		char *buf = malloc(maxx);

 		OOM_CHECK(buf);

 		memset(buf, ' ', maxx);

 		vsnprintf(buf, maxx-1, fmt, ap);

 		buf[strlen(buf)] = ' ';

 		buf[maxx-1] = '\0';

 		wattron(stats_head_window, ERROR_ATTR);
 		mvwprintw(stats_head_window, conn->line, 0, "%s", buf);
 		wattroff(stats_head_window, ERROR_ATTR);
 		wrefresh(stats_head_window);

 		free(buf);

 	} else
 		vfprintf(stdout, fmt, ap);

 	va_end(ap);
 }
 

 char *get_ip(const char *ip)
 {

     char *dupip, *p1;

     unsigned int i;

 
     /*
      * Expected format of ip:

      *     1) IPv4
      *     2) IPv4:Port
      *     3) IPv6
      *     4) [IPv6]:Port

      * 
      * Use of IPv6:Port is incorrect. An IPv6 address must be enclosed in brackets.
      */
 
     dupip = strdup(ip);
     if (!(dupip))
         return NULL;
 
     if (dupip[0] == '[') {
         /* IPv6 */
         p1 = strchr(dupip, ']');
         if (!(p1)) {
             free(dupip);
             return NULL;
         }
 
         *p1 = '\0';
 

         p1 = strdup(dupip+1);
         free(dupip);
         return p1;

     }
 

     p1 = dupip;
     i=0;

     while ((p1 = strchr(p1, ':'))) {

         i++;
         p1++;

     }
 

     if (i == 0 || i > 1)
         return dupip;

     if (i == 1) {
         p1 = strchr(dupip, ':');
         *p1 = '\0';
         return dupip;

     }
 
     return dupip;
 }
 
 char *get_port(const char *ip)
 {
     char *dupip, *p;

     unsigned int offset=0;

 
     dupip = get_ip(ip);
     if (!(dupip))
         return NULL;
 

     if (ip[0] == '[')
         offset += 2;
 

     p = (char *)ip + strlen(dupip) + offset;

     if (*p == ':') {
         p = strdup(p+1);
         free(dupip);
         return p;
     }

     return NULL;

 }
 
 char *make_ip(const char *host, const char *port)
 {
     char *ip;
     size_t len;
     int ipv6;
 
     len = strlen(host) + strlen(port);
 
     ipv6 = (strchr(host, ':') != NULL);
 

     len += (ipv6 ? 4 : 3);

 
     ip = calloc(1, len);
     if (!(ip))
         return NULL;
 
     snprintf(ip, len, "%s%s%s:%s", ipv6 ? "[" : "", host, ipv6 ? "]" : "", port);
 
     return ip;
 }

 static int make_connection_real(const char *soname, conn_t *conn)

 {

     int s = -1;

     struct timeval tv;

     char *port=NULL;

     char *pt = strdup(soname);

     const char *host = pt;
     struct addrinfo hints, *res=NULL, *p;

     int err;

     OOM_CHECK(pt);

     conn->tcp = 0;
 
 #ifndef _WIN32
     if(cli_is_abspath(soname) || (access(soname, F_OK) == 0)) {
         struct sockaddr_un addr;
 
         s = socket(AF_UNIX, SOCK_STREAM, 0);
         if(s < 0) {
             perror("socket");
             return -1;
         }
 
         memset(&addr, 0, sizeof(addr));
         addr.sun_family = AF_UNIX;
         strncpy(addr.sun_path, soname, sizeof(addr.sun_path));
         addr.sun_path[sizeof(addr.sun_path) - 1] = 0x0;
 
         print_con_info(conn, "Connecting to: %s\n", soname);
         if (connect(s, (struct sockaddr *)&addr, sizeof(addr))) {
             perror("connect");

             close(s);

             return -1;
         }
 
         goto end;
     }

 #endif

 
     memset(&hints, 0x00, sizeof(struct addrinfo));
     hints.ai_family = AF_UNSPEC;
     hints.ai_socktype = SOCK_STREAM;
     hints.ai_flags = AI_PASSIVE;
 

     host = get_ip(soname);
     if (!(host))
         return -1;
 
     port = get_port(soname);
 

     conn->tcp=1;
 

     print_con_info(conn, "Looking up: %s:%s\n", host, port ? port : "3310");
     if ((err = getaddrinfo(host, (port != NULL) ? port : "3310", &hints, &res))) {
         print_con_info(conn, "Could not look up %s:%s, getaddrinfo returned: %s\n", host, port ? port : "3310", gai_strerror(err));

         return -1;

     }

 
     for (p = res; p != NULL; p = p->ai_next) {
         if ((s = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) < 0) {
             perror("socket");
             continue;
         }
 

         print_con_info(conn, "Connecting to: %s\n", soname);

         if (connect(s, p->ai_addr, p->ai_addrlen)) {
             perror("connect");

             close(s);

             continue;
         }
 
         break;
     }
 
     free(pt);
 
     if (res)
         freeaddrinfo(res);
 
     if (p == NULL)
         return -1;
 
 end:
     if (conn->remote != soname) {
         /* when we reconnect, they are the same */
         if (conn->remote)
             free(conn->remote);
 

         conn->remote = make_ip(host, (port != NULL) ? port : "3310");

     }

     if (port)
         free(port);

     conn->sd = s;
     gettimeofday(&conn->tv_conn, NULL);
     tv.tv_sec = 30;
     tv.tv_usec = 0;
     setsockopt(conn->sd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
     return 0;

 }
 

 static int make_connection(const char *soname, conn_t *conn)
 {
     int rc;
 
     if ((rc = make_connection_real(soname, conn)))

         return rc;
 

     send_string(conn, "nIDSESSION\nnVERSION\n");
     free(conn->version);
     conn->version = NULL;
     if (!read_version(conn))

         return 0;

 
     /* clamd < 0.95 */
     if ((rc = make_connection_real(soname, conn)))

         return rc;
 

     send_string(conn, "nSESSION\nnVERSION\n");
     conn->version = NULL;
     if (!read_version(conn))

         return 0;
 

     return -1;
 }
 

 static void reconnect(conn_t *conn);

 static int send_string_noreconn(conn_t *conn, const char *cmd)

 {
 	assert(cmd);
 	assert(conn && conn->sd > 0);

 	return send(conn->sd, cmd, strlen(cmd), 0);
 }

 static void send_string(conn_t *conn, const char *cmd)
 {
 	while(send_string_noreconn(conn, cmd) == -1) {

 		reconnect(conn);
 	}
 }
 

 static int tries = 0;
 static void reconnect(conn_t *conn)
 {
 	if(++tries > 3) {
 		EXIT_PROGRAM(RECONNECT_FAIL);
 	}

 	if (conn->sd != -1)
 	    close(conn->sd);

 	if (make_connection(conn->remote, conn) < 0) {

 		print_con_info(conn, "Unable to reconnect to %s: %s", conn->remote, strerror(errno));

 		EXIT_PROGRAM(RECONNECT_FAIL);

 	}
 	tries = 0;
 }
 

 static int recv_line(conn_t *conn, char *buf, size_t len)
 {
 	assert(len > 0);

 	assert(conn);

 	assert(buf);
 
 	len--;

 	if (!len || conn->sd == -1)

 		return 0;

 	assert(conn->sd > 0);

 	while (len > 0) {
 		ssize_t nread = recv(conn->sd, buf, len, MSG_PEEK);

 		if (nread  <= 0) {
 			print_con_info(conn, "%s: %s", conn->remote, strerror(errno));
 			/* it could be a timeout, be nice and send an END */

 			send_string_noreconn(conn, "nEND\n");

 			close(conn->sd);
 			conn->sd = -1;
 			return 0;
 		} else {

 			char *p = memchr(buf, '\n', nread);
 			if (p) {
 				len = p - buf + 1;
 			} else
 				len = nread;
 			assert(len > 0);
 			assert(len <= (size_t)nread);
 			nread = recv(conn->sd, buf, len, 0);
 			if (nread == -1)
 				reconnect(conn);
 			else {
 				assert(nread >0 && (size_t)nread == len);
 				buf += nread;
 			}
 			if (p)
 				break;
 		}
 	}
 	*buf = '\0';
 	return 1;
 }
 

 static void output_queue(size_t line, ssize_t max)
 {

 	ssize_t i, j;

 	struct task *tasks = global.tasks;

 	struct task *filtered_tasks = calloc(global.n, sizeof(*filtered_tasks));
 	OOM_CHECK(filtered_tasks);
 	for (i=0,j=0;i<global.n;i++) {
 		if (detail_selected == -1 || detail_is_selected(tasks[i].clamd_no-1)) {
 			filtered_tasks[j++] = tasks[i];
 		}
 	}
 

 	wattron(stats_window, COLOR_PAIR(queue_header_color));
 	mvwprintw(stats_window, line++, 0, "%s", queue_header);
 	wattroff(stats_window, COLOR_PAIR(queue_header_color));

 	if (max >= j)
 		max = j;

 	else
 		--max;
 	if (max < 0) max = 0;
 	for(i=0;i<max;i++) {

 		char *cmde;

 		assert(tasks);

 		cmde = strchr(filtered_tasks[i].line, ' ');

 		if(cmde) {
 			char cmd[16];
 			const char *filstart = strchr(cmde + 1, ' ');

 			strncpy(cmd, filtered_tasks[i].line, sizeof(cmd)-1);

 			cmd[15]='\0';

 			if (filtered_tasks[i].line+15 > cmde)
 				cmd[cmde - filtered_tasks[i].line] = '\0';

 			if(filstart) {
 				++filstart;

 				if (detail_selected == -1 && global.num_clamd > 1)
 					mvwprintw(stats_window, line + i, 0, "%2u %s", filtered_tasks[i].clamd_no, cmd + 1);

 				else
 					mvwprintw(stats_window, line + i, 0, " %s", cmd + 1);

 				mvwprintw(stats_window, line + i, 15, "%10.03fs", filtered_tasks[i].tim);

 				mvwprintw(stats_window, line + i, 30, "%s",filstart);
 			}
 		}
 	}

 	if (max < j) {

 		/* in summary mode we can only show a max amount of tasks */
 		wattron(stats_window, A_DIM | COLOR_PAIR(header_color));

 		mvwprintw(stats_window, line+i, 0, "*** %u more task(s) not shown ***", (unsigned)(j - max));

 		wattroff(stats_window, A_DIM | COLOR_PAIR(header_color));
 	}

 	free(filtered_tasks);

 }
 

 /* ---------------------- stats parsing routines ------------------- */

 
 
 static void parse_queue(conn_t *conn, char* buf, size_t len, unsigned idx)

 {
 	do {
 		double tim;
 		const char *t = strchr(buf, ' ');
 		if(!t)
 			continue;
 		if(sscanf(t,"%lf", &tim) != 1)
 			continue;

 		++global.n;
 		global.tasks = realloc(global.tasks, sizeof(*global.tasks)*global.n);

 		OOM_CHECK(global.tasks);

 		global.tasks[global.n-1].line = strdup(buf);

 		OOM_CHECK(global.tasks[global.n-1].line);

 		global.tasks[global.n-1].tim  = tim;

 		global.tasks[global.n-1].clamd_no = idx + 1;

 	} while (recv_line(conn, buf, len) && buf[0] == '\t' && strcmp("END\n", buf) != 0);

 }
 

 static unsigned biggest_mem = 0;

 static void output_memstats(struct stats *stats)

 {
 	char buf[128];

 	unsigned long totalmem;

 	int blink = 0;
 
 	werase(mem_window);

 	if (stats->mem > 0 || (stats->mem >=0 && (stats->lpoolt > 0))) {

 		box(mem_window, 0, 0);

 		if (stats->mem > 0)

 		    snprintf(buf, sizeof(buf),"heap %4luM mmap %4luM unused %3luM",

 			     stats->lheapu/1000, stats->lmmapu/1000, stats->lreleasable/1000);

 		else
 		    snprintf(buf, sizeof(buf), "heap   N/A mmap   N/A unused  N/A");

 		mvwprintw(mem_window, 1, 1, "Mem:  ");
 		print_colored(mem_window, buf);

 		mvwprintw(mem_window, 2, 1, "Libc: ");

 		if (stats->mem > 0)

 		    snprintf(buf, sizeof(buf),"used %4luM free %4luM total %4luM",

 			     stats->ltotalu/1000, stats->ltotalf/1000, (stats->ltotalu+stats->ltotalf)/1000);

 		else
 		    snprintf(buf, sizeof(buf), "used   N/A free   N/A total   N/A");

 		print_colored(mem_window, buf);

 		mvwprintw(mem_window, 3, 1, "Pool: ");

 		snprintf(buf, sizeof(buf), "count %4u used %4luM total %4luM",

 			stats->pools_cnt, stats->lpoolu/1000, stats->lpoolt/1000);

 		print_colored(mem_window, buf);

 		totalmem = stats->lheapu + stats->lmmapu + stats->lpoolt;
 		if(totalmem > biggest_mem) {
 			biggest_mem = totalmem;
 			blink = 1;
 		}
 		show_bar(mem_window, 4, totalmem, stats->lmmapu + stats->lreleasable + stats->lpoolt - stats->lpoolu,
 				biggest_mem, blink);

 	}
 	wrefresh(mem_window);
 }
 

 static void parse_memstats(const char *line, struct stats *stats)
 {
 	double heapu, mmapu, totalu, totalf, releasable, pools_used, pools_total;
 
 	if(sscanf(line, " heap %lfM mmap %lfM used %lfM free %lfM releasable %lfM pools %u pools_used %lfM pools_total %lfM",

 			&heapu, &mmapu, &totalu, &totalf, &releasable, &stats->pools_cnt, &pools_used, &pools_total) != 8) {
 	    if (sscanf(line , " heap N/A mmap N/A used N/A free N/A releasable N/A pools %u pools_used %lfM pools_total %lfM",
 		       &stats->pools_cnt, &pools_used, &pools_total) != 3) {
 		stats->mem = -1;

 		return;

 	    }
 	    stats->lpoolu = pools_used*1000;
 	    stats->lpoolt = pools_total*1000;
 	    stats->mem = 0;
 	    return;
 	}

 	stats->lheapu = heapu*1000;
 	stats->lmmapu = mmapu*1000;
 	stats->ltotalu = totalu*1000;
 	stats->ltotalf = totalf*1000;
 	stats->lreleasable = releasable*1000;
 	stats->lpoolu = pools_used*1000;
 	stats->lpoolt = pools_total*1000;
 	stats->mem = heapu + mmapu + pools_total;
 }

 static int output_stats(struct stats *stats, unsigned idx)
 {
 	char buf[128];
 	char timbuf[15];
 	int blink = 0;
 	size_t i= 0;
 	char mem[6];

 	WINDOW *win = stats_head_window;

 	int sel = detail_is_selected(idx);
 	char *line = malloc(maxx+1);
 
 	OOM_CHECK(line);

 	if (stats->mem <= 0 || stats->stats_unsupp) {

 		strncpy(mem, "N/A", sizeof(mem));

 		mem[sizeof(mem)-1]='\0';
 	}

 	else {
 		char c;
 		double s;
 		if (stats->mem > 999.0)  {
 			c = 'G';
 			s = stats->mem / 1024.0;
 		} else {
 			c = 'M';
 			s = stats->mem;
 		}
 		snprintf(mem, sizeof(mem), "%7.3f", s);
 		i = 4;
 		if (mem[i-1] == '.') i--;
 		mem[i++] = c;
 		mem[i] = '\0';
 	}
 	i = idx+1;
 

 	if (!stats->db_time.tm_year) {

 		strncpy(timbuf,"N/A",sizeof(timbuf));

 		timbuf[sizeof(timbuf)-1]='\0';

 	}

 	else
 		snprintf(timbuf, sizeof(timbuf), "%04u-%02u-%02u %02uh",
 				1900 + stats->db_time.tm_year,

 				stats->db_time.tm_mon+1,

 				stats->db_time.tm_mday,
 				stats->db_time.tm_hour);
 

 	memset(line, ' ', maxx+1);

 	if (!stats->stats_unsupp) {

 		snprintf(line, maxx-1, "%2u %02u:%02u:%02u %3u %3u %5u %5u %5s %-14s %-6s %5s %s", idx+1,  stats->conn_hr, stats->conn_min, stats->conn_sec,

 			stats->live, stats->idle,
 			stats->current_q, stats->biggest_queue,
 			mem,
 			stats->remote, stats->engine_version, stats->db_version, timbuf);

 	} else {

 		snprintf(line, maxx-1, "%2u %02u:%02u:%02u N/A N/A   N/A   N/A   N/A %-14s %-6s %5s %s", idx+1,  stats->conn_hr, stats->conn_min, stats->conn_sec,

 			stats->remote, stats->engine_version, stats->db_version, timbuf);
 	}

 	line[maxx] = '\0';
 	line[strlen(line)] = ' ';
 	if (sel) {
 		wattron(win,  COLOR_PAIR(selected_color));
 	}

 	mvwprintw(win, i, 0, "%s", line);

 	if (sel) {
 		wattroff(win, COLOR_PAIR(selected_color));
 	}

 	win = stats_window;
 	i = 0;

 	if (sel && !stats->stats_unsupp) {
 		memset(line, ' ', maxx+1);
 		snprintf(line, maxx-1, "Details for Clamd version: %s", stats->version);
 		line[maxx] = '\0';
 		line[strlen(line)]= ' ';
 		wattron(win,  COLOR_PAIR(queue_header_color));
 		mvwprintw(win, i++, 0, "%s", line);
 		wattroff(win, COLOR_PAIR(queue_header_color));

 		mvwprintw(win, i++, 0, "Primary threads: ");
 		snprintf(buf, sizeof(buf), "live %3u idle %3u max %3u", stats->prim_live, stats->prim_idle, stats->prim_max);
 		print_colored(win, buf);
 		show_bar(win, i++, stats->prim_live, stats->prim_idle, stats->prim_max, 0);

 /*		mvwprintw(win, i++, 0, "Multiscan pool : ");

 		snprintf(buf, sizeof(buf), "live %3u idle %3u max %3u", stats->live, stats->idle, stats->max);
 		print_colored(win, buf);

 		show_bar(win, i++, stats->live, stats->idle, stats->max, 0);*/

 		blink = 0;
 		if(stats->current_q > stats->biggest_queue) {
 			stats->biggest_queue = stats->current_q;
 			blink = 1;
 		}

 		mvwprintw(win, i++, 0, "Queue:");
 		snprintf(buf, sizeof(buf), "%6u items %6u max", stats->current_q, stats->biggest_queue);
 		print_colored(win, buf);

 		show_bar(win, i++, stats->current_q, 0, stats->biggest_queue, blink);

 		i += 2;

 		werase(mem_window);
 		output_memstats(stats);
 	}

 	free(line);

 	return i;
 }
 
 static void output_all(void)
 {
 	unsigned i, stats_line=0;
 	werase(stats_head_window);
 	werase(stats_window);
 	wattron(stats_head_window, COLOR_PAIR(queue_header_color));
 	mvwprintw(stats_head_window, 0, 0, "%s", clamd_header);
 	wattroff(stats_head_window, COLOR_PAIR(queue_header_color));

 	for (i=0;i<global.num_clamd;i++) {
 		unsigned  j = output_stats(&global.all_stats[i], i);
 		if (j > stats_line)
 			stats_line = j;
 	}

 	output_queue(stats_line, maxystats - stats_line-1);
 	wrefresh(stats_head_window);
 	wrefresh(stats_window);

 	if (detail_exists()) {

 		/* overlaps, must be done at the end */
 		wrefresh(mem_window);
 	}
 }
 
 static void parse_stats(conn_t *conn, struct stats *stats, unsigned idx)
 {

 	char buf[1025];

 	size_t j;

 	struct timeval tv;
 	unsigned conn_dt;

 	int primary = 0;

 	const char *pstart, *p, *vstart;

 
 	if (conn->tcp)
 		stats->remote = conn->remote;
 	else
 		stats->remote = "local";
 

 	if (!conn->version) {

 		stats->engine_version = strdup("???");

 		OOM_CHECK(stats->engine_version);

 		return;
 	}

 	p = pstart = vstart = strchr(conn->version, ' ');
 	if (!vstart) {

 	    stats->engine_version = strdup("???");

 	    OOM_CHECK(stats->engine_version);

 	    return;
 	}

 	/* find digit in version */
 	while (*p && !isdigit(*p))
 		p++;
 	/* rewind to first space or dash */
 	while (p > pstart && *p && *p != ' ' && *p != '-')
 		p--;
 	if (*p) p++;
 	/* keep only base version, and cut -exp, and -gittags */
 	pstart = p;
 	while (*p && *p != '-' && *p != '/')
 		p++;
 
 	stats->engine_version = malloc(p - pstart+1);

 	OOM_CHECK(stats->engine_version);

 	memcpy(stats->engine_version, pstart, p-pstart);
 	stats->engine_version[p-pstart] = '\0';
 
 	pstart = strchr(p, '/');

 	if (!pstart) {

 		stats->db_version = strdup("????");

 		OOM_CHECK(stats->db_version);

 	} else {

 		pstart++;
 		p = strchr(pstart, '/');
 		if (!p)
 			p = pstart + strlen(pstart);
 		stats->db_version = malloc(p - pstart + 1);

 		OOM_CHECK(stats->db_version);

 		memcpy(stats->db_version, pstart, p-pstart);
 		stats->db_version[p-pstart] = '\0';
 		if(*p) p++;
 		if (!*p || !strptime(p,"%a %b  %d %H:%M:%S %Y", &stats->db_time)) {
 			memset(&stats->db_time, 0, sizeof(stats->db_time));
 		}
 	}
 	if (maxx > 61 && strlen(stats->db_version) > (maxx-61)) {
 		stats->db_version[maxx-61] = '\0';
 	}
 

 	stats->version = vstart; /* for details view */

 	gettimeofday(&tv, NULL);

 	tv.tv_sec -= conn->tv_conn.tv_sec;
 	tv.tv_usec -= conn->tv_conn.tv_usec;

 	conn_dt = tv.tv_sec + tv.tv_usec/1e6;

 
 	stats->live = stats->idle = stats->max = 0;
 	stats->conn_hr = conn_dt/3600;
 	stats->conn_min = (conn_dt/60)%60;
 	stats->conn_sec = conn_dt%60;

 	stats->current_q = 0;

 	buf[sizeof(buf) - 1] = 0x0;

 	while(recv_line(conn, buf, sizeof(buf)-1) && strcmp("END\n",buf) != 0) {

 		char *val = strchr(buf, ':');
 
 		if(buf[0] == '\t') {

 			parse_queue(conn, buf, sizeof(buf)-1, idx);

 			continue;
 		} else if(val)
 			*val++ = '\0';
 		if(!strcmp("MEMSTATS", buf)) {

 			parse_memstats(val, stats);

 			continue;
 		}

 		if(!strncmp("UNKNOWN COMMAND", buf, 15)) {
 			stats->stats_unsupp = 1;
 			break;
 		}

 		for(j=1;j<strlen(buf);j++)
 			buf[j] = tolower(buf[j]);

 	/*	mvwprintw(win, i, 0, "%s", buf);

 		if(!val) {
 			i++;
 			continue;
 		}
 		waddch(win, ':');
 		print_colored(win, val);

 		i++;*/
 		if(!strncmp("State",buf,5)) {
 			if(strstr(val, "PRIMARY")) {
 				/* primary thread pool */
 				primary = 1;
 			} else {
 				/* multiscan pool */
 				primary = 0;
 			}
 		}

 		if(!strcmp("Threads",buf)) {
 			unsigned live, idle, max;
 			if(sscanf(val, " live %u idle %u max %u", &live, &idle, &max) != 3)
 				continue;

 			if (primary) {
 				stats->prim_live = live;
 				stats->prim_idle = idle;
 				assert(!stats->prim_max && "There can be only one primary pool!");
 				stats->prim_max = max;
 			}

 			stats->live += live;
 			stats->idle += idle;
 			stats->max += max;

 		} else if (!strcmp("Queue",buf)) {
 			unsigned len;
 			if(sscanf(val, "%u", &len) != 1)
 				continue;

 			stats->current_q += len;

 		}
 	}
 }
 

 static int read_version(conn_t *conn)

 {
 	char buf[1024];

 	unsigned i;
 	if(!recv_line(conn, buf, sizeof(buf)))
 	    return -1;
 	if (!strcmp(buf, "UNKNOWN COMMAND\n"))
 	    return -2;
 
 	conn->version = strdup(buf);
 	OOM_CHECK(conn->version);
 	for (i=0;i<strlen(conn->version);i++)
 		    if (conn->version[i] == '\n')
 			conn->version[i] = ' ';
 	return 0;

 }
 

 static void sigint(int a)
 {

     UNUSEDPARAM(a);

 	EXIT_PROGRAM(SIGINT_REASON);
 }
 

 static void help(void)
 {
     printf("\n");

     printf("                       Clam AntiVirus: Monitoring Tool %s\n", get_version());

     printf("           By The ClamAV Team: https://www.clamav.net/about.html#credits\n");

     printf("           (C) 2019 Cisco Systems, Inc.\n");

     printf("\n");
     printf("    clamdtop [-hVc] [host[:port] /path/to/clamd.socket ...]\n");
     printf("\n");
     printf("    --help                 -h         Show this help\n");

     printf("    --version              -V         Show version\n");
     printf("    --config-file=FILE     -c FILE    Read clamd's configuration files from FILE\n");

     printf("    --defaultcolors	       -d         Use default terminal colors\n");
     printf("    host[:port]                       Connect to clamd on host at port (default 3310)\n");
     printf("    /path/to/clamd.socket             Connect to clamd over a local socket\n");

     printf("\n");
     return;
 }

 static int default_colors=0;

 /* -------------------------- Initialization ---------------- */
 static void setup_connections(int argc, char *argv[])

 {

     struct optstruct *opts;
     struct optstruct *clamd_opts;
     unsigned i;
     char *conn = NULL;
 
     opts = optparse(NULL, argc, argv, 1, OPT_CLAMDTOP, 0, NULL);
     if (!opts) {
         fprintf(stderr, "ERROR: Can't parse command line options\n");
         EXIT_PROGRAM(FAIL_CMDLINE);
     }
 
     if(optget(opts, "help")->enabled) {
         optfree(opts);
         help();
         normal_exit = 1;
         exit(0);
     }
 
     if(optget(opts, "version")->enabled) {
         printf("Clam AntiVirus Monitoring Tool %s\n", get_version());
         optfree(opts);
         normal_exit = 1;
         exit(0);
     }
 
     if(optget(opts, "defaultcolors")->enabled)
         default_colors = 1;
 
     memset(&global, 0, sizeof(global));
     if (!opts->filename || !opts->filename[0]) {
         const struct optstruct *opt;
         const char *clamd_conf = optget(opts, "config-file")->strarg;
 
         if ((clamd_opts = optparse(clamd_conf, 0, NULL, 1, OPT_CLAMD, 0, NULL)) == NULL) {
             fprintf(stderr, "Can't parse clamd configuration file %s\n", clamd_conf);
             EXIT_PROGRAM(FAIL_CMDLINE);
         }
 
         if((opt = optget(clamd_opts, "LocalSocket"))->enabled) {
             conn = strdup(opt->strarg);
             if (!conn) {
                 fprintf(stderr, "Can't strdup LocalSocket value\n");
                 EXIT_PROGRAM(FAIL_INITIAL_CONN);
             }
         } else if ((opt = optget(clamd_opts, "TCPSocket"))->enabled) {
             char buf[512];
             const struct optstruct *opt_addr;
             const char *host = "localhost";
             if ((opt_addr = optget(clamd_opts, "TCPAddr"))->enabled) {
                 host = opt_addr->strarg;
             }

             snprintf(buf, sizeof(buf), "%lld", opt->numarg);
             conn = make_ip(host, buf);

         } else {
             fprintf(stderr, "Can't find how to connect to clamd\n");
             EXIT_PROGRAM(FAIL_INITIAL_CONN);
         }
 
         optfree(clamd_opts);
         global.num_clamd = 1;
     } else {
         unsigned i = 0;
         while (opts->filename[i]) { i++; }
         global.num_clamd = i;
     }

 #ifdef _WIN32

     WSADATA wsaData;
     if (WSAStartup(MAKEWORD(2,2), &wsaData) != NO_ERROR) {
         fprintf(stderr, "Error at WSAStartup(): %d\n", WSAGetLastError());
         EXIT_PROGRAM(FAIL_INITIAL_CONN);
     }

 #endif

     /* clamdtop */
     puts( "        __                    ____");
     puts("  _____/ /___ _____ ___  ____/ / /_____  ____");
     puts(" / ___/ / __ `/ __ `__ \\/ __  / __/ __ \\/ __ \\");
     puts("/ /__/ / /_/ / / / / / / /_/ / /_/ /_/ / /_/ /");
     puts("\\___/_/\\__,_/_/ /_/ /_/\\__,_/\\__/\\____/ .___/");
     puts("                                     /_/");
 
     global.all_stats = calloc(global.num_clamd, sizeof(*global.all_stats));
     OOM_CHECK(global.all_stats);
     global.conn = calloc(global.num_clamd, sizeof(*global.conn));
     OOM_CHECK(global.conn);
 
     for (i=0;i < global.num_clamd;i++) {
         const char *soname = conn ? conn : opts->filename[i];
         global.conn[i].line = i+1;
         if (make_connection(soname, &global.conn[i]) < 0) {
             EXIT_PROGRAM(FAIL_INITIAL_CONN);
         }
     }
 
     optfree(opts);
     free(conn);

 #ifndef _WIN32

     signal(SIGPIPE, SIG_IGN);
     signal(SIGINT, sigint);

 #endif

 }
 
 static void free_global_stats(void)
 {
 	unsigned i;

 	for (i=0;i<(unsigned)global.n;i++) {

 		free(global.tasks[i].line);
 	}
 	for (i=0;i<global.num_clamd;i++) {
 		free(global.all_stats[i].engine_version);
 		free(global.all_stats[i].db_version);
 	}
 	free(global.tasks);
 	global.tasks = NULL;
 	global.n=0;
 }
 

 static int help_line;
 static void explain(const char *abbrev, const char *msg)
 {
 	wattron(stdscr, A_BOLD);
 	mvwprintw(stdscr, help_line++, 0, "%-15s", abbrev);
 	wattroff(stdscr, A_BOLD);
 	wprintw(stdscr,"  %s", msg);
 }
 
 static int show_help(void)
 {
 	int ch;
 	werase(stdscr);
 	help_line = 0;
 
 	explain("NO","Unique clamd number");
 	explain("CONNTIME", "How long it is connected");
 	explain("LIV", "Total number of live threads");
 	explain("IDL", "Total number of idle threads");
 	explain("QUEUE", "Number of items in queue");
 	explain("MAXQ","Maximum number of items observed in queue");
 	explain("MEM", "Total memory usage (if available)");
 	explain("HOST", "Which clamd, local means unix socket");
 	explain("ENGINE", "Engine version");
 	explain("DBVER", "Database version");
 	explain("DBTIME", "Database publish time");
 	explain("Primary threads", "Threadpool used to receive commands");

 	explain("Multiscan pool","Threadpool used for multiscan");

 	explain("live","Executing commands, or scanning");
 	explain("idle","Waiting for commands, will exit after idle_timeout");
 	explain("max", "Maximum number of threads configured for this pool");
 	explain("Queue","Tasks queued for processing, but not yet picked up by a thread");
 	explain("COMMAND","Command this thread is executing");
 	explain("QUEUEDSINCE","How long this task is executing");
 	explain("FILE","Which file it is processing (if applicable)");
 	explain("Mem","Memory usage reported by libc");
 	explain("Libc","Used/free memory reported by libc");
 	explain("Pool","Memory usage reported by libclamav's pool");
 
 	wrefresh(stdscr);
 	werase(status_bar_window);
 	wattron(status_bar_window, A_REVERSE);
 	mvwprintw(status_bar_window, 0, 0, "Press any key to exit help");
 	wattroff(status_bar_window, A_REVERSE);
 	wrefresh(status_bar_window);
 	/* getch() times out after a few seconds */
 	do {
 		ch = getch();
 		/* we do need to exit on resize, because the text scroll out of
 		 * view */
 	} while (ch == -1 /*|| ch == KEY_RESIZE*/);
 	return ch == KEY_RESIZE ? KEY_RESIZE : -1;
 }
 

 int main(int argc, char *argv[])
 {
 	int ch = 0;
 	struct timeval tv_last, tv;
 	unsigned i;
 
 	atexit(cleanup);
 	setup_connections(argc, argv);

 	init_ncurses(global.num_clamd, default_colors);

 
 	memset(&tv_last, 0, sizeof(tv_last));
 	do {

 		if (toupper(ch) == 'H') {

 			ch = show_help();
 		}

 		switch(ch) {
 			case KEY_RESIZE:
 				resize();
 				endwin();
 				refresh();
 				init_windows(global.num_clamd);
 				break;
 			case 'R':

 			case 'r':

 				for (i=0;i<global.num_clamd;i++)
 					global.all_stats[i].biggest_queue = 1;

 				biggest_mem = 0;
 				break;
 			case KEY_UP:
 				if (global.num_clamd > 1) {
 					if (detail_selected == -1)
 						detail_selected = global.num_clamd-1;
 					else
 						--detail_selected;
 				}
 				break;
 			case KEY_DOWN:
 				if (global.num_clamd > 1) {
 					if (detail_selected == -1)
 						detail_selected = 0;
 					else {
 						if((unsigned)++detail_selected >= global.num_clamd)
 							detail_selected = -1;
 					}
 				}
 				break;

 		}
 		gettimeofday(&tv, NULL);

 		header();

 		if(tv.tv_sec - tv_last.tv_sec >= MIN_INTERVAL) {

 			free_global_stats();
 			for(i=0;i<global.num_clamd;i++) {

 				unsigned biggest_q;

 				struct stats *stats = &global.all_stats[i];

 				if (global.conn[i].sd != -1)

 					send_string(&global.conn[i], "nSTATS\n");

 				biggest_q = stats->biggest_queue;

 				memset(stats, 0, sizeof(*stats));

 				stats->biggest_queue = biggest_q;

 				parse_stats(&global.conn[i], stats, i);

 			}

 			if (global.tasks)
 				qsort(global.tasks, global.n, sizeof(*global.tasks), tasks_compare);

 			tv_last = tv;
 		}

 		/* always show, so that screen resizes take effect instantly*/
 		output_all();

 		for(i=0;i<global.num_clamd;i++) {
 			if (global.conn[i].sd == -1)
 				reconnect(&global.conn[i]);
 		}

 	} while(toupper(ch = getch()) != 'Q');

 	free_global_stats();

 	normal_exit = 1;
 	return 0;
 }