/* parse the <VirtualHost> addresses */
const char *ap_parse_vhost_addrs(apr_pool_t *p,
const char *hostname,
server_rec *s)
{
server_addr_rec **addrs;
const char *err;
/* start the list of addreses */
addrs = &s->addrs;
while (hostname[0]) {
err = get_addresses(p, ap_getword_conf(p, &hostname), &addrs, s->port);
if (err) {
*addrs = NULL;
return err;
}
}
/* terminate the list */
*addrs = NULL;
if (s->addrs) {
if (s->addrs->host_port) {
/* override the default port which is inherited from main_server */
s->port = s->addrs->host_port;
}
}
return NULL;
}
int main(int argc, char **argv) {
char devicename[PROP_VALUE_MAX];
char buildid[PROP_VALUE_MAX];
int fd;
__system_property_get("ro.build.product", devicename);
__system_property_get("ro.build.id", buildid);
printf("ro.build.product=%s\n", devicename);
printf("ro.build.id=%s\n", buildid);
fd = open("/dev/kmem", O_RDONLY);
if (fd < 0) {
fprintf(stderr, "/dev/kmem open failed: %s.\n", strerror(errno));
return -1;
}
pmem = mmap(NULL, KERNEL_SIZE, PROT_READ, MAP_SHARED, fd, KERNEL_START_ADDRESS);
if (pmem == MAP_FAILED) {
fprintf(stderr, "mmap failed: %s.\n", strerror(errno));
close(fd);
return -1;
}
if (get_addresses() != 0) {
munmap(pmem, KERNEL_SIZE);
close(fd);
exit(EXIT_FAILURE);
}
munmap(pmem, KERNEL_SIZE);
close(fd);
exit(EXIT_SUCCESS);
return 0;
}
int
main(int argc, char **argv)
{
int ret;
pcap_wrapper *pw;
char ch, filter[128], is_usage = 0, show_version = 0;
while((ch = getopt(argc, argv, "s:p:i:S:Cd:l:hv")) != -1) {
switch(ch) {
case 's': opts.server = strdup(optarg); break;
case 'p': opts.port= atoi(optarg); break;
case 'i': opts.device = strdup(optarg); break;
case 'S': opts.script = strdup(optarg); break;
case 'C': opts.is_calc_mode = 1; break;
case 'd': opts.duration = atoi(optarg); break;
case 'l':
opts.specified_addresses = 1;
if (parse_addresses(optarg)) {
logger(ERROR, "parsing local addresses\n");
return EXIT_FAILURE;
}
break;
case 'f': opts.log_file = strdup(optarg); break;
case 'h': is_usage = 1; break;
case 'v': show_version= 1; break;
}
}
if( is_usage ) {
usage(argv[0]);
exit(0);
}
if(show_version) {
printf("%s version is %s\n", argv[0], VERSION);
exit(0);
}
if(!opts.specified_addresses && get_addresses() != 0) {
exit(0);
}
if (!opts.port) logger(ERROR, "port is required.\n");
if (!opts.device) logger(ERROR, "device is required.\n");
if (opts.log_file) set_log_file(opts.log_file);
if (!(pw = pw_create(opts.device))) logger(ERROR, "start captrue packet failed.\n");
if(opts.server) {
snprintf(filter, sizeof(filter), "host %s and tcp port %d", opts.server, opts.port);
} else {
snprintf(filter, sizeof(filter), "tcp port %d", opts.port);
}
check_lua_script();
// start capature loop.
ret = core_loop(pw, filter, process_packet);
if(ret == -1) logger(ERROR, "start core loop failed.\n");
pw_release(pw);
script_release(L);
return 0;
}
static void
rndc_start(isc_task_t *task, isc_event_t *event) {
isc_event_free(&event);
get_addresses(servername, (in_port_t) remoteport);
currentaddr = 0;
rndc_startconnect(&serveraddrs[currentaddr++], task);
}
int find_interfaces(struct rarpd *rarpd)
{
if (nl_open(&rarpd->nl_ctx) != 0) {
return -1;
}
if (get_links(rarpd) != 0) {
return -1;
}
if (get_addresses(rarpd) != 0) {
return -1;
}
nl_close(&rarpd->nl_ctx);
return 0;
}
int server_start(int lockfd)
{
int errsv;
int new_fd;
int sock;
pid_t pid;
socklen_t addr_size;
struct addrinfo *p = NULL;
struct sockaddr_storage their_addr;
char address[NI_MAXHOST];
char buf[sizeof(long)];
/* get addresses */
get_addresses(&p);
/* attempt bind to each address */
do {
getnameinfo(p->ai_addr, p->ai_addrlen, address, NI_MAXHOST,
NULL, 0, NI_NUMERICSERV);
syslog(LOG_DEBUG, "Binding to %s", address);
sock = get_socket(p); /* get a socket and bind */
if (sock != -1) break;
p = p->ai_next;
} while (p != NULL);
freeaddrinfo(p);
if (sock == -1) {
syslog(LOG_ERR, "Failed to bind. Exiting");
_exit(EXIT_FAILURE);
}
/* listening */
if (listen(sock, BACKLOG) == 0) {
syslog(LOG_INFO, "Listening on [%s]:%li", address,config->port);
}
else {
errsv = errno;
fprintf(stderr, "ERROR: %s\n", strerror(errsv));
syslog(LOG_ERR, "Failed to listen on [%s]:%li Exiting.",
address, config->port);
free_config();
_exit(EXIT_FAILURE);
}
/* drop privileges */
if (config->dropprivs) {
gid_t newgid = getgid();
setgroups(1, &newgid);
if (setuid(getuid()) != 0) {
fprintf(stderr,
"ERROR: Failed to drop root privileges. Exiting.\n");
exit(EXIT_FAILURE);
}
/* verify privileges cannot be restored */
if (setuid(0) != -1) {
fprintf(stderr,
"ERROR: Regained root privileges. Exiting.\n");
exit(EXIT_FAILURE);
}
}
addr_size = sizeof their_addr;
/* daemonize */
if (config->daemon == 0) {
if (daemon(0, 0) == -1) {
errsv = errno;
fprintf(stderr, "ERROR: %s\n", strerror(errsv));
syslog(LOG_ERR, "Failed to daemonize. Exiting.");
free_config();
exit(EXIT_FAILURE);
}
}
/* write pid to lockfile */
snprintf(buf, sizeof(long), "%ld\n", (long) getpid());
if (write(lockfd, buf, strlen(buf)) != strlen(buf)) {
fprintf(stderr, "Error writing to pidfile\n");
exit(EXIT_FAILURE);
}
/* install exit handler to kill child procs */
atexit(killhandlerprocs);
for (;;) {
/* incoming! */
++hits;
new_fd = accept(sock, (struct sockaddr *)&their_addr,
&addr_size);
pid = fork(); /* fork new process to handle connection */
if (pid == -1) {
/* fork failed */
close(new_fd);
close(sock);
return -1;
}
else if (pid == 0) {
/* let the children play */
close(sock); /* children never listen */
handle_connection(new_fd, their_addr);
}
else {
/* parent can close connection */
handler_procs++;
close(new_fd);
}
}
}
API_EXPORT_NONSTD(const char *) ap_set_name_virtual_host (cmd_parms *cmd, void *dummy, char *arg)
{
/* use whatever port the main server has at this point */
return get_addresses(cmd->pool, arg, &name_vhost_list_tail,
cmd->server->port);
}
int
main(int argc, char **argv) {
isc_boolean_t show_final_mem = ISC_FALSE;
isc_result_t result = ISC_R_SUCCESS;
isc_taskmgr_t *taskmgr = NULL;
isc_task_t *task = NULL;
isc_log_t *log = NULL;
isc_logconfig_t *logconfig = NULL;
isc_logdestination_t logdest;
cfg_parser_t *pctx = NULL;
cfg_obj_t *config = NULL;
const char *keyname = NULL;
struct in_addr in;
struct in6_addr in6;
char *p;
size_t argslen;
int ch;
int i;
result = isc_file_progname(*argv, program, sizeof(program));
if (result != ISC_R_SUCCESS)
memcpy(program, "rndc", 5);
progname = program;
admin_conffile = RNDC_CONFFILE;
admin_keyfile = RNDC_KEYFILE;
isc_sockaddr_any(&local4);
isc_sockaddr_any6(&local6);
result = isc_app_start();
if (result != ISC_R_SUCCESS)
fatal("isc_app_start() failed: %s", isc_result_totext(result));
isc_commandline_errprint = ISC_FALSE;
while ((ch = isc_commandline_parse(argc, argv, "b:c:hk:Mmp:s:Vy:"))
!= -1) {
switch (ch) {
case 'b':
if (inet_pton(AF_INET, isc_commandline_argument,
&in) == 1) {
isc_sockaddr_fromin(&local4, &in, 0);
local4set = ISC_TRUE;
} else if (inet_pton(AF_INET6, isc_commandline_argument,
&in6) == 1) {
isc_sockaddr_fromin6(&local6, &in6, 0);
local6set = ISC_TRUE;
}
break;
case 'c':
admin_conffile = isc_commandline_argument;
break;
case 'k':
admin_keyfile = isc_commandline_argument;
break;
case 'M':
isc_mem_debugging = ISC_MEM_DEBUGTRACE;
break;
case 'm':
show_final_mem = ISC_TRUE;
break;
case 'p':
remoteport = atoi(isc_commandline_argument);
if (remoteport > 65535 || remoteport == 0)
fatal("port '%s' out of range",
isc_commandline_argument);
break;
case 's':
servername = isc_commandline_argument;
break;
case 'V':
verbose = ISC_TRUE;
break;
case 'y':
keyname = isc_commandline_argument;
break;
case '?':
if (isc_commandline_option != '?') {
fprintf(stderr, "%s: invalid argument -%c\n",
program, isc_commandline_option);
usage(1);
}
case 'h':
usage(0);
break;
default:
fprintf(stderr, "%s: unhandled option -%c\n",
program, isc_commandline_option);
exit(1);
}
}
argc -= isc_commandline_index;
argv += isc_commandline_index;
if (argc < 1)
usage(1);
isc_random_get(&serial);
DO("create memory context", isc_mem_create(0, 0, &mctx));
DO("create socket manager", isc_socketmgr_create(mctx, &socketmgr));
DO("create task manager", isc_taskmgr_create(mctx, 1, 0, &taskmgr));
DO("create task", isc_task_create(taskmgr, 0, &task));
DO("create logging context", isc_log_create(mctx, &log, &logconfig));
isc_log_setcontext(log);
DO("setting log tag", isc_log_settag(logconfig, progname));
logdest.file.stream = stderr;
logdest.file.name = NULL;
logdest.file.versions = ISC_LOG_ROLLNEVER;
logdest.file.maximum_size = 0;
DO("creating log channel",
isc_log_createchannel(logconfig, "stderr",
ISC_LOG_TOFILEDESC, ISC_LOG_INFO, &logdest,
ISC_LOG_PRINTTAG|ISC_LOG_PRINTLEVEL));
DO("enabling log channel", isc_log_usechannel(logconfig, "stderr",
NULL, NULL));
parse_config(mctx, log, keyname, &pctx, &config);
isccc_result_register();
command = *argv;
/*
* Convert argc/argv into a space-delimited command string
* similar to what the user might enter in interactive mode
* (if that were implemented).
*/
argslen = 0;
for (i = 0; i < argc; i++)
argslen += strlen(argv[i]) + 1;
args = isc_mem_get(mctx, argslen);
if (args == NULL)
DO("isc_mem_get", ISC_R_NOMEMORY);
p = args;
for (i = 0; i < argc; i++) {
size_t len = strlen(argv[i]);
memcpy(p, argv[i], len);
p += len;
*p++ = ' ';
}
p--;
*p++ = '\0';
INSIST(p == args + argslen);
notify("%s", command);
if (strcmp(command, "restart") == 0)
fatal("'%s' is not implemented", command);
if (nserveraddrs == 0)
get_addresses(servername, (in_port_t) remoteport);
DO("post event", isc_app_onrun(mctx, task, rndc_start, NULL));
result = isc_app_run();
if (result != ISC_R_SUCCESS)
fatal("isc_app_run() failed: %s", isc_result_totext(result));
if (connects > 0 || sends > 0 || recvs > 0)
isc_socket_cancel(sock, task, ISC_SOCKCANCEL_ALL);
isc_task_detach(&task);
isc_taskmgr_destroy(&taskmgr);
isc_socketmgr_destroy(&socketmgr);
isc_log_destroy(&log);
isc_log_setcontext(NULL);
cfg_obj_destroy(pctx, &config);
cfg_parser_destroy(&pctx);
isc_mem_put(mctx, args, argslen);
isccc_ccmsg_invalidate(&ccmsg);
dns_name_destroy();
if (show_final_mem)
isc_mem_stats(mctx, stderr);
isc_mem_destroy(&mctx);
if (failed)
return (1);
return (0);
}
static void
parse_config(isc_mem_t *mctx, isc_log_t *log, const char *keyname,
cfg_parser_t **pctxp, cfg_obj_t **configp)
{
isc_result_t result;
const char *conffile = admin_conffile;
const cfg_obj_t *addresses = NULL;
const cfg_obj_t *defkey = NULL;
const cfg_obj_t *options = NULL;
const cfg_obj_t *servers = NULL;
const cfg_obj_t *server = NULL;
const cfg_obj_t *keys = NULL;
const cfg_obj_t *key = NULL;
const cfg_obj_t *defport = NULL;
const cfg_obj_t *secretobj = NULL;
const cfg_obj_t *algorithmobj = NULL;
cfg_obj_t *config = NULL;
const cfg_obj_t *address = NULL;
const cfg_listelt_t *elt;
const char *secretstr;
const char *algorithm;
static char secretarray[1024];
const cfg_type_t *conftype = &cfg_type_rndcconf;
isc_boolean_t key_only = ISC_FALSE;
const cfg_listelt_t *element;
if (! isc_file_exists(conffile)) {
conffile = admin_keyfile;
conftype = &cfg_type_rndckey;
if (! isc_file_exists(conffile))
fatal("neither %s nor %s was found",
admin_conffile, admin_keyfile);
key_only = ISC_TRUE;
}
DO("create parser", cfg_parser_create(mctx, log, pctxp));
/*
* The parser will output its own errors, so DO() is not used.
*/
result = cfg_parse_file(*pctxp, conffile, conftype, &config);
if (result != ISC_R_SUCCESS)
fatal("could not load rndc configuration");
if (!key_only)
(void)cfg_map_get(config, "options", &options);
if (key_only && servername == NULL)
servername = "127.0.0.1";
else if (servername == NULL && options != NULL) {
const cfg_obj_t *defserverobj = NULL;
(void)cfg_map_get(options, "default-server", &defserverobj);
if (defserverobj != NULL)
servername = cfg_obj_asstring(defserverobj);
}
if (servername == NULL)
fatal("no server specified and no default");
if (!key_only) {
(void)cfg_map_get(config, "server", &servers);
if (servers != NULL) {
for (elt = cfg_list_first(servers);
elt != NULL;
elt = cfg_list_next(elt))
{
const char *name;
server = cfg_listelt_value(elt);
name = cfg_obj_asstring(cfg_map_getname(server));
if (strcasecmp(name, servername) == 0)
break;
server = NULL;
}
}
}
/*
* Look for the name of the key to use.
*/
if (keyname != NULL)
; /* Was set on command line, do nothing. */
else if (server != NULL) {
DO("get key for server", cfg_map_get(server, "key", &defkey));
keyname = cfg_obj_asstring(defkey);
} else if (options != NULL) {
DO("get default key", cfg_map_get(options, "default-key",
&defkey));
keyname = cfg_obj_asstring(defkey);
} else if (!key_only)
fatal("no key for server and no default");
/*
* Get the key's definition.
*/
if (key_only)
DO("get key", cfg_map_get(config, "key", &key));
else {
DO("get config key list", cfg_map_get(config, "key", &keys));
for (elt = cfg_list_first(keys);
elt != NULL;
elt = cfg_list_next(elt))
{
key = cfg_listelt_value(elt);
if (strcasecmp(cfg_obj_asstring(cfg_map_getname(key)),
keyname) == 0)
break;
}
if (elt == NULL)
fatal("no key definition for name %s", keyname);
}
(void)cfg_map_get(key, "secret", &secretobj);
(void)cfg_map_get(key, "algorithm", &algorithmobj);
if (secretobj == NULL || algorithmobj == NULL)
fatal("key must have algorithm and secret");
secretstr = cfg_obj_asstring(secretobj);
algorithm = cfg_obj_asstring(algorithmobj);
if (strcasecmp(algorithm, "hmac-md5") != 0)
fatal("unsupported algorithm: %s", algorithm);
secret.rstart = (unsigned char *)secretarray;
secret.rend = (unsigned char *)secretarray + sizeof(secretarray);
DO("decode base64 secret", isccc_base64_decode(secretstr, &secret));
secret.rend = secret.rstart;
secret.rstart = (unsigned char *)secretarray;
/*
* Find the port to connect to.
*/
if (remoteport != 0)
; /* Was set on command line, do nothing. */
else {
if (server != NULL)
(void)cfg_map_get(server, "port", &defport);
if (defport == NULL && options != NULL)
(void)cfg_map_get(options, "default-port", &defport);
}
if (defport != NULL) {
remoteport = cfg_obj_asuint32(defport);
if (remoteport > 65535 || remoteport == 0)
fatal("port %u out of range", remoteport);
} else if (remoteport == 0)
remoteport = NS_CONTROL_PORT;
if (server != NULL)
result = cfg_map_get(server, "addresses", &addresses);
else
result = ISC_R_NOTFOUND;
if (result == ISC_R_SUCCESS) {
for (element = cfg_list_first(addresses);
element != NULL;
element = cfg_list_next(element))
{
isc_sockaddr_t sa;
address = cfg_listelt_value(element);
if (!cfg_obj_issockaddr(address)) {
unsigned int myport;
const char *name;
const cfg_obj_t *obj;
obj = cfg_tuple_get(address, "name");
name = cfg_obj_asstring(obj);
obj = cfg_tuple_get(address, "port");
if (cfg_obj_isuint32(obj)) {
myport = cfg_obj_asuint32(obj);
if (myport > ISC_UINT16_MAX ||
myport == 0)
fatal("port %u out of range",
myport);
} else
myport = remoteport;
if (nserveraddrs < SERVERADDRS)
get_addresses(name, (in_port_t) myport);
else
fprintf(stderr, "too many address: "
"%s: dropped\n", name);
continue;
}
sa = *cfg_obj_assockaddr(address);
if (isc_sockaddr_getport(&sa) == 0)
isc_sockaddr_setport(&sa, remoteport);
if (nserveraddrs < SERVERADDRS)
serveraddrs[nserveraddrs++] = sa;
else {
char socktext[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_format(&sa, socktext,
sizeof(socktext));
fprintf(stderr,
"too many address: %s: dropped\n",
socktext);
}
}
}
if (!local4set && server != NULL) {
address = NULL;
cfg_map_get(server, "source-address", &address);
if (address != NULL) {
local4 = *cfg_obj_assockaddr(address);
local4set = ISC_TRUE;
}
}
if (!local4set && options != NULL) {
address = NULL;
cfg_map_get(options, "default-source-address", &address);
if (address != NULL) {
local4 = *cfg_obj_assockaddr(address);
local4set = ISC_TRUE;
}
}
if (!local6set && server != NULL) {
address = NULL;
cfg_map_get(server, "source-address-v6", &address);
if (address != NULL) {
local6 = *cfg_obj_assockaddr(address);
local6set = ISC_TRUE;
}
}
if (!local6set && options != NULL) {
address = NULL;
cfg_map_get(options, "default-source-address-v6", &address);
if (address != NULL) {
local6 = *cfg_obj_assockaddr(address);
local6set = ISC_TRUE;
}
}
*configp = config;
}
/*
* Query or search the SRV RRs for a given name.
*
* If dname == NULL then search (as in res_nsearch(3RESOLV), honoring any
* search list/option), else query (as in res_nquery(3RESOLV)).
*
* The output TTL will be the one of the SRV RR with the lowest TTL.
*/
ad_disc_cds_t *
srv_query(res_state state, const char *svc_name, const char *dname,
ad_disc_ds_t *prefer)
{
ad_disc_cds_t *cds_res = NULL;
uchar_t *msg = NULL;
int len, scnt, maxcnt;
msg = malloc(NS_MAXMSG);
if (msg == NULL) {
logger(LOG_ERR, "Out of memory");
return (NULL);
}
/* query necessary resource records */
/* Search, querydomain or query */
if (dname == NULL) {
dname = "*";
if (DBG(DNS, 1)) {
logger(LOG_DEBUG, "Looking for SRV RRs '%s.*'",
svc_name);
}
len = res_nsearch(state, svc_name, C_IN, T_SRV,
msg, NS_MAXMSG);
if (len < 0) {
if (DBG(DNS, 0)) {
logger(LOG_DEBUG,
"DNS search for '%s' failed (%s)",
svc_name, hstrerror(state->res_h_errno));
}
goto errout;
}
} else { /* dname != NULL */
if (DBG(DNS, 1)) {
logger(LOG_DEBUG, "Looking for SRV RRs '%s.%s' ",
svc_name, dname);
}
len = res_nquerydomain(state, svc_name, dname, C_IN, T_SRV,
msg, NS_MAXMSG);
if (len < 0) {
if (DBG(DNS, 0)) {
logger(LOG_DEBUG, "DNS: %s.%s: %s",
svc_name, dname,
hstrerror(state->res_h_errno));
}
goto errout;
}
}
if (len > NS_MAXMSG) {
logger(LOG_WARNING,
"DNS query %ib message doesn't fit into %ib buffer",
len, NS_MAXMSG);
len = NS_MAXMSG;
}
/* parse the reply header */
cds_res = srv_parse(msg, len, &scnt, &maxcnt);
if (cds_res == NULL)
goto errout;
if (prefer != NULL)
add_preferred(cds_res, prefer, &scnt, maxcnt);
get_addresses(cds_res, scnt);
/* sort list of candidates */
if (scnt > 1)
qsort(cds_res, scnt, sizeof (*cds_res),
(int (*)(const void *, const void *))srvcmp);
free(msg);
return (cds_res);
errout:
free(msg);
return (NULL);
}
int
main(int argc, char *argv[]) {
struct sigaction sa;
char c;
int option_index = 0;
// Program name
program_name = strrchr(argv[0], '/');
if (program_name)
program_name ++;
else
program_name = argv[0];
// Parse command line options
do {
c = getopt_long(argc, argv, short_options, long_options, &option_index);
switch (c) {
case -1:
break;
case 'r':
capture_file = fopen(optarg, "r");
if (!capture_file) {
LOGGER(ERROR, "Cannot open file '%s': %s\n", optarg,
strerror(errno));
return EXIT_FAILURE;
}
break;
case 'l':
specified_addresses = 1;
if (parse_addresses(optarg)) {
LOGGER(ERROR, "Error parsing local addresses\n");
return EXIT_FAILURE;
}
break;
case 'p':
port = strdup(optarg);
break;
case 'f':
if (!check_format(optarg)) {
LOGGER(ERROR, "Bad format provided: `%s'\n", optarg);
return EXIT_FAILURE;
}
global_options.format = optarg;
break;
case 't':
global_options.interval = strtoul(optarg, NULL, 10);
if (interval <= 0 || interval >= MAX_OUTPUT_INTERVAL) {
LOGGER(ERROR, "Bad interval provided\n");
return EXIT_FAILURE;
}
break;
case 'n':
global_options.iterations = strtol(optarg, NULL, 10);
if (interval < 0) {
LOGGER(ERROR, "Bad iterations provided\n");
return EXIT_FAILURE;
}
break;
case 'T':
global_options.threshold = strtol(optarg, NULL, 10) * 1000;
if (global_options.threshold < 0) {
LOGGER(ERROR, "Bad threshold provided\n");
return EXIT_FAILURE;
}
break;
case 'd':
global_options.server = strdup(optarg);
break;
case 'i':
global_options.interface = strdup(optarg);
break;
case 'c':
global_options.is_client = 1;
break;
case 's':
global_options.header = optarg;
global_options.show_header = 1;
break;
case 'S':
global_options.show_header = 0;
break;
case 'h':
dump_help(stdout);
return EXIT_SUCCESS;
case 'V':
dump_version(stdout);
return EXIT_SUCCESS;
default:
dump_usage(stderr);
return EXIT_FAILURE;
}
}
while (c != -1);
if(! global_options.interface) {
global_options.interface = "any";
}
if(global_options.is_client) {
if(!global_options.server) {
LOGGER(ERROR, "%s -d destination server is required.\n", argv[0]);
return 0;
}
}
if(global_options.server) {
global_options.is_client = 1;
}
if(!port) {
LOGGER(ERROR, "%s -p port is required.\n", argv[0]);
return 0;
}
// Set up signals
sa.sa_handler = terminate;
sigemptyset(&sa.sa_mask);
sigaddset(&sa.sa_mask, SIGTERM);
sigaddset(&sa.sa_mask, SIGINT);
sa.sa_flags = 0;
sa.sa_restorer = NULL;
sigaction(SIGTERM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
// Get local addresses
if (!specified_addresses && get_addresses() != 0)
return EXIT_FAILURE;
// Operations timestamp
time(×tamp);
// Stats
init_stats();
if (capture_file) {
output_offline_start(&global_options);
offline_capture(capture_file);
fclose(capture_file);
}
else {
// Fire up capturing thread
pthread_create(&capture_thread_id, NULL, capture, NULL);
if(!global_options.threshold) {
// Options thread
pthread_create(&output_thread_id, NULL, output_thread, &global_options);
pthread_kill(output_thread_id, SIGINT);
}
pthread_join(capture_thread_id, NULL);
}
free_stats();
free_addresses();
free(global_options.server);
return EXIT_SUCCESS;
}