void init_othp_table(struct othptable *table)
{
unsigned int winht;
unsigned int wintop;
unsigned int obmaxx __unused;
winht = LINES - (LINES * 0.6) - 2;
wintop = (LINES * 0.6) + 1;
table->count = 0;
table->lastpos = 0;
table->strindex = 0;
table->htstat = NOHTIND;
table->head = table->tail = NULL;
table->firstvisible = table->lastvisible = NULL;
table->borderwin = newwin(winht, COLS, wintop, 0);
table->borderpanel = new_panel(table->borderwin);
wattrset(table->borderwin, BOXATTR);
tx_box(table->borderwin, ACS_VLINE, ACS_HLINE);
table->head = table->tail = NULL;
table->othpwin = newwin(winht - 2, COLS - 2, wintop + 1, 1);
table->othppanel = new_panel(table->othpwin);
wattrset(table->othpwin, STDATTR);
tx_colorwin(table->othpwin);
update_panels();
doupdate();
tx_stdwinset(table->othpwin);
getmaxyx(table->borderwin, table->obmaxy, obmaxx);
table->oimaxy = table->obmaxy - 2;
}
void tx_infobox(char *text, char *prompt)
{
WINDOW *win;
PANEL *panel;
int ch;
win = newwin(4, 50, (LINES - 4) / 2, (COLS - 50) / 2);
panel = new_panel(win);
wattrset(win, INFO_BORDER_ATTR);
tx_colorwin(win);
tx_box(win, ACS_VLINE, ACS_HLINE);
wattrset(win, INFO_TEXT_ATTR);
mvwprintw(win, 1, 2, text);
wattrset(win, INFO_PROMPT_ATTR);
mvwprintw(win, 2, 2, prompt);
update_panels();
doupdate();
do {
ch = wgetch(win);
if (ch == 12)
tx_refresh_screen();
} while (ch == 12);
del_panel(panel);
delwin(win);
update_panels();
doupdate();
}
void tui_error_va(const char *prompt, const char *err, va_list vararg)
{
WINDOW *win = newwin(4, 70, (LINES - 4) / 2, (COLS - 70) / 2);
PANEL *panel = new_panel(win);
wattrset(win, ERR_BORDER_ATTR);
tx_colorwin(win);
tx_box(win, ACS_VLINE, ACS_HLINE);
wattrset(win, ERR_PROMPT_ATTR);
mvwprintw(win, 2, 2, "%s", prompt);
wattrset(win, ERR_TEXT_ATTR);
wmove(win, 1, 2);
vw_printw(win, err, vararg);
update_panels();
doupdate();
int response;
do {
response = wgetch(win);
if (response == 12)
tx_refresh_screen();
} while (response == 12);
del_panel(panel);
delwin(win);
update_panels();
doupdate();
}
void tx_init_listbox(struct scroll_list *list, int width, int height,
int startx, int starty,
int mainattr, int borderattr, int selectattr,
int keyattr)
{
bzero(list, sizeof(struct scroll_list));
list->borderwin = newwin(height, width, starty, startx);
list->borderpanel = new_panel(list->borderwin);
wattrset(list->borderwin, borderattr);
tx_box(list->borderwin, ACS_VLINE, ACS_HLINE);
list->win = newwin(height - 2, width - 2, starty + 1, startx + 1);
list->panel = new_panel(list->win);
wattrset(list->win, mainattr);
tx_colorwin(list->win);
list->mainattr = mainattr;
list->selectattr = selectattr;
list->height = height;
list->width = width;
list->keyattr = keyattr;
tx_stdwinset(list->win);
scrollok(list->win, 0);
}
void tx_errbox(char *message, char *prompt, int *response)
{
WINDOW *win;
PANEL *panel;
win = newwin(4, 70, (LINES - 4) / 2, (COLS - 70) / 2);
panel = new_panel(win);
wattrset(win, ERR_BORDER_ATTR);
tx_colorwin(win);
tx_box(win, ACS_VLINE, ACS_HLINE);
wmove(win, 2, 2);
wattrset(win, ERR_PROMPT_ATTR);
wprintw(win, "%s", prompt);
wattrset(win, ERR_TEXT_ATTR);
wmove(win, 1, 2);
wprintw(win, "%s", message);
update_panels();
doupdate();
do {
*response = wgetch(win);
if (*response == 12)
tx_refresh_screen();
} while (*response == 12);
del_panel(panel);
delwin(win);
update_panels();
doupdate();
}
static void show_hostsort_keywin(WINDOW ** win, PANEL ** panel)
{
*win = newwin(13, 35, (LINES - 10) / 2, COLS - 40);
*panel = new_panel(*win);
wattrset(*win, DLGBOXATTR);
tx_colorwin(*win);
tx_box(*win, ACS_VLINE, ACS_HLINE);
wattrset(*win, DLGTEXTATTR);
mvwprintw(*win, 2, 2, "Select sort criterion");
wmove(*win, 4, 2);
tx_printkeyhelp("P", " - total packets in", *win, DLGHIGHATTR,
DLGTEXTATTR);
wmove(*win, 5, 2);
tx_printkeyhelp("I", " - IP packets in", *win, DLGHIGHATTR,
DLGTEXTATTR);
wmove(*win, 6, 2);
tx_printkeyhelp("B", " - total bytes in", *win, DLGHIGHATTR,
DLGTEXTATTR);
wmove(*win, 7, 2);
tx_printkeyhelp("K", " - total packets out", *win, DLGHIGHATTR,
DLGTEXTATTR);
wmove(*win, 8, 2);
tx_printkeyhelp("O", " - IP packets out", *win, DLGHIGHATTR,
DLGTEXTATTR);
wmove(*win, 9, 2);
tx_printkeyhelp("Y", " - total bytes out", *win, DLGHIGHATTR,
DLGTEXTATTR);
wmove(*win, 10, 2);
tx_printkeyhelp("Any other key", " - cancel sort", *win, DLGHIGHATTR,
DLGTEXTATTR);
update_panels();
doupdate();
}
void show_sort_statwin(WINDOW ** statwin, PANEL ** panel)
{
*statwin = newwin(5, 30, (LINES - 5) / 2, (COLS - 30) / 2);
*panel = new_panel(*statwin);
wattrset(*statwin, BOXATTR);
tx_colorwin(*statwin);
tx_box(*statwin, ACS_VLINE, ACS_HLINE);
wattrset(*statwin, STDATTR);
mvwprintw(*statwin, 2, 2, "Sorting, please wait...");
}
void init_tcp_table(struct tcptable *table)
{
int i;
table->bmaxy = LINES * 0.6; /* 60% of total screen */
table->imaxy = table->bmaxy - 2;
table->borderwin = newwin(table->bmaxy, COLS, 1, 0);
table->borderpanel = new_panel(table->borderwin);
wattrset(table->borderwin, BOXATTR);
tx_box(table->borderwin, ACS_VLINE, ACS_HLINE);
mvwprintw(table->borderwin, 0, 1, " TCP Connections (Source Host:Port) ");
setlabels(table->borderwin, 0); /* initially use mode 0 */
mvwprintw(table->borderwin, 0, 65 * COLS / 80, " Flag ");
mvwprintw(table->borderwin, 0, 70 * COLS / 80, " Iface ");
update_panels();
doupdate();
table->ifnamew = COLS - (70 * COLS / 80) - 3;
if (table->ifnamew < 7)
table->ifnamew = 7;
if (table->ifnamew > IFNAMSIZ)
table->ifnamew = IFNAMSIZ;
table->head = table->tail = NULL;
table->firstvisible = table->lastvisible = NULL;
table->tcpscreen = newwin(table->imaxy, COLS - 2, 2, 1);
table->tcppanel = new_panel(table->tcpscreen);
table->closedentries = table->closedtail = NULL;
wattrset(table->tcpscreen, BOXATTR);
tx_colorwin(table->tcpscreen);
table->lastpos = 0;
table->count = 0;
wtimeout(table->tcpscreen, -1);
tx_stdwinset(table->tcpscreen);
print_tcp_num_entries(table);
/*
* Initialize hash table to nulls
*/
for (i = 0; i <= ENTRIES_IN_HASH_TABLE - 1; i++) {
table->hash_table[i] = NULL;
table->hash_tails[i] = NULL;
}
table->barptr = NULL;
table->baridx = 0;
}
static void settimeout(time_t *value, const char *units, int allow_zero,
int *aborted)
{
WINDOW *dlgwin;
PANEL *dlgpanel;
struct FIELDLIST field;
time_t tmval = 0;
dlgwin = newwin(7, 40, (LINES - 7) / 2, (COLS - 40) / 4);
dlgpanel = new_panel(dlgwin);
wattrset(dlgwin, DLGBOXATTR);
tx_colorwin(dlgwin);
tx_box(dlgwin, ACS_VLINE, ACS_HLINE);
wattrset(dlgwin, DLGTEXTATTR);
wmove(dlgwin, 2, 2);
wprintw(dlgwin, "Enter value in %s", units);
wmove(dlgwin, 5, 2);
stdkeyhelp(dlgwin);
tx_initfields(&field, 1, 10, (LINES - 7) / 2 + 3, (COLS - 40) / 4 + 2,
DLGTEXTATTR, FIELDATTR);
tx_addfield(&field, 3, 0, 0, "");
do {
tx_fillfields(&field, aborted);
if (!(*aborted)) {
unsigned int tm;
tmval = 0;
int ret = strtoul_ui(field.list->buf, 10, &tm);
if ((ret == -1) || (!allow_zero && (tm == 0)))
tui_error(ANYKEY_MSG, "Invalid timeout value");
else
tmval = tm;
}
} while (((!allow_zero) && (tmval == 0)) && (!(*aborted)));
if (!(*aborted))
*value = tmval;
del_panel(dlgpanel);
delwin(dlgwin);
tx_destroyfields(&field);
update_panels();
doupdate();
}
void about(void)
{
WINDOW *win;
PANEL *panel;
int ch;
win = newwin(18, 62, (LINES - 17) / 2, (COLS - 62) / 2);
panel = new_panel(win);
tx_stdwinset(win);
wtimeout(win, -1);
wattrset(win, BOXATTR);
tx_colorwin(win);
tx_box(win, ACS_VLINE, ACS_HLINE);
wattrset(win, STDATTR);
mvwprintw(win, 1, 2, IPTRAF_NAME);
mvwprintw(win, 2, 2, "An IP Network Statistics Utility");
mvwprintw(win, 3, 2, "Version %s", IPTRAF_VERSION);
mvwprintw(win, 5, 2, "Written by Gerard Paul Java");
mvwprintw(win, 6, 2, "Copyright (c) Gerard Paul Java 1997-2004");
mvwprintw(win, 8, 2, "This program is open-source software released");
mvwprintw(win, 9, 2, "under the terms of the GNU General Public");
mvwprintw(win, 10, 2, "Public License Version 2 or any later version.");
mvwprintw(win, 11, 2, "See the included LICENSE file for details.");
mvwprintw(win, 13, 2,
"IPv6 support by Markus Ullmann <*****@*****.**>");
mvwprintw(win, 14, 2,
"inspired by 2.7.0 diff by Guy Martin <*****@*****.**>");
wattrset(win, HIGHATTR);
mvwprintw(win, 16, 2, ANYKEY_MSG);
update_panels();
doupdate();
do {
ch = wgetch(win);
if (ch == 12)
tx_refresh_screen();
} while (ch == 12);
del_panel(panel);
delwin(win);
update_panels();
doupdate();
}
static void initethtab(struct ethtab *table)
{
table->head = table->tail = NULL;
table->firstvisible = table->lastvisible = NULL;
table->count = table->entcount = 0;
table->borderwin = newwin(LINES - 2, COLS, 1, 0);
table->borderpanel = new_panel(table->borderwin);
table->tabwin = newwin(LINES - 4, COLS - 2, 2, 1);
table->tabpanel = new_panel(table->tabwin);
wattrset(table->borderwin, BOXATTR);
tx_box(table->borderwin, ACS_VLINE, ACS_HLINE);
wmove(table->borderwin, 0, 5 * COLS / 80);
wprintw(table->borderwin, " PktsIn ");
wmove(table->borderwin, 0, 16 * COLS / 80);
wprintw(table->borderwin, " IP In ");
wmove(table->borderwin, 0, 24 * COLS / 80);
wprintw(table->borderwin, " BytesIn ");
wmove(table->borderwin, 0, 34 * COLS / 80);
wprintw(table->borderwin, " InRate ");
wmove(table->borderwin, 0, 42 * COLS / 80);
wprintw(table->borderwin, " PktsOut ");
wmove(table->borderwin, 0, 53 * COLS / 80);
wprintw(table->borderwin, " IP Out ");
wmove(table->borderwin, 0, 61 * COLS / 80);
wprintw(table->borderwin, " BytesOut ");
wmove(table->borderwin, 0, 70 * COLS / 80);
wprintw(table->borderwin, " OutRate ");
wmove(table->borderwin, LINES - 3, 40);
wprintw(table->borderwin, " InRate and OutRate are in %s ",
dispmode(options.actmode));
wattrset(table->tabwin, STDATTR);
tx_colorwin(table->tabwin);
tx_stdwinset(table->tabwin);
wtimeout(table->tabwin, -1);
update_panels();
doupdate();
}
static void initiftab(struct iftab *table)
{
table->borderwin = newwin(LINES - 2, COLS, 1, 0);
table->borderpanel = new_panel(table->borderwin);
move(LINES - 1, 1);
scrollkeyhelp();
stdexitkeyhelp();
wattrset(table->borderwin, BOXATTR);
tx_box(table->borderwin, ACS_VLINE, ACS_HLINE);
labelstats(table->borderwin);
table->statwin = newwin(LINES - 4, COLS - 2, 2, 1);
table->statpanel = new_panel(table->statwin);
tx_stdwinset(table->statwin);
wtimeout(table->statwin, -1);
wattrset(table->statwin, STDATTR);
tx_colorwin(table->statwin);
wattrset(table->statwin, BOXATTR);
wmove(table->borderwin, LINES - 3, 32 * COLS / 80);
wprintw(table->borderwin,
" Total, IP, NonIP, and BadIP are packet counts ");
}
void setoptions(struct OPTIONS *options, struct porttab **ports)
{
int row = 1;
int trow = 1; /* row for timer submenu */
int aborted;
struct MENU menu;
struct MENU timermenu;
WINDOW *statwin;
PANEL *statpanel;
if (!is_first_instance) {
tui_error(ANYKEY_MSG,
"Only the first instance of ipraf-ng"
" can configure");
return;
}
makeoptionmenu(&menu);
statwin = newwin(15, 35, (LINES - 19) / 2 - 1, (COLS - 40) / 16 + 40);
statpanel = new_panel(statwin);
wattrset(statwin, BOXATTR);
tx_colorwin(statwin);
tx_box(statwin, ACS_VLINE, ACS_HLINE);
wmove(statwin, 9, 1);
whline(statwin, ACS_HLINE, 33);
mvwprintw(statwin, 0, 1, " Current Settings ");
wattrset(statwin, STDATTR);
mvwprintw(statwin, 1, 2, "Reverse DNS lookups:");
mvwprintw(statwin, 2, 2, "Service names:");
mvwprintw(statwin, 3, 2, "Promiscuous:");
mvwprintw(statwin, 4, 2, "Color:");
mvwprintw(statwin, 5, 2, "Logging:");
mvwprintw(statwin, 6, 2, "Activity mode:");
mvwprintw(statwin, 7, 2, "MAC addresses:");
mvwprintw(statwin, 8, 2, "v6-in-v4 as IPv6:");
mvwprintw(statwin, 10, 2, "TCP timeout:");
mvwprintw(statwin, 11, 2, "Log interval:");
mvwprintw(statwin, 12, 2, "Update interval:");
mvwprintw(statwin, 13, 2, "Closed/idle persist:");
showoptions(options, statwin);
do {
tx_showmenu(&menu);
tx_operatemenu(&menu, &row, &aborted);
switch (row) {
case 1:
options->revlook = ~(options->revlook);
break;
case 2:
options->servnames = ~(options->servnames);
break;
case 3:
options->promisc = ~(options->promisc);
break;
case 4:
options->color = ~(options->color);
break;
case 5:
options->logging = ~(options->logging);
break;
case 6:
options->actmode = ~(options->actmode);
break;
case 7:
options->mac = ~(options->mac);
break;
case 8:
options->v6inv4asv6 = ~(options->v6inv4asv6);
break;
case 10:
maketimermenu(&timermenu);
trow = 1;
do {
tx_showmenu(&timermenu);
tx_operatemenu(&timermenu, &trow, &aborted);
switch (trow) {
case 1:
settimeout(&(options->timeout),
"minutes", DONT_ALLOW_ZERO,
&aborted);
if (!aborted)
updatetimes(options, statwin);
break;
case 2:
settimeout(&(options->logspan),
"minutes", DONT_ALLOW_ZERO,
&aborted);
if (!aborted) {
options->logspan =
options->logspan * 60;
updatetimes(options, statwin);
}
break;
case 3:
settimeout(&options->updrate, "seconds",
ALLOW_ZERO, &aborted);
if (!aborted)
updatetimes(options, statwin);
break;
case 4:
settimeout(&options->closedint,
"minutes", ALLOW_ZERO,
&aborted);
if (!aborted)
updatetimes(options, statwin);
break;
}
} while (trow != 6);
tx_destroymenu(&timermenu);
update_panels();
doupdate();
break;
case 12:
addmoreports(ports);
break;
case 13:
removeaport(ports);
break;
case 15:
manage_eth_desc(ARPHRD_ETHER);
break;
case 16:
manage_eth_desc(ARPHRD_FDDI);
break;
}
indicatesetting(row, options, statwin);
} while (row != 18);
tx_destroymenu(&menu);
del_panel(statpanel);
delwin(statwin);
update_panels();
doupdate();
}
/*
* The detailed interface statistics function
*/
void detstats(char *iface, time_t facilitytime)
{
int logging = options.logging;
WINDOW *statwin;
PANEL *statpanel;
int pkt_result = 0;
FILE *logfile = NULL;
unsigned int iplen = 0;
struct ifcounts ifcounts;
int ch;
struct timeval tv;
struct timeval start_tv;
struct timeval updtime;
time_t starttime;
time_t now;
time_t statbegin;
time_t startlog;
struct proto_counter span;
struct rate rate;
struct rate rate_in;
struct rate rate_out;
unsigned long peakactivity = 0;
unsigned long peakactivity_in = 0;
unsigned long peakactivity_out = 0;
struct rate pps_rate;
struct rate pps_rate_in;
struct rate pps_rate_out;
unsigned long peakpps = 0;
unsigned long peakpps_in = 0;
unsigned long peakpps_out = 0;
int fd;
if (!dev_up(iface)) {
err_iface_down();
return;
}
LIST_HEAD(promisc);
if (options.promisc) {
promisc_init(&promisc, iface);
promisc_set_list(&promisc);
}
move(LINES - 1, 1);
stdexitkeyhelp();
statwin = newwin(LINES - 2, COLS, 1, 0);
statpanel = new_panel(statwin);
tx_stdwinset(statwin);
wtimeout(statwin, -1);
wattrset(statwin, BOXATTR);
tx_colorwin(statwin);
tx_box(statwin, ACS_VLINE, ACS_HLINE);
wmove(statwin, 0, 1);
wprintw(statwin, " Statistics for %s ", iface);
wattrset(statwin, STDATTR);
update_panels();
doupdate();
memset(&ifcounts, 0, sizeof(struct ifcounts));
if (logging) {
if (strcmp(current_logfile, "") == 0) {
snprintf(current_logfile, 64, "%s-%s.log", DSTATLOG,
iface);
if (!daemonized)
input_logfile(current_logfile, &logging);
}
}
if (logging) {
opentlog(&logfile, current_logfile);
if (logfile == NULL)
logging = 0;
}
if (logging) {
signal(SIGUSR1, rotate_dstat_log);
rotate_flag = 0;
writelog(logging, logfile,
"******** Detailed interface statistics started ********");
}
printdetlabels(statwin);
printdetails(&ifcounts, statwin);
update_panels();
doupdate();
memset(&span, 0, sizeof(span));
rate_alloc(&rate, 5);
rate_alloc(&rate_in, 5);
rate_alloc(&rate_out, 5);
rate_alloc(&pps_rate, 5);
rate_alloc(&pps_rate_in, 5);
rate_alloc(&pps_rate_out, 5);
gettimeofday(&tv, NULL);
start_tv = tv;
updtime = tv;
starttime = startlog = statbegin = tv.tv_sec;
leaveok(statwin, TRUE);
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if(fd == -1) {
write_error("Unable to obtain monitoring socket");
goto err;
}
if(dev_bind_ifname(fd, iface) == -1) {
write_error("Unable to bind interface on the socket");
goto err_close;
}
exitloop = 0;
PACKET_INIT(pkt);
/*
* Data-gathering loop
*/
while (!exitloop) {
gettimeofday(&tv, NULL);
now = tv.tv_sec;
if ((now - starttime) >= 1) {
char buf[64];
unsigned long activity, activity_in, activity_out;
unsigned long pps, pps_in, pps_out;
unsigned long msecs;
wattrset(statwin, BOXATTR);
printelapsedtime(statbegin, now, LINES - 3, 1, statwin);
msecs = timeval_diff_msec(&tv, &start_tv);
rate_add_rate(&rate, span.proto_total.pc_bytes, msecs);
activity = rate_get_average(&rate);
rate_add_rate(&rate_in, span.proto_in.pc_bytes, msecs);
activity_in = rate_get_average(&rate_in);
rate_add_rate(&rate_out, span.proto_out.pc_bytes, msecs);
activity_out = rate_get_average(&rate_out);
rate_add_rate(&pps_rate, span.proto_total.pc_packets, msecs);
pps = rate_get_average(&pps_rate);
rate_add_rate(&pps_rate_in, span.proto_in.pc_packets, msecs);
pps_in = rate_get_average(&pps_rate_in);
rate_add_rate(&pps_rate_out, span.proto_out.pc_packets, msecs);
pps_out = rate_get_average(&pps_rate_out);
memset(&span, 0, sizeof(span));
starttime = now;
start_tv = tv;
wattrset(statwin, HIGHATTR);
rate_print(activity, buf, sizeof(buf));
mvwprintw(statwin, 14, 19, "%s", buf);
rate_print_pps(pps, buf, sizeof(buf));
mvwprintw(statwin, 15, 19, "%s", buf);
rate_print(activity_in, buf, sizeof(buf));
mvwprintw(statwin, 17, 19, "%s", buf);
rate_print_pps(pps_in, buf, sizeof(buf));
mvwprintw(statwin, 18, 19, "%s", buf);
rate_print(activity_out, buf, sizeof(buf));
mvwprintw(statwin, 20, 19, "%s", buf);
rate_print_pps(pps_out, buf, sizeof(buf));
mvwprintw(statwin, 21, 19, "%s", buf);
if (activity > peakactivity)
peakactivity = activity;
if (activity_in > peakactivity_in)
peakactivity_in = activity_in;
if (activity_out > peakactivity_out)
peakactivity_out = activity_out;
if (pps > peakpps)
peakpps = pps;
if (pps_in > peakpps_in)
peakpps_in = pps_in;
if (pps_out > peakpps_out)
peakpps_out = pps_out;
}
if (logging) {
check_rotate_flag(&logfile);
if ((now - startlog) >= options.logspan) {
writedstatlog(iface,
peakactivity, peakpps,
peakactivity_in, peakpps_in,
peakactivity_out, peakpps_out,
&ifcounts, time(NULL) - statbegin,
logfile);
startlog = now;
}
}
if (screen_update_needed(&tv, &updtime)) {
printdetails(&ifcounts, statwin);
update_panels();
doupdate();
updtime = tv;
}
if ((facilitytime != 0)
&& (((now - statbegin) / 60) >= facilitytime))
exitloop = 1;
if (packet_get(fd, &pkt, &ch, statwin) == -1) {
write_error("Packet receive failed");
exitloop = 1;
break;
}
switch (ch) {
case ERR:
/* no key ready, do nothing */
break;
case 12:
case 'l':
case 'L':
tx_refresh_screen();
break;
case 'Q':
case 'q':
case 'X':
case 'x':
case 24:
case 27:
exitloop = 1;
break;
}
if (pkt.pkt_len <= 0)
continue;
int outgoing;
pkt_result =
packet_process(&pkt, NULL, NULL, NULL,
MATCH_OPPOSITE_USECONFIG,
options.v6inv4asv6);
if (pkt_result != PACKET_OK
&& pkt_result != MORE_FRAGMENTS)
continue;
outgoing = (pkt.pkt_pkttype == PACKET_OUTGOING);
update_proto_counter(&ifcounts.total, outgoing, pkt.pkt_len);
if (pkt.pkt_pkttype == PACKET_BROADCAST) {
update_pkt_counter(&ifcounts.bcast, pkt.pkt_len);
}
update_proto_counter(&span, outgoing, pkt.pkt_len);
/* account network layer protocol */
switch(pkt.pkt_protocol) {
case ETH_P_IP:
if (pkt_result == CHECKSUM_ERROR) {
update_pkt_counter(&ifcounts.bad, pkt.pkt_len);
continue;
}
iplen = ntohs(pkt.iphdr->tot_len);
update_proto_counter(&ifcounts.ipv4, outgoing, iplen);
break;
case ETH_P_IPV6:
iplen = ntohs(pkt.ip6_hdr->ip6_plen) + 40;
update_proto_counter(&ifcounts.ipv6, outgoing, iplen);
break;
default:
update_proto_counter(&ifcounts.nonip, outgoing, iplen);
continue;
}
__u8 ip_protocol = pkt_ip_protocol(&pkt);
/* account transport layer protocol */
switch (ip_protocol) {
case IPPROTO_TCP:
update_proto_counter(&ifcounts.tcp, outgoing, iplen);
break;
case IPPROTO_UDP:
update_proto_counter(&ifcounts.udp, outgoing, iplen);
break;
case IPPROTO_ICMP:
case IPPROTO_ICMPV6:
update_proto_counter(&ifcounts.icmp, outgoing, iplen);
break;
default:
update_proto_counter(&ifcounts.other, outgoing, iplen);
break;
}
}
err_close:
close(fd);
err:
rate_destroy(&pps_rate_out);
rate_destroy(&pps_rate_in);
rate_destroy(&pps_rate);
rate_destroy(&rate_out);
rate_destroy(&rate_in);
rate_destroy(&rate);
if (options.promisc) {
promisc_restore_list(&promisc);
promisc_destroy(&promisc);
}
if (logging) {
signal(SIGUSR1, SIG_DFL);
writedstatlog(iface,
peakactivity, peakpps, peakactivity_in,
peakpps_in, peakactivity_out, peakpps_out,
&ifcounts, time(NULL) - statbegin,
logfile);
writelog(logging, logfile,
"******** Detailed interface statistics stopped ********");
fclose(logfile);
}
del_panel(statpanel);
delwin(statwin);
strcpy(current_logfile, "");
pkt_cleanup();
update_panels();
doupdate();
}
void setoptions(void)
{
int row = 1;
int trow = 1; /* row for timer submenu */
int aborted;
struct MENU menu;
struct MENU timermenu;
WINDOW *statwin;
PANEL *statpanel;
struct porttab *ports;
loadaddports(&ports);
makeoptionmenu(&menu);
statwin = newwin(15, 35, (LINES - 19) / 2 - 1, (COLS - 40) / 16 + 40);
statpanel = new_panel(statwin);
wattrset(statwin, BOXATTR);
tx_colorwin(statwin);
tx_box(statwin, ACS_VLINE, ACS_HLINE);
wmove(statwin, 9, 1);
whline(statwin, ACS_HLINE, 33);
mvwprintw(statwin, 0, 1, " Current Settings ");
wattrset(statwin, STDATTR);
mvwprintw(statwin, 1, 2, "Reverse DNS lookups:");
mvwprintw(statwin, 2, 2, "Service names:");
mvwprintw(statwin, 3, 2, "Promiscuous:");
mvwprintw(statwin, 4, 2, "Color:");
mvwprintw(statwin, 5, 2, "Logging:");
mvwprintw(statwin, 6, 2, "Activity mode:");
mvwprintw(statwin, 7, 2, "MAC addresses:");
mvwprintw(statwin, 8, 2, "v6-in-v4 as IPv6:");
mvwprintw(statwin, 10, 2, "TCP timeout:");
mvwprintw(statwin, 11, 2, "Log interval:");
mvwprintw(statwin, 12, 2, "Update interval:");
mvwprintw(statwin, 13, 2, "Closed/idle persist:");
showoptions(statwin);
do {
tx_showmenu(&menu);
tx_operatemenu(&menu, &row, &aborted);
switch (row) {
case 1:
options.revlook = ~options.revlook;
break;
case 2:
options.servnames = ~options.servnames;
break;
case 3:
options.promisc = ~options.promisc;
break;
case 4:
options.color = ~options.color;
break;
case 5:
options.logging = ~options.logging;
break;
case 6:
options.actmode = ~options.actmode;
break;
case 7:
options.mac = ~options.mac;
break;
case 8:
options.v6inv4asv6 = ~options.v6inv4asv6;
break;
case 10:
maketimermenu(&timermenu);
trow = 1;
do {
tx_showmenu(&timermenu);
tx_operatemenu(&timermenu, &trow, &aborted);
switch (trow) {
case 1:
settimeout(&options.timeout,
"minutes", DONT_ALLOW_ZERO,
&aborted);
if (!aborted)
updatetimes(statwin);
break;
case 2:
settimeout(&options.logspan,
"seconds", DONT_ALLOW_ZERO,
&aborted);
if (!aborted) {
// options.logspan =
// options.logspan * 60;
updatetimes(statwin);
}
break;
case 3:
settimeout(&options.updrate, "seconds",
ALLOW_ZERO, &aborted);
if (!aborted)
updatetimes(statwin);
break;
case 4:
settimeout(&options.closedint,
"minutes", ALLOW_ZERO,
&aborted);
if (!aborted)
updatetimes(statwin);
break;
}
} while (trow != 6);
tx_destroymenu(&timermenu);
update_panels();
doupdate();
break;
case 12:
addmoreports(&ports);
break;
case 13:
removeaport(&ports);
break;
case 15:
manage_eth_desc(ARPHRD_ETHER);
break;
case 16:
manage_eth_desc(ARPHRD_FDDI);
break;
}
indicatesetting(row, statwin);
} while (row != 18);
destroyporttab(ports);
tx_destroymenu(&menu);
del_panel(statpanel);
delwin(statwin);
update_panels();
doupdate();
}
void packet_size_breakdown(struct OPTIONS *options, char *ifname,
int facilitytime, struct filterstate *ofilter)
{
WINDOW *win;
PANEL *panel;
WINDOW *borderwin;
PANEL *borderpanel;
struct ifstat_brackets brackets[20];
unsigned int interval;
int ch;
int fd;
char buf[MAX_PACKET_SIZE];
int br;
char *ipacket;
char iface[10];
unsigned int mtu;
struct sockaddr_ll fromaddr;
unsigned short linktype;
int pkt_result;
struct timeval tv;
unsigned long starttime, startlog, timeint;
unsigned long now;
unsigned long long unow;
unsigned long updtime = 0;
unsigned long long updtime_usec = 0;
int logging = options->logging;
FILE *logfile = NULL;
struct promisc_states *promisc_list;
char msgstring[80];
if (!facility_active(PKTSIZEIDFILE, ifname))
mark_facility(PKTSIZEIDFILE, "Packet size breakdown", ifname);
else {
snprintf(msgstring, 80,
"Packet sizes already being monitored on %s", ifname);
write_error(msgstring, daemonized);
return;
}
if (!iface_supported(ifname)) {
err_iface_unsupported();
unmark_facility(PKTSIZEIDFILE, ifname);
return;
}
if (!iface_up(ifname)) {
err_iface_down();
unmark_facility(PKTSIZEIDFILE, ifname);
return;
}
borderwin = newwin(LINES - 2, COLS, 1, 0);
borderpanel = new_panel(borderwin);
wattrset(borderwin, BOXATTR);
tx_box(borderwin, ACS_VLINE, ACS_HLINE);
mvwprintw(borderwin, 0, 1, " Packet Distribution by Size ");
win = newwin(LINES - 4, COLS - 2, 2, 1);
panel = new_panel(win);
tx_stdwinset(win);
wtimeout(win, -1);
wattrset(win, STDATTR);
tx_colorwin(win);
move(LINES - 1, 1);
stdexitkeyhelp();
initialize_brackets(ifname, brackets, &interval, &mtu, win);
mvwprintw(win, 1, 1, "Packet size brackets for interface %s", ifname);
wattrset(win, BOXATTR);
mvwprintw(win, 4, 1, "Packet Size (bytes)");
mvwprintw(win, 4, 26, "Count");
mvwprintw(win, 4, 36, "Packet Size (bytes)");
mvwprintw(win, 4, 60, "Count");
wattrset(win, HIGHATTR);
if (logging) {
if (strcmp(current_logfile, "") == 0) {
snprintf(current_logfile, 80, "%s-%s.log", PKTSIZELOG, ifname);
if (!daemonized)
input_logfile(current_logfile, &logging);
}
}
if (logging) {
opentlog(&logfile, current_logfile);
if (logfile == NULL)
logging = 0;
}
if (logging)
signal(SIGUSR1, rotate_size_log);
writelog(logging, logfile,
"******** Packet size distribution facility started ********");
exitloop = 0;
gettimeofday(&tv, NULL);
starttime = startlog = timeint = tv.tv_sec;
open_socket(&fd);
if (fd < 0) {
unmark_facility(PKTSIZEIDFILE, ifname);
return;
}
if ((first_active_facility()) && (options->promisc)) {
init_promisc_list(&promisc_list);
save_promisc_list(promisc_list);
srpromisc(1, promisc_list);
destroy_promisc_list(&promisc_list);
}
adjust_instance_count(PROCCOUNTFILE, 1);
active_facility_countfile[0] = '\0';
do {
gettimeofday(&tv, NULL);
now = tv.tv_sec;
unow = tv.tv_sec * 1e+6 + tv.tv_usec;
if (((options->updrate != 0)
&& (now - updtime >= options->updrate))
|| ((options->updrate == 0)
&& (unow - updtime_usec >= DEFAULT_UPDATE_DELAY))) {
update_panels();
doupdate();
updtime = now;
updtime_usec = unow;
}
if (now - timeint >= 5) {
printelapsedtime(starttime, now, LINES - 3, 1, borderwin);
timeint = now;
}
if ((now - startlog >= options->logspan) && (logging)) {
write_size_log(brackets, now - starttime, ifname, mtu,
logfile);
startlog = now;
}
check_rotate_flag(&logfile, logging);
if ((facilitytime != 0)
&& (((now - starttime) / 60) >= facilitytime))
exitloop = 1;
getpacket(fd, buf, &fromaddr, &ch, &br, iface, win);
if (ch != ERR) {
switch (ch) {
case 12:
case 'l':
case 'L':
tx_refresh_screen();
break;
case 'x':
case 'X':
case 'q':
case 'Q':
case 27:
case 24:
exitloop = 1;
}
}
if (br > 0) {
pkt_result =
processpacket(buf, &ipacket, &br, NULL, NULL, NULL,
&fromaddr, &linktype, ofilter,
MATCH_OPPOSITE_USECONFIG, iface, ifname);
if (pkt_result != PACKET_OK)
continue;
update_size_distrib(br, brackets, interval, win);
}
} while (!exitloop);
if (logging) {
signal(SIGUSR1, SIG_DFL);
write_size_log(brackets, now - starttime, ifname, mtu, logfile);
writelog(logging, logfile,
"******** Packet size distribution facility stopped ********");
fclose(logfile);
}
close(fd);
if ((options->promisc) && (is_last_instance())) {
load_promisc_list(&promisc_list);
srpromisc(0, promisc_list);
destroy_promisc_list(&promisc_list);
}
adjust_instance_count(PROCCOUNTFILE, -1);
del_panel(panel);
delwin(win);
del_panel(borderpanel);
delwin(borderwin);
unmark_facility(PKTSIZEIDFILE, ifname);
strcpy(current_logfile, "");
}
void modify_host_parameters(struct filterlist *fl)
{
WINDOW *bwin;
PANEL *bpanel;
WINDOW *win;
PANEL *panel;
struct filterent *fe;
struct filterent *ftemp;
struct filterent *firstvisible = NULL;
unsigned int idx = 0;
int endloop_local = 0;
int ch;
int gh_aborted = 0;
char s_portstr1[8];
char d_portstr1[8];
char s_portstr2[8];
char d_portstr2[8];
char inexstr[2];
char matchop[2];
bwin = newwin(15, 80, (LINES - 15) / 2, (COLS - 80) / 2);
bpanel = new_panel(bwin);
win = newwin(13, 78, (LINES - 13) / 2, (COLS - 78) / 2);
panel = new_panel(win);
wattrset(bwin, BOXATTR);
tx_box(bwin, ACS_VLINE, ACS_HLINE);
mvwprintw(bwin, 0, 2, " Source ");
mvwprintw(bwin, 0, 38, " Destination ");
mvwprintw(bwin, 0, 74, " I/E ");
mvwprintw(bwin, 14, 1, " Filter Data ");
tx_stdwinset(win);
scrollok(win, 0);
wattrset(win, STDATTR);
tx_colorwin(win);
move(LINES - 1, 1);
tx_printkeyhelp("Up/Down", "-move ptr ", stdscr, HIGHATTR,
STATUSBARATTR);
tx_printkeyhelp("I", "-insert ", stdscr, HIGHATTR, STATUSBARATTR);
tx_printkeyhelp("A", "-add to list ", stdscr, HIGHATTR, STATUSBARATTR);
tx_printkeyhelp("D", "-delete ", stdscr, HIGHATTR, STATUSBARATTR);
tx_printkeyhelp("Enter", "-edit ", stdscr, HIGHATTR, STATUSBARATTR);
tx_printkeyhelp("X/Ctrl+X", "-exit", stdscr, HIGHATTR, STATUSBARATTR);
update_panels();
doupdate();
firstvisible = fl->head;
update_hp_screen(firstvisible, win);
idx = 0;
fe = firstvisible;
update_panels();
doupdate();
do {
if (fe != NULL) {
print_hostparam_line(fe, idx, win, BARSTDATTR);
}
ch = wgetch(win);
if (fe != NULL)
print_hostparam_line(fe, idx, win, STDATTR);
switch (ch) {
case KEY_UP:
if (fl->head != NULL) {
if (fe->prev_entry != NULL) {
if (idx > 0)
idx--;
else {
scrollok(win, 1);
wscrl(win, -1);
firstvisible =
firstvisible->prev_entry;
}
fe = fe->prev_entry;
}
}
break;
case KEY_DOWN:
if (fl->head != NULL) {
if (fe->next_entry != NULL) {
if (idx < 12)
idx++;
else {
scrollok(win, 1);
wscrl(win, 1);
firstvisible =
firstvisible->next_entry;
}
fe = fe->next_entry;
}
}
break;
case 'i':
case 'I':
case KEY_IC:
ftemp = xmallocz(sizeof(struct filterent));
gethostparams(&(ftemp->hp), "", "", "", "", "", "", "",
"", "I", "N", &gh_aborted);
if (gh_aborted) {
free(ftemp);
continue;
}
if (fl->head == NULL) {
ftemp->next_entry = ftemp->prev_entry = NULL;
fl->head = fl->tail = ftemp;
firstvisible = fl->head;
idx = 0;
} else {
ftemp->next_entry = fe;
ftemp->prev_entry = fe->prev_entry;
/*
* Point firstvisible at new entry if we inserted at the
* top of the list.
*/
if (ftemp->prev_entry == NULL) {
fl->head = ftemp;
firstvisible = ftemp;
} else
fe->prev_entry->next_entry = ftemp;
fe->prev_entry = ftemp;
}
if (ftemp->next_entry == NULL)
fl->tail = ftemp;
fe = ftemp;
update_hp_screen(firstvisible, win);
break;
case 'a':
case 'A':
case 1:
ftemp = xmallocz(sizeof(struct filterent));
gethostparams(&(ftemp->hp), "", "", "", "", "", "", "",
"", "I", "N", &gh_aborted);
if (gh_aborted) {
free(ftemp);
continue;
}
/*
* Add new node to the end of the list (or to the head if the
* list is empty.
*/
if (fl->tail != NULL) {
fl->tail->next_entry = ftemp;
ftemp->prev_entry = fl->tail;
} else {
fl->head = ftemp;
fl->tail = ftemp;
ftemp->prev_entry = ftemp->next_entry = NULL;
firstvisible = fl->head;
fe = ftemp;
idx = 0;
}
ftemp->next_entry = NULL;
fl->tail = ftemp;
update_hp_screen(firstvisible, win);
break;
case 'd':
case 'D':
case KEY_DC:
if (fl->head != NULL) {
/*
* Move firstvisible down if it's pointing to the target
* entry.
*/
if (firstvisible == fe)
firstvisible = fe->next_entry;
/*
* Detach target node from list.
*/
if (fe->next_entry != NULL)
fe->next_entry->prev_entry =
fe->prev_entry;
else
fl->tail = fe->prev_entry;
if (fe->prev_entry != NULL)
fe->prev_entry->next_entry =
fe->next_entry;
else
fl->head = fe->next_entry;
/*
* Move pointer up if we're deleting the last entry.
* The list tail pointer has since been moved to the
* previous entry.
*/
if (fe->prev_entry == fl->tail) {
ftemp = fe->prev_entry;
/*
* Move screen pointer up. Really adjust the index if
* the pointer is anywhere below the top of the screen.
*/
if (idx > 0)
idx--;
else {
/*
* Otherwise scroll the list down, and adjust the
* firstvisible pointer to point to the entry
* previous to the target.
*/
if (ftemp != NULL) {
firstvisible = ftemp;
}
}
} else
/*
* If we reach this point, we're deleting from before
* the tail of the list. In that case, we point the
* screen pointer at the entry following the target.
*/
ftemp = fe->next_entry;
free(fe);
fe = ftemp;
update_hp_screen(firstvisible, win);
}
break;
case 13:
if (fe != NULL) {
sprintf(s_portstr1, "%u", fe->hp.sport1);
sprintf(s_portstr2, "%u", fe->hp.sport2);
sprintf(d_portstr1, "%u", fe->hp.dport1);
sprintf(d_portstr2, "%u", fe->hp.dport2);
inexstr[0] = toupper(fe->hp.reverse);
inexstr[1] = '\0';
matchop[0] = toupper(fe->hp.match_opposite);
matchop[1] = '\0';
gethostparams(&(fe->hp), fe->hp.s_fqdn,
fe->hp.s_mask, s_portstr1,
s_portstr2, fe->hp.d_fqdn,
fe->hp.d_mask, d_portstr1,
d_portstr2, inexstr, matchop,
&gh_aborted);
update_hp_screen(firstvisible, win);
}
break;
case 'x':
case 'X':
case 'q':
case 'Q':
case 27:
case 24:
endloop_local = 1;
break;
case 'l':
case 'L':
tx_refresh_screen();
break;
}
update_panels();
doupdate();
} while (!endloop_local);
del_panel(panel);
delwin(win);
del_panel(bpanel);
delwin(bwin);
update_panels();
doupdate();
}