-/*
- * $Log$
- */
-
/* conffile.c - process the configuration file */
/* #define DUMP_PARSE_TREE */
+#include "secnet.h"
+#include <assert.h>
+#include <limits.h>
#include <stdio.h>
-#include <stdlib.h>
#include <string.h>
-
-#include "secnet.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};
struct dict *parent;
struct searchlist *search;
struct entry *entries;
- uint32_t size;
+ int32_t size;
};
static struct atomlist *atoms=NULL;
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");
+ NEW(e);
e->next=dict->entries;
e->key=key;
e->val=val;
{
dict_t *d;
- d=safe_malloc(sizeof(*d),"dict_new");
+ NEW(d);
d->parent=parent;
d->search=NULL;
d->entries=NULL;
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;
}
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;
}
#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";
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;
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);
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",
{
item_t *i;
- i=safe_malloc(sizeof(*i),"new_item");
+ NEW(i);
i->type=type;
i->loc=loc;
return 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 "
struct p_node *i;
list_t *r;
- /* ASSERT l->type==T_LISTITEM */
+ ASSERT(!l || l->type==T_LISTITEM);
r=list_new();
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);
}
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);
return r;
}
+/* Take a list consisting of a closure and some other things. Apply the
+ closure to the other things, and return the resulting list */
+static list_t *map(closure_t *self, struct cloc loc, dict_t *context,
+ list_t *args)
+{
+ list_t *r=NULL, *al;
+ item_t *ci;
+ closure_t *cl;
+ list_t se;
+
+ ci=list_elem(args,0);
+ if (ci && ci->type==t_closure) {
+ cl=ci->data.closure;
+ if (!cl->apply) {
+ cfgfatal(loc,"map","closure cannot be applied\n");
+ }
+ for (al=args->next; al; al=al->next) {
+ /* Construct a single-element list */
+ se.next=NULL;
+ se.item=al->item;
+ /* Invoke the closure, append its result to the output */
+ r=list_append_list(r,cl->apply(cl,loc,context,&se));
+ }
+ } else {
+ cfgfatal(loc,"map","you must supply a closure as the "
+ "first argument\n");
+ }
+ return r;
+}
+
/* Read a file and turn it into a string */
static list_t *readfile(closure_t *self, struct cloc loc,
dict_t *context, list_t *args)
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) {
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);
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);
+ add_closure(root,"map",map);
init_builtin_modules(root);
/***** Externally accessible functions */
-atom_t intern(string_t s)
+atom_t intern(cstring_t s)
{
struct atomlist *i;
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;
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;
- 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;
}
return NULL;
}
+int32_t list_length(const list_t *a)
+{
+ int32_t l=0;
+ const 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) {
+ NEW(b);
+ 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;
{
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;
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");
+ NEW(c);
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);
}
/* 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;
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;
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)
+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)
{
item_t *i;
uint32_t r;
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;
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));
- 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 string_to_word(cstring_t s, struct cloc loc,
+ struct flagstr *f, cstring_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);
+ 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;
}
-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_list_to_word(list_t *l, struct flagstr *f, cstring_t desc)
{
- list_t *l, *li;
- item_t *i;
- uint32_t e=0;
+ list_t *i;
+ uint32_t r=0;
+ struct flagstr *j;
- 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);
+ for (i=l; i; i=i->next) {
+ if (i->item->type!=t_string) {
+ cfgfatal(i->item->loc,desc,"all elements of list must be "
+ "strings\n");
}
- sl->list[e++]=string_to_subnet(i,desc);
+ for (j=f; j->name; j++)
+ 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;
~ianmdlvl / secnet.git / blobdiff