chiark / gitweb /
changelog: describe version 0.3.0
[secnet.git] / conffile.c
index 9e10efa..ede9c49 100644 (file)
@@ -1,18 +1,17 @@
-/*
- * $Log$
- */
-
 /* conffile.c - process the configuration file */
 
 /* #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 "modules.h"
+#include "ipaddr.h"
 
 static struct cloc no_loc={"none",0};
 
@@ -36,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,10 +72,8 @@ static list_t *dict_ilookup(dict_t *dict, atom_t key)
 static void dict_iadd(dict_t *dict, atom_t key, list_t *val)
 {
     struct entry *e;
-    /* XXX May want to permit redefinition of keys in the future */
-    /* (although it could be very confusing) */
     if (dict_ilookup_primitive(dict, key)) {
-       fatal("duplicate key \"%s\" in dictionary\n",key);
+       fatal("duplicate key \"%s\" in dictionary",key);
     }
     e=safe_malloc(sizeof(*e),"dict_add");
     e->next=dict->entries;
@@ -131,25 +128,25 @@ static void ptree_mangle(struct p_node *t)
     ptree_mangle(t->r);
     switch (t->type) {
     case T_DICT:
-       /* ASSERT !t->l || t->l->type==T_ALIST */
-       /* ASSERT !t->r || t->r->type==T_LISTITEM */
+       ASSERT(!t->l || t->l->type==T_ALIST);
+       ASSERT(!t->r || t->r->type==T_LISTITEM);
        t->l=list_reverse(t->l);
        t->r=list_reverse(t->r);
        break;
     case T_ASSIGNMENT:
-       /* ASSERT t->l->type==T_KEY */
-       /* ASSERT t->r->type==T_LISTITEM */
+       ASSERT(t->l->type==T_KEY);
+       ASSERT(t->r->type==T_LISTITEM);
        t->r=list_reverse(t->r);
        break;
     case T_ABSPATH:
     case T_RELPATH:
-       /* ASSERT t->l==NULL */
-       /* ASSERT t->r->type==T_PATHELEM */
+       ASSERT(t->l==NULL);
+       ASSERT(t->r->type==T_PATHELEM);
        t->r=list_reverse(t->r);
        break;
     case T_EXEC:
-       /* ASSERT t->l */
-       /* ASSERT t->r->type==T_LISTITEM */
+       ASSERT(t->l);
+       ASSERT(t->r==NULL || t->r->type==T_LISTITEM);
        t->r=list_reverse(t->r);
        break;
     }
@@ -157,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";
@@ -176,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;
@@ -200,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);
@@ -223,8 +221,8 @@ static list_t *dict_lookup_path(dict_t *context, struct p_node *p)
     dict_t *i;
     list_t *l;
 
-    /* ASSERT p->type==T_PATHELEM */
-    /* ASSERT p->l->type==T_KEY */
+    ASSERT(p->type==T_PATHELEM);
+    ASSERT(p->l->type==T_KEY);
     l=dict_ilookup(context, p->l->data.key);
     if (!l) {
        cfgfatal(p->loc,"conffile","can't find key %s\n",
@@ -291,7 +289,7 @@ static list_t *process_item(dict_t *context, struct p_node *i)
     default:
 #ifdef DUMP_PARSE_TREE
        ptree_dump(i,0);
-       fatal("process_item: invalid node type for a list item (%s)\n",
+       fatal("process_item: invalid node type for a list item (%s)",
              ntype(i->type));
 #else
        fatal("process_item: list item has invalid node type %d - recompile "
@@ -308,7 +306,7 @@ static list_t *process_ilist(dict_t *context, struct p_node *l)
     struct p_node *i;
     list_t *r;
 
-    /* ASSERT l->type==T_LISTITEM */
+    ASSERT(!l || l->type==T_LISTITEM);
 
     r=list_new();
 
@@ -324,14 +322,16 @@ static list_t *process_invocation(dict_t *context, struct p_node *i)
     item_t *cl;
     list_t *args;
 
-    /* ASSERT i->type==T_EXEC */
-    /* ASSERT i->r->type==T_LISTITEM */
-    /* XXX it might be null too */
+    ASSERT(i->type==T_EXEC);
+    ASSERT(i->r==NULL || i->r->type==T_LISTITEM);
     cll=process_item(context,i->l);
     cl=cll->item;
     if (cl->type != t_closure) {
        cfgfatal(i->l->loc,"conffile","only closures can be invoked\n");
     }
+    if (!cl->data.closure->apply) {
+       cfgfatal(i->l->loc,"conffile","this closure cannot be invoked\n");
+    }
     args=process_ilist(context, i->r);
     return cl->data.closure->apply(cl->data.closure, i->loc, context, args);
 }
@@ -344,15 +344,15 @@ static void process_alist(dict_t *context, struct p_node *c)
 
     if (!c) return; /* NULL assignment lists are valid (empty dictionary) */
 
-    /* ASSERT c->type==T_ALIST */
+    ASSERT(c->type==T_ALIST);
     if (c->type!=T_ALIST) {
-       fatal("invalid node type in assignment list\n");
+       fatal("invalid node type in assignment list");
     }
 
     for (i=c; i; i=i->r) {
-       /* ASSERT i->l && i->l->type==T_ASSIGNMENT */
-       /* ASSERT i->l->l->type==T_KEY */
-       /* ASSERT i->l->r->type==T_LISTITEM */
+       ASSERT(i->l && i->l->type==T_ASSIGNMENT);
+       ASSERT(i->l->l->type==T_KEY);
+       ASSERT(i->l->r->type==T_LISTITEM);
        k=i->l->l->data.key;
        l=process_ilist(context, i->l->r);
        dict_iadd(context, k, l);
@@ -444,8 +444,9 @@ static list_t *readfile(closure_t *self, struct cloc loc,
     r=new_item(t_string,loc);
     r->data.string=safe_malloc(length+1,"readfile");
     if (fread(r->data.string,length,1,f)!=1) {
-       fatal("readfile (%s:%d): fread: could not read all of file\n",
-             loc.file,loc.line);
+       (ferror(f) ? fatal_perror : fatal)
+           ("readfile (%s:%d): fread: could not read all of file",
+            loc.file,loc.line);
     }
     r->data.string[length]=0;
     if (fclose(f)!=0) {
@@ -466,6 +467,9 @@ static dict_t *process_config(struct p_node *c)
     context=root;
 
     /* Predefined keys for boolean values */
+    /* "nowise" and "verily" have the advantage of being the same
+       length, so they line up nicely...  thanks VKC and SGT (who also
+       point out that "mayhap" is a good "maybe" value as well) */
     i=new_item(t_bool,no_loc);
     i->data.bool=False;
     false=list_append(NULL,i);
@@ -478,12 +482,18 @@ static dict_t *process_config(struct p_node *c)
     dict_add(root,"no",false);
     dict_add(root,"No",false);
     dict_add(root,"NO",false);
+    dict_add(root,"nowise",false);
+    dict_add(root,"Nowise",false);
+    dict_add(root,"NOWISE",false);
     dict_add(root,"true",true);
     dict_add(root,"True",true);
     dict_add(root,"TRUE",true);
     dict_add(root,"yes",true);
     dict_add(root,"Yes",true);
     dict_add(root,"YES",true);
+    dict_add(root,"verily",true);
+    dict_add(root,"Verily",true);
+    dict_add(root,"VERILY",true);
 
     add_closure(root,"makelist",makelist);
     add_closure(root,"readfile",readfile);
@@ -498,7 +508,7 @@ static dict_t *process_config(struct p_node *c)
 
 /***** Externally accessible functions */
 
-atom_t intern(string_t s)
+atom_t intern(cstring_t s)
 {
     struct atomlist *i;
 
@@ -516,22 +526,22 @@ atom_t intern(string_t s)
     return i->a;
 }
 
-list_t *dict_lookup(dict_t *dict, string_t key)
+list_t *dict_lookup(dict_t *dict, cstring_t key)
 {
     return dict_ilookup(dict, intern(key));
 }
 
-list_t *dict_lookup_primitive(dict_t *dict, string_t key)
+list_t *dict_lookup_primitive(dict_t *dict, cstring_t key)
 {
     return dict_ilookup_primitive(dict, intern(key));
 }
 
-void dict_add(dict_t *dict, string_t key, list_t *val)
+void dict_add(dict_t *dict, cstring_t key, list_t *val)
 {
     dict_iadd(dict,intern(key),val);
 }
 
-string_t *dict_keys(dict_t *dict)
+cstring_t *dict_keys(dict_t *dict)
 {
     atom_t *r, *j;
     struct entry *i;
@@ -551,10 +561,36 @@ list_t *list_new(void)
     return NULL;
 }
 
+int32_t list_length(list_t *a)
+{
+    int32_t l=0;
+    list_t *i;
+    for (i=a; i; i=i->next) { assert(l < INT_MAX); l++; }
+    return l;
+}
+
+static list_t *list_copy(list_t *a)
+{
+    list_t *r, *i, *b, *l;
+
+    if (!a) return NULL;
+    l=NULL;
+    r=NULL;
+    for (i=a; i; i=i->next) {
+       b=safe_malloc(sizeof(*b),"list_copy");
+       if (l) l->next=b; else r=b;
+       l=b;
+       b->item=i->item;
+       b->next=NULL;
+    }
+    return r;
+}
+
 list_t *list_append_list(list_t *a, list_t *b)
 {
     list_t *i;
 
+    b=list_copy(b);
     if (!a) return b;
     for (i=a; i->next; i=i->next);
     i->next=b;
@@ -572,7 +608,7 @@ list_t *list_append(list_t *list, item_t *item)
     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;
@@ -588,30 +624,25 @@ list_t *new_closure(closure_t *cl)
     return list_append(NULL,i);
 }
 
-void add_closure(dict_t *dict, string_t name, apply_fn apply)
+void add_closure(dict_t *dict, cstring_t name, apply_fn apply)
 {
     closure_t *c;
     c=safe_malloc(sizeof(*c),"add_closure");
     c->description=name;
+    c->type=CL_PURE;
     c->apply=apply;
     c->interface=NULL;
 
     dict_add(dict,name,new_closure(c));
 }
 
-void *find_cl_if(dict_t *dict, string_t name, uint32_t type,
-                bool_t fail_if_invalid, string_t desc, struct cloc loc)
+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);
@@ -625,8 +656,8 @@ void *find_cl_if(dict_t *dict, string_t name, uint32_t type,
 }
 
 /* Convenience functions for modules reading configuration dictionaries */
-item_t *dict_find_item(dict_t *dict, string_t key, bool_t required,
-                      string_t desc, struct cloc loc)
+item_t *dict_find_item(dict_t *dict, cstring_t key, bool_t required,
+                      cstring_t desc, struct cloc loc)
 {
     list_t *l;
     item_t *i;
@@ -636,12 +667,14 @@ item_t *dict_find_item(dict_t *dict, string_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;
 }
 
-string_t dict_read_string(dict_t *dict, string_t key, bool_t required,
-                         string_t desc, struct cloc loc)
+string_t dict_read_string(dict_t *dict, cstring_t key, bool_t required,
+                         cstring_t desc, struct cloc loc)
 {
     item_t *i;
     string_t r;
@@ -651,12 +684,15 @@ string_t dict_read_string(dict_t *dict, string_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;
 }
 
-uint32_t dict_read_number(dict_t *dict, string_t key, bool_t required,
-                         string_t desc, struct cloc loc, uint32_t def)
+uint32_t dict_read_number(dict_t *dict, cstring_t key, bool_t required,
+                         cstring_t desc, struct cloc loc, uint32_t def)
 {
     item_t *i;
     uint32_t r;
@@ -666,12 +702,15 @@ uint32_t dict_read_number(dict_t *dict, string_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;
 }
 
-bool_t dict_read_bool(dict_t *dict, string_t key, bool_t required,
-                     string_t desc, struct cloc loc, bool_t def)
+bool_t dict_read_bool(dict_t *dict, cstring_t key, bool_t required,
+                     cstring_t desc, struct cloc loc, bool_t def)
 {
     item_t *i;
     bool_t r;
@@ -685,95 +724,18 @@ bool_t dict_read_bool(dict_t *dict, string_t key, bool_t required,
     return r;
 }
 
-static struct subnet string_to_subnet(item_t *i, string_t desc)
-{
-    struct subnet s;
-    uint32_t a, b, c, d, n;
-    uint32_t match;
-
-    /* i is not guaranteed to be a string */
-    if (i->type!=t_string) {
-       cfgfatal(i->loc,desc,"expecting a string (subnet specification)\n");
-    }
-
-    /* We expect strings of the form "a.b.c.d[/n]", i.e. the dots are
-       NOT optional. The subnet mask is optional; if missing it is assumed
-       to be /32. */
-    match=sscanf(i->data.string,"%u.%u.%u.%u/%u", &a, &b, &c, &d, &n);
-    if (match<4) {
-       cfgfatal(i->loc,desc,"\"%s\" is not a valid "
-                "subnet specification\n",i->data.string);
-    }
-    if (match<5) {
-       n=32;
-    }
-    if (a>255 || b>255 || c>255 || d>255 || n>32) {
-       cfgfatal(i->loc,desc,"\"%s\": range error\n",i->data.string);
-    }
-    s.prefix=(a<<24)|(b<<16)|(c<<8)|(d);
-    s.mask=(~0UL << (32-n));
-    s.len=n;
-    if (s.prefix & ~s.mask) {
-       cfgfatal(i->loc,desc,"\"%s\": prefix not fully contained "
-                "in mask\n",i->data.string);
-    }
-    return s;
-}
-
-uint32_t string_to_ipaddr(item_t *i, string_t desc)
-{
-    uint32_t a, b, c, d;
-    uint32_t match;
-
-    /* i is not guaranteed to be a string */
-    if (i->type!=t_string) {
-       cfgfatal(i->loc,desc,"expecting a string (IP address)\n");
-    }
-
-    match=sscanf(i->data.string,"%u.%u.%u.%u", &a, &b, &c, &d);
-    if (match<4) {
-       cfgfatal(i->loc,desc,"\"%s\" is not a valid "
-                "IP address\n",i->data.string);
-    }
-    if (a>255 || b>255 || c>255 || d>255) {
-       cfgfatal(i->loc,desc,"\"%s\": range error\n",i->data.string);
-    }
-    return (a<<24)|(b<<16)|(c<<8)|(d);
-}
-
-void dict_read_subnet_list(dict_t *dict, string_t key, bool_t required,
-                          string_t desc, struct cloc loc,
-                          struct subnet_list *sl)
+uint32_t string_to_word(cstring_t s, struct cloc loc,
+                       struct flagstr *f, cstring_t desc)
 {
-    list_t *l, *li;
-    item_t *i;
-    uint32_t e=0;
-
-    sl->entries=0;
-    sl->list=NULL;
-    l=dict_lookup(dict, key);
-    if (!l) {
-       if (!required) return;
-       cfgfatal(loc,desc,"required parameter \"%s\" not found\n",key);
-    }
-    /* Count the items in the list */
-    for (li=l; li; li=li->next) e++;
-    if (e==0) return;
-    sl->entries=e;
-    sl->list=safe_malloc(sizeof(struct subnet)*e, "dict_read_subnet_list");
-    e=0;
-    /* Fill in the list */
-    for (li=l; li; li=li->next) {
-       i=li->item;
-       if (i->type!=t_string) {
-           cfgfatal(loc,desc,"parameter \"%s\": all elements must "
-                    "be strings\n",key);
-       }
-       sl->list[e++]=string_to_subnet(i,desc);
-    }
+    struct flagstr *j;
+    for (j=f; j->name; j++)
+       if (strcmp(s,j->name)==0)
+           return j->value;
+    cfgfatal(loc,desc,"option \"%s\" not known\n",s);
+    return 0;
 }
 
-uint32_t string_list_to_word(list_t *l, struct flagstr *f, string_t desc)
+uint32_t string_list_to_word(list_t *l, struct flagstr *f, cstring_t desc)
 {
     list_t *i;
     uint32_t r=0;
@@ -785,13 +747,12 @@ uint32_t string_list_to_word(list_t *l, struct flagstr *f, string_t desc)
                     "strings\n");
        }
        for (j=f; j->name; j++)
-           if (strcmp(i->item->data.string,j->name)==0)
-               r|=j->value;
+           r|=string_to_word(i->item->data.string,i->item->loc,f,desc);
     }
     return r;
 }
 
-dict_t *read_conffile(char *name)
+dict_t *read_conffile(const char *name)
 {
     FILE *conffile;
     struct p_node *config;