void PG_Lock(struct DBdesc *db)
{
PGresult *PGret;
if (!db->fail) {
PGret = PQexec(db->desc, lock_clause);
if (PQresultStatus(PGret) != PGRES_COMMAND_OK) {
db->errmsg = PQresultErrorMessage(PGret);
sql_db_errmsg(db);
sql_db_fail(db);
}
PQclear(PGret);
/* If using COPY, let's initialize it */
if (config.sql_use_copy) {
PGret = PQexec(db->desc, copy_clause);
if (PQresultStatus(PGret) != PGRES_COPY_IN) {
db->errmsg = PQresultErrorMessage(PGret);
sql_db_errmsg(db);
sql_db_fail(db);
}
else Log(LOG_DEBUG, "DEBUG ( %s/%s ): %s\n", config.name, config.type, copy_clause);
PQclear(PGret);
}
}
}
int PG_cache_dbop_copy(struct DBdesc *db, struct db_cache *cache_elem, struct insert_data *idata)
{
PGresult *ret;
char *ptr_values, *ptr_where;
char default_delim[] = ",", delim_buf[SRVBUFLEN];
int num=0, have_flows=0;
if (config.what_to_count & COUNT_FLOWS) have_flows = TRUE;
if (!config.sql_delimiter)
snprintf(delim_buf, SRVBUFLEN, "%s", default_delim);
else
snprintf(delim_buf, SRVBUFLEN, "%s", config.sql_delimiter);
/* constructing SQL query */
ptr_where = where_clause;
ptr_values = values_clause;
memset(where_clause, 0, sizeof(where_clause));
memset(values_clause, 0, sizeof(values_clause));
memcpy(&values, ©_values, sizeof(values));
while (num < idata->num_primitives) {
(*where[num].handler)(cache_elem, idata, num, &ptr_values, &ptr_where);
num++;
}
#if defined HAVE_64BIT_COUNTERS
if (have_flows) snprintf(ptr_values, SPACELEFT(values_clause), "%s%llu%s%llu%s%llu\n", delim_buf, cache_elem->packet_counter,
delim_buf, cache_elem->bytes_counter,
delim_buf, cache_elem->flows_counter);
else snprintf(ptr_values, SPACELEFT(values_clause), "%s%llu%s%llu\n", delim_buf, cache_elem->packet_counter,
delim_buf, cache_elem->bytes_counter);
#else
if (have_flows) snprintf(ptr_values, SPACELEFT(values_clause), "%s%lu%s%lu%s%lu\n", delim_buf, cache_elem->packet_counter,
delim_buf, cache_elem->bytes_counter,
delim_buf, cache_elem->flows_counter);
else snprintf(ptr_values, SPACELEFT(values_clause), "%s%lu%s%lu\n", delim_buf, cache_elem->packet_counter,
delim_buf, cache_elem->bytes_counter);
#endif
strncpy(sql_data, values_clause, SPACELEFT(sql_data));
if (PQputCopyData(db->desc, sql_data, strlen(sql_data)) < 0) { // avoid strlen()
db->errmsg = PQerrorMessage(db->desc);
Log(LOG_DEBUG, "DEBUG ( %s/%s ): FAILED query follows:\n%s\n", config.name, config.type, sql_data);
if (db->errmsg) Log(LOG_ERR, "ERROR ( %s/%s ): %s\n", config.name, config.type, db->errmsg);
sql_db_fail(db);
return TRUE;
}
idata->iqn++;
idata->een++;
Log(LOG_DEBUG, "DEBUG ( %s/%s ): %s\n", config.name, config.type, sql_data);
return FALSE;
}
void SQLI_Lock(struct DBdesc *db)
{
if (!db->fail) {
if (sqlite3_exec(db->desc, lock_clause, NULL, NULL, NULL)) {
SQLI_get_errmsg(db);
sql_db_errmsg(db);
sql_db_fail(db);
}
}
}
void MY_Lock(struct DBdesc *db)
{
if (!db->fail) {
if (mysql_query(db->desc, lock_clause)) {
MY_get_errmsg(db);
sql_db_errmsg(db);
sql_db_fail(db);
}
}
}
void SQLI_DB_Connect(struct DBdesc *db, char *host)
{
if (!db->fail) {
if (sqlite3_open(db->filename, (sqlite3 **)&db->desc)) {
sql_db_fail(db);
SQLI_get_errmsg(db);
sql_db_errmsg(db);
}
else sql_db_ok(db);
}
}
void MY_DB_Connect(struct DBdesc *db, char *host)
{
MYSQL *dbptr = db->desc;
if (!db->fail) {
mysql_init(db->desc);
dbptr->reconnect = TRUE;
if (!mysql_real_connect(db->desc, host, config.sql_user, config.sql_passwd, config.sql_db, 0, NULL, 0)) {
sql_db_fail(db);
MY_get_errmsg(db);
sql_db_errmsg(db);
}
else sql_db_ok(db);
}
}
void PG_DB_Connect(struct DBdesc *db, char *host)
{
if (!db->fail) {
db->desc = PQconnectdb(db->conn_string);
if (PQstatus(db->desc) == CONNECTION_BAD) {
char errmsg[64+SRVBUFLEN];
sql_db_fail(db);
strcpy(errmsg, "Failed connecting to ");
strcat(errmsg, db->conn_string);
db->errmsg = errmsg;
sql_db_errmsg(db);
}
else sql_db_ok(db);
}
}
void PG_cache_purge(struct db_cache *queue[], int index, struct insert_data *idata)
{
PGresult *ret;
struct logfile lf;
struct db_cache **reprocess_queries_queue, **bulk_reprocess_queries_queue;
char orig_insert_clause[LONGSRVBUFLEN], orig_update_clause[LONGSRVBUFLEN], orig_lock_clause[LONGSRVBUFLEN];
char orig_copy_clause[LONGSRVBUFLEN], tmpbuf[LONGLONGSRVBUFLEN], tmptable[SRVBUFLEN];
time_t start;
int j, r, reprocess = 0, stop, go_to_pending, reprocess_idx, bulk_reprocess_idx, saved_index = index;
struct primitives_ptrs prim_ptrs;
struct pkt_data dummy_data;
pid_t writer_pid = getpid();
if (!index) {
Log(LOG_INFO, "INFO ( %s/%s ): *** Purging cache - START (PID: %u) ***\n", config.name, config.type, writer_pid);
Log(LOG_INFO, "INFO ( %s/%s ): *** Purging cache - END (PID: %u, QN: 0/0, ET: 0) ***\n", config.name, config.type, writer_pid);
return;
}
bed.lf = &lf;
memset(&lf, 0, sizeof(struct logfile));
memset(&prim_ptrs, 0, sizeof(prim_ptrs));
memset(&dummy_data, 0, sizeof(dummy_data));
reprocess_queries_queue = (struct db_cache **) malloc(qq_size*sizeof(struct db_cache *));
bulk_reprocess_queries_queue = (struct db_cache **) malloc(qq_size*sizeof(struct db_cache *));
if (!reprocess_queries_queue || !bulk_reprocess_queries_queue) {
Log(LOG_ERR, "ERROR ( %s/%s ): malloc() failed (reprocess_queries_queue). Exiting ..\n", config.name, config.type);
exit_plugin(1);
}
for (j = 0, stop = 0; (!stop) && sql_preprocess_funcs[j]; j++)
stop = sql_preprocess_funcs[j](queue, &index, j);
if (config.what_to_count & COUNT_CLASS)
sql_invalidate_shadow_entries(queue, &index);
idata->ten = index;
Log(LOG_INFO, "INFO ( %s/%s ): *** Purging cache - START (PID: %u) ***\n", config.name, config.type, writer_pid);
start = time(NULL);
/* re-using pending queries queue stuff from parent and saving clauses */
memcpy(pending_queries_queue, queue, index*sizeof(struct db_cache *));
pqq_ptr = index;
strlcpy(orig_copy_clause, copy_clause, LONGSRVBUFLEN);
strlcpy(orig_insert_clause, insert_clause, LONGSRVBUFLEN);
strlcpy(orig_update_clause, update_clause, LONGSRVBUFLEN);
strlcpy(orig_lock_clause, lock_clause, LONGSRVBUFLEN);
start:
memcpy(queue, pending_queries_queue, pqq_ptr*sizeof(struct db_cache *));
memset(pending_queries_queue, 0, pqq_ptr*sizeof(struct db_cache *));
index = pqq_ptr; pqq_ptr = 0;
/* We check for variable substitution in SQL table */
if (idata->dyn_table) {
time_t stamp = 0;
memset(tmpbuf, 0, LONGLONGSRVBUFLEN);
stamp = queue[0]->basetime;
prim_ptrs.data = &dummy_data;
primptrs_set_all_from_db_cache(&prim_ptrs, queue[0]);
strlcpy(idata->dyn_table_name, config.sql_table, SRVBUFLEN);
strlcpy(insert_clause, orig_insert_clause, LONGSRVBUFLEN);
strlcpy(update_clause, orig_update_clause, LONGSRVBUFLEN);
strlcpy(lock_clause, orig_lock_clause, LONGSRVBUFLEN);
handle_dynname_internal_strings_same(tmpbuf, LONGSRVBUFLEN, copy_clause, &prim_ptrs);
handle_dynname_internal_strings_same(tmpbuf, LONGSRVBUFLEN, insert_clause, &prim_ptrs);
handle_dynname_internal_strings_same(tmpbuf, LONGSRVBUFLEN, update_clause, &prim_ptrs);
handle_dynname_internal_strings_same(tmpbuf, LONGSRVBUFLEN, lock_clause, &prim_ptrs);
handle_dynname_internal_strings_same(tmpbuf, LONGSRVBUFLEN, idata->dyn_table_name, &prim_ptrs);
strftime_same(copy_clause, LONGSRVBUFLEN, tmpbuf, &stamp);
strftime_same(insert_clause, LONGSRVBUFLEN, tmpbuf, &stamp);
strftime_same(update_clause, LONGSRVBUFLEN, tmpbuf, &stamp);
strftime_same(lock_clause, LONGSRVBUFLEN, tmpbuf, &stamp);
strftime_same(idata->dyn_table_name, LONGSRVBUFLEN, tmpbuf, &stamp);
if (config.sql_table_schema) sql_create_table(bed.p, &stamp, &prim_ptrs);
}
/* beginning DB transaction */
(*sqlfunc_cbr.lock)(bed.p);
/* for each element of the queue to be processed we execute sql_query(); the function
returns a non-zero value if DB has failed; then we use reprocess_queries_queue and
bulk_reprocess_queries_queue to handle reprocessing of specific elements or bulk
queue (of elements not being held in a pending_queries_queue) due to final COMMIT
failure */
memset(reprocess_queries_queue, 0, qq_size*sizeof(struct db_cache *));
memset(bulk_reprocess_queries_queue, 0, qq_size*sizeof(struct db_cache *));
reprocess_idx = 0; bulk_reprocess_idx = 0;
for (j = 0; j < index; j++) {
go_to_pending = FALSE;
if (idata->dyn_table) {
time_t stamp = 0;
memset(tmpbuf, 0, LONGLONGSRVBUFLEN); // XXX: pedantic?
stamp = queue[idata->current_queue_elem]->basetime;
strlcpy(tmptable, config.sql_table, SRVBUFLEN);
prim_ptrs.data = &dummy_data;
primptrs_set_all_from_db_cache(&prim_ptrs, queue[idata->current_queue_elem]);
handle_dynname_internal_strings_same(tmpbuf, LONGSRVBUFLEN, tmptable, &prim_ptrs);
strftime_same(tmptable, LONGSRVBUFLEN, tmpbuf, &stamp);
if (strncmp(idata->dyn_table_name, tmptable, SRVBUFLEN)) {
pending_queries_queue[pqq_ptr] = queue[idata->current_queue_elem];
pqq_ptr++;
go_to_pending = TRUE;
}
}
if (!go_to_pending) {
if (queue[j]->valid) {
r = sql_query(&bed, queue[j], idata);
/* note down all elements in case of a reprocess due to COMMIT failure */
bulk_reprocess_queries_queue[bulk_reprocess_idx] = queue[j];
bulk_reprocess_idx++;
}
else r = FALSE; /* not valid elements are marked as not to be reprocessed */
if (r) {
reprocess_queries_queue[reprocess_idx] = queue[j];
reprocess_idx++;
if (!reprocess) sql_db_fail(&p);
reprocess = REPROCESS_SPECIFIC;
}
}
}
/* Finalizing DB transaction */
if (!p.fail) {
if (config.sql_use_copy) {
if (PQputCopyEnd(p.desc, NULL) < 0) Log(LOG_ERR, "ERROR ( %s/%s ): COPY failed!\n\n", config.name, config.type);
}
ret = PQexec(p.desc, "COMMIT");
if (PQresultStatus(ret) != PGRES_COMMAND_OK) {
if (!reprocess) sql_db_fail(&p);
reprocess = REPROCESS_BULK;
}
PQclear(ret);
}
/* don't reprocess free (SQL_CACHE_FREE) and already recovered (SQL_CACHE_ERROR) elements */
if (p.fail) {
if (reprocess == REPROCESS_SPECIFIC) {
for (j = 0; j < reprocess_idx; j++) {
if (reprocess_queries_queue[j]->valid == SQL_CACHE_COMMITTED) sql_query(&bed, reprocess_queries_queue[j], idata);
}
}
else if (reprocess == REPROCESS_BULK) {
for (j = 0; j < bulk_reprocess_idx; j++) {
if (bulk_reprocess_queries_queue[j]->valid == SQL_CACHE_COMMITTED) sql_query(&bed, bulk_reprocess_queries_queue[j], idata);
}
}
}
if (b.connected) {
if (config.sql_use_copy) {
if (PQputCopyEnd(b.desc, NULL) < 0) Log(LOG_ERR, "ERROR ( %s/%s ): COPY failed!\n\n", config.name, config.type);
}
ret = PQexec(b.desc, "COMMIT");
if (PQresultStatus(ret) != PGRES_COMMAND_OK) sql_db_fail(&b);
PQclear(ret);
}
/* rewinding stuff */
if (lf.file) PG_file_close(&lf);
if (lf.fail || b.fail) Log(LOG_ALERT, "ALERT ( %s/%s ): recovery for PgSQL operation failed.\n", config.name, config.type);
/* If we have pending queries then start again */
if (pqq_ptr) goto start;
idata->elap_time = time(NULL)-start;
Log(LOG_INFO, "INFO ( %s/%s ): *** Purging cache - END (PID: %u, QN: %u/%u, ET: %u) ***\n",
config.name, config.type, writer_pid, idata->qn, saved_index, idata->elap_time);
if (config.sql_trigger_exec) {
if (!config.debug) idata->elap_time = time(NULL)-start;
SQL_SetENV_child(idata);
}
}
int PG_cache_dbop(struct DBdesc *db, struct db_cache *cache_elem, struct insert_data *idata)
{
PGresult *ret;
char *ptr_values, *ptr_where, *ptr_set, *ptr_insert;
int num=0, num_set=0, have_flows=0;
if (config.what_to_count & COUNT_FLOWS) have_flows = TRUE;
/* constructing SQL query */
ptr_where = where_clause;
ptr_values = values_clause;
ptr_set = set_clause;
ptr_insert = insert_full_clause;
memset(where_clause, 0, sizeof(where_clause));
memset(values_clause, 0, sizeof(values_clause));
memset(set_clause, 0, sizeof(set_clause));
memset(insert_full_clause, 0, sizeof(insert_full_clause));
for (num = 0; num < idata->num_primitives; num++)
(*where[num].handler)(cache_elem, idata, num, &ptr_values, &ptr_where);
if (cache_elem->flow_type == NF9_FTYPE_EVENT || cache_elem->flow_type == NF9_FTYPE_OPTION) {
for (num_set = 0; set_event[num_set].type; num_set++)
(*set_event[num_set].handler)(cache_elem, idata, num_set, &ptr_set, NULL);
}
else {
for (num_set = 0; set[num_set].type; num_set++)
(*set[num_set].handler)(cache_elem, idata, num_set, &ptr_set, NULL);
}
/* sending UPDATE query a) if not switched off and
b) if we actually have something to update */
if (!config.sql_dont_try_update && num_set) {
strncpy(sql_data, update_clause, SPACELEFT(sql_data));
strncat(sql_data, set_clause, SPACELEFT(sql_data));
strncat(sql_data, where_clause, SPACELEFT(sql_data));
ret = PQexec(db->desc, sql_data);
if (PQresultStatus(ret) != PGRES_COMMAND_OK) {
db->errmsg = PQresultErrorMessage(ret);
PQclear(ret);
Log(LOG_DEBUG, "DEBUG ( %s/%s ): FAILED query follows:\n%s\n", config.name, config.type, sql_data);
if (db->errmsg) Log(LOG_ERR, "ERROR ( %s/%s ): %s\n\n", config.name, config.type, db->errmsg);
sql_db_fail(db);
return TRUE;
}
PQclear(ret);
}
if (config.sql_dont_try_update || !num_set || (!PG_affected_rows(ret))) {
/* UPDATE failed, trying with an INSERT query */
if (cache_elem->flow_type == NF9_FTYPE_EVENT || cache_elem->flow_type == NF9_FTYPE_OPTION) {
strncpy(insert_full_clause, insert_clause, SPACELEFT(insert_full_clause));
strncat(insert_full_clause, insert_nocounters_clause, SPACELEFT(insert_full_clause));
strncat(ptr_values, ")", SPACELEFT(values_clause));
}
else {
strncpy(insert_full_clause, insert_clause, SPACELEFT(insert_full_clause));
strncat(insert_full_clause, insert_counters_clause, SPACELEFT(insert_full_clause));
#if defined HAVE_64BIT_COUNTERS
if (have_flows) snprintf(ptr_values, SPACELEFT(values_clause), ", %llu, %llu, %llu)", cache_elem->packet_counter, cache_elem->bytes_counter, cache_elem->flows_counter);
else snprintf(ptr_values, SPACELEFT(values_clause), ", %llu, %llu)", cache_elem->packet_counter, cache_elem->bytes_counter);
#else
if (have_flows) snprintf(ptr_values, SPACELEFT(values_clause), ", %lu, %lu, %lu)", cache_elem->packet_counter, cache_elem->bytes_counter, cache_elem->flows_counter);
else snprintf(ptr_values, SPACELEFT(values_clause), ", %lu, %lu)", cache_elem->packet_counter, cache_elem->bytes_counter);
#endif
}
strncpy(sql_data, insert_full_clause, sizeof(sql_data));
strncat(sql_data, values_clause, SPACELEFT(sql_data));
ret = PQexec(db->desc, sql_data);
if (PQresultStatus(ret) != PGRES_COMMAND_OK) {
db->errmsg = PQresultErrorMessage(ret);
PQclear(ret);
Log(LOG_DEBUG, "DEBUG ( %s/%s ): FAILED query follows:\n%s\n", config.name, config.type, sql_data);
if (db->errmsg) Log(LOG_ERR, "ERROR ( %s/%s ): %s\n\n", config.name, config.type, db->errmsg);
sql_db_fail(db);
return TRUE;
}
PQclear(ret);
idata->iqn++;
}
else idata->uqn++;
idata->een++;
Log(LOG_DEBUG, "DEBUG ( %s/%s ): %s\n\n", config.name, config.type, sql_data);
return FALSE;
}
/* Functions */
void sqlite3_plugin(int pipe_fd, struct configuration *cfgptr, void *ptr)
{
struct pkt_data *data;
struct ports_table pt;
struct pollfd pfd;
struct insert_data idata;
struct timezone tz;
time_t refresh_deadline;
int timeout;
int ret, num;
struct ring *rg = &((struct channels_list_entry *)ptr)->rg;
struct ch_status *status = ((struct channels_list_entry *)ptr)->status;
u_int32_t bufsz = ((struct channels_list_entry *)ptr)->bufsize;
struct pkt_bgp_primitives *pbgp;
char *dataptr;
unsigned char *rgptr;
int pollagain = TRUE;
u_int32_t seq = 1, rg_err_count = 0;
memcpy(&config, cfgptr, sizeof(struct configuration));
recollect_pipe_memory(ptr);
pm_setproctitle("%s [%s]", "SQLite3 Plugin", config.name);
memset(&idata, 0, sizeof(idata));
if (config.pidfile) write_pid_file_plugin(config.pidfile, config.type, config.name);
if (config.logfile) {
fclose(config.logfile_fd);
config.logfile_fd = open_logfile(config.logfile);
}
sql_set_signals();
sql_init_default_values();
SQLI_init_default_values(&idata);
SQLI_set_callbacks(&sqlfunc_cbr);
sql_set_insert_func();
/* some LOCAL initialization AFTER setting some default values */
reload_map = FALSE;
idata.now = time(NULL);
refresh_deadline = idata.now;
sql_init_maps(&nt, &nc, &pt);
sql_init_global_buffers();
sql_init_pipe(&pfd, pipe_fd);
sql_init_historical_acct(idata.now, &idata);
sql_init_triggers(idata.now, &idata);
sql_init_refresh_deadline(&refresh_deadline);
/* setting number of entries in _protocols structure */
while (_protocols[protocols_number].number != -1) protocols_number++;
/* building up static SQL clauses */
idata.num_primitives = SQLI_compose_static_queries();
glob_num_primitives = idata.num_primitives;
/* handling purge preprocessor */
set_preprocess_funcs(config.sql_preprocess, &prep);
/* setting up environment variables */
SQL_SetENV();
sql_link_backend_descriptors(&bed, &p, &b);
/* plugin main loop */
for(;;) {
poll_again:
status->wakeup = TRUE;
sql_calc_refresh_timeout(refresh_deadline, idata.now, &timeout);
ret = poll(&pfd, 1, timeout);
if (ret < 0) goto poll_again;
idata.now = time(NULL);
if (config.sql_history) {
while (idata.now > (idata.basetime + idata.timeslot)) {
time_t saved_basetime = idata.basetime;
idata.basetime += idata.timeslot;
if (config.sql_history == COUNT_MONTHLY)
idata.timeslot = calc_monthly_timeslot(idata.basetime, config.sql_history_howmany, ADD);
glob_basetime = idata.basetime;
idata.new_basetime = saved_basetime;
glob_new_basetime = saved_basetime;
}
}
switch (ret) {
case 0: /* timeout */
if (qq_ptr) sql_cache_flush(queries_queue, qq_ptr, &idata, FALSE);
switch (fork()) {
case 0: /* Child */
/* we have to ignore signals to avoid loops:
because we are already forked */
signal(SIGINT, SIG_IGN);
signal(SIGHUP, SIG_IGN);
pm_setproctitle("%s [%s]", "SQLite3 Plugin -- DB Writer", config.name);
if (qq_ptr && sql_writers.flags != CHLD_ALERT) {
if (sql_writers.flags == CHLD_WARNING) sql_db_fail(&p);
(*sqlfunc_cbr.connect)(&p, NULL);
(*sqlfunc_cbr.purge)(queries_queue, qq_ptr, &idata);
(*sqlfunc_cbr.close)(&bed);
}
if (config.sql_trigger_exec) {
if (idata.now > idata.triggertime) sql_trigger_exec(config.sql_trigger_exec);
}
exit(0);
default: /* Parent */
if (pqq_ptr) sql_cache_flush_pending(pending_queries_queue, pqq_ptr, &idata);
gettimeofday(&idata.flushtime, &tz);
while (idata.now > refresh_deadline)
refresh_deadline += config.sql_refresh_time;
while (idata.now > idata.triggertime && idata.t_timeslot > 0) {
idata.triggertime += idata.t_timeslot;
if (config.sql_trigger_time == COUNT_MONTHLY)
idata.t_timeslot = calc_monthly_timeslot(idata.triggertime, config.sql_trigger_time_howmany, ADD);
}
idata.new_basetime = FALSE;
glob_new_basetime = FALSE;
qq_ptr = pqq_ptr;
memcpy(queries_queue, pending_queries_queue, qq_ptr*sizeof(struct db_cache *));
if (reload_map) {
load_networks(config.networks_file, &nt, &nc);
load_ports(config.ports_file, &pt);
reload_map = FALSE;
}
break;
}
break;
default: /* we received data */
read_data:
if (!pollagain) {
seq++;
seq %= MAX_SEQNUM;
if (seq == 0) rg_err_count = FALSE;
idata.now = time(NULL);
}
else {
if ((ret = read(pipe_fd, &rgptr, sizeof(rgptr))) == 0)
exit_plugin(1); /* we exit silently; something happened at the write end */
}
if (((struct ch_buf_hdr *)rg->ptr)->seq != seq) {
if (!pollagain) {
pollagain = TRUE;
goto poll_again;
}
else {
rg_err_count++;
if (config.debug || (rg_err_count > MAX_RG_COUNT_ERR)) {
Log(LOG_ERR, "ERROR ( %s/%s ): We are missing data.\n", config.name, config.type);
Log(LOG_ERR, "If you see this message once in a while, discard it. Otherwise some solutions follow:\n");
Log(LOG_ERR, "- increase shared memory size, 'plugin_pipe_size'; now: '%u'.\n", config.pipe_size);
Log(LOG_ERR, "- increase buffer size, 'plugin_buffer_size'; now: '%u'.\n", config.buffer_size);
Log(LOG_ERR, "- increase system maximum socket size.\n\n");
}
seq = ((struct ch_buf_hdr *)rg->ptr)->seq;
}
}
pollagain = FALSE;
memcpy(pipebuf, rg->ptr, bufsz);
if ((rg->ptr+bufsz) >= rg->end) rg->ptr = rg->base;
else rg->ptr += bufsz;
/* lazy sql refresh handling */
if (idata.now > refresh_deadline) {
if (qq_ptr) sql_cache_flush(queries_queue, qq_ptr, &idata, FALSE);
switch (fork()) {
case 0: /* Child */
/* we have to ignore signals to avoid loops:
because we are already forked */
signal(SIGINT, SIG_IGN);
signal(SIGHUP, SIG_IGN);
pm_setproctitle("%s [%s]", "SQLite3 Plugin -- DB Writer", config.name);
if (qq_ptr && sql_writers.flags != CHLD_ALERT) {
if (sql_writers.flags == CHLD_WARNING) sql_db_fail(&p);
(*sqlfunc_cbr.connect)(&p, NULL);
(*sqlfunc_cbr.purge)(queries_queue, qq_ptr, &idata);
(*sqlfunc_cbr.close)(&bed);
}
if (config.sql_trigger_exec) {
if (idata.now > idata.triggertime) sql_trigger_exec(config.sql_trigger_exec);
}
exit(0);
default: /* Parent */
if (pqq_ptr) sql_cache_flush_pending(pending_queries_queue, pqq_ptr, &idata);
gettimeofday(&idata.flushtime, &tz);
while (idata.now > refresh_deadline)
refresh_deadline += config.sql_refresh_time;
while (idata.now > idata.triggertime && idata.t_timeslot > 0) {
idata.triggertime += idata.t_timeslot;
if (config.sql_trigger_time == COUNT_MONTHLY)
idata.t_timeslot = calc_monthly_timeslot(idata.triggertime, config.sql_trigger_time_howmany, ADD);
}
idata.new_basetime = FALSE;
glob_new_basetime = FALSE;
qq_ptr = pqq_ptr;
memcpy(queries_queue, pending_queries_queue, qq_ptr*sizeof(struct db_cache *));
if (reload_map) {
load_networks(config.networks_file, &nt, &nc);
load_ports(config.ports_file, &pt);
reload_map = FALSE;
}
break;
}
}
else {
if (config.sql_trigger_exec) {
while (idata.now > idata.triggertime && idata.t_timeslot > 0) {
sql_trigger_exec(config.sql_trigger_exec);
idata.triggertime += idata.t_timeslot;
if (config.sql_trigger_time == COUNT_MONTHLY)
idata.t_timeslot = calc_monthly_timeslot(idata.triggertime, config.sql_trigger_time_howmany, ADD);
}
}
}
data = (struct pkt_data *) (pipebuf+sizeof(struct ch_buf_hdr));
while (((struct ch_buf_hdr *)pipebuf)->num) {
for (num = 0; net_funcs[num]; num++)
(*net_funcs[num])(&nt, &nc, &data->primitives);
if (config.ports_file) {
if (!pt.table[data->primitives.src_port]) data->primitives.src_port = 0;
if (!pt.table[data->primitives.dst_port]) data->primitives.dst_port = 0;
}
if (PbgpSz) pbgp = (struct pkt_bgp_primitives *) ((u_char *)data+PdataSz);
else pbgp = NULL;
(*insert_func)(data, pbgp, &idata);
((struct ch_buf_hdr *)pipebuf)->num--;
if (((struct ch_buf_hdr *)pipebuf)->num) {
dataptr = (unsigned char *) data;
dataptr += PdataSz + PbgpSz;
data = (struct pkt_data *) dataptr;
}
}
goto read_data;
}
}
}
