int
skTimerCreateAtTime(
sk_timer_t **new_timer,
uint32_t interval,
sktime_t start,
skTimerFn_t callback_fn,
void *callback_data)
{
#if TRACEMSG_LEVEL > 0
char tstamp[SKTIMESTAMP_STRLEN];
#endif
sk_timer_t *timer;
pthread_t thread;
int err;
timer = (sk_timer_t *)calloc(1, sizeof(sk_timer_t));
if (NULL == timer) {
return errno;
}
timer->interval = (int64_t)interval;
timer->callback_fn = callback_fn;
timer->callback_data = callback_data;
timer->base_time.tv_sec = sktimeGetSeconds(start);
timer->base_time.tv_usec = sktimeGetMilliseconds(start) * 1000;
pthread_mutex_init(&timer->mutex, NULL);
pthread_cond_init(&timer->cond, NULL);
TRACEMSG(1, (("Timer %p: Created with interval=%" PRId64
", start_time=%sZ"),
(void *)timer, timer->interval,
sktimestamp_r(tstamp, start, SKTIMESTAMP_UTC)));
/* Mutex starts locked */
sk_timer_lock(timer);
timer->started = 1;
err = skthread_create_detached("sktimer", &thread, sk_timer_thread,
(void *)timer);
if (err) {
timer->started = 0;
sk_timer_unlock(timer);
TRACEMSG(1, ("Timer %p: Failed to start; errno = %d",
(void *)timer, err));
skTimerDestroy(timer);
return err;
}
sk_timer_unlock(timer);
TRACEMSG(1, ("Timer %p: Started", (void *)timer));
*new_timer = timer;
return 0;
}
static void
printRecords(
const rwRec rec[])
{
char starttime[2][RWCOMPARE_BUFSIZ];
uint32_t elapsed[2];
uint32_t sport[2];
uint32_t dport[2];
uint32_t proto[2];
uint32_t flowtype[2];
uint32_t sensor[2];
uint32_t flags[2];
uint32_t initflags[2];
uint32_t restflags[2];
uint32_t tcpstate[2];
uint32_t application[2];
uint32_t memo[2];
uint32_t input[2];
uint32_t output[2];
uint32_t pkts[2];
uint32_t bytes[2];
char sip[2][RWCOMPARE_BUFSIZ];
char dip[2][RWCOMPARE_BUFSIZ];
char nhip[2][RWCOMPARE_BUFSIZ];
skipaddr_t ip;
unsigned i;
for (i = 0; i < 2; ++i) {
sktimestamp_r(
starttime[i], rwRecGetStartTime(&rec[i]), SKTIMESTAMP_EPOCH);
elapsed[i] = rwRecGetElapsed(&rec[i]);
sport[i] = rwRecGetSPort(&rec[i]);
dport[i] = rwRecGetDPort(&rec[i]);
proto[i] = rwRecGetProto(&rec[i]);
flowtype[i] = rwRecGetFlowType(&rec[i]);
sensor[i] = rwRecGetSensor(&rec[i]);
flags[i] = rwRecGetFlags(&rec[i]);
initflags[i] = rwRecGetInitFlags(&rec[i]);
restflags[i] = rwRecGetRestFlags(&rec[i]);
tcpstate[i] = rwRecGetTcpState(&rec[i]);
application[i] = rwRecGetApplication(&rec[i]);
memo[i] = rwRecGetMemo(&rec[i]);
input[i] = rwRecGetInput(&rec[i]);
output[i] = rwRecGetOutput(&rec[i]);
pkts[i] = rwRecGetPkts(&rec[i]);
bytes[i] = rwRecGetBytes(&rec[i]);
rwRecMemGetSIP(&rec[i], &ip);
skipaddrString(sip[i], &ip, SKIPADDR_HEXADECIMAL);
rwRecMemGetDIP(&rec[i], &ip);
skipaddrString(dip[i], &ip, SKIPADDR_HEXADECIMAL);
rwRecMemGetNhIP(&rec[i], &ip);
skipaddrString(nhip[i], &ip, SKIPADDR_HEXADECIMAL);
}
compareStrings("StartTime", starttime);
compareNumbers("Elapsed", elapsed);
compareNumbers("SPort", sport);
compareNumbers("DPort", dport);
compareNumbers("Proto", proto);
compareNumbers("FlowType", flowtype);
compareNumbers("Sensor", sensor);
compareNumbers("Flags", flags);
compareNumbers("InitFlags", initflags);
compareNumbers("RestFlags", restflags);
compareNumbers("TcpState", tcpstate);
compareNumbers("Application", application);
compareNumbers("Memo", memo);
compareNumbers("Input", input);
compareNumbers("Output", output);
compareNumbers("Pkts", pkts);
compareNumbers("Bytes", bytes);
compareStrings("SIP", sip);
compareStrings("DIP", dip);
compareStrings("NhIP", nhip);
}
/*
* appSetup(argc, argv);
*
* Perform all the setup for this application include setting up
* required modules, parsing options, etc. This function should be
* passed the same arguments that were passed into main().
*
* Returns to the caller if all setup succeeds. If anything fails,
* this function will cause the application to exit with a FAILURE
* exit status.
*/
void
appSetup(
int argc,
char **argv)
{
SILK_FEATURES_DEFINE_STRUCT(features);
int optctx_flags;
sktime_t t;
unsigned int end_precision;
unsigned int is_epoch;
int64_t bin_count;
int rv;
/* make sure count of option's declarations and help-strings match */
assert((sizeof(appOptions)/sizeof(struct option)) ==
(sizeof(appHelp)/sizeof(char *)));
/* register the application */
skAppRegister(argv[0]);
skAppVerifyFeatures(&features, NULL);
skOptionsSetUsageCallback(&appUsageLong);
/* initialize globals */
memset(&flags, 0, sizeof(flags));
flags.delimiter = '|';
flags.load_scheme = DEFAULT_LOAD_SCHEME;
memset(&output, 0, sizeof(output));
output.of_fp = stdout;
memset(&bins, 0, sizeof(bins));
bins.start_time = RWCO_UNINIT_START;
bins.end_time = RWCO_UNINIT_END;
bins.size = DEFAULT_BINSIZE;
optctx_flags = (SK_OPTIONS_CTX_INPUT_SILK_FLOW | SK_OPTIONS_CTX_ALLOW_STDIN
| SK_OPTIONS_CTX_XARGS | SK_OPTIONS_CTX_PRINT_FILENAMES
| SK_OPTIONS_CTX_COPY_INPUT);
/* register the options */
if (skOptionsCtxCreate(&optctx, optctx_flags)
|| skOptionsCtxOptionsRegister(optctx)
|| skOptionsRegister(appOptions, &appOptionsHandler, NULL)
|| skOptionsRegister(deprecatedOptions, &appOptionsHandler, NULL)
|| skOptionsRegister(deprecatedOptionsShort, &appOptionsHandler, NULL)
|| sksiteOptionsRegister(SK_SITE_FLAG_CONFIG_FILE))
{
skAppPrintErr("Unable to register options");
exit(EXIT_FAILURE);
}
/* register the teardown handler */
if (atexit(appTeardown) < 0) {
skAppPrintErr("Unable to register appTeardown() with atexit()");
appTeardown();
exit(EXIT_FAILURE);
}
/* parse options; print usage if error */
rv = skOptionsCtxOptionsParse(optctx, argc, argv);
if (rv < 0) {
skAppUsage();
}
/* try to load site config file; if it fails, we will not be able
* to resolve flowtype and sensor from input file names */
sksiteConfigure(0);
/* parse the times */
if (start_time) {
rv = skStringParseDatetime(&bins.start_time, start_time, NULL);
if (rv) {
skAppPrintErr("Invalid %s '%s': %s",
appOptions[OPT_START_TIME].name, start_time,
skStringParseStrerror(rv));
exit(EXIT_FAILURE);
}
}
if (end_time) {
rv = skStringParseDatetime(&t, end_time, &end_precision);
if (rv) {
skAppPrintErr("Invalid %s '%s': %s",
appOptions[OPT_END_TIME].name, end_time,
skStringParseStrerror(rv));
exit(EXIT_FAILURE);
}
/* get the precision; treat epoch time as seconds resolution
* unless its precision is already seconds or milliseconds */
is_epoch = SK_PARSED_DATETIME_EPOCH & end_precision;
end_precision &= SK_PARSED_DATETIME_MASK_PRECISION;
if (is_epoch && end_precision < SK_PARSED_DATETIME_SECOND) {
end_precision = SK_PARSED_DATETIME_SECOND;
}
if (start_time) {
/* move end-time to its ceiling */
skDatetimeCeiling(&t, &t, end_precision);
++t;
/* verify times */
if (t <= bins.start_time) {
char buf_s[SKTIMESTAMP_STRLEN];
char buf_e[SKTIMESTAMP_STRLEN];
skAppPrintErr("The %s is less than %s: %s < %s",
appOptions[OPT_END_TIME].name,
appOptions[OPT_START_TIME].name,
sktimestamp_r(buf_e, t, SKTIMESTAMP_NOMSEC),
sktimestamp_r(buf_s, bins.start_time,
SKTIMESTAMP_NOMSEC));
exit(EXIT_FAILURE);
}
/* make certain end-time fails on a boundary by computing
* the number of bins required to hold the end-time. we
* subtract 1 then add 1 to get a valid count whether or
* not the division would have a remainder. */
bin_count = 1 + ((t - bins.start_time - 1) / bins.size);
bins.end_time = bins.start_time + bins.size * bin_count;
} else {
/* when only end_time is given, create bins up to its
* ceiling value */
bins.end_time = t;
skDatetimeCeiling(&t, &t, end_precision);
++t;
/* determine the number of bins between the end-time
* specified by the user and the ceiling of that end-time,
* then increase the end time by that number of bins */
bin_count = 1 + ((t - bins.end_time - 1) / bins.size);
bins.end_time += bin_count * bins.size;
}
}
/* make certain stdout is not being used for multiple outputs */
if (skOptionsCtxCopyStreamIsStdout(optctx)) {
if ((NULL == output.of_name)
|| (0 == strcmp(output.of_name, "-"))
|| (0 == strcmp(output.of_name, "stdout")))
{
skAppPrintErr("May not use stdout for multiple output streams");
exit(EXIT_FAILURE);
}
}
/* open the --output-path: the 'of_name' member is non-NULL when
* the switch is given */
if (output.of_name) {
rv = skFileptrOpen(&output, SK_IO_WRITE);
if (rv) {
skAppPrintErr("Cannot open '%s': %s",
output.of_name, skFileptrStrerror(rv));
exit(EXIT_FAILURE);
}
}
/* looks good, open the --copy-input destination */
if (skOptionsCtxOpenStreams(optctx, &skAppPrintErr)) {
exit(EXIT_FAILURE);
}
return; /* OK */
}
