/*
* 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.
*/
static void
appSetup(
int argc,
char **argv)
{
SILK_FEATURES_DEFINE_STRUCT(features);
unsigned int optctx_flags;
sk_file_header_t *silk_hdr;
int logmask;
int rv;
/* verify same number of options and help strings */
assert((sizeof(appHelp)/sizeof(char *)) ==
(sizeof(appOptions)/sizeof(struct option)));
/* register the application */
skAppRegister(argv[0]);
skAppVerifyFeatures(&features, NULL);
skOptionsSetUsageCallback(&appUsageLong);
optctx_flags = (SK_OPTIONS_CTX_INPUT_BINARY | SK_OPTIONS_CTX_XARGS);
/* register the options */
if (skOptionsCtxCreate(&optctx, optctx_flags)
|| skOptionsCtxOptionsRegister(optctx)
|| skOptionsRegister(appOptions, &appOptionsHandler, NULL)
|| skOptionsNotesRegister(NULL)
|| skCompMethodOptionsRegister(&comp_method))
{
skAppPrintErr("Unable to register options");
exit(EXIT_FAILURE);
}
/* enable the logger */
sklogSetup(0);
sklogSetDestination("stderr");
sklogSetStampFunction(&logprefix);
/* register the teardown handler */
if (atexit(appTeardown) < 0) {
skAppPrintErr("Unable to register appTeardown() with atexit()");
appTeardown();
exit(EXIT_FAILURE);
}
/* parse the options */
rv = skOptionsCtxOptionsParse(optctx, argc, argv);
if (rv < 0) {
skAppUsage(); /* never returns */
}
if ('\0' == log_destination[0]) {
strncpy(log_destination, LOG_DESTINATION_DEFAULT,
sizeof(log_destination));
} else {
sklogSetLevel("debug");
}
sklogSetDestination(log_destination);
/* default output is "stdout" */
if (!silk_output) {
if ((rv =skStreamCreate(&silk_output,SK_IO_WRITE,SK_CONTENT_SILK_FLOW))
|| (rv = skStreamBind(silk_output, "-")))
{
skStreamPrintLastErr(silk_output, rv, &skAppPrintErr);
exit(EXIT_FAILURE);
}
}
/* get the header */
silk_hdr = skStreamGetSilkHeader(silk_output);
/* open the output */
if ((rv = skHeaderSetCompressionMethod(silk_hdr, comp_method))
|| (rv = skOptionsNotesAddToStream(silk_output))
|| (rv = skHeaderAddInvocation(silk_hdr, 1, argc, argv))
|| (rv = skStreamOpen(silk_output))
|| (rv = skStreamWriteSilkHeader(silk_output)))
{
skStreamPrintLastErr(silk_output, rv, &skAppPrintErr);
exit(EXIT_FAILURE);
}
if (skpcSetup()) {
exit(EXIT_FAILURE);
}
if (skpcProbeCreate(&probe, PROBE_ENUM_NETFLOW_V5)) {
exit(EXIT_FAILURE);
}
skpcProbeSetName(probe, skAppName());
skpcProbeSetFileSource(probe, "/dev/null");
if (parseLogFlags(log_flags)) {
exit(EXIT_FAILURE);
}
if (skpcProbeVerify(probe, 0)) {
exit(EXIT_FAILURE);
}
/* set level to "warning" to avoid the "Started logging" message */
logmask = sklogGetMask();
sklogSetLevel("warning");
sklogOpen();
sklogSetMask(logmask);
return; /* OK */
}
/*
* 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.
*/
static void
appSetup(
int argc,
char **argv)
{
SILK_FEATURES_DEFINE_STRUCT(features);
unsigned int optctx_flags;
int rv;
int i;
/* verify same number of options and help strings */
assert((sizeof(appHelp)/sizeof(char *)) ==
(sizeof(appOptions)/sizeof(struct option)));
assert(PREFIX_COUNT == _FINAL_MASK_);
/* register the application */
skAppRegister(argv[0]);
skAppVerifyFeatures(&features, NULL);
skOptionsSetUsageCallback(&appUsageLong);
/* initialize variables */
memset(net_mask, 0, sizeof(net_mask));
optctx_flags = (SK_OPTIONS_CTX_INPUT_SILK_FLOW | SK_OPTIONS_CTX_ALLOW_STDIN
| SK_OPTIONS_CTX_XARGS | SK_OPTIONS_CTX_PRINT_FILENAMES);
/* register the options */
if (skOptionsCtxCreate(&optctx, optctx_flags)
|| skOptionsCtxOptionsRegister(optctx)
|| skOptionsRegister(appOptions, &appOptionsHandler, NULL)
|| skOptionsRegister(legacyOptions, &appOptionsHandler, NULL)
|| skIPv6PolicyOptionsRegister(&ipv6_policy)
|| skOptionsNotesRegister(NULL)
|| skCompMethodOptionsRegister(&comp_method)
|| 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 */
rv = skOptionsCtxOptionsParse(optctx, argc, argv);
if (rv < 0) {
skAppUsage(); /* never returns */
}
/* make certain at least one mask was specified */
for (i = 0; i < PREFIX_COUNT; ++i) {
if (net_mask[i].bits6 || net_mask[i].bits4) {
break;
}
}
if (i == PREFIX_COUNT) {
skAppPrintErr("Must specify at least one prefix length option");
skAppUsage();
}
/* check the output */
if (output_path == NULL) {
output_path = "-";
}
}
/*
* 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.
*/
static void
appSetup(
int argc,
char **argv)
{
SILK_FEATURES_DEFINE_STRUCT(features);
unsigned int optctx_flags;
int rv;
/* verify same number of options and help strings */
assert((sizeof(appHelp)/sizeof(char *)) ==
(sizeof(appOptions)/sizeof(struct option)));
/* register the application */
skAppRegister(argv[0]);
skAppVerifyFeatures(&features, NULL);
skOptionsSetUsageCallback(&appUsageLong);
/* initialize globals */
memset(&ab_options, 0, sizeof(sk_aggbag_options_t));
ab_options.existing_silk_files = 1;
ab_options.argc = argc;
ab_options.argv = argv;
optctx_flags = (SK_OPTIONS_CTX_INPUT_SILK_FLOW | SK_OPTIONS_CTX_ALLOW_STDIN
| SK_OPTIONS_CTX_XARGS | SK_OPTIONS_CTX_COPY_INPUT
| SK_OPTIONS_CTX_PRINT_FILENAMES);
/* register the options */
if (skOptionsCtxCreate(&optctx, optctx_flags)
|| skOptionsCtxOptionsRegister(optctx)
|| skOptionsRegister(appOptions, &appOptionsHandler, NULL)
|| skAggBagOptionsRegister(&ab_options)
|| skIPv6PolicyOptionsRegister(&ipv6_policy)
|| 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()");
exit(EXIT_FAILURE);
}
/* parse options */
rv = skOptionsCtxOptionsParse(optctx, argc, argv);
if (rv < 0) {
skAppUsage(); /* never returns */
}
/* try to load site config file; if it fails, we will not be able
* to resolve flowtype and sensor from input file names, but we
* should not consider it a complete failure */
sksiteConfigure(0);
/* make sure the user specified at least one key field and one
* counter field */
if (keys_arg == NULL || keys_arg[0] == '\0') {
skAppPrintErr("The --%s switch is required",
appOptions[OPT_KEYS].name);
skAppUsage(); /* never returns */
}
if (counters_arg == NULL || counters_arg[0] == '\0') {
skAppPrintErr("The --%s switch is required",
appOptions[OPT_COUNTERS].name);
skAppUsage(); /* never returns */
}
/* set up the key_name_map and counter_name_map */
if (createStringmaps()) {
exit(EXIT_FAILURE);
}
/* create the aggregate bag */
if (skAggBagCreate(&ab)) {
exit(EXIT_FAILURE);
}
skAggBagOptionsBind(ab, &ab_options);
/* parse the --keys and --counters switches */
if (parseFields(key_name_map, keys_arg, OPT_KEYS)) {
exit(EXIT_FAILURE);
}
if (parseFields(counter_name_map, counters_arg, OPT_COUNTERS)) {
exit(EXIT_FAILURE);
}
/* create output stream to stdout if no --output-path was given */
if (NULL == output) {
if ((rv = skStreamCreate(&output, SK_IO_WRITE, SK_CONTENT_SILK))
|| (rv = skStreamBind(output, "-")))
{
skStreamPrintLastErr(output, rv, &skAppPrintErr);
skStreamDestroy(&output);
exit(EXIT_FAILURE);
}
}
/* make certain stdout is not being used for multiple outputs */
if (skStreamIsStdout(output) && skOptionsCtxCopyStreamIsStdout(optctx)) {
skAppPrintErr("May not use stdout for multiple output streams");
exit(EXIT_FAILURE);
}
/* open the output stream but do not write anything yet */
rv = skStreamOpen(output);
if (rv) {
skStreamPrintLastErr(output, rv, &skAppPrintErr);
skStreamDestroy(&output);
exit(EXIT_FAILURE);
}
/* open the --copy-input stream */
if (skOptionsCtxOpenStreams(optctx, &skAppPrintErr)) {
exit(EXIT_FAILURE);
}
return; /* OK */
}
/*
* 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 */
}