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 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; }
static void print_flist_1( flist_t *flist, char **ppfx, int parentoff) { char buf[16]; const field_t *f; const ftattr_t *fa; flist_t *fl; int low; int neednl; char **pfx; for (fl = flist; fl && !seenint(); fl = fl->sibling) { pfx = copy_strvec(ppfx); if (fl->name[0]) add_strvec(&pfx, fl->name); if (fl->flags & FL_OKLOW) { add_strvec(&pfx, "["); snprintf(buf, sizeof(buf), "%d", fl->low); add_strvec(&pfx, buf); if (fl->low != fl->high) { add_strvec(&pfx, "-"); snprintf(buf, sizeof(buf), "%d", fl->high); add_strvec(&pfx, buf); } add_strvec(&pfx, "]"); } if (fl->child) { if (fl->name[0]) add_strvec(&pfx, "."); print_flist_1(fl->child, pfx, fl->offset); } else { f = fl->fld; fa = &ftattrtab[f->ftyp]; ASSERT(fa->ftyp == f->ftyp); print_strvec(pfx); dbprintf(" = "); if (fl->flags & FL_OKLOW) low = fl->low; else low = 0; if (fa->prfunc) { neednl = fa->prfunc(iocur_top->data, fl->offset, fcount(f, iocur_top->data, parentoff), fa->fmtstr, fsize(f, iocur_top->data, parentoff, 0), fa->arg, low, (f->flags & FLD_ARRAY) != 0); if (neednl) dbprintf("\n"); } else { ASSERT(fa->arg & FTARG_OKEMPTY); dbprintf(_("(empty)\n")); } } free_strvec(pfx); } }
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; }
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; }
void print_flist( flist_t *flist) { char **pfx; pfx = new_strvec(0); print_flist_1(flist, pfx, 0); free_strvec(pfx); }
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); }
static void email_handler(vector_t *strvec) { vector_t *email_vec = read_value_block(); int i; char *str; for (i = 0; i < vector_size(email_vec); i++) { str = vector_slot(email_vec, i); alloc_email(str); } free_strvec(email_vec); }
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 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 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 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; }