char *
get_ipa_config(
void)
{
skstream_t *conf_stream = NULL;
char filename[PATH_MAX];
char line[IPA_CONFIG_LINE_LENGTH];
char *ipa_url = NULL;
int rv;
/* Read in the data file */
if (NULL == skFindFile(IPA_CONFIG_FILE, filename, sizeof(filename), 1)) {
skAppPrintErr("Could not locate config file '%s'.",
IPA_CONFIG_FILE);
return NULL;
}
/* open input */
if ((rv = skStreamCreate(&conf_stream, SK_IO_READ, SK_CONTENT_TEXT))
|| (rv = skStreamBind(conf_stream, filename))
|| (rv = skStreamSetCommentStart(conf_stream, "#"))
|| (rv = skStreamOpen(conf_stream)))
{
skStreamPrintLastErr(conf_stream, rv, &skAppPrintErr);
skStreamDestroy(&conf_stream);
exit(EXIT_FAILURE);
}
while (skStreamGetLine(conf_stream, line, sizeof(line), NULL)
== SKSTREAM_OK)
{
/* FIXME: smarter config file reading, please */
if (strlen(line) > 0) {
ipa_url = strdup(line);
break;
}
}
skStreamDestroy(&conf_stream);
/* Should be free()d by the caller */
return ipa_url;
}
/*
* 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);
}
}
/*
* status = processInputFile(filein);
*
* For every line in 'filein', look up the address in Country Code
* map and print out the corresponding country code. There should
* be as many lines of output as there are of input.
*/
static int
processInputFile(
const char *f_name)
{
char final_delim[] = {'\0', '\0'};
char line[2048];
skstream_t *stream = NULL;
skIPWildcardIterator_t iter;
skIPWildcard_t ipwild;
skipaddr_t ip;
int retval = 1;
int rv;
int lc = 0;
char cc[32];
char ipbuf[SK_NUM2DOT_STRLEN];
if (!app_opt.no_final_delimiter) {
final_delim[0] = app_opt.column_separator;
}
/* open input */
if ((rv = skStreamCreate(&stream, SK_IO_READ, SK_CONTENT_TEXT))
|| (rv = skStreamBind(stream, f_name))
|| (rv = skStreamSetCommentStart(stream, "#"))
|| (rv = skStreamOpen(stream)))
{
skStreamPrintLastErr(stream, rv, &skAppPrintErr);
goto END;
}
/* read until end of file */
while ((rv = skStreamGetLine(stream, line, sizeof(line), &lc))
!= SKSTREAM_ERR_EOF)
{
switch (rv) {
case SKSTREAM_OK:
/* good, we got our line */
break;
case SKSTREAM_ERR_LONG_LINE:
/* bad: line was longer than sizeof(line) */
skAppPrintErr("Input line %d too long. ignored",
lc);
continue;
default:
/* unexpected error */
skStreamPrintLastErr(stream, rv, &skAppPrintErr);
goto END;
}
/* parse the line: fill in octet_bitmap */
rv = skStringParseIPWildcard(&ipwild, line);
if (rv && rv != SKUTILS_ERR_EMPTY) {
/* error */
skAppPrintErr("Error on line %d: %s\n",
lc, skStringParseStrerror(rv));
goto END;
}
#if SK_ENABLE_IPV6
if (skIPWildcardIsV6(&ipwild)) {
continue;
}
#endif /* SK_ENABLE_IPV6 */
skIPWildcardIteratorBind(&iter, &ipwild);
while (skIPWildcardIteratorNext(&iter, &ip) == SK_ITERATOR_OK) {
skCountryLookupName(&ip, cc, sizeof(cc));
if (!app_opt.print_ips) {
skStreamPrint(out, "%s\n", cc);
} else {
skipaddrString(ipbuf, &ip, ip_flags);
if (app_opt.no_columns) {
skStreamPrint(out, "%s%c%s%s\n",
ipbuf, app_opt.column_separator,
cc, final_delim);
} else {
skStreamPrint(out, "%15s%c%2s%s\n",
ipbuf, app_opt.column_separator,
cc, final_delim);
}
}
}
}
retval = 0;
END:
skStreamDestroy(&stream);
return retval;
}
