static void account_au_fn(const char *token, char *value, void *setting, FILE *f) {
struct s_auth *account = setting;
if (value) {
// set default values for usage during runtime from Webif
account->autoau = 0;
if (!account->aureader_list)
account->aureader_list = ll_create("aureader_list");
if (streq(value, "1"))
account->autoau = 1;
strtolower(value);
ll_clear(account->aureader_list);
LL_ITER itr = ll_iter_create(configured_readers);
struct s_reader *rdr;
char *pch, *saveptr1 = NULL;
for (pch = strtok_r(value, ",", &saveptr1); pch != NULL; pch = strtok_r(NULL, ",", &saveptr1)) {
ll_iter_reset(&itr);
while ((rdr = ll_iter_next(&itr))) {
if (streq(rdr->label, pch) || account->autoau) {
ll_append(account->aureader_list, rdr);
}
}
}
return;
}
if (account->autoau == 1) {
fprintf_conf(f, token, "%d\n", account->autoau);
} else if (account->aureader_list) {
value = mk_t_aureader(account);
if (strlen(value) > 0)
fprintf_conf(f, token, "%s\n", value);
free_mk_t(value);
} else if (cfg.http_full_cfg) {
fprintf_conf(f, token, "%s\n", "");
}
}
/*
* returns string of comma separated values
*/
char *mk_t_emmbylen(struct s_reader *rdr)
{
char *value, *pos, *dot = "";
int32_t num, needed = 0;
struct s_emmlen_range *blocklen;
if(!rdr->blockemmbylen)
{
return "";
}
LL_ITER it = ll_iter_create(rdr->blockemmbylen);
while((blocklen = ll_iter_next(&it)))
{
needed += 5 + 1; // max digits of int16 + ","
if(blocklen->max == 0)
{
needed += 1 + 1; // "-" + ","
}
else if(blocklen->min != blocklen->max)
{
needed += 1 + 5 + 1; // "-" + max digits of int16 + ","
}
}
// the trailing zero is already included: it's the first ","
if(!cs_malloc(&value, needed))
{
return "";
}
pos = value;
ll_iter_reset(&it);
while((blocklen = ll_iter_next(&it)))
{
if(blocklen->min == blocklen->max)
{
num = snprintf(pos, needed, "%s%d", dot, blocklen->min);
}
else if(blocklen->max == 0)
{
num = snprintf(pos, needed, "%s%d-", dot, blocklen->min);
}
else
{
num = snprintf(pos, needed, "%s%d-%d", dot, blocklen->min, blocklen->max);
}
pos += num;
needed -= num;
dot = ",";
}
return value;
}
void log_list_thread(void)
{
char buf[LOG_BUF_SIZE];
int last_count=ll_count(log_list), count, grow_count=0, write_count;
do {
LL_ITER it = ll_iter_create(log_list);
struct s_log *log;
write_count = 0;
while ((log=ll_iter_next_remove(&it))) {
int8_t do_flush = ll_count(log_list) == 0; //flush on writing last element
cs_strncpy(buf, log->txt, LOG_BUF_SIZE);
if (log->direct_log)
cs_write_log(buf, do_flush);
else
write_to_log(buf, log, do_flush);
free(log->txt);
free(log);
//If list is faster growing than we could write to file, drop list:
write_count++;
if (write_count%10000 == 0) { //check every 10000 writes:
count = ll_count(log_list);
if (count > last_count) {
grow_count++;
if (grow_count > 5) { //5 times still growing
cs_write_log("------------->logging temporary disabled (30s) - too much data!\n", 1);
cfg.disablelog = 1;
ll_iter_reset(&it);
while ((log=ll_iter_next_remove(&it))) { //clear log
free(log->txt);
free(log);
}
cs_sleepms(30*1000);
cfg.disablelog = 0;
grow_count = 0;
last_count = 0;
break;
}
}
else
grow_count = 0;
last_count = count;
}
}
cs_sleepms(250);
} while(1);
}
