static const char * field_get_name(int field)
{
static char fld_name_buff[LNF_INFO_BUFSIZE];
if (field <= LNF_FLD_ZERO_ || field >= LNF_FLD_TERM_) {
return NULL;
}
lnf_fld_info(field, LNF_FLD_INFO_NAME, fld_name_buff, LNF_INFO_BUFSIZE);
return fld_name_buff;
}
int output_start_line(output_t *output) {
int i,j;
char buf[LNF_INFO_BUFSIZE];
field_ent_t *fe;
format_ent_t fmte;
for (i = 0; i < output->numfields; i++) {
fe = &output->fields[i]; /* get field entry for better manipulation */
/* set output formating function and formating callback */
for (j = 0; j < sizeof(formats) / sizeof(format_ent_t); j++) {
/* default for all */
if ( formats[j].type == 0 ) {
memcpy(&fmte, &formats[j], sizeof(format_ent_t));
}
/* default for type */
if ( formats[j].type == lnf_fld_type(fe->field) && formats[j].field == 0) {
memcpy(&fmte, &formats[j], sizeof(format_ent_t));
}
/* particular type and field */
if ( formats[j].type == lnf_fld_type(fe->field) && formats[j].field == fe->field) {
memcpy(&fmte, &formats[j], sizeof(format_ent_t));
}
}
strncpy(fe->format, fmte.format, MAX_STR);
fe->format_func = fmte.format_func;
/* print header */
lnf_fld_info(fe->field, LNF_FLD_INFO_NAME, &buf, LNF_INFO_BUFSIZE);
strncpy(fe->name, buf, MAX_STR);
printf(output->fields[i].format, &buf);
}
printf("\n");
return 1;
}
int main (int argc, char **argv) {
int fields[LNF_FLD_TERM_];
int aggr, sort, ipfix_id, ipfix_eid;
int idx = 0;
int ipfix_info = 0;
char name[LNF_INFO_BUFSIZE];
char descr[LNF_INFO_BUFSIZE];
char buf[LNF_INFO_BUFSIZE];
char c;
while ((c = getopt (argc, argv, "i")) != -1) {
switch (c) {
case 'i':
ipfix_info = 1;
break;
case '?':
printf(" -i - print additional IPFIX mapping info\n");
exit(1);;
}
}
lnf_info(NULL, LNF_INFO_VERSION, buf, LNF_INFO_BUFSIZE);
printf("libnf version: %s\n", buf);
lnf_info(NULL, LNF_INFO_NFDUMP_VERSION, buf, LNF_INFO_BUFSIZE);
printf("libnf based on nfdump: %s\n", buf);
lnf_fld_info(LNF_FLD_ZERO_, LNF_FLD_INFO_FIELDS, &fields, sizeof(fields));
printf("Supported items:\n");
while (fields[idx] != LNF_FLD_TERM_) {
lnf_fld_info(fields[idx], LNF_FLD_INFO_AGGR, &aggr, sizeof(aggr));
lnf_fld_info(fields[idx], LNF_FLD_INFO_SORT, &sort, sizeof(sort));
lnf_fld_info(fields[idx], LNF_FLD_INFO_NAME, &name, sizeof(name));
lnf_fld_info(fields[idx], LNF_FLD_INFO_DESCR, &descr, sizeof(descr));
printf(" 0x%08x 0x%02x 0x%02x %-20s %s\n", fields[idx], aggr, sort, name, descr);
if (ipfix_info) {
if (lnf_fld_info(fields[idx], LNF_FLD_INFO_IPFIX_NAME, &name, sizeof(name)) == LNF_OK) {
lnf_fld_info(fields[idx], LNF_FLD_INFO_IPFIX_EID, &ipfix_eid, sizeof(ipfix_eid));
lnf_fld_info(fields[idx], LNF_FLD_INFO_IPFIX_ID, &ipfix_id, sizeof(ipfix_id));
printf(" %-30s %04d %04d\n", name, ipfix_eid, ipfix_id);
}
if (lnf_fld_info(fields[idx], LNF_FLD_INFO_IPFIX_NAME6, &name, sizeof(name)) == LNF_OK) {
lnf_fld_info(fields[idx], LNF_FLD_INFO_IPFIX_EID6, &ipfix_eid, sizeof(ipfix_eid));
lnf_fld_info(fields[idx], LNF_FLD_INFO_IPFIX_ID6, &ipfix_id, sizeof(ipfix_id));
printf(" %-30s %04d %04d\n", name, ipfix_eid, ipfix_id);
}
}
idx++;
}
return 0;
}
int main(int argc, char **argv) {
lnf_rec_t *recp;
pthread_t th[MAX_THREADS];
int i = 0;
int numthreads = 1;
int sortfield = 0;
int sortbits4 = 0;
int sortbits6 = 0;
char c;
// lnf_filter_t *filterp;
flist_init(&flist);
numthreads = get_cpu_cores() * NUM_THREADS_FACTOR;
/* initalise one instance of memory heap (share by all threads) */
memp = NULL;
filterp = NULL;
progressp = NULL;
recp = NULL;
filter[0] = '\0';
/* fields in all outpusts */
fields_add(LNF_FLD_FIRST);
fields_add(LNF_FLD_CALC_DURATION);
while ((c = getopt_long(argc, argv, "A:O:r:R:T:W;", longopts, NULL)) != -1) {
switch (c) {
case 1:
case 'T': /* T option will be removed in future */
numthreads = atoi(optarg);
if (numthreads > MAX_THREADS) {
fprintf(stderr, "Maximim allowed threads is %d\n", MAX_THREADS);
exit(1);
// numthreads = MAX_THREADS - 1;
}
break;
case 2:
if (strcmp(optarg, "nfdump") == 0) {
filter_type = NFDUMPP_FILTER_NFDUMP;
} else if (strcmp(optarg, "libnf") == 0) {
filter_type = NFDUMPP_FILTER_LIBNF;
} else {
fprintf(stderr, "Invalid filter type \"%s\". Allowed options nfdump or libnf. \n", optarg);
exit(1);
}
break;
case 'r':
case 'R':
flist_lookup_dir(&flist, optarg);
break;
case 'A':
if (memp == NULL) {
lnf_mem_init(&memp);
}
parse_aggreg(memp, optarg);
break;
case 'O':
sortfield = lnf_fld_parse(optarg, &sortbits4, &sortbits6);
if (sortfield == 0) {
fprintf(stderr, "Unknow or unsupported sort field: %s\n", optarg);
exit(1);
}
break;
case '?':
printf("Usage: %s [ -A ] [ -R -r ] [ <filter> ] \n", argv[0]);
printf(" -r : \n");
printf(" -R : Input file or directory (multiple -r -R options is allowed)\n");
printf(" -A : aggregation\n");
printf(" -O : sort order\n");
printf(" --num-threads = <num> : num threads (default: %.0f%% number of CPU cores, %d on this system)\n",
NUM_THREADS_FACTOR * 100, numthreads);
printf(" --filter-type = nfdump|libnf : use original nfdump filter or new libnf implementation \n");
printf("\n");
exit(1);
}
}
/* set filter */
if (optind < argc ) {
for ( ; optind < argc; optind++) {
if (strlen(filter) + strlen(argv[optind]) > MAX_FILTER_LEN) {
fprintf(stderr, "Not enough space for filter in buffer\n");
exit(1);
}
strcat(filter, argv[optind]);
strcat(filter, " ");
printf("filter: %s \n", filter);
}
filterp = NULL;
switch (filter_type) {
case NFDUMPP_FILTER_DEFAULT:
lnf_filter_init(&filterp, filter);
break;
case NFDUMPP_FILTER_NFDUMP:
lnf_filter_init_v1(&filterp, filter);
break;
case NFDUMPP_FILTER_LIBNF:
lnf_filter_init_v2(&filterp, filter);
break;
default:
fprintf(stderr, "This should never hapen line: %d\n", __LINE__);
exit(1);
break;
}
if (filterp == NULL) {
fprintf(stderr, "Can not compile filter: %s\n", filter);
exit(1);
}
// lnf_filter_free(filterp);
}
/* init progress bar */
if (progress_init(&progressp, 0, NULL) != NULL) {
progress_steps(progressp, flist_count(&flist));
}
/* aggregated or not aggregated records */
if (memp == NULL) {
/* not aggregated, but sorted */
if (sortfield > 0) {
lnf_mem_init(&memp);
/* switch memp into list mode */
lnf_mem_setopt(memp, LNF_OPT_LISTMODE, NULL, 0);
lnf_mem_fastaggr(memp, LNF_FAST_AGGR_BASIC);
lnf_mem_fadd(memp, LNF_FLD_PROT, LNF_AGGR_KEY, 0, 0);
lnf_mem_fadd(memp, LNF_FLD_SRCADDR, LNF_AGGR_KEY, 24, 128);
lnf_mem_fadd(memp, LNF_FLD_SRCPORT, LNF_AGGR_KEY, 0, 0);
lnf_mem_fadd(memp, LNF_FLD_DSTADDR, LNF_AGGR_KEY, 24, 128);
lnf_mem_fadd(memp, LNF_FLD_DSTPORT, LNF_AGGR_KEY, 0, 0);
}
fields_add(LNF_FLD_PROT);
fields_add(LNF_FLD_SRCADDR);
fields_add(LNF_FLD_SRCPORT);
fields_add(LNF_FLD_DSTADDR);
fields_add(LNF_FLD_DSTPORT);
}
/* default fields on the ond of the list */
fields_add(LNF_FLD_DPKTS);
fields_add(LNF_FLD_DOCTETS);
fields_add(LNF_FLD_CALC_BPS);
fields_add(LNF_FLD_CALC_BPP);
fields_add(LNF_FLD_AGGR_FLOWS);
/* set sort firld */
if (sortfield > 0) {
int defaultaggr = 0;
int defaultsort = 0;
lnf_fld_info(sortfield, LNF_FLD_INFO_AGGR, &defaultaggr, sizeof(int));
lnf_fld_info(sortfield, LNF_FLD_INFO_SORT, &defaultsort, sizeof(int));
lnf_mem_fadd(memp, sortfield, defaultaggr|defaultsort, sortbits4, sortbits6);
}
print_header();
/* prepare and run threads */
pthread_mutex_init(&mutex, NULL);
for ( i = 0 ; i < numthreads ; i++ ) {
if ( pthread_create(&th[i], NULL, process_thread, NULL) < 0) {
fprintf(stderr, "Can not create thread for %d\n", i);
break;
}
}
/* wait for threads */
for ( i = 0; i < numthreads; i++ ) {
if( pthread_join(th[i], NULL) ) {
fprintf(stderr, "Error joining thread\n");
break;
}
}
/* print the records out */
if (memp != NULL) {
i = 0;
lnf_rec_init(&recp);
while (lnf_mem_read(memp, recp) != LNF_EOF) {
i++;
print_row(recp);
outputflows++;
}
}
/* header */
printf("Total input flows %d, output flows: %lu\n", totalrows, outputflows);
lnf_mem_free(memp);
lnf_rec_free(recp);
if (filterp != NULL) {
lnf_filter_free(filterp);
}
}
