chiark / gitweb /
Import release 0.1.15
[secnet.git] / conffile.c
index 3c629e4..b17517b 100644 (file)
@@ -1,7 +1,3 @@
-/*
- * $Log$
- */
-
 /* conffile.c - process the configuration file */
 
 /* #define DUMP_PARSE_TREE */
@@ -76,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;
@@ -134,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;
     }
@@ -226,8 +220,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",
@@ -294,7 +288,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 "
@@ -311,7 +305,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();
 
@@ -327,9 +321,8 @@ 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) {
@@ -350,15 +343,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);
@@ -450,8 +443,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) {
@@ -504,7 +498,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;
 
@@ -522,22 +516,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;
@@ -620,7 +614,7 @@ 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");
@@ -631,8 +625,8 @@ void add_closure(dict_t *dict, string_t name, apply_fn apply)
     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;
@@ -657,8 +651,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;
@@ -672,8 +666,8 @@ item_t *dict_find_item(dict_t *dict, string_t key, bool_t required,
     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;
@@ -687,8 +681,8 @@ string_t dict_read_string(dict_t *dict, string_t key, bool_t required,
     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;
@@ -702,8 +696,8 @@ uint32_t dict_read_number(dict_t *dict, string_t key, bool_t required,
     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;
@@ -717,8 +711,8 @@ bool_t dict_read_bool(dict_t *dict, string_t key, bool_t required,
     return r;
 }
 
-uint32_t string_to_word(string_t s, struct cloc loc,
-                       struct flagstr *f, string_t desc)
+uint32_t string_to_word(cstring_t s, struct cloc loc,
+                       struct flagstr *f, cstring_t desc)
 {
     struct flagstr *j;
     for (j=f; j->name; j++)
@@ -728,7 +722,7 @@ uint32_t string_to_word(string_t s, struct cloc loc,
     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;
@@ -745,7 +739,7 @@ uint32_t string_list_to_word(list_t *l, struct flagstr *f, string_t desc)
     return r;
 }
 
-dict_t *read_conffile(char *name)
+dict_t *read_conffile(const char *name)
 {
     FILE *conffile;
     struct p_node *config;