/*
* appTeardown()
*
* Teardown all modules, close all files, and tidy up all
* application state.
*
* This function is idempotent.
*/
static void
appTeardown(
void)
{
static int teardownFlag = 0;
int rv;
if (teardownFlag) {
return;
}
teardownFlag = 1;
/* close SiLK flow output file */
if (silk_output) {
rv = skStreamClose(silk_output);
if (rv && rv != SKSTREAM_ERR_NOT_OPEN) {
skStreamPrintLastErr(silk_output, rv, &skAppPrintErr);
}
skStreamDestroy(&silk_output);
}
skpcTeardown();
/* set level to "warning" to avoid the "Stopped logging" message */
sklogSetLevel("warning");
sklogTeardown();
skOptionsNotesTeardown();
skOptionsCtxDestroy(&optctx);
skAppUnregister();
}
int main(int UNUSED(argc), char UNUSED(**argv))
{
skDQErr_t err;
pthread_t a, b, c;
int rv;
char *v;
skAppRegister("skdeque-test");
skthread_init("main");
rv = sklogSetup(0);
assert(rv == 0);
rv = sklogSetDestination("stderr");
assert(rv == 0);
rv = sklogOpen();
assert(rv == 0);
rv = sklogSetLevel("debug");
assert(rv == 0);
rv = sklogEnableThreadedLogging();
assert(rv == 0);
rv = sklogSetStampFunction(&log_stamp);
assert(rv == 0);
da = skDequeCreate();
db = skDequeCreate();
dc = skDequeCreate();
/*** Single threaded tests ***/
/* check empty deque */
CHECK_EMPTY(da);
/* push first element onto 'da' and check */
err = skDequePushFront(da, (void*)xa);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
XASSERT(1 == skDequeSize(da));
/* push first element onto 'db' and check */
err = skDequePushBack(db, (void*)xb);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
err = skDequeFront(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
XASSERT(1 == skDequeSize(db));
/* push first element onto 'dc' */
err = skDequePushFront(dc, (void*)xc);
XASSERT(err == SKDQ_SUCCESS);
/* push second element onto front 'da' and check */
err = skDequePushFront(da, (void*)xx);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(2 == skDequeSize(da));
/* push second element onto 'db' and 'dc' */
err = skDequePushFront(db, (void*)xy);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushFront(dc, (void*)xz);
XASSERT(err == SKDQ_SUCCESS);
/* push third element onto back of 'da' and check */
err = skDequePushBack(da, (void*)xa);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(3 == skDequeSize(da));
/* push third element onto back of 'db' and 'dc' */
err = skDequePushBack(db, (void*)xb);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(dc, (void*)xc);
XASSERT(err == SKDQ_SUCCESS);
/* push fourth element onto back of 'da' and check */
err = skDequePushBack(da, (void*)xx);
XASSERT(err == SKDQ_SUCCESS);
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(4 == skDequeSize(da));
/* push fourth element onto back of 'db' and 'dc' */
err = skDequePushBack(db, (void*)xy);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(dc, (void*)xz);
XASSERT(err == SKDQ_SUCCESS);
/* pop four elements from 'da', each from the front */
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(3 == skDequeSize(da));
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
XASSERT(2 == skDequeSize(da));
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
XASSERT(1 == skDequeSize(da));
err = skDequePopFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
XASSERT(0 == skDequeSize(da));
/* verify 'da' is empty */
CHECK_EMPTY(da);
/* pop four elements from 'db', each from the back */
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
XASSERT(3 == skDequeSize(db));
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
XASSERT(2 == skDequeSize(db));
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
XASSERT(1 == skDequeSize(db));
err = skDequePopBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
XASSERT(0 == skDequeSize(db));
/* verify 'db' is empty */
CHECK_EMPTY(db);
/* pop four elements from 'dc' */
err = skDequePopFrontNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
err = skDequePopBackNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
err = skDequePopFrontNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
err = skDequePopBackNB(dc, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
err = skDequePopBackNB(dc, (void**)&v);
XASSERT(err == SKDQ_EMPTY);
/* verify 'dc' is empty */
CHECK_EMPTY(dc);
/* create a merged queue from 'da' and 'db' */
dd = skDequeCreateMerged(da, db);
/* verify 'dd' is empty */
CHECK_EMPTY(dd);
/* push the first element onto each of 'da' and 'db' */
err = skDequePushBack(da, (void*)xa);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(db, (void*)xx);
XASSERT(err == SKDQ_SUCCESS);
/* check sizes */
XASSERT(1 == skDequeSize(da));
XASSERT(1 == skDequeSize(db));
XASSERT(2 == skDequeSize(dd));
/* peek at front and back of merged deck */
err = skDequeBack(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
err = skDequeFront(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
/* push the second element onto each of 'da' and 'db' */
err = skDequePushBack(da, (void*)xb);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(db, (void*)xy);
XASSERT(err == SKDQ_SUCCESS);
/* peek at front and back of merged deck */
err = skDequeBack(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
err = skDequeFront(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
/* push a third element onto front and back of merged deck */
err = skDequePushFront(dd, (void*)xc);
XASSERT(err == SKDQ_SUCCESS);
err = skDequePushBack(db, (void*)xz);
XASSERT(err == SKDQ_SUCCESS);
/* check sizes */
XASSERT(3 == skDequeSize(da));
XASSERT(3 == skDequeSize(db));
XASSERT(6 == skDequeSize(dd));
/* peek at front and back of 'da' */
err = skDequeBack(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
err = skDequeFront(da, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
/* peek at front and back of 'db' */
err = skDequeBack(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
err = skDequeFront(db, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
/* pop three elements from front of 'dd' */
XASSERT(6 == skDequeSize(dd));
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xc);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xa);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xb);
/* verify 'da' is empty */
CHECK_EMPTY(da);
/* pop three elements from front of 'dd' */
XASSERT(3 == skDequeSize(dd));
XASSERT(3 == skDequeSize(db));
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xx);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xy);
err = skDequePopFrontNB(dd, (void**)&v);
XASSERT(err == SKDQ_SUCCESS);
XASSERT(v == xz);
/* verify 'db' is empty */
CHECK_EMPTY(db);
/* verify 'dd' is empty */
CHECK_EMPTY(dd);
/* done with 'dd' */
skDequeDestroy(dd);
/* verify 'da' and 'db' are still empty (and valid) */
CHECK_EMPTY(da);
CHECK_EMPTY(db);
/*** Multi-threaded tests ***/
rv = skthread_create("a", &a, thread_a, NULL);
XASSERT(rv == 0);
rv = skthread_create("b", &b, thread_b, NULL);
XASSERT(rv == 0);
rv = skthread_create("c", &c, thread_c, NULL);
XASSERT(rv == 0);
rv = pthread_join(a, NULL);
XASSERT(rv == 0);
rv = pthread_join(b, NULL);
XASSERT(rv == 0);
rv = pthread_join(c, NULL);
XASSERT(rv == 0);
skDequeDestroy(dc);
skDequeDestroy(db);
skDequeDestroy(da);
sklogClose();
sklogTeardown();
skthread_teardown();
skAppUnregister();
return 0;
}
/*
* 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 */
}