Static buffers: ipaddr_getbuf: Rename some variables

[secnet.git] / conffile.c

diff --git a/conffile.c b/conffile.c
index 90235290fb03a72b436524892c28240fa2f82186..f5a10a184a79566cd612da405ed9c69d333de596 100644 (file)
--- a/conffile.c
+++ b/conffile.c
@@ -3,10 +3,13 @@
 /* #define DUMP_PARSE_TREE */
 
 #include "secnet.h"
+#include <assert.h>
+#include <limits.h>
 #include <stdio.h>
 #include <string.h>
 #include "conffile.h"
 #include "conffile_internal.h"
+#include "conffile.yy.h"
 #include "util.h"
 #include "ipaddr.h"
 
@@ -32,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;
@@ -72,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;
@@ -86,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;
@@ -97,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;
 }
@@ -151,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";
@@ -170,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; i<amount; i++) printf("  . ");
 }
 
-static void ptree_dump(struct p_node *n, uint32_t d)
+static void ptree_dump(struct p_node *n, int d)
 {
     if (!n) {
        printf("NULL\n");
        return;
     }
     
-    if (n->type<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;
@@ -194,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);
@@ -246,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;
@@ -514,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;
@@ -541,7 +545,7 @@ cstring_t *dict_keys(dict_t *dict)
 {
     atom_t *r, *j;
     struct entry *i;
-    r=safe_malloc(sizeof(*r)*(dict->size+1),"dict_keys");
+    NEW_ARY(r,dict->size+1);
     for (i=dict->entries, j=r; i; i=i->next, j++) {
        *j=i->key;
     }
@@ -557,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;
 }
 
@@ -573,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;
@@ -597,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;
@@ -623,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;
@@ -635,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);
@@ -669,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;
 }
@@ -684,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);
+    NEW_ARY(ra, ll+1);
+    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)
 {
@@ -699,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;
 }