int main(int argc, char *argv[])
{
if(argc != 4) {
printf("usage: %s -i <device> <host> or\n", argv[0]);
printf("usage: %s -p <capfile> <host>\n" , argv[0]);
return 1;
}
if(g_ascii_strncasecmp(argv[1], "-i", 2) == 0) {
pcap_init(LIVE, argv[2], argv[3]);
} else {
pcap_init(OFF_LINE, argv[2], argv[3]);
}
return 0;
}
/********************************************************************************
* main...
*/
int
main(int argc, char *argv[])
{
co_rc_t rc;
HANDLE daemon_handle = 0;
HANDLE pcap_thread;
start_parameters_t start_parameters;
int exit_code = 0;
co_daemon_handle_t daemon_handle_;
rc = handle_paramters(&start_parameters, argc, argv);
if (!CO_OK(rc))
return -1;
if (start_parameters.show_help) {
co_net_syntax();
return 0;
}
if (!start_parameters.mac_specified) {
printf("Error, MAC address not specified\n");
return CO_RC(ERROR);
}
if (start_parameters.index == -1) {
printf("Error, index not specified\n");
return CO_RC(ERROR);
}
daemon_parameters = &start_parameters;
exit_code = pcap_init();
if (exit_code) {
co_debug("Error initializing winPCap\n");
goto out;
}
rc = co_os_open_daemon_pipe(daemon_parameters->instance,
CO_MODULE_CONET0 + daemon_parameters->index, &daemon_handle_);
if (!CO_OK(rc)) {
co_debug("Error opening a pipe to the daemon\n");
goto out;
}
pcap_thread = CreateThread(NULL, 0, pcap2Daemon, NULL, 0, NULL);
if (pcap_thread == NULL) {
co_debug("Failed to spawn pcap_thread\n");
goto out;
}
daemon_handle = daemon_handle_->handle;
exit_code = wait_loop(daemon_handle);
co_os_daemon_close(daemon_handle_);
out:
ExitProcess(exit_code);
return exit_code;
}
int
main(int argc, char *argv[])
{
int c, sock;
char *intf, *filter, ebuf[PCAP_ERRBUF_SIZE];
pcap_t *pd;
intf = NULL;
while ((c = getopt(argc, argv, "i:n:Ih?V")) != -1) {
switch (c) {
case 'i':
intf = optarg;
break;
case 'n':
Opt_nice = atoi(optarg);
if (Opt_nice < MIN_NICE || Opt_nice > MAX_NICE)
usage();
break;
case 'I':
Opt_icmp = 1;
break;
default:
usage();
break;
}
}
if (intf == NULL && (intf = pcap_lookupdev(ebuf)) == NULL)
errx(1, "%s", ebuf);
argc -= optind;
argv += optind;
if (argc == 0)
usage();
filter = copy_argv(argv);
if ((pd = pcap_init(intf, filter, 128)) == NULL)
errx(1, "couldn't initialize sniffing");
if ((pcap_off = pcap_dloff(pd)) < 0)
errx(1, "couldn't determine link layer offset");
if ((sock = libnet_open_raw_sock(IPPROTO_RAW)) == -1)
errx(1, "couldn't initialize sending");
warnx("listening on %s [%s]", intf, filter);
tcp_nice_loop(pd, sock);
/* NOTREACHED */
exit(0);
}
int main(int argc, char *argv[])
{
unsigned int port;
int opt;
unsigned long delay;
pid_t pid;
char *interface, *endptr;
char libnet_ebuf[LIBNET_ERRBUF_SIZE];
pcap_t *pcap;
char pcap_expr[100];
libnet_t *libnet;
u_int32_t target_addr, source_addr;
struct sigaction sa;
interface = NULL;
while ((opt = getopt(argc, argv, "i:")) != -1) {
switch (opt) {
case 'i':
interface = optarg;
break;
default:
usage();
break;
}
}
argc -= optind;
argv += optind;
if (argc != 3) {
usage();
}
port = strtoul(argv[1], &endptr, 10);
if ((*endptr != '\0') || port < 1 || port > 65535) {
errx(1, "Invalid port: %s", argv[1]);
}
errno = 0;
delay = strtoul(argv[2], &endptr, 10);
if (*endptr != '\0') {
errx(1, "invalid delay: %s", argv[2]);
} else if ((errno == ERANGE &&
(delay == LONG_MAX)) ||
(errno != 0 && delay == 0)) {
errx(1, "invalid delay (%s): %s", strerror(errno), argv[2]);
}
/* Initialize libnet */
if ((libnet = libnet_init(LIBNET_RAW4, interface, libnet_ebuf)) == NULL) {
errx(1, "couldn't initialize libnet: %s", libnet_ebuf);
}
if ((target_addr = libnet_name2addr4(libnet, argv[0], LIBNET_RESOLVE)) == -1) {
errx(1, "could not resolve target %s", argv[0]);
}
if ((source_addr = libnet_get_ipaddr4(libnet)) == -1) {
errx(1, "could not get local IP: %s", libnet_ebuf);
}
/* Initialize pcap */
snprintf(pcap_expr, 99, "tcp and tcp[tcpflags] == 18 and src host %s and port %s",
argv[0], argv[1]);
if ((pcap = pcap_init(interface, pcap_expr, 64)) == NULL)
errx(1, "couldn't initialize sniffing");
if ((pcap_off = pcap_dloff(pcap)) < 0)
errx(1, "couldn't determine link layer offset");
/* Fork */
pid = fork();
if (pid == -1)
errx(1, "fork failed");
else if (pid == 0)
send_syns(libnet, source_addr, target_addr, port, delay);
else {
child_pid = pid;
sa.sa_handler = &handle_signal;
sigaction(SIGINT, &sa, NULL);
sigaction(SIGQUIT, &sa, NULL);
sigaction(SIGTERM, &sa, NULL);
send_acks(pcap, libnet);
}
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
dhcpctl_handle conn = NULL;
char *conffile=NULL;
char ch;
name = strdup("OMAPI");
openlog("dhcparpd", LOG_PID, LOG_DAEMON);
/* Parse Commandline Options */
while((ch = getopt(argc, argv, "c:dh")) != -1) {
switch(ch){
case 'c':
conffile = strdup(optarg);
break;
case 'd':
do_daemonise=0;
break;
case 'h':
usage(argv[0]);
return 0;
default:
fprintf(stderr, "Unknown option '%c'!", ch);
usage(argv[0]);
return 1;
}
}
/* Try a default configfile if non specified */
if (conffile==NULL) {
conffile = strdup("/etc/dhcparpd.conf");
}
if (parse_config(config,conffile)) {
fprintf(stderr,"Unable to parse configfile: %s\n",
conffile);
return 1;
}
free(conffile);
/* Daemonise */
if (do_daemonise) {
daemonise(argv[0]);
put_pid(pidfile);
}
parse_mappings();
conn = dhcpd_connect(servername, port, name, key);
if (!conn) {
Log(LOG_CRIT, "failed to connect to dhcp server");
return 1;
}
arp_init(interface,conn);
init_event();
init_netlink();
if (pcap_init(interface))
return 1;
Log(LOG_NOTICE, "Ready for action! Lets Go...");
run();
return 0;
}
int
main(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
int c;
char *intf, *filter, ebuf[PCAP_ERRBUF_SIZE];
char libnet_ebuf[LIBNET_ERRBUF_SIZE];
libnet_t *l;
pcap_t *pd;
intf = NULL;
while ((c = getopt(argc, argv, "i:AIMh?V")) != -1) {
switch (c) {
case 'i':
intf = optarg;
break;
case 'A':
Opt_win = 1;
break;
case 'I':
Opt_icmp = 1;
break;
case 'M':
Opt_pmtu = 1;
break;
default:
usage();
break;
}
}
if (intf == NULL && (intf = pcap_lookupdev(ebuf)) == NULL)
errx(1, "%s", ebuf);
argc -= optind;
argv += optind;
if (argc == 0)
usage();
if ((Opt_win | Opt_icmp | Opt_pmtu) == 0)
Opt_win = Opt_icmp = Opt_pmtu = 1;
filter = copy_argv(argv);
if ((pd = pcap_init(intf, filter, 128)) == NULL)
errx(1, "couldn't initialize sniffing");
if ((pcap_off = pcap_dloff(pd)) < 0)
errx(1, "couldn't determine link layer offset");
if ((l = libnet_init(LIBNET_RAW4, intf, libnet_ebuf)) == NULL)
errx(1, "couldn't initialize sending");
libnet_seed_prand(l);
warnx("listening on %s [%s]", intf, filter);
pcap_loop(pd, -1, tcp_nice_cb, (u_char *)l);
/* NOTREACHED */
exit(0);
}
int
main(int argc, char *argv[])
{
extern char *optarg;
extern int optind;
int c;
char *p, *intf, *filter, ebuf[PCAP_ERRBUF_SIZE];
char libnet_ebuf[LIBNET_ERRBUF_SIZE];
libnet_t *l;
intf = NULL;
while ((c = getopt(argc, argv, "i:m:123456789h?V")) != -1) {
switch (c) {
case 'i':
intf = optarg;
break;
case 'm':
Opt_max_kill = atoi(optarg);
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
p = argv[optind - 1];
if (p[0] == '-' && p[1] == c && p[2] == '\0')
Opt_severity = atoi(++p);
else
Opt_severity = atoi(argv[optind] + 1);
break;
default:
usage();
break;
}
}
if (intf == NULL && (intf = pcap_lookupdev(ebuf)) == NULL)
errx(1, "%s", ebuf);
argc -= optind;
argv += optind;
if (argc == 0)
usage();
filter = copy_argv(argv);
if ((pd = pcap_init(intf, filter, 64)) == NULL)
errx(1, "couldn't initialize sniffing");
if ((pcap_off = pcap_dloff(pd)) < 0)
errx(1, "couldn't determine link layer offset");
if ((l = libnet_init(LIBNET_RAW4, intf, libnet_ebuf)) == NULL)
errx(1, "couldn't initialize sending");
libnet_seed_prand(l);
warnx("listening on %s [%s]", intf, filter);
pcap_loop(pd, -1, tcp_kill_cb, (u_char *)l);
/* NOTREACHED */
exit(0);
}
