int bgpstream_datasource_mgr_update_input_queue(
bgpstream_datasource_mgr_t *datasource_mgr, bgpstream_input_mgr_t *input_mgr)
{
bgpstream_debug("\tBSDS_MGR: get data start");
if (datasource_mgr == NULL) {
return -1; // no datasource manager
}
int results = -1;
do {
switch (datasource_mgr->datasource) {
#ifdef WITH_DATA_INTERFACE_SINGLEFILE
case BGPSTREAM_DATA_INTERFACE_SINGLEFILE:
results = bgpstream_singlefile_datasource_update_input_queue(
datasource_mgr->singlefile_ds, input_mgr);
break;
#endif
#ifdef WITH_DATA_INTERFACE_CSVFILE
case BGPSTREAM_DATA_INTERFACE_CSVFILE:
results = bgpstream_csvfile_datasource_update_input_queue(
datasource_mgr->csvfile_ds, input_mgr);
break;
#endif
#ifdef WITH_DATA_INTERFACE_SQLITE
case BGPSTREAM_DATA_INTERFACE_SQLITE:
results = bgpstream_sqlite_datasource_update_input_queue(
datasource_mgr->sqlite_ds, input_mgr);
break;
#endif
#ifdef WITH_DATA_INTERFACE_BROKER
case BGPSTREAM_DATA_INTERFACE_BROKER:
results = bgpstream_broker_datasource_update_input_queue(
datasource_mgr->broker_ds, input_mgr);
break;
#endif
default:
fprintf(stderr, "Invalid data interface\n");
break;
}
if (results == 0 && datasource_mgr->blocking) {
// results = 0 => 2+ time and database did not give any error
sleep(datasource_mgr->backoff_time);
datasource_mgr->backoff_time = datasource_mgr->backoff_time * 2;
if (datasource_mgr->backoff_time > DATASOURCE_BLOCKING_MAX_WAIT) {
datasource_mgr->backoff_time = DATASOURCE_BLOCKING_MAX_WAIT;
}
}
bgpstream_debug("\tBSDS_MGR: got %d (blocking: %d)", results,
datasource_mgr->blocking);
} while (datasource_mgr->blocking && results == 0);
datasource_mgr->backoff_time = DATASOURCE_BLOCKING_MIN_WAIT;
bgpstream_debug("\tBSDS_MGR: get data end");
return results;
}
static void instantiate_filter(bgpstream_t *bs, bgpstream_filter_item_t *item)
{
bgpstream_filter_type_t usetype = item->termtype;
switch (item->termtype) {
case BGPSTREAM_FILTER_TYPE_RECORD_TYPE:
case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_MORE:
case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_LESS:
case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_ANY:
case BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_EXACT:
case BGPSTREAM_FILTER_TYPE_ELEM_COMMUNITY:
case BGPSTREAM_FILTER_TYPE_ELEM_PEER_ASN:
case BGPSTREAM_FILTER_TYPE_PROJECT:
case BGPSTREAM_FILTER_TYPE_COLLECTOR:
case BGPSTREAM_FILTER_TYPE_ELEM_ASPATH:
case BGPSTREAM_FILTER_TYPE_ELEM_IP_VERSION:
case BGPSTREAM_FILTER_TYPE_ELEM_TYPE:
bgpstream_debug("Added filter for %s", item->value);
bgpstream_add_filter(bs, usetype, item->value);
break;
default:
bgpstream_debug("Implementation of filter type %s is still to come!",
bgpstream_filter_type_to_string(item->termtype));
break;
}
}
bgpstream_singlefile_datasource_t *
bgpstream_singlefile_datasource_create(bgpstream_filter_mgr_t *filter_mgr,
char *singlefile_rib_mrtfile,
char *singlefile_upd_mrtfile)
{
bgpstream_debug("\t\tBSDS_CLIST: create singlefile_ds start");
bgpstream_singlefile_datasource_t *singlefile_ds = (bgpstream_singlefile_datasource_t*) malloc(sizeof(bgpstream_singlefile_datasource_t));
if(singlefile_ds == NULL) {
bgpstream_log_err("\t\tBSDS_CLIST: create singlefile_ds can't allocate memory");
return NULL; // can't allocate memory
}
singlefile_ds->filter_mgr = filter_mgr;
singlefile_ds->rib_filename[0] = '\0';
singlefile_ds->rib_header[0] = '\0';
singlefile_ds->last_rib_filetime = 0;
if(singlefile_rib_mrtfile != NULL)
{
strcpy(singlefile_ds->rib_filename, singlefile_rib_mrtfile);
}
singlefile_ds->update_filename[0] = '\0';
singlefile_ds->update_header[0] = '\0';
singlefile_ds->last_update_filetime = 0;
if(singlefile_upd_mrtfile != NULL)
{
strcpy(singlefile_ds->update_filename, singlefile_upd_mrtfile);
}
bgpstream_debug("\t\tBSDS_CLIST: create customlist_ds end");
return singlefile_ds;
}
/* turn on the bgpstream interface, i.e.:
* it makes the interface ready
* for a new get next call
*/
int bgpstream_start(bgpstream_t *bs) {
bgpstream_debug("BS: init start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return 0; // nothing to init
}
// validate the filters that have been set
int rc;
if((rc = bgpstream_filter_mgr_validate(bs->filter_mgr)) != 0) {
return rc;
}
// turn on datasource interface
bgpstream_datasource_mgr_init(bs->datasource_mgr, bs->filter_mgr);
if(bs->datasource_mgr->status == BGPSTREAM_DATASOURCE_STATUS_ON) {
bs->status = BGPSTREAM_STATUS_ON; // interface is on
bgpstream_debug("BS: init end: ok");
return 0;
}
else{
// interface is not on (something wrong with datasource)
bs->status = BGPSTREAM_STATUS_ALLOCATED;
bgpstream_debug("BS: init warning: check if the datasource provided is ok");
bgpstream_debug("BS: init end: not ok");
return -1;
}
}
/* destroy the memory allocated for bgpstream filter */
void bgpstream_filter_mgr_destroy(bgpstream_filter_mgr_t *bs_filter_mgr)
{
bgpstream_debug("\tBSF_MGR:: destroy start");
if (bs_filter_mgr == NULL) {
return; // nothing to destroy
}
// destroying filters
bgpstream_interval_filter_t *tif;
khiter_t k;
// projects
if (bs_filter_mgr->projects != NULL) {
bgpstream_str_set_destroy(bs_filter_mgr->projects);
}
// collectors
if (bs_filter_mgr->collectors != NULL) {
bgpstream_str_set_destroy(bs_filter_mgr->collectors);
}
// bgp_types
if (bs_filter_mgr->bgp_types != NULL) {
bgpstream_str_set_destroy(bs_filter_mgr->bgp_types);
}
// peer asns
if (bs_filter_mgr->peer_asns != NULL) {
bgpstream_id_set_destroy(bs_filter_mgr->peer_asns);
}
// aspath expressions
if (bs_filter_mgr->aspath_exprs != NULL) {
bgpstream_str_set_destroy(bs_filter_mgr->aspath_exprs);
}
// prefixes
if (bs_filter_mgr->prefixes != NULL) {
bgpstream_patricia_tree_destroy(bs_filter_mgr->prefixes);
}
// communities
if (bs_filter_mgr->communities != NULL) {
kh_destroy(bgpstream_community_filter, bs_filter_mgr->communities);
}
// time_intervals
tif = NULL;
while (bs_filter_mgr->time_intervals != NULL) {
tif = bs_filter_mgr->time_intervals;
bs_filter_mgr->time_intervals = bs_filter_mgr->time_intervals->next;
free(tif);
}
// rib/update frequency
if (bs_filter_mgr->last_processed_ts != NULL) {
for (k = kh_begin(bs_filter_mgr->last_processed_ts);
k != kh_end(bs_filter_mgr->last_processed_ts); ++k) {
if (kh_exist(bs_filter_mgr->last_processed_ts, k)) {
free(kh_key(bs_filter_mgr->last_processed_ts, k));
}
}
kh_destroy(collector_ts, bs_filter_mgr->last_processed_ts);
}
// free the mgr structure
free(bs_filter_mgr);
bs_filter_mgr = NULL;
bgpstream_debug("\tBSF_MGR:: destroy end");
}
/* configure the interface so that it blocks
* waiting for new data
*/
void bgpstream_set_live_mode(bgpstream_t *bs) {
bgpstream_debug("BS: set_live_mode start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return; // nothing to customize
}
bgpstream_datasource_mgr_set_blocking(bs->datasource_mgr);
bgpstream_debug("BS: set_blocking stop");
}
/* turn off the bgpstream interface */
void bgpstream_stop(bgpstream_t *bs) {
bgpstream_debug("BS: close start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ON)) {
return; // nothing to close
}
bgpstream_datasource_mgr_close(bs->datasource_mgr);
bs->status = BGPSTREAM_STATUS_OFF; // interface is off
bgpstream_debug("BS: close end");
}
/* configure the interface so that it connects
* to a specific datasource interface
*/
void bgpstream_set_data_interface(bgpstream_t *bs,
bgpstream_data_interface_id_t datasource) {
bgpstream_debug("BS: set_data_interface start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return; // nothing to customize
}
bgpstream_datasource_mgr_set_data_interface(bs->datasource_mgr, datasource);
bgpstream_debug("BS: set_data_interface stop");
}
void bgpstream_add_rib_period_filter(bgpstream_t *bs, uint32_t period)
{
bgpstream_debug("BS: set_filter start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return; // nothing to customize
}
bgpstream_filter_mgr_rib_period_filter_add(bs->filter_mgr, period);
bgpstream_debug("BS: set_filter end");
}
void bgpstream_datasource_mgr_init(bgpstream_datasource_mgr_t *datasource_mgr,
bgpstream_filter_mgr_t *filter_mgr)
{
bgpstream_debug("\tBSDS_MGR: init start");
if (datasource_mgr == NULL) {
return; // no manager
}
void *ds = NULL;
switch (datasource_mgr->datasource) {
#ifdef WITH_DATA_INTERFACE_SINGLEFILE
case BGPSTREAM_DATA_INTERFACE_SINGLEFILE:
datasource_mgr->singlefile_ds = bgpstream_singlefile_datasource_create(
filter_mgr, datasource_mgr->singlefile_rib_mrtfile,
datasource_mgr->singlefile_upd_mrtfile);
ds = (void *)datasource_mgr->singlefile_ds;
break;
#endif
#ifdef WITH_DATA_INTERFACE_CSVFILE
case BGPSTREAM_DATA_INTERFACE_CSVFILE:
datasource_mgr->csvfile_ds = bgpstream_csvfile_datasource_create(
filter_mgr, datasource_mgr->csvfile_file);
ds = (void *)datasource_mgr->csvfile_ds;
break;
#endif
#ifdef WITH_DATA_INTERFACE_SQLITE
case BGPSTREAM_DATA_INTERFACE_SQLITE:
datasource_mgr->sqlite_ds = bgpstream_sqlite_datasource_create(
filter_mgr, datasource_mgr->sqlite_file);
ds = (void *)datasource_mgr->sqlite_ds;
break;
#endif
#ifdef WITH_DATA_INTERFACE_BROKER
case BGPSTREAM_DATA_INTERFACE_BROKER:
datasource_mgr->broker_ds = bgpstream_broker_datasource_create(
filter_mgr, datasource_mgr->broker_url, datasource_mgr->broker_params,
datasource_mgr->broker_params_cnt);
ds = (void *)datasource_mgr->broker_ds;
break;
#endif
default:
ds = NULL;
}
if (ds == NULL) {
datasource_mgr->status = BGPSTREAM_DATASOURCE_STATUS_ERROR;
} else {
datasource_mgr->status = BGPSTREAM_DATASOURCE_STATUS_ON;
}
bgpstream_debug("\tBSDS_MGR: init end");
}
void bgpstream_datasource_mgr_set_blocking(
bgpstream_datasource_mgr_t *datasource_mgr)
{
bgpstream_debug("\tBSDS_MGR: set blocking start");
if (datasource_mgr == NULL) {
return; // no manager
}
datasource_mgr->blocking = 1;
bgpstream_debug("\tBSDS_MGR: set blocking end");
}
/* configure filters in order to select a subset of the bgp data available */
void bgpstream_add_filter(bgpstream_t *bs,
bgpstream_filter_type_t filter_type,
const char* filter_value) {
bgpstream_debug("BS: set_filter start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return; // nothing to customize
}
bgpstream_filter_mgr_filter_add(bs->filter_mgr, filter_type, filter_value);
bgpstream_debug("BS: set_filter end");
}
/* allocate memory for a new bgpstream filter */
bgpstream_filter_mgr_t *bgpstream_filter_mgr_create()
{
bgpstream_debug("\tBSF_MGR: create start");
bgpstream_filter_mgr_t *bs_filter_mgr =
(bgpstream_filter_mgr_t *)malloc_zero(sizeof(bgpstream_filter_mgr_t));
if (bs_filter_mgr == NULL) {
return NULL; // can't allocate memory
}
bgpstream_debug("\tBSF_MGR: create end");
return bs_filter_mgr;
}
void
bgpstream_singlefile_datasource_destroy(bgpstream_singlefile_datasource_t* singlefile_ds)
{
bgpstream_debug("\t\tBSDS_CLIST: destroy singlefile_ds start");
if(singlefile_ds == NULL) {
return; // nothing to destroy
}
singlefile_ds->filter_mgr = NULL;
free(singlefile_ds);
bgpstream_debug("\t\tBSDS_CLIST: destroy singlefile_ds end");
}
void bgpstream_datasource_mgr_set_data_interface(
bgpstream_datasource_mgr_t *datasource_mgr,
const bgpstream_data_interface_id_t datasource)
{
bgpstream_debug("\tBSDS_MGR: set data interface start");
if (datasource_mgr == NULL) {
return; // no manager
}
datasource_mgr->datasource = datasource;
bgpstream_debug("\tBSDS_MGR: set data interface end");
}
int
bgpstream_csvfile_datasource_update_input_queue(bgpstream_csvfile_datasource_t* csvfile_ds,
bgpstream_input_mgr_t *input_mgr) {
bgpstream_debug("\t\tBSDS_CSVFILE: csvfile_ds update input queue start");
io_t *file_io = NULL;
char buffer[BUFFER_LEN];
int read = 0;
struct timeval tv;
gettimeofday(&tv, NULL);
/* we accept all timestamp earlier than now() - 1 second */
csvfile_ds->max_accepted_ts = tv.tv_sec - 1;
csvfile_ds->num_results = 0;
csvfile_ds->max_ts_infile = 0;
csvfile_ds->input_mgr = input_mgr;
if((file_io = wandio_create(csvfile_ds->csvfile_file)) == NULL)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: create csvfile_ds can't open file %s", csvfile_ds->csvfile_file);
return -1;
}
while((read = wandio_read(file_io, &buffer, BUFFER_LEN)) > 0)
{
if(csv_parse(&(csvfile_ds->parser), buffer, read,
parse_csvfile_field,
parse_csvfile_rowend,
csvfile_ds) != read)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: CSV error %s", csv_strerror(csv_error(&(csvfile_ds->parser))));
return -1;
}
}
if(csv_fini(&(csvfile_ds->parser),
parse_csvfile_field,
parse_csvfile_rowend,
csvfile_ds) != 0)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: CSV error %s", csv_strerror(csv_error(&(csvfile_ds->parser))));
return -1;
}
wandio_destroy(file_io);
csvfile_ds->input_mgr = NULL;
csvfile_ds->last_processed_ts = csvfile_ds->max_ts_infile;
bgpstream_debug("\t\tBSDS_CSVFILE: csvfile_ds update input queue end");
return csvfile_ds->num_results;
}
void bgpstream_add_interval_filter(bgpstream_t *bs,
uint32_t begin_time,
uint32_t end_time) {
bgpstream_debug("BS: set_filter start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return; // nothing to customize
}
if(end_time == BGPSTREAM_FOREVER) {
bgpstream_set_live_mode(bs);
}
bgpstream_filter_mgr_interval_filter_add(bs->filter_mgr, begin_time, end_time);
bgpstream_debug("BS: set_filter end");
}
void bgpstream_filter_mgr_rib_period_filter_add(
bgpstream_filter_mgr_t *bs_filter_mgr, uint32_t period)
{
bgpstream_debug("\tBSF_MGR:: add_filter start");
assert(bs_filter_mgr != NULL);
if (period != 0 && bs_filter_mgr->last_processed_ts == NULL) {
if ((bs_filter_mgr->last_processed_ts = kh_init(collector_ts)) == NULL) {
bgpstream_log_warn(
"\tBSF_MGR: can't allocate memory for collectortype map");
}
}
bs_filter_mgr->rib_period = period;
bgpstream_debug("\tBSF_MGR:: add_filter end");
}
void bgpstream_set_data_interface_option(bgpstream_t *bs,
bgpstream_data_interface_option_t *option_type,
const char *option_value) {
bgpstream_debug("BS: set_data_interface_options start");
if(bs == NULL || (bs != NULL && bs->status != BGPSTREAM_STATUS_ALLOCATED)) {
return; // nothing to customize
}
bgpstream_datasource_mgr_set_data_interface_option(bs->datasource_mgr,
option_type, option_value);
bgpstream_debug("BS: set_data_interface_options stop");
}
bgpstream_csvfile_datasource_t *
bgpstream_csvfile_datasource_create(bgpstream_filter_mgr_t *filter_mgr,
char *csvfile_file)
{
bgpstream_debug("\t\tBSDS_CSVFILE: create csvfile_ds start");
bgpstream_csvfile_datasource_t *csvfile_ds = (bgpstream_csvfile_datasource_t*) malloc_zero(sizeof(bgpstream_csvfile_datasource_t));
if(csvfile_ds == NULL) {
bgpstream_log_err("\t\tBSDS_CSVFILE: create csvfile_ds can't allocate memory");
goto err;
}
if(csvfile_file == NULL)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: create csvfile_ds no file provided");
goto err;
}
if((csvfile_ds->csvfile_file = strdup(csvfile_file)) == NULL)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: can't allocate memory for filename");
goto err;
}
/* cvs file parser options */
unsigned char options = CSV_STRICT | CSV_REPALL_NL | CSV_STRICT_FINI |
CSV_APPEND_NULL | CSV_EMPTY_IS_NULL;
if(csv_init(&(csvfile_ds->parser), options) !=0)
{
bgpstream_log_err("\t\tBSDS_CSVFILE: can't initialize csv parser");
goto err;
}
csvfile_ds->current_field = CSVFILE_PATH;
csvfile_ds->filter_mgr = filter_mgr;
csvfile_ds->input_mgr = NULL;
csvfile_ds->num_results = 0;
csvfile_ds->max_ts_infile = 0;
csvfile_ds->last_processed_ts = 0;
csvfile_ds->max_accepted_ts = 0;
bgpstream_debug("\t\tBSDS_CSVFILE: create csvfile_ds end");
return csvfile_ds;
err:
bgpstream_csvfile_datasource_destroy(csvfile_ds);
return NULL;
}
/* destroy a bgpstream interface istance
*/
void bgpstream_destroy(bgpstream_t *bs){
bgpstream_debug("BS: destroy start");
if(bs == NULL) {
return; // nothing to destroy
}
bgpstream_input_mgr_destroy(bs->input_mgr);
bs->input_mgr = NULL;
bgpstream_reader_mgr_destroy(bs->reader_mgr);
bs->reader_mgr = NULL;
bgpstream_filter_mgr_destroy(bs->filter_mgr);
bs->filter_mgr = NULL;
bgpstream_datasource_mgr_destroy(bs->datasource_mgr);
bs->datasource_mgr = NULL;
free(bs);
bgpstream_debug("BS: destroy end");
}
static int bgpstream_parse_quotedvalue(char *value, fp_state_t *state,
bgpstream_filter_item_t *curr)
{
char *endquote = NULL;
/* Check for end quote */
endquote = strchr(value, '"');
if (endquote != NULL) {
*endquote = '\0';
*state = ENDVALUE;
}
if (strlen(value) == 0)
return *state;
if (curr->value == NULL) {
curr->value = strdup(value);
} else {
/* Append this part of the value to whatever we've already got */
/* +2 = 1 byte for space, 1 byte for null */
curr->value = realloc(curr->value, strlen(curr->value) + strlen(value) + 2);
assert(curr->value);
strncat(curr->value, " ", 1);
strncat(curr->value, value, strlen(value));
}
if (*state == ENDVALUE) {
/* Create our new filter here? */
bgpstream_debug("Set our quoted value to %s", curr->value);
}
return *state;
}
bgpstream_datasource_mgr_t *bgpstream_datasource_mgr_create()
{
bgpstream_debug("\tBSDS_MGR: create start");
bgpstream_datasource_mgr_t *datasource_mgr =
(bgpstream_datasource_mgr_t *)malloc(sizeof(bgpstream_datasource_mgr_t));
if (datasource_mgr == NULL) {
return NULL; // can't allocate memory
}
// default values
datasource_mgr->datasource =
BGPSTREAM_DATA_INTERFACE_BROKER; // default data source
datasource_mgr->blocking = 0;
datasource_mgr->backoff_time = DATASOURCE_BLOCKING_MIN_WAIT;
// datasources (none of them is active at the beginning)
#ifdef WITH_DATA_INTERFACE_SINGLEFILE
datasource_mgr->singlefile_ds = NULL;
GET_DEFAULT_STR_VALUE(datasource_mgr->singlefile_rib_mrtfile,
BGPSTREAM_DS_SINGLEFILE_RIB_FILE);
GET_DEFAULT_STR_VALUE(datasource_mgr->singlefile_upd_mrtfile,
BGPSTREAM_DS_SINGLEFILE_UPDATE_FILE);
#endif
#ifdef WITH_DATA_INTERFACE_CSVFILE
datasource_mgr->csvfile_ds = NULL;
GET_DEFAULT_STR_VALUE(datasource_mgr->csvfile_file,
BGPSTREAM_DS_CSVFILE_CSV_FILE);
#endif
#ifdef WITH_DATA_INTERFACE_SQLITE
datasource_mgr->sqlite_ds = NULL;
GET_DEFAULT_STR_VALUE(datasource_mgr->sqlite_file,
BGPSTREAM_DS_SQLITE_DB_FILE);
#endif
#ifdef WITH_DATA_INTERFACE_BROKER
datasource_mgr->broker_ds = NULL;
GET_DEFAULT_STR_VALUE(datasource_mgr->broker_url, BGPSTREAM_DS_BROKER_URL);
datasource_mgr->broker_params = NULL;
datasource_mgr->broker_params_cnt = 0;
#endif
datasource_mgr->status = BGPSTREAM_DATASOURCE_STATUS_OFF;
bgpstream_debug("\tBSDS_MGR: create end");
return datasource_mgr;
}
void
bgpstream_csvfile_datasource_destroy(bgpstream_csvfile_datasource_t* csvfile_ds) {
bgpstream_debug("\t\tBSDS_CSVFILE: destroy csvfile_ds start");
if(csvfile_ds == NULL) {
return; // nothing to destroy
}
csvfile_ds->filter_mgr = NULL;
if(csvfile_ds->csvfile_file !=NULL)
{
free(csvfile_ds->csvfile_file);
}
if(&(csvfile_ds->parser) != NULL)
{
csv_free(&(csvfile_ds->parser));
}
free(csvfile_ds);
bgpstream_debug("\t\tBSDS_CSVFILE: destroy csvfile_ds end");
}
void bgpstream_datasource_mgr_destroy(
bgpstream_datasource_mgr_t *datasource_mgr)
{
bgpstream_debug("\tBSDS_MGR: destroy start");
if (datasource_mgr == NULL) {
return; // no manager to destroy
}
// destroy any active datasource (if they have not been destroyed before)
#ifdef WITH_DATA_INTERFACE_SINGLEFILE
bgpstream_singlefile_datasource_destroy(datasource_mgr->singlefile_ds);
datasource_mgr->singlefile_ds = NULL;
free(datasource_mgr->singlefile_rib_mrtfile);
free(datasource_mgr->singlefile_upd_mrtfile);
#endif
#ifdef WITH_DATA_INTERFACE_CSVFILE
bgpstream_csvfile_datasource_destroy(datasource_mgr->csvfile_ds);
datasource_mgr->csvfile_ds = NULL;
free(datasource_mgr->csvfile_file);
#endif
#ifdef WITH_DATA_INTERFACE_SQLITE
bgpstream_sqlite_datasource_destroy(datasource_mgr->sqlite_ds);
datasource_mgr->sqlite_ds = NULL;
free(datasource_mgr->sqlite_file);
#endif
#ifdef WITH_DATA_INTERFACE_BROKER
bgpstream_broker_datasource_destroy(datasource_mgr->broker_ds);
datasource_mgr->broker_ds = NULL;
free(datasource_mgr->broker_url);
int i;
for (i = 0; i < datasource_mgr->broker_params_cnt; i++) {
free(datasource_mgr->broker_params[i]);
datasource_mgr->broker_params[i] = NULL;
}
free(datasource_mgr->broker_params);
datasource_mgr->broker_params = NULL;
datasource_mgr->broker_params_cnt = 0;
#endif
free(datasource_mgr);
bgpstream_debug("\tBSDS_MGR: destroy end");
}
void bgpstream_datasource_mgr_close(bgpstream_datasource_mgr_t *datasource_mgr)
{
bgpstream_debug("\tBSDS_MGR: close start");
if (datasource_mgr == NULL) {
return; // no manager to destroy
}
switch (datasource_mgr->datasource) {
#ifdef WITH_DATA_INTERFACE_SINGLEFILE
case BGPSTREAM_DATA_INTERFACE_SINGLEFILE:
bgpstream_singlefile_datasource_destroy(datasource_mgr->singlefile_ds);
datasource_mgr->singlefile_ds = NULL;
break;
#endif
#ifdef WITH_DATA_INTERFACE_CSVFILE
case BGPSTREAM_DATA_INTERFACE_CSVFILE:
bgpstream_csvfile_datasource_destroy(datasource_mgr->csvfile_ds);
datasource_mgr->csvfile_ds = NULL;
break;
#endif
#ifdef WITH_DATA_INTERFACE_SQLITE
case BGPSTREAM_DATA_INTERFACE_SQLITE:
bgpstream_sqlite_datasource_destroy(datasource_mgr->sqlite_ds);
datasource_mgr->sqlite_ds = NULL;
break;
#endif
#ifdef WITH_DATA_INTERFACE_BROKER
case BGPSTREAM_DATA_INTERFACE_BROKER:
bgpstream_broker_datasource_destroy(datasource_mgr->broker_ds);
datasource_mgr->broker_ds = NULL;
break;
#endif
default:
assert(0);
break;
}
datasource_mgr->status = BGPSTREAM_DATASOURCE_STATUS_OFF;
bgpstream_debug("\tBSDS_MGR: close end");
}
int
bgpstream_singlefile_datasource_update_input_queue(bgpstream_singlefile_datasource_t* singlefile_ds,
bgpstream_input_mgr_t *input_mgr)
{
bgpstream_debug("\t\tBSDS_CLIST: singlefile_ds update input queue start");
struct timeval tv;
gettimeofday(&tv, NULL);
uint32_t now = tv.tv_sec;
int num_results = 0;
/* check digest, if different (or first) then add files to input queue) */
if(singlefile_ds->rib_filename[0] != '\0' &&
now - singlefile_ds->last_rib_filetime > RIB_FREQUENCY_CHECK &&
same_header(singlefile_ds->rib_filename, singlefile_ds->rib_header) == 0)
{
/* fprintf(stderr, "new RIB at: %"PRIu32"\n", now); */
singlefile_ds->last_rib_filetime = now;
num_results += bgpstream_input_mgr_push_sorted_input(input_mgr, strdup(singlefile_ds->rib_filename),
strdup("singlefile_ds"),
strdup("singlefile_ds"),
strdup("ribs"),
singlefile_ds->last_rib_filetime,
RIB_FREQUENCY_CHECK);
}
if(singlefile_ds->update_filename[0] != '\0' &&
now - singlefile_ds->last_update_filetime > UPDATE_FREQUENCY_CHECK &&
same_header(singlefile_ds->update_filename, singlefile_ds->update_header) == 0)
{
/* fprintf(stderr, "new updates at: %"PRIu32"\n", now); */
singlefile_ds->last_update_filetime = now;
num_results += bgpstream_input_mgr_push_sorted_input(input_mgr, strdup(singlefile_ds->update_filename),
strdup("singlefile_ds"),
strdup("singlefile_ds"),
strdup("updates"),
singlefile_ds->last_update_filetime,
UPDATE_FREQUENCY_CHECK);
}
bgpstream_debug("\t\tBSDS_CLIST: singlefile_ds update input queue end");
return num_results;
}
static int bgpstream_parse_prefixext(char *ext, fp_state_t *state,
bgpstream_filter_item_t *curr)
{
assert(curr->termtype == BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_MORE);
if (strcmp(ext, "any") == 0) {
/* Any prefix that our prefix belongs to */
bgpstream_debug("Got an 'any' prefix");
curr->termtype = BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_ANY;
*state = VALUE;
return *state;
}
if (strcmp(ext, "more") == 0) {
/* Either match this prefix or any more specific prefixes */
bgpstream_debug("Got an 'more' prefix");
curr->termtype = BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_MORE;
*state = VALUE;
return *state;
}
if (strcmp(ext, "less") == 0) {
/* Either match this prefix or any less specific prefixes */
bgpstream_debug("Got an 'less' prefix");
curr->termtype = BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_LESS;
*state = VALUE;
return *state;
}
if (strcmp(ext, "exact") == 0) {
/* Only match exactly this prefix */
bgpstream_debug("Got an 'exact' prefix");
curr->termtype = BGPSTREAM_FILTER_TYPE_ELEM_PREFIX_EXACT;
*state = VALUE;
return *state;
}
/* At this point, assume we're looking at a value instead */
return bgpstream_parse_value(ext, state, curr);
}
/* allocate memory for a bs_record */
bgpstream_record_t *bgpstream_record_create()
{
bgpstream_debug("BS: create record start");
bgpstream_record_t *bs_record;
if ((bs_record = (bgpstream_record_t *)malloc(sizeof(bgpstream_record_t))) ==
NULL) {
return NULL; // can't allocate memory
}
bs_record->bs = NULL;
bs_record->bd_entry = NULL;
if ((bs_record->elem_generator = bgpstream_elem_generator_create()) == NULL) {
bgpstream_record_destroy(bs_record);
return NULL;
}
bgpstream_record_clear(bs_record);
bgpstream_debug("BS: create record end");
return bs_record;
}
/* free memory associated to a bs_record */
void bgpstream_record_destroy(bgpstream_record_t *const bs_record)
{
bgpstream_debug("BS: destroy record start");
if (bs_record == NULL) {
bgpstream_debug("BS: record destroy end");
return; // nothing to do
}
if (bs_record->bd_entry != NULL) {
bgpstream_debug("BS - free bs_record->bgpdump_entry");
bgpdump_free_mem(bs_record->bd_entry);
bs_record->bd_entry = NULL;
}
if (bs_record->elem_generator != NULL) {
bgpstream_elem_generator_destroy(bs_record->elem_generator);
bs_record->elem_generator = NULL;
}
bgpstream_debug("BS - free bs_record");
free(bs_record);
bgpstream_debug("BS: destroy record end");
}
