X-Git-Url: http://www.chiark.greenend.org.uk/ucgi/~ian/git?a=blobdiff_plain;f=conffile.c;h=3ffbd9fd8274c2f3d3ceca8482770ae17951740d;hb=f2d5f883b327692465b0eb77da48790d03253814;hp=db7c58e31b447beb07d89dc1716ae2fd0ad38203;hpb=27f5042b0435d26ae98b22f8e42115e44afe53bc;p=secnet.git diff --git a/conffile.c b/conffile.c index db7c58e..3ffbd9f 100644 --- a/conffile.c +++ b/conffile.c @@ -3,6 +3,8 @@ /* #define DUMP_PARSE_TREE */ #include "secnet.h" +#include +#include #include #include #include "conffile.h" @@ -33,7 +35,7 @@ struct dict { struct dict *parent; struct searchlist *search; struct entry *entries; - uint32_t size; + int32_t size; }; static struct atomlist *atoms=NULL; @@ -73,7 +75,7 @@ static void dict_iadd(dict_t *dict, atom_t key, list_t *val) if (dict_ilookup_primitive(dict, key)) { fatal("duplicate key \"%s\" in dictionary",key); } - e=safe_malloc(sizeof(*e),"dict_add"); + NEW(e); e->next=dict->entries; e->key=key; e->val=val; @@ -87,7 +89,7 @@ static dict_t *dict_new(dict_t *parent) { dict_t *d; - d=safe_malloc(sizeof(*d),"dict_new"); + NEW(d); d->parent=parent; d->search=NULL; d->entries=NULL; @@ -98,7 +100,7 @@ static dict_t *dict_new(dict_t *parent) static struct p_node *node_copy(struct p_node *n) { struct p_node *r; - r=safe_malloc(sizeof(*r),"node_copy"); + NEW(r); *r=*n; return r; } @@ -152,7 +154,7 @@ static void ptree_mangle(struct p_node *t) #ifdef DUMP_PARSE_TREE /* Convert a node type to a string, for parse tree dump */ -static string_t ntype(uint32_t type) +static const char *ntype(uint32_t type) { switch(type) { case T_STRING: return "T_STRING"; @@ -171,20 +173,20 @@ static string_t ntype(uint32_t type) return "**unknown**"; } -static void ptree_indent(uint32_t amount) +static void ptree_indent(int amount) { - uint32_t i; + int i; for (i=0; itype<10) { + if (T_IS_PRIMITIVE(n->type)) { switch(n->type) { case T_STRING: printf("T_STRING: \"%s\" (%s line %d)\n", n->data.string,n->loc.file,n->loc.line); break; @@ -195,6 +197,7 @@ static void ptree_dump(struct p_node *n, uint32_t d) default: printf("**unknown primitive type**\n"); break; } } else { + assert(d<10000); printf("%s: (%s line %d)\n",ntype(n->type),n->loc.file,n->loc.line); ptree_indent(d); printf(" |-"); ptree_dump(n->l, d+1); @@ -247,7 +250,7 @@ static item_t *new_item(enum types type, struct cloc loc) { item_t *i; - i=safe_malloc(sizeof(*i),"new_item"); + NEW(i); i->type=type; i->loc=loc; return i; @@ -515,7 +518,7 @@ atom_t intern(cstring_t s) if (!i) { /* Did't find it; create a new one */ - i=safe_malloc(sizeof(*i),"intern: alloc list entry"); + NEW(i); i->a=safe_strdup(s,"intern: alloc string"); i->next=atoms; atoms=i; @@ -558,11 +561,11 @@ list_t *list_new(void) return NULL; } -uint32_t list_length(list_t *a) +int32_t list_length(const list_t *a) { - uint32_t l=0; - list_t *i; - for (i=a; i; i=i->next) l++; + int32_t l=0; + const list_t *i; + for (i=a; i; i=i->next) { assert(l < INT_MAX); l++; } return l; } @@ -574,7 +577,7 @@ static list_t *list_copy(list_t *a) l=NULL; r=NULL; for (i=a; i; i=i->next) { - b=safe_malloc(sizeof(*b),"list_copy"); + NEW(b); if (l) l->next=b; else r=b; l=b; b->item=i->item; @@ -598,14 +601,14 @@ list_t *list_append(list_t *list, item_t *item) { list_t *l; - l=safe_malloc(sizeof(*l),"list_append"); + NEW(l); l->item=item; l->next=NULL; return list_append_list(list,l); } -item_t *list_elem(list_t *l, uint32_t index) +item_t *list_elem(list_t *l, int32_t index) { if (!l) return NULL; if (index==0) return l->item; @@ -624,7 +627,7 @@ list_t *new_closure(closure_t *cl) void add_closure(dict_t *dict, cstring_t name, apply_fn apply) { closure_t *c; - c=safe_malloc(sizeof(*c),"add_closure"); + NEW(c); c->description=name; c->type=CL_PURE; c->apply=apply; @@ -636,16 +639,10 @@ void add_closure(dict_t *dict, cstring_t name, apply_fn apply) void *find_cl_if(dict_t *dict, cstring_t name, uint32_t type, bool_t fail_if_invalid, cstring_t desc, struct cloc loc) { - list_t *l; item_t *i; closure_t *cl; - l=dict_lookup(dict,name); - if (!l) { - if (!fail_if_invalid) return NULL; - cfgfatal(loc,desc,"closure \"%s\" not found\n",name); - } - i=list_elem(l,0); + i = dict_find_item(dict,name,fail_if_invalid,desc,loc); if (i->type!=t_closure) { if (!fail_if_invalid) return NULL; cfgfatal(loc,desc,"\"%s\" must be a closure\n",name); @@ -670,6 +667,8 @@ item_t *dict_find_item(dict_t *dict, cstring_t key, bool_t required, if (!required) return NULL; cfgfatal(loc,desc,"required parameter \"%s\" not found\n",key); } + if(list_length(l) != 1) + cfgfatal(loc,desc,"parameter \"%s\" has wrong number of values",key); i=list_elem(l,0); return i; } @@ -685,10 +684,38 @@ string_t dict_read_string(dict_t *dict, cstring_t key, bool_t required, if (i->type!=t_string) { cfgfatal(loc,desc,"\"%s\" must be a string\n",key); } + if (strlen(i->data.string) > INT_MAX/10) { + cfgfatal(loc,desc,"\"%s\" is unreasonably long\n",key); + } r=i->data.string; return r; } +const char **dict_read_string_array(dict_t *dict, cstring_t key, + bool_t required, cstring_t desc, + struct cloc loc, const char *const *def) +{ + list_t *l; + const char **ra, **rap; + + l=dict_lookup(dict,key); + if (!l) { + if (!required) return (const char**)def; + cfgfatal(loc,desc,"required string list \"%s\" not found\n",key); + } + + int32_t ll=list_length(l); + ra=safe_malloc_ary(sizeof(*ra), ll+1, "dict_read_string_array"); + for (rap=ra; l; l=l->next,rap++) { + item_t *it=l->item; + if (it->type!=t_string) + cfgfatal(it->loc,desc,"\"%s\" entry must be a string\n",key); + *rap=it->data.string; + } + *rap=0; + return ra; +} + uint32_t dict_read_number(dict_t *dict, cstring_t key, bool_t required, cstring_t desc, struct cloc loc, uint32_t def) { @@ -700,6 +727,9 @@ uint32_t dict_read_number(dict_t *dict, cstring_t key, bool_t required, if (i->type!=t_number) { cfgfatal(loc,desc,"\"%s\" must be a number\n",key); } + if (i->data.number >= 0x80000000) { + cfgfatal(loc,desc,"\"%s\" must fit into a 32-bit signed integer\n",key); + } r=i->data.number; return r; }