static void udp_csum_update(struct proto_hdr *hdr)
{
struct proto_hdr *lower;
uint16_t total_len;
uint16_t csum;
if (hdr->is_csum_valid)
return;
if (proto_hdr_field_is_set(hdr, UDP_CSUM))
return;
lower = proto_lower_header(hdr);
if (!lower)
return;
total_len = packet_get(hdr->pkt_id)->len - hdr->pkt_offset;
proto_hdr_field_set_default_be16(hdr, UDP_CSUM, 0);
switch (lower->ops->id) {
case PROTO_IP4:
csum = p4_csum((void *) proto_header_ptr(lower), proto_header_ptr(hdr),
total_len, IPPROTO_UDP);
break;
case PROTO_IP6:
csum = p6_csum((void *) proto_header_ptr(lower), proto_header_ptr(hdr),
total_len, IPPROTO_UDP);
break;
default:
csum = 0;
break;
}
proto_hdr_field_set_default_be16(hdr, UDP_CSUM, bswap_16(csum));
hdr->is_csum_valid = true;
}
static void icmpv6_csum_update(struct proto_hdr *hdr)
{
struct proto_hdr *lower = proto_lower_header(hdr);
struct packet *pkt = packet_get(hdr->pkt_id);
uint16_t total_len;
uint16_t csum;
if (unlikely(!lower))
return;
if (hdr->is_csum_valid)
return;
if (proto_hdr_field_is_set(hdr, ICMPV6_CSUM))
return;
total_len = pkt->len - hdr->pkt_offset;
proto_hdr_field_set_be16(hdr, ICMPV6_CSUM, 0);
if (likely(lower->ops->id == PROTO_IP6)) {
csum = p6_csum((void *) proto_header_ptr(lower), proto_header_ptr(hdr),
total_len, IPPROTO_ICMPV6);
proto_hdr_field_set_be16(hdr, ICMPV6_CSUM, bswap_16(csum));
hdr->is_csum_valid = true;
}
}
int cmd_capture(int argc, char **argv)
{
parse_opts(argc, argv, capture_options, capture_usage);
argv += optind;
if (help_opt || !*argv || argv[1])
parse_usage_and_die(capture_usage, capture_options);
char *dev = argv[0];
int fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (fd < 0)
die_errno("Unable to obtain monitoring socket");
if (dev_bind_ifname(fd, dev) < 0)
perror("Unable to bind device on the socket");
FILE *fp = NULL;
if (ofilename) {
fp = fopen(ofilename, "wb");
if (!fp)
die_errno("fopen");
}
struct pkt_hdr pkt;
packet_init(&pkt);
int captured = 0;
for (;;) {
if (packet_get(fd, &pkt, NULL, NULL) == -1)
die_errno("fail to get packet");
if (!pkt.pkt_len)
continue;
printf(".");
fflush(stdout);
if (fp)
fwrite(&pkt, sizeof(pkt), 1, fp);
if (++captured == cap_nr_pkt)
break;
}
printf("\n");
packet_destroy(&pkt);
close(fd);
if (fp)
fclose(fp);
return 0;
}
static void ipv4_csum_update(struct proto_hdr *hdr)
{
struct packet *pkt;
uint16_t csum;
if (hdr->is_csum_valid)
return;
if (proto_hdr_field_is_set(hdr, IP4_CSUM))
return;
pkt = packet_get(hdr->pkt_id);
proto_hdr_field_set_default_u16(hdr, IP4_CSUM, 0);
csum = htons(calc_csum(&pkt->payload[hdr->pkt_offset], hdr->len));
proto_hdr_field_set_default_u16(hdr, IP4_CSUM, bswap_16(csum));
hdr->is_csum_valid = true;
}
static void icmpv4_csum_update(struct proto_hdr *hdr)
{
struct packet *pkt;
uint16_t csum;
if (hdr->is_csum_valid)
return;
if (proto_hdr_field_is_set(hdr, ICMPV4_CSUM))
return;
pkt = packet_get(hdr->pkt_id);
proto_hdr_field_set_default_u16(hdr, ICMPV4_CSUM, 0);
csum = htons(calc_csum(proto_header_ptr(hdr), pkt->len - hdr->pkt_offset));
proto_hdr_field_set_default_u16(hdr, ICMPV4_CSUM, bswap_16(csum));
hdr->is_csum_valid = true;
}
static PyObject *
Lexer_get(LexerObject *self, PyObject *args)
{
ssize_t len;
int fd;
if (!PyArg_ParseTuple(args, "i;missing or invalid file descriptor argument to gpspacket.get", &fd))
return NULL;
len = packet_get(fd, &self->lexer);
if (PyErr_Occurred())
return NULL;
if (len == 0) {
self->lexer.type = BAD_PACKET;
self->lexer.outbuffer[0] = '\0';
}
return Py_BuildValue("(i, s)", self->lexer.type, self->lexer.outbuffer);
}
void* worker_thread(void* d)
{
struct thread_data* data = (struct thread_data*)d;
uint32_t i;
struct packet* p;
while (running) {
p = packet_get(data->pool);
// we could have returned from packet_get because of an abort signal
// check the running flag because we might have been woken for shutdown!
if (!p || !running) {
continue;
}
for (i = 0; i != data->dumpers->count; ++i) {
data->dumpers->modules[i]->dfunc(data->dumpers->modules[i], p);
}
packet_free(data->pool, p);
}
return NULL;
}
void hostmon(time_t facilitytime, char *ifptr)
{
int logging = options.logging;
struct ethtab table;
struct ethtabent *entry;
char scratch_saddr[ETH_ALEN];
char scratch_daddr[ETH_ALEN];
unsigned int idx = 1;
int is_ip;
int ch;
char *ifname = ifptr;
struct timeval tv;
struct timeval tv_rate;
time_t now = 0;
time_t statbegin = 0;
time_t startlog = 0;
struct timeval updtime;
struct eth_desc *list = NULL;
FILE *logfile = NULL;
int pkt_result;
WINDOW *sortwin;
PANEL *sortpanel;
int keymode = 0;
int fd;
if (ifptr && !dev_up(ifptr)) {
err_iface_down();
return;
}
LIST_HEAD(promisc);
if (options.promisc) {
promisc_init(&promisc, ifptr);
promisc_set_list(&promisc);
}
hostmonhelp();
initethtab(&table);
/* Ethernet description list */
struct eth_desc *elist = load_eth_desc(ARPHRD_ETHER);
/* FDDI description list */
struct eth_desc *flist = load_eth_desc(ARPHRD_FDDI);
if (logging) {
if (strcmp(current_logfile, "") == 0) {
strncpy(current_logfile,
gen_instance_logname(LANLOG, getpid()), 80);
if (!daemonized)
input_logfile(current_logfile, &logging);
}
}
if (logging) {
opentlog(&logfile, current_logfile);
if (logfile == NULL)
logging = 0;
}
if (logging) {
signal(SIGUSR1, rotate_lanlog);
rotate_flag = 0;
writelog(logging, logfile,
"******** LAN traffic monitor started ********");
}
leaveok(table.tabwin, TRUE);
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if(fd == -1) {
write_error("Unable to obtain monitoring socket");
goto err;
}
if(ifptr && dev_bind_ifname(fd, ifptr) == -1) {
write_error("Unable to bind interface on the socket");
goto err_close;
}
exitloop = 0;
gettimeofday(&tv, NULL);
tv_rate = tv;
updtime = tv;
statbegin = startlog = tv.tv_sec;
PACKET_INIT(pkt);
do {
gettimeofday(&tv, NULL);
now = tv.tv_sec;
unsigned long msecs = timeval_diff_msec(&tv, &tv_rate);
if (msecs >= 1000) {
printelapsedtime(statbegin, now, LINES - 3, 15,
table.borderwin);
updateethrates(&table, msecs, idx);
tv_rate = tv;
}
if (logging) {
check_rotate_flag(&logfile);
if ((now - startlog) >= options.logspan) {
writeethlog(table.head, now - statbegin,
logfile);
startlog = now;
}
}
if (screen_update_needed(&tv, &updtime)) {
update_panels();
doupdate();
updtime = tv;
}
if ((facilitytime != 0)
&& (((now - statbegin) / 60) >= facilitytime))
exitloop = 1;
if (packet_get(fd, &pkt, &ch, table.tabwin) == -1) {
write_error("Packet receive failed");
exitloop = 1;
break;
}
if (ch != ERR) {
if (keymode == 0) {
switch (ch) {
case KEY_UP:
scrollethwin(&table, SCROLLDOWN, &idx);
break;
case KEY_DOWN:
scrollethwin(&table, SCROLLUP, &idx);
break;
case KEY_PPAGE:
case '-':
pageethwin(&table, SCROLLDOWN, &idx);
break;
case KEY_NPAGE:
case ' ':
pageethwin(&table, SCROLLUP, &idx);
break;
case 12:
case 'l':
case 'L':
tx_refresh_screen();
break;
case 's':
case 'S':
show_hostsort_keywin(&sortwin,
&sortpanel);
keymode = 1;
break;
case 'q':
case 'Q':
case 'x':
case 'X':
case 27:
case 24:
exitloop = 1;
}
} else if (keymode == 1) {
del_panel(sortpanel);
delwin(sortwin);
sort_hosttab(&table, &idx, ch);
keymode = 0;
}
}
if (pkt.pkt_len <= 0)
continue;
char ifnamebuf[IFNAMSIZ];
pkt_result =
packet_process(&pkt, NULL, NULL, NULL,
MATCH_OPPOSITE_USECONFIG,
0);
if (pkt_result != PACKET_OK)
continue;
if (!ifptr) {
/* we're capturing on "All interfaces", */
/* so get the name of the interface */
/* of this packet */
int r = dev_get_ifname(pkt.pkt_ifindex, ifnamebuf);
if (r != 0) {
write_error("Unable to get interface name");
break; /* can't get interface name, get out! */
}
ifname = ifnamebuf;
}
/* get HW addresses */
switch (pkt.pkt_hatype) {
case ARPHRD_ETHER: {
memcpy(scratch_saddr, pkt.ethhdr->h_source, ETH_ALEN);
memcpy(scratch_daddr, pkt.ethhdr->h_dest, ETH_ALEN);
list = elist;
break; }
case ARPHRD_FDDI: {
memcpy(scratch_saddr, pkt.fddihdr->saddr, FDDI_K_ALEN);
memcpy(scratch_daddr, pkt.fddihdr->daddr, FDDI_K_ALEN);
list = flist;
break; }
default:
/* unknown link protocol */
continue;
}
switch(pkt.pkt_protocol) {
case ETH_P_IP:
case ETH_P_IPV6:
is_ip = 1;
break;
default:
is_ip = 0;
break;
}
/* Check source address entry */
entry = in_ethtable(&table, pkt.pkt_hatype,
scratch_saddr);
if (!entry)
entry = addethentry(&table, pkt.pkt_hatype,
ifname, scratch_saddr, list);
if (entry != NULL) {
updateethent(entry, pkt.pkt_len, is_ip, 1);
if (!entry->prev_entry->un.desc.printed)
printethent(&table, entry->prev_entry,
idx);
printethent(&table, entry, idx);
}
/* Check destination address entry */
entry = in_ethtable(&table, pkt.pkt_hatype,
scratch_daddr);
if (!entry)
entry = addethentry(&table, pkt.pkt_hatype,
ifname, scratch_daddr, list);
if (entry != NULL) {
updateethent(entry, pkt.pkt_len, is_ip, 0);
if (!entry->prev_entry->un.desc.printed)
printethent(&table, entry->prev_entry,
idx);
printethent(&table, entry, idx);
}
} while (!exitloop);
err_close:
close(fd);
err:
if (options.promisc) {
promisc_restore_list(&promisc);
promisc_destroy(&promisc);
}
if (logging) {
signal(SIGUSR1, SIG_DFL);
writeethlog(table.head, time(NULL) - statbegin, logfile);
writelog(logging, logfile,
"******** LAN traffic monitor stopped ********");
fclose(logfile);
}
del_panel(table.tabpanel);
delwin(table.tabwin);
del_panel(table.borderpanel);
delwin(table.borderwin);
update_panels();
doupdate();
destroyethtab(&table);
free_eth_desc(elist);
free_eth_desc(flist);
strcpy(current_logfile, "");
}
void hostmon(const struct OPTIONS *options, time_t facilitytime, char *ifptr,
struct filterstate *ofilter)
{
int logging = options->logging;
struct ethtab table;
struct ethtabent *entry;
char scratch_saddr[ETH_ALEN];
char scratch_daddr[ETH_ALEN];
unsigned int idx = 1;
int is_ip;
int ch;
char *ifname = ifptr;
struct timeval tv;
time_t starttime;
time_t now = 0;
unsigned long long unow = 0;
time_t statbegin = 0;
time_t startlog = 0;
time_t updtime = 0;
unsigned long long updtime_usec = 0;
struct eth_desc *list = NULL;
FILE *logfile = NULL;
int pkt_result;
WINDOW *sortwin;
PANEL *sortpanel;
int keymode = 0;
int instance_id;
int fd;
struct promisc_states *promisc_list;
if (!facility_active(LANMONIDFILE, ifptr))
mark_facility(LANMONIDFILE, "LAN monitor", ifptr);
else {
write_error("LAN station monitor already running on %s",
gen_iface_msg(ifptr));
return;
}
if (ifptr != NULL) {
if (!dev_up(ifptr)) {
err_iface_down();
unmark_facility(LANMONIDFILE, ifptr);
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);
instance_id = adjust_instance_count(LANMONCOUNTFILE, 1);
hostmonhelp();
initethtab(&table, options->actmode);
/* Ethernet description list */
struct eth_desc *elist = load_eth_desc(ARPHRD_ETHER);
/* FDDI description list */
struct eth_desc *flist = load_eth_desc(ARPHRD_FDDI);
if (logging) {
if (strcmp(current_logfile, "") == 0) {
strncpy(current_logfile,
gen_instance_logname(LANLOG, instance_id), 80);
if (!daemonized)
input_logfile(current_logfile, &logging);
}
}
if (logging) {
opentlog(&logfile, current_logfile);
if (logfile == NULL)
logging = 0;
}
if (logging) {
signal(SIGUSR1, rotate_lanlog);
rotate_flag = 0;
writelog(logging, logfile,
"******** LAN traffic monitor started ********");
}
leaveok(table.tabwin, TRUE);
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if(fd == -1) {
write_error("Unable to obtain monitoring socket");
goto err;
}
if(ifptr && dev_bind_ifname(fd, ifptr) == -1) {
write_error("Unable to bind interface on the socket");
goto err_close;
}
exitloop = 0;
gettimeofday(&tv, NULL);
starttime = statbegin = startlog = tv.tv_sec;
PACKET_INIT(pkt);
do {
gettimeofday(&tv, NULL);
now = tv.tv_sec;
unow = tv.tv_sec * 1000000ULL + tv.tv_usec;
if ((now - starttime) >= 5) {
printelapsedtime(statbegin, now, LINES - 3, 15,
table.borderwin);
updateethrates(&table, options->actmode, starttime, now,
idx);
starttime = now;
}
if (logging) {
check_rotate_flag(&logfile);
if ((now - startlog) >= options->logspan) {
writeethlog(table.head, options->actmode,
now - statbegin, logfile);
startlog = now;
}
}
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 ((facilitytime != 0)
&& (((now - statbegin) / 60) >= facilitytime))
exitloop = 1;
if (packet_get(fd, &pkt, &ch, table.tabwin) == -1) {
write_error("Packet receive failed");
exitloop = 1;
break;
}
if (ch != ERR) {
if (keymode == 0) {
switch (ch) {
case KEY_UP:
scrollethwin(&table, SCROLLDOWN, &idx);
break;
case KEY_DOWN:
scrollethwin(&table, SCROLLUP, &idx);
break;
case KEY_PPAGE:
case '-':
pageethwin(&table, SCROLLDOWN, &idx);
break;
case KEY_NPAGE:
case ' ':
pageethwin(&table, SCROLLUP, &idx);
break;
case 12:
case 'l':
case 'L':
tx_refresh_screen();
break;
case 's':
case 'S':
show_hostsort_keywin(&sortwin,
&sortpanel);
keymode = 1;
break;
case 'q':
case 'Q':
case 'x':
case 'X':
case 27:
case 24:
exitloop = 1;
}
} else if (keymode == 1) {
del_panel(sortpanel);
delwin(sortwin);
sort_hosttab(&table, &idx, ch);
keymode = 0;
}
}
if (pkt.pkt_len > 0) {
char ifnamebuf[IFNAMSIZ];
pkt_result =
packet_process(&pkt, NULL, NULL, NULL,
ofilter,
MATCH_OPPOSITE_USECONFIG,
0);
if (pkt_result != PACKET_OK)
continue;
if (!ifptr) {
/* we're capturing on "All interfaces", */
/* so get the name of the interface */
/* of this packet */
int r = dev_get_ifname(pkt.pkt_ifindex, ifnamebuf);
if (r != 0) {
write_error("Unable to get interface name");
break; /* can't get interface name, get out! */
}
ifname = ifnamebuf;
}
/* get HW addresses */
switch (pkt.pkt_hatype) {
case ARPHRD_ETHER: {
struct ethhdr *hdr_eth =
(struct ethhdr *)pkt.pkt_buf;
memcpy(scratch_saddr, hdr_eth->h_source,
ETH_ALEN);
memcpy(scratch_daddr, hdr_eth->h_dest,
ETH_ALEN);
list = elist;
break; }
case ARPHRD_FDDI: {
struct fddihdr *hdr_fddi =
(struct fddihdr *)pkt.pkt_buf;
memcpy(scratch_saddr, hdr_fddi->saddr,
FDDI_K_ALEN);
memcpy(scratch_daddr, hdr_fddi->daddr,
FDDI_K_ALEN);
list = flist;
break; }
case ARPHRD_IEEE802:
case ARPHRD_IEEE802_TR: {
struct trh_hdr *hdr_trh =
(struct trh_hdr *)pkt.pkt_buf;
memcpy(scratch_saddr, hdr_trh->saddr,
TR_ALEN);
memcpy(scratch_daddr, hdr_trh->daddr,
TR_ALEN);
list = flist;
break; }
default:
/* unknown link protocol */
continue;
}
switch(pkt.pkt_protocol) {
case ETH_P_IP:
case ETH_P_IPV6:
is_ip = 1;
break;
default:
is_ip = 0;
break;
}
/* Check source address entry */
entry = in_ethtable(&table, pkt.pkt_hatype,
scratch_saddr);
if (!entry)
entry = addethentry(&table, pkt.pkt_hatype,
ifname, scratch_saddr, list);
if (entry != NULL) {
updateethent(entry, pkt.pkt_len, is_ip, 1);
if (!entry->prev_entry->un.desc.printed)
printethent(&table, entry->prev_entry,
idx);
printethent(&table, entry, idx);
}
/* Check destination address entry */
entry = in_ethtable(&table, pkt.pkt_hatype,
scratch_daddr);
if (!entry)
entry = addethentry(&table, pkt.pkt_hatype,
ifname, scratch_daddr, list);
if (entry != NULL) {
updateethent(entry, pkt.pkt_len, is_ip, 0);
if (!entry->prev_entry->un.desc.printed)
printethent(&table, entry->prev_entry,
idx);
printethent(&table, entry, idx);
}
}
} while (!exitloop);
err_close:
close(fd);
err:
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);
adjust_instance_count(LANMONCOUNTFILE, -1);
if (logging) {
signal(SIGUSR1, SIG_DFL);
writeethlog(table.head, options->actmode,
time(NULL) - statbegin, logfile);
writelog(logging, logfile,
"******** LAN traffic monitor stopped ********");
fclose(logfile);
}
del_panel(table.tabpanel);
delwin(table.tabwin);
del_panel(table.borderpanel);
delwin(table.borderwin);
update_panels();
doupdate();
destroyethtab(&table);
free_eth_desc(elist);
free_eth_desc(flist);
unmark_facility(LANMONIDFILE, ifptr);
strcpy(current_logfile, "");
}
int main(int argc, char **argv) {
char *x;
const char *keydir = 0;
long long i;
struct pollfd p[6];
struct pollfd *q;
struct pollfd *watch0;
struct pollfd *watch1;
struct pollfd *watchtochild;
struct pollfd *watchfromchild1;
struct pollfd *watchfromchild2;
struct pollfd *watchselfpipe;
int exitsignal, exitcode;
signal(SIGPIPE, SIG_IGN);
signal(SIGALRM, timeout);
log_init(0, "tinysshd", 0, 0);
if (argc < 2) die_usage(USAGE);
if (!argv[0]) die_usage(USAGE);
for (;;) {
if (!argv[1]) break;
if (argv[1][0] != '-') break;
x = *++argv;
if (x[0] == '-' && x[1] == 0) break;
if (x[0] == '-' && x[1] == '-' && x[2] == 0) break;
while (*++x) {
if (*x == 'q') { flagverbose = 0; continue; }
if (*x == 'Q') { flagverbose = 1; continue; }
if (*x == 'v') { if (flagverbose >= 2) flagverbose = 3; else flagverbose = 2; continue; }
if (*x == 'o') { cryptotypeselected |= sshcrypto_TYPEOLDCRYPTO; continue; }
if (*x == 'O') { cryptotypeselected &= ~sshcrypto_TYPEOLDCRYPTO; continue; }
if (*x == 's') { cryptotypeselected |= sshcrypto_TYPENEWCRYPTO; continue; }
if (*x == 'S') { cryptotypeselected &= ~sshcrypto_TYPENEWCRYPTO; continue; }
if (*x == 'p') { cryptotypeselected |= sshcrypto_TYPEPQCRYPTO; continue; }
if (*x == 'P') { cryptotypeselected &= ~sshcrypto_TYPEPQCRYPTO; continue; }
if (*x == 'l') { flaglogger = 1; continue; }
if (*x == 'L') { flaglogger = 0; continue; }
if (*x == 'x') {
if (x[1]) { channel_subsystem_add(x + 1); break; }
if (argv[1]) { channel_subsystem_add(*++argv); break; }
}
die_usage(USAGE);
}
}
keydir = *++argv; if (!keydir) die_usage(USAGE);
log_init(flagverbose, "tinysshd", 1, flaglogger);
connectioninfo(channel.localip, channel.localport, channel.remoteip, channel.remoteport);
log_i4("connection from ", channel.remoteip, ":", channel.remoteport);
channel_subsystem_log();
global_init();
blocking_disable(0);
blocking_disable(1);
blocking_disable(2);
/* get server longterm keys */
fdwd = open_cwd();
if (fdwd == -1) die_fatal("unable to open current directory", 0, 0);
if (chdir(keydir) == -1) die_fatal("unable to chdir to", keydir, 0);
for (i = 0; sshcrypto_keys[i].name; ++i) sshcrypto_keys[i].sign_flagserver |= sshcrypto_kexs[i].cryptotype & cryptotypeselected;
for (i = 0; sshcrypto_keys[i].name; ++i) sshcrypto_keys[i].sign_flagclient |= sshcrypto_kexs[i].cryptotype & cryptotypeselected;
for (i = 0; sshcrypto_kexs[i].name; ++i) sshcrypto_kexs[i].flagenabled |= sshcrypto_kexs[i].cryptotype & cryptotypeselected;
for (i = 0; sshcrypto_ciphers[i].name; ++i) sshcrypto_ciphers[i].flagenabled |= sshcrypto_ciphers[i].cryptotype & cryptotypeselected;
/* read public keys */
for (i = 0; sshcrypto_keys[i].name; ++i) {
if (!sshcrypto_keys[i].sign_flagserver) continue;
if (load(sshcrypto_keys[i].sign_publickeyfilename, sshcrypto_keys[i].sign_publickey, sshcrypto_keys[i].sign_publickeybytes) == -1) {
sshcrypto_keys[i].sign_flagserver = 0;
if (errno == ENOENT) continue;
die_fatal("unable to read public key from file", keydir, sshcrypto_keys[i].sign_publickeyfilename);
}
}
if (fchdir(fdwd) == -1) die_fatal("unable to change directory to working directory", 0, 0);
close(fdwd);
/* set timeout */
alarm(60);
/* send and receive hello */
if (!packet_hello_send()) die_fatal("unable to send hello-string", 0, 0);
if (!packet_hello_receive()) die_fatal("unable to receive hello-string", 0, 0);
/* send and receive kex */
if (!packet_kex_send()) die_fatal("unable to send kex-message", 0, 0);
if (!packet_kex_receive()) die_fatal("unable to receive kex-message", 0, 0);
rekeying:
/* rekeying */
alarm(60);
if (packet.flagrekeying == 1) {
buf_purge(&packet.kexrecv);
buf_put(&packet.kexrecv, b1.buf, b1.len);
if (!packet_kex_send()) die_fatal("unable to send kex-message", 0, 0);
}
/* send and receive kexdh */
if (!packet_kexdh(keydir, &b1, &b2)) die_fatal("unable to subprocess kexdh", 0, 0);
if (packet.flagkeys) log_d1("rekeying: done");
packet.flagkeys = 1;
/* note: comunication is encrypted */
/* authentication + authorization */
if (packet.flagauthorized == 0) {
if (!packet_auth(&b1, &b2)) die_fatal("authentication failed", 0, 0);
packet.flagauthorized = 1;
}
/* note: user is authenticated and authorized */
alarm(3600);
/* main loop */
for (;;) {
if (channel_iseof())
if (!packet.sendbuf.len)
if (packet.flagchanneleofreceived)
break;
watch0 = watch1 = 0;
watchtochild = watchfromchild1 = watchfromchild2 = 0;
watchselfpipe = 0;
q = p;
if (packet_sendisready()) { watch1 = q; q->fd = 1; q->events = POLLOUT; ++q; }
if (packet_recvisready()) { watch0 = q; q->fd = 0; q->events = POLLIN; ++q; }
if (channel_writeisready()) { watchtochild = q; q->fd = channel_getfd0(); q->events = POLLOUT; ++q; }
if (channel_readisready() && packet_putisready()) { watchfromchild1 = q; q->fd = channel_getfd1(); q->events = POLLIN; ++q; }
if (channel_extendedreadisready() && packet_putisready()) { watchfromchild2 = q; q->fd = channel_getfd2(); q->events = POLLIN; ++q; }
if (selfpipe[0] != -1) { watchselfpipe = q; q->fd = selfpipe[0]; q->events = POLLIN; ++q; }
if (poll(p, q - p, 60000) < 0) {
watch0 = watch1 = 0;
watchtochild = watchfromchild1 = watchfromchild2 = 0;
watchselfpipe = 0;
}
else {
if (watch0) if (!watch0->revents) watch0 = 0;
if (watch1) if (!watch1->revents) watch1 = 0;
if (watchfromchild1) if (!watchfromchild1->revents) watchfromchild1 = 0;
if (watchfromchild2) if (!watchfromchild2->revents) watchfromchild2 = 0;
if (watchtochild) if (!watchtochild->revents) watchtochild = 0;
if (watchselfpipe) if (!watchselfpipe->revents) watchselfpipe = 0;
}
if (watchtochild) {
/* write data to child */
if (!channel_write()) die_fatal("unable to write data to child", 0, 0);
/* try to adjust window */
if (!packet_channel_send_windowadjust(&b1)) die_fatal("unable to send data to network", 0, 0);
}
/* read data from child */
if (watchfromchild1) packet_channel_send_data(&b2);
if (watchfromchild2) packet_channel_send_extendeddata(&b2);
/* check child */
if (channel_iseof()) {
if (selfpipe[0] == -1) if (open_pipe(selfpipe) == -1) die_fatal("unable to open pipe", 0, 0);
signal(SIGCHLD, trigger);
if (channel_waitnohang(&exitsignal, &exitcode)) {
packet_channel_send_eof(&b2);
if (!packet_channel_send_close(&b2, exitsignal, exitcode)) die_fatal("unable to close channel", 0, 0);
}
}
/* send data to network */
if (watch1) if (!packet_send()) die_fatal("unable to send data to network", 0, 0);
/* receive data from network */
if (watch0) {
alarm(3600); /* refresh timeout */
if (!packet_recv()) {
if (channel_iseof()) break; /* XXX */
die_fatal("unable to receive data from network", 0, 0);
}
}
/* process packets */
for (;;) {
if (!packet_get(&b1, 0)) {
if (!errno) break;
die_fatal("unable to get packets from network", 0, 0);
}
if (b1.len < 1) break; /* XXX */
switch (b1.buf[0]) {
case SSH_MSG_CHANNEL_OPEN:
if (!packet_channel_open(&b1, &b2)) die_fatal("unable to open channel", 0, 0);
break;
case SSH_MSG_CHANNEL_REQUEST:
if (!packet_channel_request(&b1, &b2)) die_fatal("unable to handle channel-request", 0, 0);
break;
case SSH_MSG_CHANNEL_DATA:
if (!packet_channel_recv_data(&b1)) die_fatal("unable to handle channel-data", 0, 0);
break;
case SSH_MSG_CHANNEL_EXTENDED_DATA:
if (!packet_channel_recv_extendeddata(&b1)) die_fatal("unable to handle channel-extended-data", 0, 0);
break;
case SSH_MSG_CHANNEL_WINDOW_ADJUST:
if (!packet_channel_recv_windowadjust(&b1)) die_fatal("unable to handle channel-window-adjust", 0, 0);
break;
case SSH_MSG_CHANNEL_EOF:
if (!packet_channel_recv_eof(&b1)) die_fatal("unable to handle channel-eof", 0, 0);
break;
case SSH_MSG_CHANNEL_CLOSE:
if (!packet_channel_recv_close(&b1)) die_fatal("unable to handle channel-close", 0, 0);
break;
case SSH_MSG_KEXINIT:
goto rekeying;
default:
if (!packet_unimplemented(&b1)) die_fatal("unable to send SSH_MSG_UNIMPLEMENTED message", 0, 0);
}
}
}
log_i1("finished");
global_die(0); return 111;
}
/*
* 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();
}
ssize_t generic_get(struct gps_device_t *session)
{
return packet_get(session->gpsdata.gps_fd, &session->packet);
}
int packet_transfer(struct interface_t * iface, struct packet_t * request, struct packet_t * response, int timeout)
{
packet_put(iface, request);
return packet_get(iface, response, timeout);
}
void ifstats(const struct OPTIONS *options, struct filterstate *ofilter,
time_t facilitytime)
{
int logging = options->logging;
struct iftab table;
int pkt_result = 0;
struct iflist *ptmp = NULL;
unsigned int idx = 1;
FILE *logfile = NULL;
int ch;
int fd;
struct timeval tv;
time_t starttime = 0;
time_t statbegin = 0;
time_t now = 0;
struct timeval start_tv;
unsigned long long unow = 0;
time_t startlog = 0;
time_t updtime = 0;
unsigned long long updtime_usec = 0;
struct promisc_states *promisc_list;
if (!facility_active(GSTATIDFILE, ""))
mark_facility(GSTATIDFILE, "general interface statistics", "");
else {
write_error("General interface stats already active in another process");
return;
}
initiflist(&(table.head));
if (table.head == NULL) {
no_ifaces_error();
unmark_facility(GSTATIDFILE, "");
return;
}
initiftab(&table);
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);
if (logging) {
if (strcmp(current_logfile, "") == 0) {
strcpy(current_logfile, GSTATLOG);
if (!daemonized)
input_logfile(current_logfile, &logging);
}
}
if (logging) {
opentlog(&logfile, GSTATLOG);
if (logfile == NULL)
logging = 0;
}
if (logging) {
signal(SIGUSR1, rotate_gstat_log);
rotate_flag = 0;
writelog(logging, logfile,
"******** General interface statistics started ********");
}
preparescreen(&table);
update_panels();
doupdate();
fd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if(fd == -1) {
write_error("Unable to obtain monitoring socket");
goto err;
}
//isdnfd = -1;
exitloop = 0;
gettimeofday(&tv, NULL);
start_tv = tv;
starttime = startlog = statbegin = tv.tv_sec;
PACKET_INIT(pkt);
while (!exitloop) {
gettimeofday(&tv, NULL);
now = tv.tv_sec;
unow = tv.tv_sec * 1000000ULL + tv.tv_usec;
if ((now - starttime) >= 1) {
unsigned long msecs;
msecs = timeval_diff_msec(&tv, &start_tv);
updaterates(&table, options->actmode, msecs, idx);
printelapsedtime(statbegin, now, LINES - 3, 1,
table.borderwin);
starttime = now;
start_tv = tv;
}
if (logging) {
check_rotate_flag(&logfile);
if ((now - startlog) >= options->logspan) {
writegstatlog(&table, options->actmode,
time(NULL) - statbegin,
logfile);
startlog = now;
}
}
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 ((facilitytime != 0)
&& (((now - statbegin) / 60) >= facilitytime))
exitloop = 1;
if (packet_get(fd, &pkt, &ch, table.statwin) == -1) {
write_error("Packet receive failed");
exitloop = 1;
break;
}
switch (ch) {
case ERR:
/* no key ready, do nothing */
break;
case KEY_UP:
scrollgstatwin(&table, SCROLLDOWN, &idx);
break;
case KEY_DOWN:
scrollgstatwin(&table, SCROLLUP, &idx);
break;
case KEY_PPAGE:
case '-':
pagegstatwin(&table, SCROLLDOWN, &idx);
break;
case KEY_NPAGE:
case ' ':
pagegstatwin(&table, SCROLLUP, &idx);
break;
case 12:
case 'l':
case 'L':
tx_refresh_screen();
break;
case 'Q':
case 'q':
case 'X':
case 'x':
case 27:
case 24:
exitloop = 1;
break;
}
if (pkt.pkt_len <= 0)
continue;
pkt_result = packet_process(&pkt, NULL, NULL, NULL,
ofilter,
MATCH_OPPOSITE_USECONFIG,
options->v6inv4asv6);
if (pkt_result != PACKET_OK
&& pkt_result != MORE_FRAGMENTS)
continue;
ptmp = positionptr(table.head, pkt.pkt_ifindex);
if (!ptmp)
continue;
ptmp->total++;
ptmp->spanbr += pkt.pkt_len;
ptmp->br += pkt.pkt_len;
if (pkt.pkt_protocol == ETH_P_IP) {
ptmp->iptotal++;
if (pkt_result == CHECKSUM_ERROR) {
(ptmp->badtotal)++;
continue;
}
} else if (pkt.pkt_protocol == ETH_P_IPV6) {
ptmp->ip6total++;
} else {
(ptmp->noniptotal)++;
}
printifentry(ptmp, table.statwin, idx);
}
close(fd);
err:
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(table.statpanel);
delwin(table.statwin);
del_panel(table.borderpanel);
delwin(table.borderwin);
update_panels();
doupdate();
if (logging) {
signal(SIGUSR1, SIG_DFL);
writegstatlog(&table, options->actmode,
time(NULL) - statbegin, logfile);
writelog(logging, logfile,
"******** General interface statistics stopped ********");
fclose(logfile);
}
destroyiflist(table.head);
pkt_cleanup();
unmark_facility(GSTATIDFILE, "");
strcpy(current_logfile, "");
}