void
alloc_value_block(void (*alloc_func) (vector_t *))
{
char *buf;
char *str = NULL;
vector_t *vec = NULL;
buf = (char *) MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = vector_slot(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (vector_size(vec))
(*alloc_func) (vec);
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
}
int
alloc_value_block(vector strvec, void (*alloc_func) (vector))
{
char *buf;
char *str = NULL;
vector vec = NULL;
buf = (char *) MALLOC(MAXBUF);
if (!buf)
return 1;
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = VECTOR_SLOT(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (VECTOR_SIZE(vec))
(*alloc_func) (vec);
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return 0;
}
vector_t *
read_value_block(vector_t *strvec)
{
char *buf;
unsigned int word;
char *str = NULL;
char *dup;
vector_t *vec = NULL;
vector_t *elements = vector_alloc();
int first = 1;
int need_bob = 1;
int got_eob = 0;
buf = (char *) MALLOC(MAXBUF);
while (first || read_line(buf, MAXBUF)) {
if (first && vector_size(strvec) > 1) {
vec = strvec;
word = 1;
}
else {
vec = alloc_strvec(buf);
word = 0;
}
if (vec) {
str = vector_slot(vec, word);
if (need_bob) {
if (!strcmp(str, BOB))
word++;
else
log_message(LOG_INFO, "'{' missing at beginning of block %s", FMT_STR_VSLOT(strvec,0));
need_bob = 0;
}
for (; word < vector_size(vec); word++) {
str = vector_slot(vec, word);
if (!strcmp(str, EOB)) {
if (word != vector_size(vec) - 1)
log_message(LOG_INFO, "Extra characters after '}' - \"%s\"", buf);
got_eob = 1;
break;
}
dup = (char *) MALLOC(strlen(str) + 1);
memcpy(dup, str, strlen(str));
vector_alloc_slot(elements);
vector_set_slot(elements, dup);
}
if (vec != strvec)
free_strvec(vec);
if (got_eob)
break;
}
memset(buf, 0, MAXBUF);
first = 0;
}
FREE(buf);
return elements;
}
vector
read_value_block(void)
{
char *buf;
int i;
char *str = NULL;
char *dup;
vector vec = NULL;
vector elements = vector_alloc();
if (!elements)
return NULL;
buf = (char *) MALLOC(MAXBUF);
if (!buf)
return NULL;
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = VECTOR_SLOT(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (VECTOR_SIZE(vec))
for (i = 0; i < VECTOR_SIZE(vec); i++) {
str = VECTOR_SLOT(vec, i);
dup = (char *) MALLOC(strlen(str) + 1);
if (!dup)
goto out;
memcpy(dup, str, strlen(str));
if (!vector_alloc_slot(elements)) {
free_strvec(vec);
goto out1;
}
vector_set_slot(elements, dup);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return elements;
out1:
FREE(dup);
out:
FREE(buf);
return NULL;
}
int
process_stream(vector keywords)
{
int i;
int r = 0;
struct keyword *keyword;
char *str;
char *buf;
vector strvec;
buf = MALLOC(MAXBUF);
if (!buf)
return 1;
while (read_line(buf, MAXBUF)) {
strvec = alloc_strvec(buf);
memset(buf,0, MAXBUF);
if (!strvec)
continue;
str = VECTOR_SLOT(strvec, 0);
if (!strcmp(str, EOB) && kw_level > 0) {
free_strvec(strvec);
break;
}
for (i = 0; i < VECTOR_SIZE(keywords); i++) {
keyword = VECTOR_SLOT(keywords, i);
if (!strcmp(keyword->string, str)) {
if (keyword->handler)
r += (*keyword->handler) (strvec);
if (keyword->sub) {
kw_level++;
r += process_stream(keyword->sub);
kw_level--;
}
break;
}
}
free_strvec(strvec);
}
FREE(buf);
return r;
}
void
process_stream(vector_t *keywords_vec)
{
int i;
keyword_t *keyword_vec;
char *str;
char *buf;
vector_t *strvec;
vector_t *prev_keywords = current_keywords;
current_keywords = keywords_vec;
buf = zalloc(MAXBUF);
while (read_line(buf, MAXBUF)) {
strvec = alloc_strvec(buf);
memset(buf,0, MAXBUF);
if (!strvec)
continue;
str = vector_slot(strvec, 0);
if (!strcmp(str, EOB) && kw_level > 0) {
free_strvec(strvec);
break;
}
for (i = 0; i < vector_size(keywords_vec); i++) {
keyword_vec = vector_slot(keywords_vec, i);
if (!strcmp(keyword_vec->string, str)) {
if (keyword_vec->handler)
(*keyword_vec->handler) (strvec);
if (keyword_vec->sub) {
kw_level++;
process_stream(keyword_vec->sub);
kw_level--;
if (keyword_vec->sub_close_handler)
(*keyword_vec->sub_close_handler) ();
}
break;
}
}
free_strvec(strvec);
}
current_keywords = prev_keywords;
free(buf);
return;
}
int
check_include(char *buf)
{
char *str;
vector_t *strvec;
char *path;
int ret;
strvec = alloc_strvec(buf);
if (!strvec){
return 0;
}
str = vector_slot(strvec, 0);
if (!strcmp(str, EOB)) {
free_strvec(strvec);
return 0;
}
if(!strcmp("include", str) && vector_size(strvec) == 2){
char *conf_file = vector_slot(strvec, 1);
FILE *prev_stream = current_stream;
char *prev_conf_file = current_conf_file;
char prev_path[MAXBUF];
path = getcwd(prev_path, MAXBUF);
if (!path) {
log_message(LOG_INFO, "getcwd(%s) error (%s)\n"
, prev_path, strerror(errno));
}
read_conf_file(conf_file);
current_stream = prev_stream;
current_conf_file = prev_conf_file;
ret = chdir(prev_path);
if (ret < 0) {
log_message(LOG_INFO, "chdir(%s) error (%s)\n"
, prev_path, strerror(errno));
}
free_strvec(strvec);
return 1;
}
free_strvec(strvec);
return 0;
}
static void
vrrp_vip_handler(vector_t *strvec)
{
vrrp_t *vrrp = LIST_TAIL_DATA(vrrp_data->vrrp);
char *buf;
char *str = NULL;
vector_t *vec = NULL;
int address_family;
buf = (char *) MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
address_family = AF_UNSPEC;
vec = alloc_strvec(buf);
if (vec) {
str = vector_slot(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (vector_size(vec)) {
alloc_vrrp_vip(vec);
if (!LIST_ISEMPTY(vrrp->vip))
address_family = IP_FAMILY((ip_address_t*)LIST_TAIL_DATA(vrrp->vip));
}
if (address_family != AF_UNSPEC) {
if (vrrp->family == AF_UNSPEC)
vrrp->family = address_family;
else if (address_family != vrrp->family) {
log_message(LOG_INFO, "(%s): address family must match VRRP instance [%s] - ignoring", vrrp->iname, buf);
free_list_element(vrrp->vip, LIST_TAIL_DATA(vrrp->vip));
}
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
}
static void
vrrp_vip_handler(vector_t *strvec)
{
vrrp_t *vrrp = LIST_TAIL_DATA(vrrp_data->vrrp);
char *buf;
char *str = NULL;
vector_t *vec = NULL;
int nbvip = 0;
buf = (char *) MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = vector_slot(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (vector_size(vec)) {
nbvip++;
if (nbvip > VRRP_MAX_VIP) {
log_message(LOG_INFO,
"VRRP_Instance(%s) "
"trunc to the first %d VIPs.",
vrrp->iname, VRRP_MAX_VIP);
log_message(LOG_INFO,
" => Declare others VIPs into"
" the excluded vip block");
} else
alloc_vrrp_vip(vec);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
}
vector_t *
read_value_block(void)
{
char *buf;
int i;
char *str = NULL;
char *dup;
vector_t *vec = NULL;
vector_t *elements = vector_alloc();
buf = (char *) MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
vec = alloc_strvec(buf);
if (vec) {
str = vector_slot(vec, 0);
if (!strcmp(str, EOB)) {
free_strvec(vec);
break;
}
if (vector_size(vec))
for (i = 0; i < vector_size(vec); i++) {
str = vector_slot(vec, i);
dup = (char *) MALLOC(strlen(str) + 1);
memcpy(dup, str, strlen(str));
vector_alloc_slot(elements);
vector_set_slot(elements, dup);
}
free_strvec(vec);
}
memset(buf, 0, MAXBUF);
}
FREE(buf);
return elements;
}
static bool
check_include(char *buf)
{
vector_t *strvec;
bool ret = false;
FILE *prev_stream;
strvec = alloc_strvec(buf);
if (!strvec)
return false;
if(!strcmp("include", vector_slot(strvec, 0)) && vector_size(strvec) == 2) {
prev_stream = current_stream;
read_conf_file(vector_slot(strvec, 1));
current_stream = prev_stream;
ret = true;
}
free_strvec(strvec);
return ret;
}
static void
process_stream(vector_t *keywords_vec, int need_bob)
{
unsigned int i;
keyword_t *keyword_vec;
char *str;
char *buf;
vector_t *strvec;
vector_t *prev_keywords = current_keywords;
current_keywords = keywords_vec;
int bob_needed = 0;
size_t config_id_len = 0;
char *buf_start;
if (config_id)
config_id_len = strlen(config_id);
buf = MALLOC(MAXBUF);
while (read_line(buf, MAXBUF)) {
if (buf[0] == '@') {
/* If the line starts '@', check the following word matches the system id */
if (!config_id)
continue;
buf_start = strpbrk(buf, " \t");
if ((size_t)(buf_start - (buf + 1)) != config_id_len ||
strncmp(buf + 1, config_id, config_id_len))
continue;
}
else
buf_start = buf;
strvec = alloc_strvec(buf_start);
memset(buf, 0, MAXBUF);
if (!strvec)
continue;
str = vector_slot(strvec, 0);
if (skip_sublevel == -1) {
/* There wasn't a '{' on the keyword line */
if (!strcmp(str, BOB)) {
/* We've got the opening '{' now */
skip_sublevel = 1;
free_strvec(strvec);
continue;
}
else {
/* The skipped keyword doesn't have a {} block, so we no longer want to skip */
skip_sublevel = 0;
}
}
if (skip_sublevel) {
for (i = 0; i < vector_size(strvec); i++) {
str = vector_slot(strvec,i);
if (!strcmp(str,BOB))
skip_sublevel++;
else if (!strcmp(str,EOB)) {
if (--skip_sublevel == 0)
break;
}
}
free_strvec(strvec);
continue;
}
if (need_bob) {
need_bob = 0;
if (!strcmp(str, BOB) && kw_level > 0) {
free_strvec(strvec);
continue;
}
else
log_message(LOG_INFO, "Missing '{' at beginning of configuration block");
}
else if (!strcmp(str, BOB)) {
log_message(LOG_INFO, "Unexpected '{' - ignoring");
free_strvec(strvec);
continue;
}
if (!strcmp(str, EOB) && kw_level > 0) {
free_strvec(strvec);
break;
}
for (i = 0; i < vector_size(keywords_vec); i++) {
keyword_vec = vector_slot(keywords_vec, i);
if (!strcmp(keyword_vec->string, str)) {
if (!keyword_vec->active) {
if (!strcmp(vector_slot(strvec, vector_size(strvec)-1), BOB))
skip_sublevel = 1;
else
skip_sublevel = -1;
}
/* There is an inconsistency here. 'static_ipaddress' for example
* does not have sub levels, but needs a '{' */
if (keyword_vec->sub) {
/* Remove a trailing '{' */
char *bob = vector_slot(strvec, vector_size(strvec)-1) ;
if (!strcmp(bob, BOB)) {
vector_unset(strvec, vector_size(strvec)-1);
FREE(bob);
bob_needed = 0;
}
else
bob_needed = 1;
}
if (keyword_vec->handler)
(*keyword_vec->handler) (strvec);
if (keyword_vec->sub) {
kw_level++;
process_stream(keyword_vec->sub, bob_needed);
kw_level--;
if (keyword_vec->active && keyword_vec->sub_close_handler)
(*keyword_vec->sub_close_handler) ();
}
break;
}
}
if (i >= vector_size(keywords_vec))
log_message(LOG_INFO, "Unknown keyword '%s'", str );
free_strvec(strvec);
}
current_keywords = prev_keywords;
FREE(buf);
return;
}
static void
read_file(const char* file_name, list *l, uint32_t max)
{
FILE *fp;
rt_entry_t *rte;
vector_t *strvec = NULL;
char buf[MAX_RT_BUF];
unsigned long id;
char *number;
char *endptr;
fp = fopen(file_name, "r");
if (!fp)
return;
while (fgets(buf, MAX_RT_BUF, fp)) {
strvec = alloc_strvec(buf);
if (!strvec)
continue;
if (vector_size(strvec) != 2) {
free_strvec(strvec);
continue;
}
rte = MALLOC(sizeof(rt_entry_t));
if (!rte) {
free_strvec(strvec);
goto err;
}
number = strvec_slot(strvec, 0);
number += strspn(number, " \t");
id = strtoul(number, &endptr, 0);
if (*number == '-' || number == endptr || *endptr || id > max) {
FREE(rte);
free_strvec(strvec);
continue;
}
rte->id = (unsigned)id;
rte->name = MALLOC(strlen(FMT_STR_VSLOT(strvec, 1)) + 1);
if (!rte->name) {
FREE(rte);
free_strvec(strvec);
goto err;
}
strcpy(rte->name, FMT_STR_VSLOT(strvec, 1));
list_add(*l, rte);
free_strvec(strvec);
}
fclose(fp);
return;
err:
fclose(fp);
if (strvec)
free_strvec(strvec);
free_list(l);
return;
}
static int
get_cmdvec (char * cmd, vector *v)
{
int i;
int r = 0;
int get_param = 0;
char * buff;
struct key * kw = NULL;
struct key * cmdkw = NULL;
vector cmdvec, strvec;
strvec = alloc_strvec(cmd);
if (!strvec)
return E_NOMEM;
cmdvec = vector_alloc();
if (!cmdvec) {
free_strvec(strvec);
return E_NOMEM;
}
vector_foreach_slot(strvec, buff, i) {
if (*buff == '"')
continue;
if (get_param) {
get_param = 0;
cmdkw->param = strdup(buff);
continue;
}
kw = find_key(buff);
if (!kw) {
r = E_SYNTAX;
goto out;
}
cmdkw = alloc_key();
if (!cmdkw) {
r = E_NOMEM;
goto out;
}
if (!vector_alloc_slot(cmdvec)) {
FREE(cmdkw);
r = E_NOMEM;
goto out;
}
vector_set_slot(cmdvec, cmdkw);
cmdkw->code = kw->code;
cmdkw->has_param = kw->has_param;
if (kw->has_param)
get_param = 1;
}
if (get_param) {
r = E_NOPARM;
goto out;
}
*v = cmdvec;
free_strvec(strvec);
return 0;
out:
free_strvec(strvec);
free_keys(cmdvec);
return r;
}
static int
process_stream(struct config *conf, FILE *stream, vector keywords, char *file)
{
int i;
int r = 0, t;
struct keyword *keyword;
char *str;
char *buf;
vector strvec;
vector uniques;
uniques = vector_alloc();
if (!uniques)
return 1;
buf = MALLOC(MAXBUF);
if (!buf) {
vector_free(uniques);
return 1;
}
while (read_line(stream, buf, MAXBUF)) {
line_nr++;
strvec = alloc_strvec(buf);
if (!strvec)
continue;
if (validate_config_strvec(strvec, file) != 0) {
free_strvec(strvec);
continue;
}
str = VECTOR_SLOT(strvec, 0);
if (!strcmp(str, EOB)) {
if (kw_level > 0) {
free_strvec(strvec);
break;
}
condlog(0, "unmatched '%s' at line %d of %s",
EOB, line_nr, file);
}
for (i = 0; i < VECTOR_SIZE(keywords); i++) {
keyword = VECTOR_SLOT(keywords, i);
if (!strcmp(keyword->string, str)) {
if (keyword->unique &&
warn_on_duplicates(uniques, str, file)) {
r = 1;
free_strvec(strvec);
goto out;
}
if (keyword->handler) {
t = (*keyword->handler) (conf, strvec);
r += t;
if (t)
condlog(1, "multipath.conf +%d, parsing failed: %s",
line_nr, buf);
}
if (keyword->sub) {
kw_level++;
r += process_stream(conf, stream,
keyword->sub, file);
kw_level--;
}
break;
}
}
if (i >= VECTOR_SIZE(keywords))
condlog(1, "%s line %d, invalid keyword: %s",
file, line_nr, str);
free_strvec(strvec);
}
out:
FREE(buf);
free_uniques(uniques);
return r;
}
static bool
read_rttables(void)
{
FILE *fp;
rt_entry_t *rte;
vector_t *strvec = NULL;
char buf[MAX_RT_TABLES_BUF];
if (rt_list)
return true;
fp = fopen(RT_TABLES_FILE, "r");
if (!fp) {
if (errno == EACCES || errno == EISDIR || errno == ENOENT) {
/* This is a permanent error, so don't keep trying to reopen the file */
rt_list = alloc_list(NULL, NULL);
return true;
}
return false;
}
rt_list = alloc_list(free_rt_entry, dump_rt_entry);
if (!rt_list)
goto err;
while (fgets(buf, MAX_RT_TABLES_BUF, fp)) {
strvec = alloc_strvec(buf);
if (!strvec)
continue;
if (vector_size(strvec) != 2) {
free_strvec(strvec);
continue;
}
rte = MALLOC(sizeof(rt_entry_t));
if (!rte)
goto err;
rte->id = strtoul(FMT_STR_VSLOT(strvec, 0), NULL, 0);
rte->name = MALLOC(strlen(FMT_STR_VSLOT(strvec, 1)) + 1);
if (!rte->name) {
FREE(rte);
goto err;
}
strcpy(rte->name, FMT_STR_VSLOT(strvec, 1));
list_add(rt_list, rte);
free_strvec(strvec);
strvec = NULL;
}
fclose(fp);
return true;
err:
fclose(fp);
if (!strvec)
free_strvec(strvec);
free_list(&rt_list);
return false;
}
