/*
* 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);
const char *in_fname;
const char *out_fname;
int arg_index;
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(&set_options, 0, sizeof(skipset_options_t));
set_options.argc = argc;
set_options.argv = argv;
/* register the options */
if (skOptionsRegister(appOptions, &appOptionsHandler, NULL)
|| skIPSetOptionsRegister(&set_options))
{
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 the options */
arg_index = skOptionsParse(argc, argv);
if (arg_index < 0) {
skAppUsage(); /* never returns */
}
/* default is to read from stdin and write to stdout */
in_fname = "-";
out_fname = "-";
/* process files named on the command line */
switch (argc - arg_index) {
case 2:
in_fname = argv[arg_index++];
out_fname = argv[arg_index++];
break;
case 1:
in_fname = argv[arg_index++];
break;
case 0:
/* Do not allow reading from a tty when no input */
if (FILEIsATty(stdin)) {
skAppPrintErr("Must specify '-' as the input to read"
" from a terminal");
exit(EXIT_FAILURE);
}
break;
default:
skAppPrintErr("Too many arguments;"
" a maximum of two files may be specified");
skAppUsage();
}
/* we should have processed all arguments */
assert(arg_index == argc);
/* create the IPset */
if (skIPSetCreate(&ipset, 0)) {
EXIT_NO_MEMORY;
}
skIPSetOptionsBind(ipset, &set_options);
/* create input */
if ((rv = skStreamCreate(&in_stream, SK_IO_READ, SK_CONTENT_TEXT))
|| (rv = skStreamBind(in_stream, in_fname))
|| (rv = skStreamSetCommentStart(in_stream, "#")))
{
skStreamPrintLastErr(in_stream, rv, &skAppPrintErr);
exit(EXIT_FAILURE);
}
/* create output */
if ((rv = skStreamCreate(&out_stream, SK_IO_WRITE, SK_CONTENT_SILK))
|| (rv = skStreamBind(out_stream, out_fname)))
{
skStreamPrintLastErr(out_stream, rv, &skAppPrintErr);
exit(EXIT_FAILURE);
}
/* open the streams */
rv = skStreamOpen(in_stream);
if (rv) {
skStreamPrintLastErr(in_stream, rv, &skAppPrintErr);
exit(EXIT_FAILURE);
}
rv = skStreamOpen(out_stream);
if (rv) {
skStreamPrintLastErr(out_stream, rv, &skAppPrintErr);
exit(EXIT_FAILURE);
}
}
int main(int argc, char **argv)
{
char errbuf[2 * PATH_MAX];
const char *filename = NULL;
skstream_t *stream = NULL;
skIPWildcard_t ipwild;
skipset_t *input_set = NULL;
skipset_t *wild_set = NULL;
char buf[64];
int found_match = 0; /* application return value */
int rv;
appSetup(argc, argv); /* never returns on error */
/* Build an IP wildcard from the pattern argument */
rv = skStringParseIPWildcard(&ipwild, pattern);
if (rv) {
skAppPrintErr("Invalid IP '%s': %s",
pattern, skStringParseStrerror(rv));
skAppUsage();
}
if (count && !quiet) {
/* Create an IPset containing the IPwildcard */
if ((rv = skIPSetCreate(&wild_set, skIPWildcardIsV6(&ipwild)))
|| (rv = skIPSetInsertIPWildcard(wild_set, &ipwild))
|| (rv = skIPSetClean(wild_set)))
{
skAppPrintErr("Unable to create temporary IPset: %s",
skIPSetStrerror(rv));
return EXIT_FAILURE;
}
}
/* Iterate over the set files */
while ((filename = appNextInput(argc, argv)) != NULL) {
/* Load the input set */
if ((rv = skStreamCreate(&stream, SK_IO_READ, SK_CONTENT_SILK))
|| (rv = skStreamBind(stream, filename))
|| (rv = skStreamOpen(stream)))
{
skStreamLastErrMessage(stream, rv, errbuf, sizeof(errbuf));
skAppPrintErr("Unable to read IPset from '%s': %s",
filename, errbuf);
skStreamDestroy(&stream);
continue;
}
rv = skIPSetRead(&input_set, stream);
if (rv) {
if (SKIPSET_ERR_FILEIO == rv) {
skStreamLastErrMessage(stream,
skStreamGetLastReturnValue(stream),
errbuf, sizeof(errbuf));
} else {
strncpy(errbuf, skIPSetStrerror(rv), sizeof(errbuf));
}
skAppPrintErr("Unable to read IPset from '%s': %s",
filename, errbuf);
skStreamDestroy(&stream);
continue;
}
skStreamDestroy(&stream);
if (quiet || !count) {
/* Only need to check for a match */
if (skIPSetCheckIPWildcard(input_set, &ipwild)) {
found_match = 1;
if (quiet) {
goto done;
}
printf("%s\n", filename);
}
} else {
/* Need a count of IPs, so intersect */
rv = skIPSetIntersect(input_set, wild_set);
if (rv) {
skAppPrintErr("Unable to intersect IPsets: %s",
skIPSetStrerror(rv));
skIPSetDestroy(&input_set);
skIPSetDestroy(&wild_set);
return EXIT_FAILURE;
}
printf("%s:%s\n",
filename,
skIPSetCountIPsString(input_set, buf, sizeof(buf)));
if ('0' != buf[0]) {
found_match = 1;
}
}
skIPSetDestroy(&input_set);
}
done:
/* done */
skIPSetDestroy(&input_set);
skIPSetDestroy(&wild_set);
return ((found_match) ? 0 : 1);
}
