/* #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"
struct dict *parent;
struct searchlist *search;
struct entry *entries;
- uint32_t size;
+ int32_t size;
};
static struct atomlist *atoms=NULL;
#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);
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;
}
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;
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);
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;
}
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)
{
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;
}