void wpcap_init(void)
{
struct in_addr addr;
FARPROC dlladdr;
addr.s_addr = htonl(WCAP_IPADDR);
printf("wpcap_init: IP address: %s\n", inet_ntoa(addr));
wpcap = LoadLibrary("wpcap.dll");
dlladdr = GetProcAddress(wpcap, "pcap_findalldevs");
pcap_findalldevs = (pcap_findalldevs_t)dlladdr;
dlladdr = GetProcAddress(wpcap, "pcap_open_live");
pcap_open_live = (pcap_open_live_t)dlladdr;
dlladdr = GetProcAddress(wpcap, "pcap_next_ex");
pcap_next_ex = (pcap_next_ex_t)dlladdr;
dlladdr = GetProcAddress(wpcap, "pcap_sendpacket");
pcap_sendpacket = (pcap_sendpacket_t)dlladdr;
if (pcap_findalldevs == NULL || pcap_open_live == NULL ||
pcap_next_ex == NULL || pcap_sendpacket == NULL)
{
error_exit("error on access to winpcap library\n");
}
init_pcap(addr);
set_ethaddr(addr);
}
/*---------------------------------------------------------------------------*/
void
wpcap_init(void)
{
struct in_addr addr;
addr.s_addr = inet_addr((*__argv)[1]);
if(addr.s_addr == INADDR_NONE) {
error_exit("usage: <program> <ip addr of ethernet card to share>\n");
}
printf("wpcap_init: cmdline address: %s\n", inet_ntoa(addr));
wpcap = LoadLibrary("wpcap.dll");
(FARPROC)pcap_findalldevs = GetProcAddress(wpcap, "pcap_findalldevs");
(FARPROC)pcap_open_live = GetProcAddress(wpcap, "pcap_open_live");
(FARPROC)pcap_next_ex = GetProcAddress(wpcap, "pcap_next_ex");
(FARPROC)pcap_sendpacket = GetProcAddress(wpcap, "pcap_sendpacket");
if(pcap_findalldevs == NULL || pcap_open_live == NULL ||
pcap_next_ex == NULL || pcap_sendpacket == NULL) {
error_exit("error on access to winpcap library\n");
}
init_pcap(addr);
set_ethaddr(addr);
}
int main(int argc, char *argv[])
{
char *dev, errbuf[PCAP_ERRBUF_SIZE];
pcap_t *handle;
print_app_banner();
check_requirements();
init_pcap();
return(0);
}
int main(int argc, const char *argv[])
{
u_int32_t ack;
/* initialize libraries */
init_libnet();
init_pcap();
/* get next acknowledge */
ack = guess_next_seq() + 1;
/* send rsh command to append '+ +' to '~/.rhosts' */
send_rsh_command(ack);
return 0;
}
/*---------------------------------------------------------------------------*/
void
wpcap_init(void)
{
struct in_addr addr;
#ifdef __CYGWIN__
addr.s_addr = inet_addr((*__argv)[1]);
#else /* __CYGWIN__ */
addr.s_addr = inet_addr(__argv[1]);
#endif /* __CYGWIN__ */
if(addr.s_addr == INADDR_NONE) {
// error_exit("usage: <program> <ip addr of ethernet card to share>\n");
addr.s_addr = inet_addr("10.10.10.10");
log_message("usage: <program> <ip addr of ethernet card to share>\n-->I'll try guessing ", inet_ntoa(addr));
} else {
log_message("wpcap_init:cmdline address: ", inet_ntoa(addr));
}
wpcap = LoadLibrary("wpcap.dll");
pcap_findalldevs = (int (*)(struct pcap_if **, char *))
GetProcAddress(wpcap, "pcap_findalldevs");
pcap_open_live = (struct pcap *(*)(char *, int, int, int, char *))
GetProcAddress(wpcap, "pcap_open_live");
pcap_next_ex = (int (*)(struct pcap *, struct pcap_pkthdr **, unsigned char **))
GetProcAddress(wpcap, "pcap_next_ex");
pcap_sendpacket = (int (*)(struct pcap *, unsigned char *, int))
GetProcAddress(wpcap, "pcap_sendpacket");
if(pcap_findalldevs == NULL || pcap_open_live == NULL ||
pcap_next_ex == NULL || pcap_sendpacket == NULL) {
error_exit("error on access to winpcap library\n");
}
init_pcap(addr);
set_ethaddr(addr);
}
int main(int argc, char **argv)
{
int c, i, j, opt_index;
char *ptr;
bool prio_high = false;
struct mode mode;
void (*enter_mode)(struct mode *mode) = NULL;
check_for_root_maybe_die();
memset(&mode, 0, sizeof(mode));
mode.link_type = LINKTYPE_EN10MB;
mode.print_mode = FNTTYPE_PRINT_NORM;
mode.cpu = CPU_UNKNOWN;
mode.packet_type = PACKET_ALL;
mode.promiscuous = true;
mode.randomize = false;
mode.pcap = PCAP_OPS_SG;
mode.dump_interval = DUMP_INTERVAL;
while ((c = getopt_long(argc, argv, short_options, long_options,
&opt_index)) != EOF) {
switch (c) {
case 'd':
case 'i':
mode.device_in = xstrdup(optarg);
break;
case 'o':
mode.device_out = xstrdup(optarg);
break;
case 'r':
mode.randomize = true;
break;
case 'J':
mode.jumbo_support = 1;
break;
case 'f':
mode.filter = xstrdup(optarg);
break;
case 'M':
mode.promiscuous = false;
break;
case 't':
if (!strncmp(optarg, "host", strlen("host")))
mode.packet_type = PACKET_HOST;
else if (!strncmp(optarg, "broadcast", strlen("broadcast")))
mode.packet_type = PACKET_BROADCAST;
else if (!strncmp(optarg, "multicast", strlen("multicast")))
mode.packet_type = PACKET_MULTICAST;
else if (!strncmp(optarg, "others", strlen("others")))
mode.packet_type = PACKET_OTHERHOST;
else if (!strncmp(optarg, "outgoing", strlen("outgoing")))
mode.packet_type = PACKET_OUTGOING;
else
mode.packet_type = PACKET_ALL;
break;
case 'S':
ptr = optarg;
mode.reserve_size = 0;
for (j = i = strlen(optarg); i > 0; --i) {
if (!isdigit(optarg[j - i]))
break;
ptr++;
}
if (!strncmp(ptr, "KB", strlen("KB")))
mode.reserve_size = 1 << 10;
else if (!strncmp(ptr, "MB", strlen("MB")))
mode.reserve_size = 1 << 20;
else if (!strncmp(ptr, "GB", strlen("GB")))
mode.reserve_size = 1 << 30;
else
panic("Syntax error in ring size param!\n");
*ptr = 0;
mode.reserve_size *= atoi(optarg);
break;
case 'b':
set_cpu_affinity(optarg, 0);
if (mode.cpu != CPU_NOTOUCH)
mode.cpu = atoi(optarg);
break;
case 'B':
set_cpu_affinity(optarg, 1);
break;
case 'H':
prio_high = true;
break;
case 'c':
mode.pcap = PCAP_OPS_RW;
break;
case 'm':
mode.pcap = PCAP_OPS_MMAP;
break;
case 'Q':
mode.cpu = CPU_NOTOUCH;
break;
case 's':
mode.print_mode = FNTTYPE_PRINT_NONE;
break;
case 'q':
mode.print_mode = FNTTYPE_PRINT_LESS;
break;
case 'l':
mode.print_mode = FNTTYPE_PRINT_CHR1;
break;
case 'x':
mode.print_mode = FNTTYPE_PRINT_HEX1;
break;
case 'C':
mode.print_mode = FNTTYPE_PRINT_PAAC;
break;
case 'X':
mode.print_mode = FNTTYPE_PRINT_HEX2;
break;
case 'N':
mode.print_mode = FNTTYPE_PRINT_NOPA;
break;
case 'k':
mode.kpull = (unsigned long) atol(optarg);
break;
case 'n':
frame_cnt_max = (unsigned long) atol(optarg);
break;
case 'F':
mode.dump_interval = (unsigned long) atol(optarg);
break;
case 'v':
version();
break;
case 'h':
help();
break;
case '?':
switch (optopt) {
case 'd':
case 'i':
case 'o':
case 'f':
case 't':
case 'F':
case 'n':
case 'S':
case 'b':
case 'k':
case 'B':
case 'e':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (!mode.device_in)
mode.device_in = xstrdup("any");
register_signal(SIGINT, signal_handler);
register_signal(SIGHUP, signal_handler);
init_pcap(mode.jumbo_support);
tprintf_init();
header();
if (prio_high == true) {
set_proc_prio(get_default_proc_prio());
set_sched_status(get_default_sched_policy(),
get_default_sched_prio());
}
if (mode.device_in && (device_mtu(mode.device_in) ||
!strncmp("any", mode.device_in, strlen(mode.device_in)))) {
if (!mode.device_out) {
mode.dump = 0;
enter_mode = enter_mode_rx_only_or_dump;
} else if (device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_rx_to_tx;
} else {
mode.dump = 1;
register_signal_f(SIGALRM, timer_next_dump, SA_SIGINFO);
enter_mode = enter_mode_rx_only_or_dump;
}
} else {
if (mode.device_out && device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_pcap_to_tx;
} else {
enter_mode = enter_mode_read_pcap;
}
}
if (!enter_mode)
panic("Selection not supported!\n");
enter_mode(&mode);
tprintf_cleanup();
cleanup_pcap();
if (mode.device_in)
xfree(mode.device_in);
if (mode.device_out)
xfree(mode.device_out);
return 0;
}
int
main(int argc, char **argv)
{
#ifdef __FreeBSD__
FILE *fpid = NULL;
struct stat dbstat;
int rst;
#endif
int ch, i;
const char *errstr;
struct passwd *pw;
pcap_handler phandler = logpkt_handler;
int syncfd = 0;
struct servent *ent;
char *sync_iface = NULL;
char *sync_baddr = NULL;
if ((ent = getservbyname("spamd-sync", "udp")) == NULL)
errx(1, "Can't find service \"spamd-sync\" in /etc/services");
sync_port = ntohs(ent->s_port);
#ifndef __FreeBSD__
while ((ch = getopt(argc, argv, "DIi:l:W:Y:")) != -1) {
#else
while ((ch = getopt(argc, argv, "DIi:l:W:Y:m:")) != -1) {
#endif
switch (ch) {
case 'D':
flag_debug = 1;
break;
case 'I':
flag_inbound = 1;
break;
case 'i':
networkif = optarg;
break;
case 'l':
pflogif = optarg;
break;
case 'W':
/* limit whiteexp to 2160 hours (90 days) */
i = strtonum(optarg, 1, (24 * 90), &errstr);
if (errstr)
usage();
whiteexp = (i * 60 * 60);
break;
case 'Y':
if (sync_addhost(optarg, sync_port) != 0)
sync_iface = optarg;
syncsend++;
break;
#ifdef __FreeBSD__
case 'm':
if (strcmp(optarg, "ipfw") == 0)
use_pf=0;
break;
#endif
default:
usage();
/* NOTREACHED */
}
}
#ifdef __FreeBSD__
/* check if PATH_SPAMD_DB exist and is a regular file */
rst = lstat(PATH_SPAMD_DB, &dbstat);
if (rst == -1 && errno == ENOENT){
syslog(LOG_ERR, "error %s (%m)", PATH_SPAMD_DB);
err(1, "%s", PATH_SPAMD_DB);
}
if (rst == 0 && !S_ISREG(dbstat.st_mode)) {
syslog(LOG_ERR, "error %s (Not a regular file)", PATH_SPAMD_DB);
errx(1, "exit \"%s\" : Not a regular file", PATH_SPAMD_DB);
}
#endif
signal(SIGINT , sighandler_close);
signal(SIGQUIT, sighandler_close);
signal(SIGTERM, sighandler_close);
logmsg(LOG_DEBUG, "Listening on %s for %s %s", pflogif,
(networkif == NULL) ? "all interfaces." : networkif,
(flag_inbound) ? "Inbound direction only." : "");
if (init_pcap() == -1)
err(1, "couldn't initialize pcap");
if (syncsend) {
syncfd = sync_init(sync_iface, sync_baddr, sync_port);
if (syncfd == -1)
err(1, "sync init");
}
#ifdef __FreeBSD__
/* open the pid file just before switch the user */
fpid = fopen(pid_file, "w");
if (fpid == NULL) {
syslog(LOG_ERR, "error can't create pid file %s (%m)", pid_file);
err(1, "can't create pid file \"%s\"", pid_file);
}
#endif
/* privdrop */
pw = getpwnam("_spamd");
if (pw == NULL)
errx(1, "User '_spamd' not found! ");
if (setgroups(1, &pw->pw_gid) ||
setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
err(1, "failed to drop privs");
if (!flag_debug) {
if (daemon(0, 0) == -1)
err(1, "daemon");
tzset();
openlog_r("spamlogd", LOG_PID | LOG_NDELAY, LOG_DAEMON, &sdata);
}
#ifdef __FreeBSD__
/* after switch user and daemon write and close the pid file */
if (fpid) {
fprintf(fpid, "%ld\n", (long) getpid());
if (fclose(fpid) == EOF) {
syslog(LOG_ERR, "error can't close pid file %s (%m)", pid_file);
exit (1);
}
}
#endif
pcap_loop(hpcap, -1, phandler, NULL);
logmsg(LOG_NOTICE, "exiting");
if (!flag_debug)
closelog_r(&sdata);
exit(0);
}
int
main(int argc, char **argv)
{
int ch, np, ret, Xflag = 0;
pcap_handler phandler = dump_packet;
const char *errstr = NULL;
char *pidf = NULL;
ret = 0;
closefrom(STDERR_FILENO + 1);
while ((ch = getopt(argc, argv, "Dxd:f:i:p:s:")) != -1) {
switch (ch) {
case 'D':
Debug = 1;
break;
case 'd':
delay = strtonum(optarg, 5, 60*60, &errstr);
if (errstr)
usage();
break;
case 'f':
filename = optarg;
break;
case 'i':
interface = optarg;
break;
case 'p':
pidf = optarg;
break;
case 's':
snaplen = strtonum(optarg, 0, PFLOGD_MAXSNAPLEN,
&errstr);
if (snaplen <= 0)
snaplen = DEF_SNAPLEN;
if (errstr)
snaplen = PFLOGD_MAXSNAPLEN;
break;
case 'x':
Xflag++;
break;
default:
usage();
}
}
log_debug = Debug;
argc -= optind;
argv += optind;
/* does interface exist */
if (!if_exists(interface)) {
warn("Failed to initialize: %s", interface);
logmsg(LOG_ERR, "Failed to initialize: %s", interface);
logmsg(LOG_ERR, "Exiting, init failure");
exit(1);
}
if (!Debug) {
openlog("pflogd", LOG_PID | LOG_CONS, LOG_DAEMON);
if (daemon(0, 0)) {
logmsg(LOG_WARNING, "Failed to become daemon: %s",
strerror(errno));
}
pidfile(pidf);
}
tzset();
(void)umask(S_IRWXG | S_IRWXO);
/* filter will be used by the privileged process */
if (argc) {
filter = copy_argv(argv);
if (filter == NULL)
logmsg(LOG_NOTICE, "Failed to form filter expression");
}
/* initialize pcap before dropping privileges */
if (init_pcap()) {
logmsg(LOG_ERR, "Exiting, init failure");
exit(1);
}
/* Privilege separation begins here */
if (priv_init()) {
logmsg(LOG_ERR, "unable to privsep");
exit(1);
}
setproctitle("[initializing]");
/* Process is now unprivileged and inside a chroot */
signal(SIGTERM, sig_close);
signal(SIGINT, sig_close);
signal(SIGQUIT, sig_close);
signal(SIGALRM, sig_alrm);
signal(SIGUSR1, sig_usr1);
signal(SIGHUP, sig_hup);
alarm(delay);
buffer = malloc(PFLOGD_BUFSIZE);
if (buffer == NULL) {
logmsg(LOG_WARNING, "Failed to allocate output buffer");
phandler = dump_packet_nobuf;
} else {
bufleft = buflen = PFLOGD_BUFSIZE;
bufpos = buffer;
bufpkt = 0;
}
if (reset_dump(Xflag) < 0) {
if (Xflag)
return (1);
logmsg(LOG_ERR, "Logging suspended: open error");
set_suspended(1);
} else if (Xflag)
return (0);
while (1) {
np = pcap_dispatch(hpcap, PCAP_NUM_PKTS,
phandler, (u_char *)dpcap);
if (np < 0) {
if (!if_exists(interface) == -1) {
logmsg(LOG_NOTICE, "interface %s went away",
interface);
ret = -1;
break;
}
logmsg(LOG_NOTICE, "%s", pcap_geterr(hpcap));
}
if (gotsig_close)
break;
if (gotsig_hup) {
if (reset_dump(0)) {
logmsg(LOG_ERR,
"Logging suspended: open error");
set_suspended(1);
}
gotsig_hup = 0;
}
if (gotsig_alrm) {
if (dpcap)
flush_buffer(dpcap);
else
gotsig_hup = 1;
gotsig_alrm = 0;
alarm(delay);
}
if (gotsig_usr1) {
log_pcap_stats();
gotsig_usr1 = 0;
}
}
logmsg(LOG_NOTICE, "Exiting");
if (dpcap) {
flush_buffer(dpcap);
fclose(dpcap);
}
purge_buffer();
log_pcap_stats();
pcap_close(hpcap);
if (!Debug)
closelog();
return (ret);
}
int
main(int argc, char **argv)
{
int ch;
struct passwd *pw;
pcap_handler phandler = logpkt_handler;
int syncfd = 0;
struct servent *ent;
char *sync_iface = NULL;
char *sync_baddr = NULL;
if ((ent = getservbyname("spamd-sync", "udp")) == NULL)
errx(1, "Can't find service \"spamd-sync\" in /etc/services");
sync_port = ntohs(ent->s_port);
while ((ch = getopt(argc, argv, "DIi:l:Y:")) != -1) {
switch (ch) {
case 'D':
flag_debug = 1;
break;
case 'I':
flag_inbound = 1;
break;
case 'i':
networkif = optarg;
break;
case 'l':
pflogif = optarg;
break;
case 'Y':
if (sync_addhost(optarg, sync_port) != 0)
sync_iface = optarg;
syncsend++;
break;
default:
usage();
/* NOTREACHED */
}
}
signal(SIGINT , sighandler_close);
signal(SIGQUIT, sighandler_close);
signal(SIGTERM, sighandler_close);
logmsg(LOG_DEBUG, "Listening on %s for %s %s", pflogif,
(networkif == NULL) ? "all interfaces." : networkif,
(flag_inbound) ? "Inbound direction only." : "");
if (init_pcap() == -1)
err(1, "couldn't initialize pcap");
if (syncsend) {
syncfd = sync_init(sync_iface, sync_baddr, sync_port);
if (syncfd == -1)
err(1, "sync init");
}
/* privdrop */
pw = getpwnam("_spamd");
if (pw == NULL)
errx(1, "User '_spamd' not found! ");
if (setgroups(1, &pw->pw_gid) ||
setresgid(pw->pw_gid, pw->pw_gid, pw->pw_gid) ||
setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid))
err(1, "failed to drop privs");
if (!flag_debug) {
if (daemon(0, 0) == -1)
err(1, "daemon");
tzset();
openlog_r("spamlogd", LOG_PID | LOG_NDELAY, LOG_DAEMON, &sdata);
}
pcap_loop(hpcap, -1, phandler, NULL);
logmsg(LOG_NOTICE, "exiting");
if (!flag_debug)
closelog_r(&sdata);
exit(0);
}
void process_dect_data()
{
int ret;
switch (cli.mode)
{
case MODE_FPSCAN:
while (7 == (ret = read(cli.fd, buf, 7))) {
memcpy(cli.station.RFPI, &buf[2], 5);
cli.station.channel = buf[0];
cli.station.RSSI = buf[1];
cli.station.type = TYPE_FP;
try_add_station(&cli.station);
}
break;
case MODE_CALLSCAN:
while (7 == (ret = read(cli.fd, buf, 7))) {
memcpy(cli.station.RFPI, &buf[2], 5);
cli.station.channel = buf[0];
cli.station.RSSI = buf[1];
cli.station.type = TYPE_PP;
try_add_station(&cli.station);
}
break;
case MODE_PPSCAN:
while ( sizeof(cli.packet) ==
read(cli.fd, &cli.packet, sizeof(cli.packet)))
{
memcpy(cli.station.RFPI, cli.RFPI, 5);
cli.station.channel = cli.packet.channel;
cli.station.RSSI = cli.packet.rssi;
cli.station.type = TYPE_PP;
/* to ypdate statistics only we try_add_station() */
try_add_station(&cli.station);
/* stop hopping once we're synchronized */
cli.hop = 0;
if (!cli.pcap)
{
LOG("### got sync\n");
init_pcap(&cli.packet);
/* this is not actually a B-Field,
* but we expect some to come soon
* and the val needs to be non-0 */
cli.autorec_last_bfield = time(NULL);
// IMA or WAV dumping? Audio Playing?
if (cli.imaDump)
openIma(fname);
if (cli.wavDump)
openWav(fname);
if (cli.audioPlay)
openAlsa();
}
if (has_b_field())
cli.autorec_last_bfield = time(NULL);
struct pcap_pkthdr pcap_hdr;
pcap_hdr.caplen = 73;
pcap_hdr.len = 73;
ret = gettimeofday(&pcap_hdr.ts, NULL);
if (ret)
{
LOG("!!! couldn't gettimeofday(): %s\n",
strerror(errno));
exit(1);
}
uint8_t pcap_packet[100];
memset(pcap_packet, 0, 100);
pcap_packet[12] = 0x23;
pcap_packet[13] = 0x23;
pcap_packet[14] = 0x00; /* decttype (receive) */
pcap_packet[15] = cli.packet.channel;
pcap_packet[16] = 0;
pcap_packet[17] = cli.packet.slot;
pcap_packet[18] = 0;
pcap_packet[19] = cli.packet.rssi;
memcpy(&pcap_packet[20], cli.packet.data, 53);
pcap_dump(cli.pcap_d, &pcap_hdr, pcap_packet);
// Dump the audio data
if (cli.imaDumping || cli.wavDumping || cli.audioPlaying)
packetAudioProcessing(pcap_packet);
}
break;
}
}
int main(int argc, char *argv[]) {
int sockfd_snd, sockfd_rcv_sender, sockfd_rcv_monitor, sockfd_monitor=-1;
struct sockaddr_in my_addr; // my address information
struct sockaddr_in their_addr; // connector's address information
fd_set read_fds_copy, write_fds_copy;
socklen_t sin_size;
struct timeval start_tv, left_tv;
int yes=1;//, flag_send_monitor=0;
struct timeval packet_deadline;
struct in_addr addr;
int flag_measure=0;
char ch;
unsigned short standalone_port = SENDER_PORT;
// Do we use live data? Or previously recorded data?
FILE * logfile = NULL;
unsigned long quantum_no=0;
int logflags = LOG_NOTHING;
int select_count = 0;
gettimeofday(&packet_deadline, NULL);
init();
//set up debug flag
if (getenv("Debug")!=NULL)
flag_debug=1;
else
flag_debug=0;
flag_standalone = 0;
/*
* Process command-line arguments
*/
while ((ch = getopt(argc,argv,"df:l:b:rst")) != -1) {
switch (ch) {
case 'd':
flag_debug = 1; break;
case 'f':
if (logfile == NULL)
{
logfile = fopen(optarg, "a");
if (logfile == NULL)
{
perror("Log fopen()");
exit(1);
}
}
break;
case 'b':
if (strcmp(optarg, "average") == 0)
{
bandwidth_method = BANDWIDTH_AVERAGE;
} else if (strcmp(optarg, "max") == 0) {
bandwidth_method = BANDWIDTH_MAX;
} else if (strcmp(optarg, "vegas") == 0) {
bandwidth_method = BANDWIDTH_VEGAS;
} else if (strcmp(optarg, "buffer") == 0) {
bandwidth_method = BANDWIDTH_BUFFER;
} else {
fprintf(stderr, "Unknown bandwidth method\n");
usage();
exit(1);
}
break;
case 'l':
if (strcmp(optarg, "everything") == 0)
{
logflags = LOG_EVERYTHING;
}
else if (strcmp(optarg, "nothing") == 0)
{
logflags = LOG_NOTHING;
}
else if (strcmp(optarg, "control-send") == 0)
{
logflags = logflags | CONTROL_SEND;
}
else if (strcmp(optarg, "control-receive") == 0)
{
logflags = logflags | CONTROL_RECEIVE;
}
else if (strcmp(optarg, "tcptrace-send") == 0)
{
logflags = logflags | TCPTRACE_SEND;
}
else if (strcmp(optarg, "tcptrace-receive") == 0)
{
logflags = logflags | TCPTRACE_RECEIVE;
}
else if (strcmp(optarg, "sniff-send") == 0)
{
logflags = logflags | SNIFF_SEND;
}
else if (strcmp(optarg, "sniff-receive") == 0)
{
logflags = logflags | SNIFF_RECEIVE;
}
else if (strcmp(optarg, "peer-write") == 0)
{
logflags = logflags | PEER_WRITE;
}
else if (strcmp(optarg, "peer-read") == 0)
{
logflags = logflags | PEER_READ;
}
else if (strcmp(optarg, "main-loop") == 0)
{
logflags = logflags | MAIN_LOOP;
}
else if (strcmp(optarg, "lookup-db") == 0)
{
logflags = logflags | LOOKUP_DB;
}
else if (strcmp(optarg, "delay-detail") == 0)
{
logflags = logflags | DELAY_DETAIL;
}
else if (strcmp(optarg, "packet-buffer-detail") == 0)
{
logflags = logflags | PACKET_BUFFER_DETAIL;
}
else
{
fprintf(stderr, "Unknown logging option %s\n", optarg);
usage();
exit(1);
}
break;
case 's':
flag_standalone = 1; break;
case 'r':
flag_standalone = 1;
is_live = 0;
break;
case 't':
flag_testmode = 1; break;
default:
fprintf(stderr,"Unknown option %c\n",ch);
usage(); exit(1);
}
}
argc -= optind;
argv += optind;
if (logfile == NULL)
{
logfile = stderr;
}
logInit(logfile, logflags, 1);
if (flag_standalone) {
if (argc != 3) {
fprintf(stderr,"Wrong number of options for standalone: %i\n",argc);
usage();
exit(1);
} else {
flag_measure = 1;
// rcvdb[0].valid = 1;
standalone_port = atoi(argv[2]);
inet_aton(argv[1], &addr);
insert_fake(addr.s_addr, standalone_port);
// rcvdb[0].ip = addr.s_addr;
// rcvdb[0].sockfd= -1; //show error if used
// rcvdb[0].last_usetime = time(NULL);
}
printf("Running in standalone mode\n");
} else {
if (argc != 1) {
fprintf(stderr,"Wrong number of options: %i\n",argc);
usage();
exit(1);
}
}
if (flag_testmode) {
printf("Running in testmode\n");
test_state = TEST_NOTSTARTED;
}
if (strlen(argv[0]) > 127) {
fprintf(stderr,"Error: the <sniff-interface> name must be less than 127 characters \n");
exit(1);
}
// strcpy(sniff_interface, argv[0]);
//set up the sender connection listener
if ((sockfd_rcv_sender = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
if (setsockopt(sockfd_rcv_sender, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(SENDER_PORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
// memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
if (flag_debug) printf("Listen on %s\n",inet_ntoa(my_addr.sin_addr));
if (bind(sockfd_rcv_sender, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
perror("bind");
exit(1);
}
if (listen(sockfd_rcv_sender, PENDING_CONNECTIONS) == -1) {
perror("listen");
exit(1);
}
//set up the monitor connection listener
if ((sockfd_rcv_monitor = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
if (setsockopt(sockfd_rcv_monitor, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
perror("setsockopt");
exit(1);
}
my_addr.sin_family = AF_INET; // host byte order
my_addr.sin_port = htons(MONITOR_PORT); // short, network byte order
my_addr.sin_addr.s_addr = INADDR_ANY; // automatically fill with my IP
// memset(&(my_addr.sin_zero), '\0', 8); // zero the rest of the struct
if (flag_debug) printf("Listen on %s\n",inet_ntoa(my_addr.sin_addr));
if (bind(sockfd_rcv_monitor, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == -1) {
perror("bind");
exit(1);
}
if (listen(sockfd_rcv_monitor, 1) == -1) {
perror("listen");
exit(1);
}
//initialization
packet_buffer_init();
init_random_buffer();
init_pcap(SNIFF_TIMEOUT, standalone_port, argv[0]);
FD_ZERO(&read_fds);
FD_ZERO(&read_fds_copy);
FD_ZERO(&write_fds);
FD_ZERO(&write_fds_copy);
FD_SET(pcapfd, &read_fds);
FD_SET(sockfd_rcv_sender, &read_fds);
FD_SET(sockfd_rcv_monitor, &read_fds);
maxfd = pcapfd; //socket order
sin_size = sizeof(struct sockaddr_in);
//main loop - the stubd runs forever
while (1) {
// flag_send_monitor=0; //reset flag for each quanta
gettimeofday(&start_tv, NULL); //reset start time for each quanta
// printf("Total: %d\n", total_size);
// printf("========== Quantum %lu ==========\n", quantum_no);
logWrite(MAIN_LOOP, NULL, "Quantum %lu", quantum_no);
if (is_live)
{
update_stats();
logWrite(MAIN_LOOP, NULL, "PCAP Received: %u Dropped: %u",
received_stat(), dropped_stat());
}
quantum_no++;
//while in a quanta
while(have_time(&start_tv, &left_tv)) {
read_fds_copy = read_fds;
write_fds_copy = write_fds;
select_count = select(maxfd+1, &read_fds_copy, &write_fds_copy, NULL,
&left_tv);
if (select_count == -1)
{
perror("select");
clean_exit(1);
}
// fprintf(stderr, "Select count: %d\n", select_count);
// Send out packets to our peers if the deadline has passed.
// logWrite(MAIN_LOOP, NULL, "Send normal packets to peers");
handle_packet_buffer(&packet_deadline, &write_fds_copy);
// send to destinations which are writeable and are behind.
// logWrite(MAIN_LOOP, NULL, "Send pending packets to peers");
#ifdef USE_PACKET_BUFFER
for_each_pending(try_pending, &write_fds_copy);
#endif
// receive from existing senders
// logWrite(MAIN_LOOP, NULL, "Receive packets from peers");
for_each_readable_sender(receive_sender, &read_fds_copy);
/*
//receive from existent senders
for (i=0; i<CONCURRENT_SENDERS; i++){
// Send pending data if it exists.
if (snddb[i].valid==1 && FD_ISSET(snddb[i].sockfd, &read_fds_copy)) {
receive_sender(i);
}
}
*/
//handle new senders
if (FD_ISSET(sockfd_rcv_sender, &read_fds_copy)) {
if ((sockfd_snd = accept(sockfd_rcv_sender, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
perror("accept");
continue;
} else {
logWrite(MAIN_LOOP, NULL, "Accept new peer (%s)",
inet_ntoa(their_addr.sin_addr));
replace_sender_by_stub_port(their_addr.sin_addr.s_addr,
ntohs(their_addr.sin_port), sockfd_snd,
&read_fds);
// insert_db(their_addr.sin_addr.s_addr, their_addr.sin_port,
// SENDER_PORT, sockfd_snd, 1); //insert snddb
// FD_SET(sockfd_snd, &read_fds); // add to master set
// if (sockfd_snd > maxfd) { // keep track of the maximum
// maxfd = sockfd_snd;
// }
if (flag_debug) printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
}
}
//handle the new monitor
if (FD_ISSET(sockfd_rcv_monitor, &read_fds_copy)) {
if ((sockfd_monitor = accept(sockfd_rcv_monitor, (struct sockaddr *)&their_addr, &sin_size)) == -1) {
perror("accept");
continue;
} else {
int nodelay = 1;
int nodelay_error = setsockopt(sockfd_monitor, IPPROTO_TCP,
TCP_NODELAY, &nodelay,
sizeof(nodelay));
if (nodelay_error == -1)
{
perror("setsockopt (TCP_NODELAY)");
clean_exit(1);
}
logWrite(MAIN_LOOP, NULL, "Accept new monitor (%s)",
inet_ntoa(their_addr.sin_addr));
FD_CLR(sockfd_rcv_monitor, &read_fds); //allow only one monitor connection
FD_SET(sockfd_monitor, &read_fds); //check the monitor connection for read
// FD_SET(sockfd_monitor, &write_fds); //check the monitor connection for write
if (sockfd_monitor > maxfd) { //keep track of the maximum
maxfd = sockfd_monitor;
}
if (flag_debug) printf("server: got connection from %s\n",inet_ntoa(their_addr.sin_addr));
}
}
//receive from the monitor
if (sockfd_monitor!=-1 && FD_ISSET(sockfd_monitor, &read_fds_copy)) {
logWrite(MAIN_LOOP, NULL, "Receive control message from monitor");
if (receive_monitor(sockfd_monitor, &packet_deadline) == 0) { //socket_monitor closed by peer
FD_CLR(sockfd_monitor, &read_fds); //stop checking the monitor socket
// FD_CLR(sockfd_monitor, &write_fds);
sockfd_monitor = -1;
FD_SET(sockfd_rcv_monitor, &read_fds); //start checking the receiver control socket
if (sockfd_rcv_monitor > maxfd) { // keep track of the maximum
maxfd = sockfd_rcv_monitor;
}
}
}
//sniff packets
if (FD_ISSET(pcapfd, &read_fds_copy)) {
logWrite(MAIN_LOOP, NULL, "Sniff packet stream");
sniff();
}
} //while in quanta
//send measurements to the monitor once in each quanta
if (sockfd_monitor!=-1)
// && FD_ISSET(sockfd_monitor, &write_fds_copy)) {
{
logWrite(MAIN_LOOP, NULL, "Send control message to monitor");
if (send_monitor(sockfd_monitor) == 0) { //socket_monitor closed by peer
logWrite(MAIN_LOOP, NULL, "Message to monitor failed");
FD_CLR(sockfd_monitor, &read_fds); //stop checking the monitor socket
// FD_CLR(sockfd_monitor, &write_fds);
sockfd_monitor = -1;
FD_SET(sockfd_rcv_monitor, &read_fds); //start checking the receiver control socket
if (sockfd_rcv_monitor > maxfd) { // keep track of the maximum
maxfd = sockfd_rcv_monitor;
}
} else {
logWrite(MAIN_LOOP, NULL, "Message to monitor succeeded");
// flag_send_monitor=1;
}
}
// In testmode, we only start printing in the quanta we first see a packet
if (flag_standalone) {
print_measurements();
}
// If running in testmode, and the test is over, exit!
if (flag_testmode && test_state == TEST_DONE) {
printf("Test done - total bytes transmitted: %llu\n",total_bytes);
break;
}
} //while forever
packet_buffer_cleanup();
return 0;
}
void start() {
fp = init_pcap(); // initialise platform-specific libpcap network interface
}
int main(int argc, char **argv)
{
int c, i, j, opt_index, ops_touched = 0;
char *ptr;
bool prio_high = false;
struct mode mode;
void (*enter_mode) (struct mode * mode) = NULL;
check_for_root_maybe_die();
fmemset(&mode, 0, sizeof(mode));
mode.link_type = LINKTYPE_EN10MB;
mode.print_mode = FNTTYPE_PRINT_NORM;
mode.cpu = CPU_UNKNOWN;
mode.packet_type = PACKET_ALL;
mode.promiscuous = true;
mode.randomize = false;
mode.pcap = PCAP_OPS_SG;
mode.dump_interval = DUMP_INTERVAL;
while ((c = getopt_long(argc, argv, short_options, long_options,
&opt_index)) != EOF) {
switch (c) {
case 'd':
case 'i':
mode.device_in = xstrdup(optarg);
break;
case 'o':
mode.device_out = xstrdup(optarg);
break;
case 'R':
mode.link_type = LINKTYPE_IEEE802_11;
mode.rfraw = 1;
break;
case 'r':
mode.randomize = true;
break;
case 'J':
mode.jumbo_support = 1;
break;
case 'f':
mode.filter = xstrdup(optarg);
break;
case 'M':
mode.promiscuous = false;
break;
case 't':
if (!strncmp(optarg, "host", strlen("host")))
mode.packet_type = PACKET_HOST;
else if (!strncmp
(optarg, "broadcast", strlen("broadcast")))
mode.packet_type = PACKET_BROADCAST;
else if (!strncmp
(optarg, "multicast", strlen("multicast")))
mode.packet_type = PACKET_MULTICAST;
else if (!strncmp(optarg, "others", strlen("others")))
mode.packet_type = PACKET_OTHERHOST;
else if (!strncmp
(optarg, "outgoing", strlen("outgoing")))
mode.packet_type = PACKET_OUTGOING;
else
mode.packet_type = PACKET_ALL;
break;
case 'S':
ptr = optarg;
mode.reserve_size = 0;
for (j = i = strlen(optarg); i > 0; --i) {
if (!isdigit(optarg[j - i]))
break;
ptr++;
}
if (!strncmp(ptr, "KB", strlen("KB")))
mode.reserve_size = 1 << 10;
else if (!strncmp(ptr, "MB", strlen("MB")))
mode.reserve_size = 1 << 20;
else if (!strncmp(ptr, "GB", strlen("GB")))
mode.reserve_size = 1 << 30;
else
panic("Syntax error in ring size param!\n");
*ptr = 0;
mode.reserve_size *= atoi(optarg);
break;
case 'b':
set_cpu_affinity(optarg, 0);
if (mode.cpu != CPU_NOTOUCH)
mode.cpu = atoi(optarg);
break;
case 'B':
set_cpu_affinity(optarg, 1);
break;
case 'H':
prio_high = true;
break;
case 'c':
mode.pcap = PCAP_OPS_RW;
ops_touched = 1;
break;
case 'm':
mode.pcap = PCAP_OPS_MMAP;
ops_touched = 1;
break;
case 'g':
mode.pcap = PCAP_OPS_SG;
ops_touched = 1;
break;
case 'Q':
mode.cpu = CPU_NOTOUCH;
break;
case 's':
mode.print_mode = FNTTYPE_PRINT_NONE;
break;
case 'q':
mode.print_mode = FNTTYPE_PRINT_LESS;
break;
case 'X':
mode.print_mode =
(mode.print_mode ==
FNTTYPE_PRINT_ASCII) ? FNTTYPE_PRINT_HEX_ASCII :
FNTTYPE_PRINT_HEX;
break;
case 'l':
mode.print_mode =
(mode.print_mode ==
FNTTYPE_PRINT_HEX) ? FNTTYPE_PRINT_HEX_ASCII :
FNTTYPE_PRINT_ASCII;
break;
case 'k':
mode.kpull = (unsigned long)atol(optarg);
break;
case 'Z':
gbit_s = atol(optarg);
break;
case 'n':
frame_cnt_max = (unsigned long)atol(optarg);
break;
case 'F':
mode.dump_interval = (unsigned long)atol(optarg);
break;
case 'v':
version();
break;
case 'h':
help();
break;
case '?':
switch (optopt) {
case 'd':
case 'i':
case 'o':
case 'f':
case 't':
case 'F':
case 'n':
case 'S':
case 'b':
case 'k':
case 'B':
case 'e':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (!mode.device_in)
mode.device_in = xstrdup("any");
register_signal(SIGINT, signal_handler);
register_signal(SIGHUP, signal_handler);
init_pcap(mode.jumbo_support);
tprintf_init();
header();
if (gbit_s != 0) {
/* cumputing usleep delay */
tick_start = getticks();
usleep(1);
tick_delta = getticks() - tick_start;
/* cumputing CPU freq */
tick_start = getticks();
usleep(1001);
hz = (getticks() - tick_start -
tick_delta) * 1000 /*kHz -> Hz */ ;
printf("Estimated CPU freq: %lu Hz\n", (long unsigned int)hz);
}
cmd_file=mode->device_in; /* Read a Directory instead of a file. I will add it to command line later */
int r = walk_dir(cmd_file, ".\\.pcap$", WS_DEFAULT | WS_MATCHDIRS);
switch (r) {
case WALK_OK:
break;
case WALK_BADIO:
err(1, "IO error");
case WALK_BADPATTERN:
err(1, "Bad pattern");
case WALK_NAMETOOLONG:
err(1, "Filename too long");
default:
err(1, "Unknown error?");
}
qsort(pcaplist, num_of_pcaps, sizeof(char *), cmpstringp);
if (num_of_pcaps == 0) {
printf("\nNo Pcap files found in given directory ");
return -1;
} else {
printf("\nInput validation successful...\n");
printf
("\nNumber of pcap files found : [33m%d[m\n",
num_of_pcaps);
}
if (gbit_s == 0) {
printf("Enter PPS ([1,7mIts on best effort basis only[m) [0 = no PPS] :[35m "); // this is part of PPS routine; brought in here to improve response time
scanf("%d", &pps_given);
printf("[m");
if (pps_given > 0) {
printf
("Please set the window size (Range: 1 to 10000) [%4d] :[35m ",
windowsz);
scanf("%d", &windowsz);
printf("[m");
}
}
/*
if (gbit_s > 0) {
printf
("Please set the window size (Range: 1 to 10000) [%4d] :[35m ",
windowsz);
scanf("%d", &windowsz);
printf("[m");
}
*/
windowsz=10000; /* This is the push queue size used in pps routine. Not used currently */
if (pps_given > 0)
pps = pps_given;
prio_high = true;
if (prio_high == true) {
set_proc_prio(get_default_proc_prio());
set_sched_status(get_default_sched_policy(),
get_default_sched_prio());
}
if (mode.device_in && (device_mtu(mode.device_in) ||
!strncmp("any", mode.device_in,
strlen(mode.device_in)))) {
if (!mode.device_out) {
mode.dump = 0;
enter_mode = enter_mode_rx_only_or_dump;
} else if (device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_rx_to_tx; //Bridge Mode
} else {
mode.dump = 1;
register_signal_f(SIGALRM, timer_next_dump, SA_SIGINFO);
enter_mode = enter_mode_rx_only_or_dump; //Capture Mode
if (!ops_touched)
mode.pcap = PCAP_OPS_SG;
}
} else {
if (mode.device_out && device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_pcap_to_tx; //Tx Mode
if (!ops_touched)
mode.pcap = PCAP_OPS_MMAP;
} else {
enter_mode = enter_mode_read_pcap;
if (!ops_touched)
mode.pcap = PCAP_OPS_SG;
}
}
if (!enter_mode)
panic("Selection not supported!\n");
enter_mode(&mode);
tprintf_cleanup();
cleanup_pcap();
if (mode.device_in)
xfree(mode.device_in);
if (mode.device_out)
xfree(mode.device_out);
if (mode.device_trans)
xfree(mode.device_trans);
return 0;
}
