flowmon-export-csv.c

Go to the documentation of this file.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
#include <flowmonexp/plugin_export.h>

#define PRINTV(format, args...) do {if (VERBOSE) { fprintf(stdout, format, ##args); fflush(stdout); } } while (0)

#define PRINTD(format, args...) do {if (DEBUG) { fprintf(stdout, format, ##args); fflush(stdout); } } while (0)

#define PRINTA(format, args...) do {if (VERBOSE || DEBUG) { fprintf(stdout, format, ##args); fflush(stdout); } } while (0)

SET_PLUGIN_TYPE(PLUGIN_TYPE_EXPORT);

extern int verbose_level;

extern int debug_level;

bool VERBOSE;

bool DEBUG;

typedef struct {

        int counter;

        flow_record_getter_t *getters;

        FILE *f;

} plugin_private_csv;

static plugin_desc_t pcap_desc = {
        "export-csv",
        "Plugin which outputs all records to file in csv format\n"
        "parameters :\n"
        " file=/path/file       file to write into\n"
        " verbose=y/n               verbose mode(default same as flowmonexp)\n"
        " debug=y/n                 debug mode(default same as flowmonexp\n)",
        0,
        0
};

PLUGIN_EXPORT_DESC {
        return &pcap_desc;
}

int fei_parse_params(char *params, plugin_private_csv *conf)
{
        char *token, *value, *param;
        uint8_t state = 0;      /* state 0: expect param, state 1: expect value */

        /* Check that there are parameters */
        if (params == NULL) {
                fprintf(stderr, "input-http-flow need parameters\n");
                return 1;
        }

        /* Parse parameter string */
        token = strtok(params, ",=");
        while (token != NULL) {
                if (state == 0) {
                        param = token;
                } else {
                        value = token;
                        PRINTA("param: %s\t", param);
                        PRINTA("value: %s\n", value);
                        if (strcmp("file", param) == 0) {
                                conf->f = fopen(value, "a");
                        } else if (strcmp("verbose", param) == 0) {
                                if (strcmp(value, "y") == 0) {
                                        VERBOSE = true;
                                } else if (strcmp(value, "n") == 0) {
                                        VERBOSE = false;
                                } else {
                                        fprintf(stderr, " value of 'verbose' parameter is not valid");
                                }
                        } else if (strcmp("debug", param) == 0) {
                                if (strcmp(value, "y") == 0) {
                                        DEBUG = true;
                                } else if (strcmp(value, "n") == 0) {
                                        DEBUG = false;
                                } else {
                                        fprintf(stderr, " value of 'debug' parameter is not valid");
                                }
                        }  else {
                                fprintf(stderr, "Unknown parameter '%s'\n", param);
                        return 1;
                        }
                }

                /* Move to next token */
                token = strtok(NULL, ",=");
                state = 1 - state;
        }
        return 0;
}

void *plugin_export_init(char *params, flow_record_getter_t *getter_list)
{
        if (verbose_level >= 0) {
                VERBOSE = true;
        } else{
                VERBOSE = false;
        }
        if (debug_level >= 0) {
                DEBUG = true;
        } else{
                DEBUG = false;
        }
        PRINTA("plugin export init start\n");
        plugin_private_csv *retval;
        flow_record_getter_t *tmp = getter_list;

        retval = malloc(sizeof(plugin_private_csv));
        if (!retval) {
                return NULL;
        }
        fei_parse_params(params, retval);
        retval->counter = 0;

        retval->getters = NULL;
        while (tmp && tmp->name) {
                PRINTD("getter: %s - %i\n", tmp->name, tmp->length);
                getter_copy_to(&retval->getters, tmp);
                tmp++;
        }

        PRINTA("plugin export init end\n");
        return retval;
}

int plugin_export_export(void *plugin_private, flow_record_t *record)
{
        PRINTD("plugin export export start\n");
        plugin_private_csv *p = (plugin_private_csv *) plugin_private;
        flow_record_getter_t *tmp = p->getters;
        unsigned char block[1024];
        int i;
        int len;
        FILE *output;

        output = p->f;
        if (!output) {
                fputs("Cant open output file.\n", stderr);
                return 5;
        }

        fprintf(output, "FLOW: %i, ", p->counter++);
        while (tmp && tmp->name) {
                if (tmp->valid(tmp->self, record)) {
                        fprintf(output, ", ");
                        len = tmp->current_length(tmp->self, record);

                        if (len > 1024) {
                                len = 1024;
                        }

                        fprintf(output, "%s: ", tmp->name);

                        tmp->filler(tmp->self, record, block, len, 1);
                        if (tmp->length > 0) {
                                for (i = 0; i < len; i++) {
                                        fprintf(output, "%02X", block[i]);
                                }
                        } else {
                                block[len] = 0;
                                printf("%s", block);
                        }
                }
                tmp++;
        }
        fprintf(output, "\n");
        PRINTV("flow data written into file\n");
        PRINTD("plugin export export end\n");
        fflush(stdout);
        return 0;
}

int plugin_export_flush(void *plugin_private)
{
        PRINTD("plugin flush start\n");
        fflush(stdout);
        PRINTD("plugin flush end\n");
        return 0;
}