void
update_channel_win(WINDOW *win)
{
box(win, 0 , 0);
print_centered(win, 0, 39, " Channel Settings ");
mvwprintw(win, 2, 2, "a: [%c] Automatically change channel",
conf.do_change_channel ? '*' : ' ');
mvwprintw(win, 3, 2, "d: Channel dwell time: %d ms ",
conf.channel_time/1000);
mvwprintw(win, 4, 2, "u: Upper channel limit: %d ", conf.channel_max);
mvwprintw(win, 6, 2, "m: Manually change channel: %d ", channel_get_current_chan());
print_centered(win, 8, 39, "[ Press key or ENTER ]");
wrefresh(win);
}
void
update_help_win(WINDOW *win)
{
int i, t, col, l;
werase(win);
wattron(win, WHITE);
box(win, 0 , 0);
print_centered(win, 0, COLS, " Help ");
print_centered(win, 2, COLS, "HORST - Horsts OLSR Radio Scanning Tool (or)");
print_centered(win, 3, COLS, "HORST - Highly Optimized Radio Scanning Tool");
print_centered(win, 5, COLS, "Version " VERSION " (build date " __DATE__ " " __TIME__ ")");
print_centered(win, 6, COLS, "(C) 2005-2015 Bruno Randolf, Licensed under the GPLv2");
mvwprintw(win, 8, 2, "Known IEEE802.11 Packet Types:");
for (t = 0; t < WLAN_NUM_TYPES; t++) {
wattron(win, A_BOLD);
if (t == 0) {
l = 10;
col = 4;
mvwprintw(win, l++, 2, "MANAGEMENT FRAMES");
}
else if (t == 1) {
l++;
mvwprintw(win, l++, 2, "CONTROL FRAMES");
} else {
l = 10;
col = 47;
mvwprintw(win, l++, 45, "DATA FRAMES");
}
wattroff(win, A_BOLD);
for (i = 0; i < WLAN_NUM_STYPES; i++) {
if (stype_names[t][i].c != '-')
mvwprintw(win, l++, col, "%c %-6s %s",
stype_names[t][i].c,
stype_names[t][i].name,
stype_names[t][i].desc);
}
}
wattron(win, WHITE);
print_centered(win, 39, COLS, "For more info read the man page or check http://br1.einfach.org/horst/");
wrefresh(win);
}
void
update_filter_win(WINDOW *win)
{
int l, i;
box(win, 0 , 0);
print_centered(win, 0, 57, " Edit Packet Filter ");
mvwprintw(win, 2, 2, "Show these Packet Types");
l = 4;
wattron(win, get_packet_type_color(IEEE80211_FTYPE_MGMT));
wattron(win, A_BOLD);
mvwprintw(win, l++, 2, "m: [%c] MANAGEMENT FRAMES", CHECKED(PKT_TYPE_MGMT));
wattroff(win, A_BOLD);
mvwprintw(win, l++, 2, "b: [%c] Beacons", CHECKED(PKT_TYPE_BEACON));
mvwprintw(win, l++, 2, "p: [%c] Probe Req/Resp", CHECKED(PKT_TYPE_PROBE));
mvwprintw(win, l++, 2, "a: [%c] Association", CHECKED(PKT_TYPE_ASSOC));
mvwprintw(win, l++, 2, "u: [%c] Authentication", CHECKED(PKT_TYPE_AUTH));
l++;
wattron(win, get_packet_type_color(IEEE80211_FTYPE_CTL));
wattron(win, A_BOLD);
mvwprintw(win, l++, 2, "c: [%c] CONTROL FRAMES", CHECKED(PKT_TYPE_CTRL));
wattroff(win, A_BOLD);
mvwprintw(win, l++, 2, "r: [%c] CTS/RTS", CHECKED(PKT_TYPE_CTS | PKT_TYPE_RTS));
mvwprintw(win, l++, 2, "k: [%c] ACK", CHECKED(PKT_TYPE_ACK));
l++;
wattron(win, get_packet_type_color(IEEE80211_FTYPE_DATA));
wattron(win, A_BOLD);
mvwprintw(win, l++, 2, "d: [%c] DATA FRAMES", CHECKED(PKT_TYPE_DATA));
wattroff(win, A_BOLD);
mvwprintw(win, l++, 2, "q: [%c] QoS Data", CHECKED(PKT_TYPE_QDATA));
mvwprintw(win, l++, 2, "n: [%c] Null Data", CHECKED(PKT_TYPE_NULL));
mvwprintw(win, l++, 2, "R: [%c] ARP", CHECKED(PKT_TYPE_ARP));
mvwprintw(win, l++, 2, "P: [%c] ICMP/PING", CHECKED(PKT_TYPE_ICMP));
mvwprintw(win, l++, 2, "I: [%c] IP", CHECKED(PKT_TYPE_IP));
mvwprintw(win, l++, 2, "U: [%c] UDP", CHECKED(PKT_TYPE_UDP));
mvwprintw(win, l++, 2, "T: [%c] TCP", CHECKED(PKT_TYPE_TCP));
mvwprintw(win, l++, 2, "O: [%c] OLSR", CHECKED(PKT_TYPE_OLSR));
mvwprintw(win, l++, 2, "B: [%c] BATMAN", CHECKED(PKT_TYPE_BATMAN));
mvwprintw(win, l++, 2, "M: [%c] MeshCruzer", CHECKED(PKT_TYPE_MESHZ));
l = 4;
wattron(win, WHITE);
wattron(win, A_BOLD);
mvwprintw(win, l++, MAC_COL, "BSSID");
wattroff(win, A_BOLD);
mvwprintw(win, l++, MAC_COL, "s: [%c] %s",
CHECK_ETHER(conf.filterbssid), ether_sprintf(conf.filterbssid));
l++;
mvwprintw(win, l++, MAC_COL, "Show only these");
wattron(win, A_BOLD);
mvwprintw(win, l++, MAC_COL, "Source MAC ADDRESSES");
wattroff(win, A_BOLD);
for (i = 0; i < MAX_FILTERMAC; i++) {
mvwprintw(win, l++, MAC_COL, "%d: [%c] %s", i+1,
CHECK_FILTER_EN(i), ether_sprintf(conf.filtermac[i]));
}
l++;
wattron(win, A_BOLD);
mvwprintw(win, l++, MAC_COL, "o: [%c] All Filters Off", conf.filter_off ? '*' : ' ' );
wattroff(win, A_BOLD);
print_centered(win, FILTER_MAX, 57, "[ Press key or ENTER ]");
wrefresh(win);
}
int
filter_input(WINDOW *win, int c)
{
char buf[18];
int i;
switch (c) {
case 'm':
TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_MGMT);
if (conf.filter_pkt & PKT_TYPE_MGMT)
conf.filter_pkt |= PKT_TYPE_ALL_MGMT;
else
conf.filter_pkt &= ~PKT_TYPE_ALL_MGMT;
break;
case 'b': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_BEACON); break;
case 'p': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_PROBE); break;
case 'a': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_ASSOC); break;
case 'u': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_AUTH); break;
case 'c':
TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_CTRL);
if (conf.filter_pkt & PKT_TYPE_CTRL)
conf.filter_pkt |= PKT_TYPE_ALL_CTRL;
else
conf.filter_pkt &= ~PKT_TYPE_ALL_CTRL;
break;
case 'r': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_CTS | PKT_TYPE_RTS); break;
case 'k': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_ACK); break;
case 'd':
TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_DATA);
if (conf.filter_pkt & PKT_TYPE_DATA)
conf.filter_pkt |= PKT_TYPE_ALL_DATA;
else
conf.filter_pkt &= ~PKT_TYPE_ALL_DATA;
break;
case 'q': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_QDATA); break;
case 'n': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_NULL); break;
case 'R': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_ARP); break;
case 'P': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_ICMP); break;
case 'I': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_IP); break;
case 'U': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_UDP); break;
case 'T': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_TCP); break;
case 'O': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_OLSR|PKT_TYPE_OLSR_LQ|PKT_TYPE_OLSR_GW); break;
case 'B': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_BATMAN); break;
case 'M': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_MESHZ); break;
case 's':
echo();
print_centered(win, FILTER_MAX, 57,
"[ Enter new BSSID and ENTER ]");
mvwprintw(win, 5, MAC_COL + 4, ">");
mvwgetnstr(win, 5, MAC_COL + 7, buf, 17);
noecho();
convert_string_to_mac(buf, conf.filterbssid);
break;
case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
i = c - '1';
if (MAC_NOT_EMPTY(conf.filtermac[i]) && conf.filtermac_enabled[i]) {
conf.filtermac_enabled[i] = 0;
}
else {
echo();
print_centered(win, FILTER_MAX, 57,
"[ Enter new MAC %d and ENTER ]", i+1);
mvwprintw(win, 9 + i, MAC_COL + 4, ">");
mvwgetnstr(win, 9 + i, MAC_COL + 7, buf, 17);
noecho();
/* just enable old MAC if user pressed return only */
if (*buf == '\0' && MAC_NOT_EMPTY(conf.filtermac[i]))
conf.filtermac_enabled[i] = 1;
else {
convert_string_to_mac(buf, conf.filtermac[i]);
if (MAC_NOT_EMPTY(conf.filtermac[i]))
conf.filtermac_enabled[i] = true;
}
}
break;
case 'o':
conf.filter_off = conf.filter_off ? 0 : 1;
break;
default:
return 0;
}
/* convenience: */
/* if one of the individual mgmt frames is deselected we dont want to see all mgmt frames */
if ((conf.filter_pkt & PKT_TYPE_ALL_MGMT) != PKT_TYPE_ALL_MGMT)
conf.filter_pkt = conf.filter_pkt & ~PKT_TYPE_MGMT;
/* same for ctl */
if ((conf.filter_pkt & PKT_TYPE_ALL_CTRL) != PKT_TYPE_ALL_CTRL)
conf.filter_pkt = conf.filter_pkt & ~PKT_TYPE_CTRL;
/* same for data */
if ((conf.filter_pkt & PKT_TYPE_ALL_DATA) != PKT_TYPE_ALL_DATA)
conf.filter_pkt = conf.filter_pkt & ~PKT_TYPE_DATA;
/* recalculate filter flag */
conf.do_macfilter = 0;
for (i = 0; i < MAX_FILTERMAC; i++) {
if (conf.filtermac_enabled[i])
conf.do_macfilter = 1;
}
net_send_filter_config();
update_filter_win(win);
return 1;
}
void
update_channel_win(WINDOW *win)
{
int l = 2;
box(win, 0 , 0);
print_centered(win, 0, 39, " Channel Settings ");
wattron(win, WHITE);
for (int b = 0; b < channel_get_num_bands(); b++) {
const struct band_info* bp = channel_get_band(b);
int c = channel_get_idx_from_band_idx(b, 0);
int col = channel_get_chan(c) > 14 ? COL_BAND2 : 2;
wattron(win, A_BOLD);
mvwprintw(win, 2, col, "%s: %s",
col == 2 ? "2.4GHz" : "5GHz",
channel_width_string(bp->max_chan_width, -1));
if (bp->streams_rx || bp->streams_tx)
wprintw(win, " %dx%d", bp->streams_rx, bp->streams_tx);
wattroff(win, A_BOLD);
l = 3;
for (int i = 0; (c = channel_get_idx_from_band_idx(b, i)) != -1; i++) {
if (c == conf.channel_idx)
wattron(win, CYAN);
else
wattron(win, WHITE);
mvwprintw(win, l++,
col,
"%s", channel_get_string(c));
}
}
wattroff(win, WHITE);
l = 17;
wattron(win, A_BOLD);
mvwprintw(win, l++, 2, "s: [%c] Scan",
CHECKED(conf.do_change_channel));
wattroff(win, A_BOLD);
mvwprintw(win, l++, 2, "d: Dwell: %d ms ",
conf.channel_time/1000);
mvwprintw(win, l++, 2, "u: Upper limit: %d ", conf.channel_max);
l++;
wattron(win, A_BOLD);
mvwprintw(win, l++, 2, "m: Set channel: %d ",
channel_get_chan(conf.channel_idx));
wattroff(win, A_BOLD);
mvwprintw(win, l++, 2, "1: [%c] 20 (no HT)",
CHECKED(conf.channel_set_width == CHAN_WIDTH_20_NOHT));
mvwprintw(win, l++, 2, "2: [%c] HT20",
CHECKED(conf.channel_set_width == CHAN_WIDTH_20));
mvwprintw(win, l++, 2, "4: [%c] HT40-",
CHECKED(conf.channel_set_width == CHAN_WIDTH_40 && !conf.channel_set_ht40plus));
mvwprintw(win, l++, 2, "5: [%c] HT40+",
CHECKED(conf.channel_set_width == CHAN_WIDTH_40 && conf.channel_set_ht40plus));
mvwprintw(win, l++, 2, "8: [%c] VHT80",
CHECKED(conf.channel_set_width == CHAN_WIDTH_80));
mvwprintw(win, l++, 2, "6: [%c] VHT160",
CHECKED(conf.channel_set_width == CHAN_WIDTH_160));
print_centered(win, CHANNEL_WIN_HEIGHT-1, CHANNEL_WIN_WIDTH,
"[ Press key or ENTER ]");
wrefresh(win);
}
void update_filter_win(WINDOW *win)
{
int l, i, t, col = 2;
box(win, 0 , 0);
print_centered(win, 0, 57, " Edit Filters ");
for (t = 0; t < WLAN_NUM_TYPES; t++) {
l = 2;
wattron(win, get_packet_type_color(WLAN_FRAME_FC(t, 0)));
wattron(win, A_BOLD);
if (t == 0)
mvwprintw(win, l++, col, "m: [%c] Management", CHECKED(conf.filter_stype[t] & 0xffff));
else if (t == 1)
mvwprintw(win, l++, col, "c: [%c] Control", CHECKED(conf.filter_stype[t] & 0xffff));
else
mvwprintw(win, l++, col, "d: [%c] Data", CHECKED(conf.filter_stype[t] & 0xffff));
wattroff(win, A_BOLD);
for (i = 0; i < WLAN_NUM_STYPES; i++) {
if (stype_names[t][i].c != '-')
mvwprintw(win, l++, col, "%c: [%c] %s", stype_names[t][i].c,
CHECKED(conf.filter_stype[t] & BIT(i)),
stype_names[t][i].name);
}
col += 19;
}
l = 15;
wattron(win, RED);
mvwprintw(win, l++, 21, "*: [%c] Bad FCS", CHECKED(conf.filter_badfcs));
wattroff(win, RED);
wattron(win, A_BOLD);
mvwprintw(win, l++, 21, "0: [%c] All Off", CHECKED(conf.filter_off));
wattroff(win, A_BOLD);
l = SECOND_ROW-1;
wattron(win, A_BOLD);
mvwprintw(win, l++, 2, "Higher Level Protocols");
wattroff(win, A_BOLD);
wattron(win, WHITE);
mvwprintw(win, l++, 2, "r: [%c] ARP", CHECKED(conf.filter_pkt & PKT_TYPE_ARP));
mvwprintw(win, l++, 2, "M: [%c] ICMP/PING", CHECKED(conf.filter_pkt & PKT_TYPE_ICMP));
mvwprintw(win, l++, 2, "i: [%c] IP", CHECKED(conf.filter_pkt & PKT_TYPE_IP));
l = SECOND_ROW;
mvwprintw(win, l++, 21, "V: [%c] UDP", CHECKED(conf.filter_pkt & PKT_TYPE_UDP));
mvwprintw(win, l++, 21, "W: [%c] TCP", CHECKED(conf.filter_pkt & PKT_TYPE_TCP));
l = SECOND_ROW;
mvwprintw(win, l++, 40, "I: [%c] OLSR", CHECKED(conf.filter_pkt & PKT_TYPE_OLSR));
mvwprintw(win, l++, 40, "K: [%c] BATMAN", CHECKED(conf.filter_pkt & PKT_TYPE_BATMAN));
mvwprintw(win, l++, 40, "Z: [%c] Meshz", CHECKED(conf.filter_pkt & PKT_TYPE_MESHZ));
l = THIRD_ROW;
wattron(win, A_BOLD);
mvwprintw(win, l++, MAC_COL, "Source MAC Addresses");
wattroff(win, A_BOLD);
for (i = 0; i < MAX_FILTERMAC; i++) {
mvwprintw(win, l++, MAC_COL, "%d: [%c] " MAC_FMT, i+1,
CHECKED(conf.filtermac_enabled[i]),
MAC_PAR(conf.filtermac[i]));
}
l = THIRD_ROW;
wattron(win, A_BOLD);
mvwprintw(win, l++, MODE_COL, "BSSID");
wattroff(win, A_BOLD);
mvwprintw(win, l++, MODE_COL, "_: [%c] " MAC_FMT,
CHECKED(MAC_NOT_EMPTY(conf.filterbssid)), MAC_PAR(conf.filterbssid));
l++;
wattron(win, A_BOLD);
mvwprintw(win, l++, MODE_COL, "Mode");
wattroff(win, A_BOLD);
mvwprintw(win, l++, MODE_COL, "!: [%c] Access Point", CHECKED(conf.filter_mode & WLAN_MODE_AP));
mvwprintw(win, l++, MODE_COL, "@: [%c] Station", CHECKED(conf.filter_mode & WLAN_MODE_STA));
mvwprintw(win, l++, MODE_COL, "#: [%c] IBSS (Ad-hoc)", CHECKED(conf.filter_mode & WLAN_MODE_IBSS));
mvwprintw(win, l++, MODE_COL, "%: [%c] WDS/4ADDR", CHECKED(conf.filter_mode & WLAN_MODE_4ADDR));
mvwprintw(win, l++, MODE_COL, "^: [%c] Unknown", CHECKED(conf.filter_mode & WLAN_MODE_UNKNOWN));
wattroff(win, WHITE);
print_centered(win, ++l, FILTER_WIN_WIDTH, "[ Press key or ENTER ]");
wrefresh(win);
}
bool filter_input(WINDOW *win, int c)
{
char buf[18];
int i, t;
switch (c) {
case 'm': TOGGLE_BITSET(conf.filter_stype[WLAN_FRAME_TYPE_MGMT], 0xffff, uint16_t); break;
case 'c': TOGGLE_BITSET(conf.filter_stype[WLAN_FRAME_TYPE_CTRL], 0xffff, uint16_t); break;
case 'd': TOGGLE_BITSET(conf.filter_stype[WLAN_FRAME_TYPE_DATA], 0xffff, uint16_t); break;
case 'r': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_ARP); break;
case 'M': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_ICMP); break;
case 'i': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_IP); break;
case 'V': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_UDP); break;
case 'W': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_TCP); break;
case 'I': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_OLSR); break;
case 'K': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_BATMAN); break;
case 'Z': TOGGLE_BIT(conf.filter_pkt, PKT_TYPE_MESHZ); break;
case '!': TOGGLE_BIT(conf.filter_mode, WLAN_MODE_AP); break;
case '@': TOGGLE_BIT(conf.filter_mode, WLAN_MODE_STA); break;
case '#': TOGGLE_BIT(conf.filter_mode, WLAN_MODE_IBSS); break;
case '%': TOGGLE_BIT(conf.filter_mode, WLAN_MODE_4ADDR); break;
case '^': TOGGLE_BIT(conf.filter_mode, WLAN_MODE_UNKNOWN); break;
case '_':
echo();
print_centered(win, FILTER_WIN_HEIGHT-1, FILTER_WIN_WIDTH,
"[ Enter new BSSID and ENTER ]");
mvwprintw(win, THIRD_ROW + 1, MODE_COL + 4, ">");
mvwgetnstr(win, THIRD_ROW + 1, MODE_COL + 7, buf, 17);
noecho();
convert_string_to_mac(buf, conf.filterbssid);
break;
case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
i = c - '1';
if (MAC_NOT_EMPTY(conf.filtermac[i]) && conf.filtermac_enabled[i]) {
conf.filtermac_enabled[i] = 0;
}
else {
echo();
print_centered(win, FILTER_WIN_HEIGHT-1, FILTER_WIN_WIDTH,
"[ Enter new MAC %d and ENTER ]", i+1);
mvwprintw(win, THIRD_ROW + 1 + i, MAC_COL + 4, ">");
mvwgetnstr(win, THIRD_ROW + 1 + i, MAC_COL + 7, buf, 17);
noecho();
/* just enable old MAC if user pressed return only */
if (*buf == '\0' && MAC_NOT_EMPTY(conf.filtermac[i]))
conf.filtermac_enabled[i] = 1;
else {
convert_string_to_mac(buf, conf.filtermac[i]);
if (MAC_NOT_EMPTY(conf.filtermac[i]))
conf.filtermac_enabled[i] = true;
}
}
break;
case '0':
conf.filter_off = conf.filter_off ? 0 : 1;
break;
case '*':
conf.filter_badfcs = conf.filter_badfcs ? 0 : 1;
break;
default:
for (t = 0; t < WLAN_NUM_TYPES; t++) {
for (i = 0; i < WLAN_NUM_STYPES; i++) {
if (stype_names[t][i].c == c) {
TOGGLE_BIT(conf.filter_stype[t], BIT(i));
goto out;
}
}
}
return false; // not found
}
out:
/* recalculate filter flag */
conf.do_macfilter = 0;
for (i = 0; i < MAX_FILTERMAC; i++) {
if (conf.filtermac_enabled[i])
conf.do_macfilter = 1;
}
net_send_filter_config();
update_filter_win(win);
return true;
}
int
main(int argc,
char *argv[])
{
int
graph, i; /* loop variable */
FILE *output, /* output (print) file */
*input; /* input file */
char
*p, *q, totals[60], titles[80], buffer[LINE_SIZE]; /* holds one line */
Data_point *t;
Vector *v;
double
peak,
sustain,
temp,
temp2,
temp3, temp4, total, x[3], y[3], area, minjti, cross_over;
/*
* Step 1: check command line parameters
*/
progname = argv[0]; /* save program name */
if (argc != 3) {
fprintf(stderr, "Usage: %s input-file output-file\n",
progname);
exit(1);
}
/*
* Step 2: Open the input file, create output file
*/
input = fopen(argv[1], "r"); /* open input file */
if (input == NULL) { /* if we can't read it */
fprintf(stderr, "%s: Unable to open input file %s\n", /* talk to human */
progname, argv[1]);
exit(1); /* and die */
}
output = fopen(argv[2], "w"); /* create output file */
if (output == NULL) { /* if we can't read it */
fprintf(stderr, "%s: Unable to create output file %s\n", /* talk to human */
progname, argv[2]);
exit(1); /* and die */
}
/*
* Step 3: Pull out header records
*/
get_line(input, buffer); /* read in a line */
get_line(input, buffer); /* read in a line */
for (p = buffer, i = 0; i < 4; i++) {
q = p;
while (*p != '\t' && *p != '\0')
p++;
*p++ = '\0';
header[i] = strdup(q);
}
get_line(input, buffer); /* read in a line */
get_line(input, buffer); /* read in a line */
/*
* Step 4: Fetch data values
*/
while (!feof(input)) { /* while not at end of file */
t = (Data_point *) malloc(sizeof (Data_point));
get_line(input, buffer); /* read in a line */
if (t == NULL) {
fprintf(stderr,
"%s: Unable to allocate memory for line %d.\n",
progname, line_count);
exit(1);
}
i = sscanf(buffer, "%lf%lf%lf%lf%lf%lf",
&t->task, &t->task_rate, &t->jti,
&t->real, &t->cpu, &t->jobs_sec_user);
if (i != 6) {
fprintf(stderr, "%s: Syntax error on line %d.\n",
progname, line_count);
exit(1);
}
t->next = data;
data = t;
data_points++;
}
fclose(input);
/*
* Step 4.5: Calculate sustained and find peak and minimum jti 12/95
*/
/*
* find peak
*/
peak = 0.0;
minjti = 100.0;
t = data;
for (i = 0; i < data_points; i++) {
temp = t->task_rate;
temp2 = t->jti;
if (temp > peak)
peak = temp;
if (temp2 < minjti && i > 1)
minjti = temp2;
t = t->next;
}
fprintf(stderr, "Peak value is: %.1f\n", peak);
fprintf(stderr, "Minimum JTI value is: %.0f\n", minjti);
/*
* look for cross-over
*/
/*
* crossover point can be determined by the last two set of data points.
* * cross_over = [(X1 * Y2) - (X2 * Y1)] / (X1 - Y1 - X2 +Y2)
* * we need the crossover point to calculate the sustained performance
* * correctly
*/
t = data;
for (i = 0; i < 3; i++) {
x[i] = t->task;
y[i] = t->task_rate;
t = t->next;
}
cross_over =
((x[1] * y[2]) - (x[2] * y[1])) / (x[1] - y[1] - x[2] + y[2]);
fprintf(stderr, "Cross Over value is: %.1f\n", cross_over);
/*
* to calculate sustained value, calculate the area under the curve
* * using the trapezoidal rule.
*/
total = 0.0;
temp3 = 0.0;
temp4 = 0.0;
t = data;
for (i = 0; i < data_points; i++) {
temp2 = t->task;
temp = t->task_rate;
if (i > 1) {
if (temp4 < cross_over) {
area = fabs(((temp + temp3) / 2) * (temp2 -
temp4));
total = total + area;
} else {
area = fabs(((cross_over +
temp) / 2) * (cross_over -
temp2));
total = total + area;
}
}
temp3 = temp;
temp4 = temp2;
t = t->next;
}
sustain = sqrt(total);
fprintf(stderr, "Sustained value is: %.1f\n", sustain);
/*
* Step 5: Prime for postscript output
*/
for (i = 0; i < NUM_PS_INIT; i++)
fprintf(output, "%s\n", ps_init[i]);
v = (Vector *) malloc(sizeof (Vector) * data_points);
/*
* Step 6: Print each graph
*/
for (graph = 0; graph < 5; graph++) {
double
max_x = 0.0, max_y = 0.0,
base_x, base_y, factor_x, factor_y, delta_x, delta_y;
t = data;
for (i = 0; i < data_points; i++) {
v[i].x = t->task;
switch (graph) {
case 0:
v[i].y = t->task_rate;
break;
case 1:
v[i].y = t->jti;
break;
case 2:
v[i].y = t->real;
break;
case 3:
v[i].y = t->cpu;
break;
case 4:
v[i].y = t->jobs_sec_user;
break;
default:
fprintf(stderr, "%s: Internal error. i = %d\n",
progname, graph);
exit(1);
}
if (max_y < v[i].y)
max_y = v[i].y;
if (max_x < v[i].x)
max_x = v[i].x;
t = t->next;
}
set_xscale(&max_x);
set_yscale(&max_y);
delta_x = 1.0 / max_x;
delta_y = 1.0 / max_y;
factor_x = delta_x * GRAPH_WIDTH;
factor_y = delta_y * GRAPH_HEIGHT;
base_y = BOTTOM_SPACE + graph * VERTICAL_SPACE_BETWEEN_GRAPHS;
base_x = LEFT_MARGIN;
print_centered(output, graph_names[graph], 4.5,
base_y + GRAPH_HEIGHT + 0.05, 12);
fprintf(output, "0.1 setlinewidth\n");
fprintf(output, "\t%g inch %g inch moveto\n",
base_x + v[0].x * factor_x,
base_y + v[0].y * factor_y);
fprintf(output, "\t%g inch %g inch moveto\n",
base_x + v[0].x * factor_x, base_y);
for (i = 1; i < data_points; i++) {
double
x = base_x + v[i].x * factor_x,
y = base_y + v[i].y * factor_y;
fprintf(output, "\t%g inch %g inch lineto\n", x, y);
}
fprintf(output, "\t%g inch %g inch lineto\n",
base_x + v[data_points - 1].x * factor_x, base_y);
fprintf(output,
"closepath gsave 0.75 setgray fill grestore stroke\n");
fprintf(output, "\tstroke\n");
fprintf(output, "3 setlinewidth\n");
draw_line(output, base_x, base_y - 0.1, base_x,
base_y + GRAPH_HEIGHT + 0.1);
draw_line(output, base_x - 0.1, base_y,
base_x + GRAPH_WIDTH + 0.1, base_y);
fprintf(output, "1 setlinewidth\n");
for (i = 1; i <= 10; i++) {
char buffer[20];
sprintf(buffer, "%g", (double)i * max_x / 10.0);
draw_line(output,
base_x +
factor_x * (max_x / 10.0) * (double)i,
base_y,
base_x +
factor_x * (max_x / 10.0) * (double)i,
base_y - 0.1);
print_centered(output, buffer,
base_x +
factor_x * (max_x / 10.0) * (double)i,
base_y - 0.25, 10);
}
for (i = 1; i <= 4; i++) {
char buffer[20];
double y =
base_y + factor_y * (max_y / 4.0) * (double)i;
sprintf(buffer, "%g", (double)i * max_y / 4.0);
draw_line(output, base_x - 0.1, y,
base_x + GRAPH_WIDTH, y);
print_right(output, buffer, base_x - 0.25, y, 10);
}
}
sprintf(titles, "%s %s", header[2], header[3]);
sprintf(totals, "Peak = %.1f Sustained = %.1f Minimum JTI = %.0f",
peak, sustain, minjti);
print_centered(output, header[0], 4.5, 10.25, 24);
print_centered(output, titles, 4.5, 10.0, 16);
print_centered(output, totals, 4.5, 9.75, 12); /* add peak, sustained, jti */
print_centered(output, "Loads", 4.5, BOTTOM_SPACE - 0.5, 16);
print_centered(output,
"Copyright (c) 1996 - 2001 Caldera International, Inc.",
4.0, 0.50, 8);
print_centered(output, "All Rights Reserved.", 5.8, 0.50, 8);
print_centered(output, "These results are not certified.", 4.5, 0.35,
8);
fprintf(output, "showpage\n");
fclose(output);
exit(0);
}
void
update_history_win(WINDOW *win)
{
int i;
int col = COLS-2;
int sig, rat;
if (col > MAX_HISTORY)
col = 4 + MAX_HISTORY;
werase(win);
wattron(win, WHITE);
box(win, 0 , 0);
print_centered(win, 0, COLS, " Signal/Rate History ");
mvwhline(win, SIGN_POS, 1, ACS_HLINE, col);
mvwhline(win, SIGN_POS+2, 1, ACS_HLINE, col);
mvwvline(win, 1, 4, ACS_VLINE, LINES-3);
wattron(win, GREEN);
mvwprintw(win, 2, 1, "dBm");
mvwprintw(win, normalize_db(30, SIGN_POS - 1) + 1, 1, "-30");
mvwprintw(win, normalize_db(40, SIGN_POS - 1) + 1, 1, "-40");
mvwprintw(win, normalize_db(50, SIGN_POS - 1) + 1, 1, "-50");
mvwprintw(win, normalize_db(60, SIGN_POS - 1) + 1, 1, "-60");
mvwprintw(win, normalize_db(70, SIGN_POS - 1) + 1, 1, "-70");
mvwprintw(win, normalize_db(80, SIGN_POS - 1) + 1, 1, "-80");
mvwprintw(win, normalize_db(90, SIGN_POS - 1) + 1, 1, "-90");
mvwprintw(win, SIGN_POS-1, 1, "-99");
mvwprintw(win, 1, col-6, "Signal");
wattron(win, CYAN);
mvwprintw(win, TYPE_POS, 1, "TYP");
mvwprintw(win, 2, col-11, "Packet Type");
wattron(win, A_BOLD);
wattron(win, BLUE);
mvwprintw(win, 3, col-4, "Rate");
mvwprintw(win, RATE_POS-12, 1, "300");
mvwprintw(win, RATE_POS-11, 1, "275");
mvwprintw(win, RATE_POS-10, 1, "250");
mvwprintw(win, RATE_POS-9, 1, "225");
mvwprintw(win, RATE_POS-8, 1, "200");
mvwprintw(win, RATE_POS-7, 1, "175");
mvwprintw(win, RATE_POS-6, 1, "150");
mvwprintw(win, RATE_POS-5, 1, "125");
mvwprintw(win, RATE_POS-4, 1, "100");
mvwprintw(win, RATE_POS-3, 1, " 75");
mvwprintw(win, RATE_POS-2, 1, " 50");
mvwprintw(win, RATE_POS-1, 1, " 25");
wattroff(win, A_BOLD);
i = hist.index - 1;
while (col > 4 && hist.signal[i] != 0)
{
sig = normalize_db(-hist.signal[i], SIGN_POS - 1);
wattron(win, ALLGREEN);
mvwvline(win, sig + 1, col, ACS_BLOCK, SIGN_POS - sig - 1);
wattron(win, get_packet_type_color(hist.type[i]));
mvwprintw(win, TYPE_POS, col, "%c", \
get_packet_type_char(hist.type[i]));
if (hist.retry[i])
mvwprintw(win, TYPE_POS+1, col, "r");
rat = hist.rate[i]/250;
wattron(win, A_BOLD);
wattron(win, BLUE);
mvwvline(win, RATE_POS - rat, col, 'x', rat);
wattroff(win, A_BOLD);
i--;
col--;
if (i < 0)
i = MAX_HISTORY-1;
}
wnoutrefresh(win);
}
void update_statistics_win(WINDOW *win)
{
int i;
int line;
int bps, dps, pps, rps;
float duration;
werase(win);
wattron(win, WHITE);
box(win, 0 , 0);
print_centered(win, 0, COLS, " Packet Statistics ");
if (stats.packets == 0) {
wnoutrefresh(win);
return; /* avoid floating point exceptions */
}
mvwprintw(win, 2, 2, "Packets: %d", stats.packets );
mvwprintw(win, 3, 2, "Bytes: %s (%d)",
kilo_mega_ize(stats.bytes), stats.bytes );
mvwprintw(win, 4, 2, "Average: ~%d B/Pkt", stats.bytes / stats.packets);
mvwprintw(win, 2, 40, "Retries: %3.1f%% (%d)",
stats.retries * 100.0 / stats.packets, stats.retries);
get_per_second(stats.bytes, stats.duration, stats.packets, stats.retries,
&bps, &dps, &pps, &rps);
bps = bps * 8;
mvwprintw(win, 3, 40, "Total bit/sec: %s (%d)",
kilo_mega_ize(bps), bps);
wattron(win, A_BOLD);
mvwprintw(win, 4, 40, "Total Usage: %3.1f%% (%d)",
dps * 1.0 / 10000, dps ); /* usec in % */
wattroff(win, A_BOLD);
line = 6;
mvwprintw(win, line, STAT_PACK_POS, " Packets");
mvwprintw(win, line, STAT_BYTE_POS, " Bytes");
mvwprintw(win, line, STAT_BPP_POS, "~B/P");
mvwprintw(win, line, STAT_PP_POS, "Pkts%%");
mvwprintw(win, line, STAT_BP_POS, "Byte%%");
wattron(win, A_BOLD);
mvwprintw(win, line, STAT_AIR_POS, "Usage%%");
mvwprintw(win, line++, 2, "RATE");
wattroff(win, A_BOLD);
mvwhline(win, line++, 2, '-', COLS-4);
for (i = 1; i < MAX_RATES && line < LINES - 2; i++) {
if (stats.packets_per_rate[i] > 0) {
wattron(win, A_BOLD);
if (i <= 12)
mvwprintw(win, line, 2, "%3dM", rate_index_to_rate(i)/10);
else
mvwprintw(win, line, 2, "MCS%d", i - 12);
wattroff(win, A_BOLD);
mvwprintw(win, line, STAT_PACK_POS, "%8d",
stats.packets_per_rate[i]);
mvwprintw(win, line, STAT_BYTE_POS, "%8s",
kilo_mega_ize(stats.bytes_per_rate[i]));
mvwprintw(win, line, STAT_BPP_POS, "%4d",
stats.bytes_per_rate[i] / stats.packets_per_rate[i]);
mvwprintw(win, line, STAT_PP_POS, "%2.1f",
stats.packets_per_rate[i] * 100.0 / stats.packets);
mvwprintw(win, line, STAT_BP_POS, "%2.1f",
stats.bytes_per_rate[i] * 100.0 / stats.bytes);
wattron(win, A_BOLD);
duration = stats.duration_per_rate[i] * 100.0 / stats.duration;
mvwprintw(win, line, STAT_AIR_POS, "%2.1f", duration);
mvwhline(win, line, STAT_AIRG_POS, '*',
normalize(duration, 100, COLS - STAT_AIRG_POS - 2));
wattroff(win, A_BOLD);
line++;
}
}
line++;
if (line < LINES - 2) {
mvwprintw(win, line, STAT_PACK_POS, " Packets");
mvwprintw(win, line, STAT_BYTE_POS, " Bytes");
mvwprintw(win, line, STAT_BPP_POS, "~B/P");
mvwprintw(win, line, STAT_PP_POS, "Pkts%%");
mvwprintw(win, line, STAT_BP_POS, "Byte%%");
wattron(win, A_BOLD);
mvwprintw(win, line, STAT_AIR_POS, "Usage%%");
mvwprintw(win, line++, 2, "TYPE");
wattroff(win, A_BOLD);
}
if (line < LINES - 2)
mvwhline(win, line++, 2, '-', COLS - 4);
for (i = 0; i < MAX_FSTYPE && line < LINES - 2; i++) {
if (stats.packets_per_type[i] > 0) {
wattron(win, get_packet_type_color(i));
wattron(win, A_BOLD);
mvwprintw(win, line, 2, "%s", get_packet_type_name(i));
wattroff(win, A_BOLD);
mvwprintw(win, line, STAT_PACK_POS, "%8d",
stats.packets_per_type[i]);
mvwprintw(win, line, STAT_BYTE_POS, "%8s",
kilo_mega_ize(stats.bytes_per_type[i]));
mvwprintw(win, line, STAT_BPP_POS, "%4d",
stats.bytes_per_type[i] / stats.packets_per_type[i]);
mvwprintw(win, line, STAT_PP_POS, "%2.1f",
stats.packets_per_type[i] * 100.0 / stats.packets);
mvwprintw(win, line, STAT_BP_POS, "%2.1f",
stats.bytes_per_type[i] * 100.0 / stats.bytes);
wattron(win, A_BOLD);
if (stats.duration > 0)
duration = stats.duration_per_type[i] * 100.0 / stats.duration;
else
duration = 100.0;
mvwprintw(win, line, STAT_AIR_POS, "%2.1f", duration);
mvwhline(win, line, STAT_AIRG_POS, '*',
normalize(duration, 100, COLS - STAT_AIRG_POS - 2));
wattroff(win, A_BOLD);
line++;
}
}
wnoutrefresh(win);
}
