int main(int argc, char **argv)
{
int rv;
appSetup(argc, argv); /* never returns on error */
/* start the logger and become a daemon */
if (skdaemonize(&shuttingdown, NULL) == -1
|| sklogEnableThreadedLogging() == -1)
{
exit(EXIT_FAILURE);
}
daemonized = 1;
/* Run in client or server mode */
rv = startTransferDaemon();
if (rv != 0) {
exit(EXIT_FAILURE);
}
/* We now run forever, accepting signals */
while (!shuttingdown) {
pause();
}
/* done */
appTeardown();
return main_retval;
}
int main(int argc, char **argv)
{
char *path;
int64_t total_count;
int64_t count;
int rv;
appSetup(argc, argv); /* never returns on failure */
total_count = 0;
/* process each file on the command line */
while ((rv = skOptionsCtxNextArgument(optctx, &path)) == 0) {
count = pdu2silk(path);
if (count < 0) {
exit(EXIT_FAILURE);
}
total_count += count;
}
if (rv < 0) {
exit(EXIT_FAILURE);
}
if (print_statistics) {
fprintf(STATS_FH, ("%s: Wrote %" PRIu64 " records to '%s'\n"),
skAppName(), total_count, skStreamGetPathname(silk_output));
}
return 0;
}
int main(int argc, char **argv)
{
appSetup(argc, argv); /* never returns on error */
if (sklogOpen()) {
skAppPrintErr("Unable to open log");
}
if (!test_threaded) {
write_msg_thread((void*)"main");
} else {
pthread_t p1;
pthread_t p2;
pthread_create(&p1, NULL, &write_msg_thread, (void*)"p1");
pthread_create(&p2, NULL, &write_msg_thread, (void*)"p2");
logToAllLevels((void*)"main");
pthread_join(p2, NULL);
pthread_join(p1, NULL);
}
sklogClose();
return 0;
}
int main(int argc, char **argv)
{
skstream_t *in_stream;
int in_rv = SKSTREAM_OK;
int rv = SKSTREAM_OK;
appSetup(argc, argv); /* never returns on error */
#error "Loop over files on command line or read from stdin."
#error "Process each file, preferably in a separate function."
/* For each input, process each record */
while (NULL != (in_stream = appNextInput(argc, argv))) {
while ((in_rv = skStreamReadRecord(in_stream, &rwrec))==SKSTREAM_OK) {
/* process record */
rv = skStreamWriteRecord(out_stream, &rwrec);
if (SKSTREAM_OK != rv) {
skStreamPrintLastErr(out_stream, rv, &skAppPrintErr);
skStreamDestroy(&in_stream);
goto END;
}
}
if (SKSTREAM_ERR_EOF != in_rv) {
skStreamPrintLastErr(in_stream, in_rv, &skAppPrintErr);
}
skStreamDestroy(&in_stream);
}
rv = skStreamClose(out_stream);
if (SKSTREAM_OK != rv) {
skStreamPrintLastErr(out_stream, rv, &skAppPrintErr);
}
END:
return ((SKSTREAM_OK == rv) ? EXIT_SUCCESS : EXIT_FAILURE);
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
//Setup the exercises
appSetup();
//Start the application loop
return a.exec();
}
int main(int argc, char **argv)
{
skstream_t *inputFile;
skPrefixMap_t *prefixMap;
skPrefixMapErr_t map_error = SKPREFIXMAP_OK;
char buf[DICTIONARY_ENTRY_BUFLEN];
int rv;
appSetup(argc, argv); /* never returns on error */
/* Okay. Now we should open the prefixmap file, read it in, and */
/* then look up our address! */
if ((rv = skStreamCreate(&inputFile, SK_IO_READ, SK_CONTENT_SILK))
|| (rv = skStreamBind(inputFile, prefixmap_test_opt.map_file))
|| (rv = skStreamOpen(inputFile)))
{
skStreamPrintLastErr(inputFile, rv, &skAppPrintErr);
skStreamDestroy(&inputFile);
exit(EXIT_FAILURE);
}
map_error = skPrefixMapRead(&prefixMap, inputFile);
skStreamDestroy(&inputFile);
if ( SKPREFIXMAP_OK != map_error ) {
skAppPrintErr("Failed to read map file: %s",
skPrefixMapStrerror(map_error));
exit(EXIT_FAILURE);
}
if ( prefixmap_test_opt.string ) {
int v = skPrefixMapFindString(prefixMap, &prefixmap_test_opt.address,
buf, sizeof(buf));
if ( v < 0 ) {
strncpy(buf, "(null)", sizeof(buf));
}
printf("%s\n", buf);
} else {
printf("%d\n",
skPrefixMapFindValue(prefixMap, &prefixmap_test_opt.address));
}
skPrefixMapDelete(prefixMap);
/* done */
appTeardown();
return 0;
}
int main(int argc, char **argv)
{
int offset = 0;
struct pcap_pkthdr next_pkt_hdr;
const u_char *next_pkt_data = NULL;
appSetup(argc, argv);
while ((next_pkt_data = pcap_next(g_pkt_input, &next_pkt_hdr)) != NULL) {
next_pkt_hdr.ts.tv_usec += offset % 5000;
pcap_dump((u_char *) g_output_dumper, &next_pkt_hdr,
next_pkt_data);
offset += 1000;
}
return 0;
}
int main(int argc, char **argv)
{
int rv;
appSetup(argc, argv); /* never returns on error */
/* Check the address(es) */
if (NULL != app_opt.input_file) {
rv = processInputFile(app_opt.input_file);
} else {
rv = processOneAddress(app_opt.address);
}
/* done */
skCountryTeardown();
return ((0 == rv) ? EXIT_SUCCESS : EXIT_FAILURE);
}
int main(int argc, char **argv)
{
skstream_t *stream = NULL;
ssize_t rv;
/* Global setup */
appSetup(argc, argv);
/* process input */
while ((rv = skOptionsCtxNextSilkFile(optctx, &stream, &skAppPrintErr))
== 0)
{
skStreamSetIPv6Policy(stream, ipv6_policy);
if (0 != processFile(stream)) {
skAppPrintErr("Error processing input from %s",
skStreamGetPathname(stream));
skStreamDestroy(&stream);
return EXIT_FAILURE;
}
skStreamDestroy(&stream);
}
if (rv < 0) {
exit(EXIT_FAILURE);
}
rv = skAggBagWrite(ab, output);
if (rv) {
if (SKAGGBAG_E_WRITE == rv) {
skStreamPrintLastErr(output, skStreamGetLastReturnValue(output),
&skAppPrintErr);
} else {
skAppPrintErr("Error writing Aggregate Bag to '%s': %s",
skStreamGetPathname(output), skAggBagStrerror(rv));
}
exit(EXIT_FAILURE);
}
skAggBagDestroy(&ab);
/* Done, do cleanup */
appTeardown();
return 0;
}
int main(int argc, char **argv)
{
int rv;
appSetup(argc, argv); /* never returns on error */
sortRandom();
/* close the file */
if ((rv = skStreamClose(out_rwios))
|| (rv = skStreamDestroy(&out_rwios)))
{
skStreamPrintLastErr(out_rwios, rv, &skAppPrintErr);
appExit(EXIT_FAILURE);
}
out_rwios = NULL;
appExit(EXIT_SUCCESS);
return 0; /* NOTREACHED */
}
int main(int argc, char **argv)
{
int rv;
appSetup(argc, argv);
/* read input file */
if (ip_ranges) {
if (buildIPSetRanges(in_stream)) {
return 1;
}
} else {
if (buildIPSetWildcards(in_stream)) {
return 1;
}
}
skIPSetClean(ipset);
/* write output to stream */
rv = skIPSetWrite(ipset, out_stream);
if (rv) {
if (SKIPSET_ERR_FILEIO == rv) {
skStreamPrintLastErr(out_stream,
skStreamGetLastReturnValue(out_stream),
&skAppPrintErr);
} else {
skAppPrintErr("Unable to write IPset to '%s': %s",
skStreamGetPathname(out_stream),skIPSetStrerror(rv));
}
return 1;
}
skStreamDestroy(&in_stream);
skStreamDestroy(&out_stream);
/* done */
return 0;
}
int main(int argc, char **argv)
{
skstream_t *stream;
int rv = 0;
appSetup(argc, argv); /* never returns on error */
if (tail_buf) {
assert(tail_recs);
tail_buf_cur = tail_buf;
/* Process the files from command line or stdin */
while ((rv = skOptionsCtxNextSilkFile(optctx, &stream, &skAppPrintErr))
== 0)
{
skStreamSetIPv6Policy(stream, ipv6_policy);
rv = tailFile(stream);
skStreamDestroy(&stream);
if (-1 == rv) {
exit(EXIT_FAILURE);
}
}
if (rv < 0) {
exit(EXIT_FAILURE);
}
printTailBuffer();
} else {
/* Process the files on command line or records from stdin */
/* get first file */
rv = skOptionsCtxNextSilkFile(optctx, &stream, &skAppPrintErr);
if (rv < 0) {
exit(EXIT_FAILURE);
}
/* print title line */
rwAsciiPrintTitles(ascii_str);
if (1 == rv) {
/* xargs with no input; we are done */
appTeardown();
return 0;
}
do {
skStreamSetIPv6Policy(stream, ipv6_policy);
rv = cutFile(stream);
skStreamDestroy(&stream);
if (-1 == rv) {
exit(EXIT_FAILURE);
}
if (1 == rv) {
break;
}
} while ((rv =skOptionsCtxNextSilkFile(optctx, &stream,&skAppPrintErr))
== 0);
if (rv < 0) {
exit(EXIT_FAILURE);
}
}
/* done */
appTeardown();
return 0;
}
int main(int argc, char **argv)
{
char pathname[PATH_MAX];
struct stat statbuf;
unsigned int numFiles = 0;
unsigned int numOnTape = 0;
appSetup(argc, argv);
switch ((no_block_check << 1) | (no_file_names)) {
case 3:
/* do not stat() the files; do not print file names */
while (fglobNext(pathname, sizeof(pathname)) != NULL) {
++numFiles;
}
break;
case 2:
/* do not stat() the files; print file names */
while (fglobNext(pathname, sizeof(pathname)) != NULL) {
fprintf(OUTPUT_FH, "%s\n", pathname);
++numFiles;
}
break;
case 1:
/* stat the files; do not print the file names */
while (fglobNext(pathname, sizeof(pathname)) != NULL) {
if (-1 == stat(pathname, &statbuf)) {
/* should never happen; fglob wouldn't have returned it */
skAppPrintSyserror("Cannot stat '%s'", pathname);
exit(EXIT_FAILURE);
}
if (0 == statbuf.st_blocks && statbuf.st_size > 0) {
++numOnTape;
}
++numFiles;
}
break;
case 0:
/* stat the files; print the file names */
while (fglobNext(pathname, sizeof(pathname)) != NULL) {
if (-1 == stat(pathname, &statbuf)) {
/* should never happen; fglob wouldn't have returned it */
skAppPrintSyserror("Cannot stat '%s'", pathname);
exit(EXIT_FAILURE);
}
if (0 == statbuf.st_blocks && statbuf.st_size > 0) {
fprintf(OUTPUT_FH, "%s%s\n", BLOCK_CHECK_ZERO_MSG, pathname);
++numOnTape;
} else {
fprintf(OUTPUT_FH, "%s\n", pathname);
}
++numFiles;
}
break;
default:
skAbortBadCase((no_block_check << 1) | (no_file_names));
}
if (!no_summary) {
if (no_block_check) {
fprintf(OUTPUT_FH, "globbed %u files\n",
numFiles);
} else {
fprintf(OUTPUT_FH, "globbed %u files; %u on tape\n",
numFiles, numOnTape);
}
}
return 0;
}
int main(int argc, char **argv)
{
appSetup(argc, argv); /* never returns on error */
return compareFiles(&argv[arg_index]);
}
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);
}
