ncd: Fix missing type checks. Refactor to make these bugs less likely.

ncd/extra/NCDBProcessOpts.c

@@ -60,13 +60,22 @@ int NCDBProcessOpts_Init2 (NCDBProcessOpts *o, NCDValRef opts_arg, NCDBProcessOp
             NCDValRef val = NCDVal_MapElemVal(opts_arg, me);
             
             if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "keep_stdout")) {
-                keep_stdout = ncd_read_boolean(val);
+                if (!ncd_read_boolean(val, &keep_stdout)) {
+                    NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "bad keep_stdout");
+                    goto fail1;
+                }
             }
             else if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "keep_stderr")) {
-                keep_stderr = ncd_read_boolean(val);
+                if (!ncd_read_boolean(val, &keep_stderr)) {
+                    NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "bad keep_stderr");
+                    goto fail1;
+                }
             }
             else if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "do_setsid")) {
-                o->do_setsid = ncd_read_boolean(val);
+                if (!ncd_read_boolean(val, &o->do_setsid)) {
+                    NCDModuleInst_Backend_Log(i, blog_channel, BLOG_ERROR, "bad do_setsid");
+                    goto fail1;
+                }
             }
             else if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "username")) {
                 if (!NCDVal_IsStringNoNulls(val)) {

ncd/extra/address_utils.h

@@ -79,7 +79,7 @@ static int ncd_read_baddr (NCDValRef val, BAddr *out)
         if (!NCDVal_ListRead(val, 3, &type_val, &ipaddr_val, &port_val)) {
             goto fail;
         }
-        if (!NCDVal_IsString(ipaddr_val) || !NCDVal_IsString(port_val)) {
+        if (!NCDVal_IsString(ipaddr_val)) {
             goto fail;
         }
         
@@ -101,7 +101,7 @@ static int ncd_read_baddr (NCDValRef val, BAddr *out)
         if (!NCDVal_ListRead(val, 3, &type_val, &ipaddr_val, &port_val)) {
             goto fail;
         }
-        if (!NCDVal_IsString(ipaddr_val) || !NCDVal_IsString(port_val)) {
+        if (!NCDVal_IsString(ipaddr_val)) {
             goto fail;
         }
         

ncd/extra/value_utils.c

@@ -63,40 +63,46 @@ NCDValRef ncd_make_boolean (NCDValMem *mem, int value, NCDStringIndex *string_in
     return NCDVal_NewIdString(mem, str_id, string_index);
 }
 
-int ncd_read_boolean (NCDValRef string)
+int ncd_read_boolean (NCDValRef val, int *out)
 {
-    ASSERT(NCDVal_IsString(string))
+    ASSERT(out)
     
-    if (NCDVal_IsIdString(string)) {
-        return NCDVal_IdStringId(string) == NCD_STRING_TRUE;
+    if (!NCDVal_IsString(val)) {
+        return 0;
+    }
+    if (NCDVal_IsIdString(val)) {
+        *out = NCDVal_IdStringId(val) == NCD_STRING_TRUE;
     } else {
-        return NCDVal_StringEquals(string, "true");
+        *out = NCDVal_StringEquals(val, "true");
     }
+    return 1;
 }
 
-int ncd_read_uintmax (NCDValRef string, uintmax_t *out)
+int ncd_read_uintmax (NCDValRef val, uintmax_t *out)
 {
-    ASSERT(NCDVal_IsString(string))
     ASSERT(out)
     
-    size_t length = NCDVal_StringLength(string);
+    if (!NCDVal_IsString(val)) {
+        return 0;
+    }
+    
+    size_t length = NCDVal_StringLength(val);
     
-    if (NCDVal_IsContinuousString(string)) {
-        return parse_unsigned_integer_bin(NCDVal_StringData(string), length, out);
+    if (NCDVal_IsContinuousString(val)) {
+        return parse_unsigned_integer_bin(NCDVal_StringData(val), length, out);
     }
     
-    b_cstring cstr = NCDVal_StringCstring(string);
+    b_cstring cstr = NCDVal_StringCstring(val);
     
     return parse_unsigned_integer_cstr(cstr, 0, cstr.length, out);
 }
 
-int ncd_read_time (NCDValRef string, btime_t *out)
+int ncd_read_time (NCDValRef val, btime_t *out)
 {
-    ASSERT(NCDVal_IsString(string))
     ASSERT(out)
     
     uintmax_t n;
-    if (!ncd_read_uintmax(string, &n)) {
+    if (!ncd_read_uintmax(val, &n)) {
         return 0;
     }
     

ncd/extra/value_utils.h

@@ -40,7 +40,7 @@
 
 int ncd_is_none (NCDValRef val);
 NCDValRef ncd_make_boolean (NCDValMem *mem, int value, NCDStringIndex *string_index);
-int ncd_read_boolean (NCDValRef val);
+int ncd_read_boolean (NCDValRef val, int *out) WARN_UNUSED;
 int ncd_read_uintmax (NCDValRef string, uintmax_t *out) WARN_UNUSED;
 int ncd_read_time (NCDValRef string, btime_t *out) WARN_UNUSED;
 NCD_string_id_t ncd_get_string_id (NCDValRef string, NCDStringIndex *string_index);

ncd/module_common.h

@@ -35,6 +35,10 @@
 #include <ncd/extra/value_utils.h>
 
 #define ModuleGlobal(i) ((i)->m->group->group_state)
-#define ModuleLog(i, ...) NCDModuleInst_Backend_Log((i), BLOG_CURRENT_CHANNEL, __VA_ARGS__)
 #define ModuleString(i, id) ((i)->m->group->strings[(id)])
-#define FunctionLog(params, ...) BContextLog(NCDModuleFunction_LogContext(params), __VA_ARGS__)
+
+#define ModuleLc(i) NCDModuleInst_Backend_LogContext((i))
+#define ModuleLog(i, ...) NCDModuleInst_Backend_Log((i), BLOG_CURRENT_CHANNEL, __VA_ARGS__)
+
+#define FunctionLc(params) NCDModuleFunction_LogContext((params))
+#define FunctionLog(params, ...) BContextLog(FunctionLc(params), __VA_ARGS__)

ncd/modules/arithmetic.c

@@ -180,10 +180,6 @@ static void new_boolean_templ (void *vo, NCDModuleInst *i, const struct NCDModul
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(n1_arg) || !NCDVal_IsString(n2_arg)) {
-        ModuleLog(o->i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     uintmax_t n1;
     if (!ncd_read_uintmax(n1_arg, &n1)) {
@@ -229,10 +225,6 @@ static void new_number_templ (void *vo, NCDModuleInst *i, const struct NCDModule
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(n1_arg) || !NCDVal_IsString(n2_arg)) {
-        ModuleLog(o->i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     uintmax_t n1;
     if (!ncd_read_uintmax(n1_arg, &n1)) {

ncd/modules/basic_functions.c

@@ -64,11 +64,12 @@ static int if_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRef *out, struc
     if (!NCDEvaluatorArgs_EvalArg(&args, 0, mem, &cond)) {
         return 0;
     }
-    if (!NCDVal_IsString(cond)) {
-        FunctionLog(params, BLOG_ERROR, "if: wrong type");
+    int cond_val;
+    if (!ncd_read_boolean(cond, &cond_val)) {
+        FunctionLog(params, BLOG_ERROR, "if: bad condition");
         return 0;
     }
-    int eval_arg = 2 - ncd_read_boolean(cond);
+    int eval_arg = 2 - cond_val;
     return NCDEvaluatorArgs_EvalArg(&args, eval_arg, mem, out);
 }
 
@@ -78,16 +79,16 @@ static int bool_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRef *out, str
         FunctionLog(params, BLOG_ERROR, "bool: need one argument");
         return 0;
     }
-    NCDValRef cond;
-    if (!NCDEvaluatorArgs_EvalArg(&args, 0, mem, &cond)) {
+    NCDValRef arg;
+    if (!NCDEvaluatorArgs_EvalArg(&args, 0, mem, &arg)) {
         return 0;
     }
-    if (!NCDVal_IsString(cond)) {
-        FunctionLog(params, BLOG_ERROR, "bool: wrong type");
+    int arg_val;
+    if (!ncd_read_boolean(arg, &arg_val)) {
+        FunctionLog(params, BLOG_ERROR, "bool: bad argument");
         return 0;
     }
-    int res = ncd_read_boolean(cond);
-    *out = ncd_make_boolean(mem, res, params->params->iparams->string_index);
+    *out = ncd_make_boolean(mem, arg_val, params->params->iparams->string_index);
     return 1;
 }
 
@@ -97,16 +98,16 @@ static int not_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRef *out, stru
         FunctionLog(params, BLOG_ERROR, "not: need one argument");
         return 0;
     }
-    NCDValRef cond;
-    if (!NCDEvaluatorArgs_EvalArg(&args, 0, mem, &cond)) {
+    NCDValRef arg;
+    if (!NCDEvaluatorArgs_EvalArg(&args, 0, mem, &arg)) {
         return 0;
     }
-    if (!NCDVal_IsString(cond)) {
-        FunctionLog(params, BLOG_ERROR, "not: wrong type");
+    int arg_val;
+    if (!ncd_read_boolean(arg, &arg_val)) {
+        FunctionLog(params, BLOG_ERROR, "not: bad argument");
         return 0;
     }
-    int res = !ncd_read_boolean(cond);
-    *out = ncd_make_boolean(mem, res, params->params->iparams->string_index);
+    *out = ncd_make_boolean(mem, !arg_val, params->params->iparams->string_index);
     return 1;
 }
 
@@ -115,15 +116,16 @@ static int and_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRef *out, stru
     size_t count = NCDEvaluatorArgs_Count(&args);
     int res = 1;
     for (size_t i = 0; i < count; i++) {
-        NCDValRef cond;
-        if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &cond)) {
+        NCDValRef arg;
+        if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &arg)) {
             return 0;
         }
-        if (!NCDVal_IsString(cond)) {
-            FunctionLog(params, BLOG_ERROR, "and: wrong type");
+        int arg_val;
+        if (!ncd_read_boolean(arg, &arg_val)) {
+            FunctionLog(params, BLOG_ERROR, "and: bad argument");
             return 0;
         }
-        if (!ncd_read_boolean(cond)) {
+        if (!arg_val) {
             res = 0;
             break;
         }
@@ -137,15 +139,16 @@ static int or_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRef *out, struc
     size_t count = NCDEvaluatorArgs_Count(&args);
     int res = 0;
     for (size_t i = 0; i < count; i++) {
-        NCDValRef cond;
-        if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &cond)) {
+        NCDValRef arg;
+        if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &arg)) {
             return 0;
         }
-        if (!NCDVal_IsString(cond)) {
-            FunctionLog(params, BLOG_ERROR, "or: wrong type");
+        int arg_val;
+        if (!ncd_read_boolean(arg, &arg_val)) {
+            FunctionLog(params, BLOG_ERROR, "or: bad argument");
             return 0;
         }
-        if (ncd_read_boolean(cond)) {
+        if (arg_val) {
             res = 1;
             break;
         }
@@ -162,15 +165,16 @@ static int imp_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRef *out, stru
     }
     int res = 0;
     for (size_t i = 0; i < 2; i++) {
-        NCDValRef cond;
-        if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &cond)) {
+        NCDValRef arg;
+        if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &arg)) {
             return 0;
         }
-        if (!NCDVal_IsString(cond)) {
-            FunctionLog(params, BLOG_ERROR, "imp: wrong type");
+        int arg_val;
+        if (!ncd_read_boolean(arg, &arg_val)) {
+            FunctionLog(params, BLOG_ERROR, "imp: bad argument");
             return 0;
         }
-        if (ncd_read_boolean(cond) == i) {
+        if (arg_val == i) {
             res = 1;
             break;
         }
@@ -328,10 +332,6 @@ static int integer_compare_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValRe
         if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &arg)) {
             goto fail0;
         }
-        if (!NCDVal_IsString(arg)) {
-            FunctionLog(params, BLOG_ERROR, "integer_compare: wrong type");
-            goto fail0;
-        }
         if (!ncd_read_uintmax(arg, &ints[i])) {
             FunctionLog(params, BLOG_ERROR, "integer_compare: wrong value");
             goto fail0;
@@ -379,10 +379,6 @@ static int integer_operator_eval (NCDEvaluatorArgs args, NCDValMem *mem, NCDValR
         if (!NCDEvaluatorArgs_EvalArg(&args, i, mem, &arg)) {
             goto fail0;
         }
-        if (!NCDVal_IsString(arg)) {
-            FunctionLog(params, BLOG_ERROR, "integer_operator: wrong type");
-            goto fail0;
-        }
         if (!ncd_read_uintmax(arg, &ints[i])) {
             FunctionLog(params, BLOG_ERROR, "integer_operator: wrong value");
             goto fail0;

ncd/modules/buffer.c

@@ -557,10 +557,6 @@ static void consume_func_new (void *vo, NCDModuleInst *i, const struct NCDModule
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(amount_arg)) {
-        ModuleLog(i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     // parse amount
     uintmax_t amount;

ncd/modules/call2.c

@@ -388,12 +388,13 @@ static void func_new_embcall_multif (void *vo, NCDModuleInst *i, const struct NC
         
         NCDValRef arg2 = NCDVal_ListGet(args, j + 1);
         
-        if (!NCDVal_IsString(arg) || !NCDVal_IsString(arg2)) {
+        int arg_val;
+        if (!ncd_read_boolean(arg, &arg_val) || !NCDVal_IsString(arg2)) {
             ModuleLog(i, BLOG_ERROR, "bad arguments");
             goto fail0;
         }
         
-        if (ncd_read_boolean(arg)) {
+        if (arg_val) {
             template_value = arg2;
             break;
         }

ncd/modules/choose.c

@@ -88,13 +88,14 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
             ModuleLog(i, BLOG_ERROR, "wrong choice contents arity");
             goto fail0;
         }
-        if (!NCDVal_IsString(c_cond)) {
-            ModuleLog(i, BLOG_ERROR, "wrong choice condition type");
+        int c_cond_val;
+        if (!ncd_read_boolean(c_cond, &c_cond_val)) {
+            ModuleLog(i, BLOG_ERROR, "wrong choice condition");
             goto fail0;
         }
         
         // update result
-        if (!have_result && ncd_read_boolean(c_cond)) {
+        if (!have_result && c_cond_val) {
             o->result = c_result;
             have_result = 1;
         }

ncd/modules/exit.c

@@ -51,10 +51,6 @@ static void func_new (void *unused, NCDModuleInst *i, const struct NCDModuleInst
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(exit_code_arg)) {
-        ModuleLog(i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     // parse exit code
     uintmax_t exit_code;

ncd/modules/explode.c

@@ -80,7 +80,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(delimiter_arg) || !NCDVal_IsString(input_arg) || (!NCDVal_IsInvalid(limit_arg) && !NCDVal_IsString(limit_arg))) {
+    if (!NCDVal_IsString(delimiter_arg) || !NCDVal_IsString(input_arg)) {
         ModuleLog(i, BLOG_ERROR, "wrong type");
         goto fail0;
     }

ncd/modules/file_open.c

@@ -224,7 +224,7 @@ static void open_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleIns
         
         if (!NCDVal_IsInvalid(value = NCDVal_MapGetValue(options_arg, "read_size"))) {
             uintmax_t read_size;
-            if (!NCDVal_IsString(value) || !ncd_read_uintmax(value, &read_size) || read_size > SIZE_MAX || read_size == 0) {
+            if (!ncd_read_uintmax(value, &read_size) || read_size > SIZE_MAX || read_size == 0) {
                 ModuleLog(o->i, BLOG_ERROR, "wrong read_size");
                 goto fail0;
             }

ncd/modules/if.c

@@ -54,13 +54,14 @@ static void new_templ (NCDModuleInst *i, const struct NCDModuleInst_new_params *
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(arg)) {
-        ModuleLog(i, BLOG_ERROR, "wrong type");
+    int arg_val;
+    if (!ncd_read_boolean(arg, &arg_val)) {
+        ModuleLog(i, BLOG_ERROR, "bad argument");
         goto fail0;
     }
     
     // compute logical value of argument
-    int c = ncd_read_boolean(arg);
+    int c = arg_val;
     
     // signal up if needed
     if ((is_not && !c) || (!is_not && c)) {

ncd/modules/imperative.c

@@ -244,8 +244,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         goto fail0;
     }
     if (!NCDVal_IsString(init_template_arg) || !NCDVal_IsList(init_args)  ||
-        !NCDVal_IsString(deinit_template_arg) || !NCDVal_IsList(o->deinit_args) ||
-        !NCDVal_IsString(deinit_timeout_arg)) {
+        !NCDVal_IsString(deinit_template_arg) || !NCDVal_IsList(o->deinit_args)) {
         ModuleLog(i, BLOG_ERROR, "wrong type");
         goto fail0;
     }

ncd/modules/index.c

@@ -75,10 +75,6 @@ static void func_new_from_value (void *vo, NCDModuleInst *i, const struct NCDMod
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(arg_value)) {
-        ModuleLog(i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     // parse value
     uintmax_t value;

ncd/modules/list.c

@@ -498,10 +498,6 @@ static void get_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst
         ModuleLog(o->i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(index_arg)) {
-        ModuleLog(o->i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     uintmax_t index;
     if (!ncd_read_uintmax(index_arg, &index)) {
         ModuleLog(o->i, BLOG_ERROR, "wrong value");
@@ -646,10 +642,6 @@ static void find_func_new (void *vo, NCDModuleInst *i, const struct NCDModuleIns
         ModuleLog(o->i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(start_pos_arg)) {
-        ModuleLog(o->i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     // read start position
     uintmax_t start_pos;
@@ -710,10 +702,6 @@ static void removeat_func_new (void *unused, NCDModuleInst *i, const struct NCDM
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(remove_pos_arg)) {
-        ModuleLog(i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     // read position
     uintmax_t remove_pos;

ncd/modules/log.c

@@ -114,34 +114,38 @@ static void do_log (int level, NCDValRef list, size_t start)
 
 static int parse_level (NCDModuleInst *i, NCDValRef level_arg, int *out_level)
 {
-    if (!NCDVal_IsString(level_arg)) {
-        return 0;
+    int found = 0;
+    if (NCDVal_IsString(level_arg)) {
+        NCDStringIndex *string_index = i->params->iparams->string_index;
+        found = 1;
+        
+        if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_ERROR), string_index)) {
+            *out_level = BLOG_ERROR;
+        }
+        else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_WARNING), string_index)) {
+            *out_level = BLOG_WARNING;
+        }
+        else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_NOTICE), string_index)) {
+            *out_level = BLOG_NOTICE;
+        }
+        else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_INFO), string_index)) {
+            *out_level = BLOG_INFO;
+        }
+        else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_DEBUG), string_index)) {
+            *out_level = BLOG_DEBUG;
+        }
+        else {
+            found = 0;
+        }
     }
     
-    NCDStringIndex *string_index = i->params->iparams->string_index;
-    
-    uintmax_t level_numeric;
-    if (ncd_read_uintmax(level_arg, &level_numeric) && level_numeric >= BLOG_ERROR && level_numeric <= BLOG_DEBUG) {
+    if (!found) {
+        uintmax_t level_numeric;
+        if (!ncd_read_uintmax(level_arg, &level_numeric) || !(level_numeric >= BLOG_ERROR && level_numeric <= BLOG_DEBUG)) {
+            return 0;
+        }
         *out_level = level_numeric;
     }
-    else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_ERROR), string_index)) {
-        *out_level = BLOG_ERROR;
-    }
-    else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_WARNING), string_index)) {
-        *out_level = BLOG_WARNING;
-    }
-    else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_NOTICE), string_index)) {
-        *out_level = BLOG_NOTICE;
-    }
-    else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_INFO), string_index)) {
-        *out_level = BLOG_INFO;
-    }
-    else if (NCDVal_StringEqualsId(level_arg, ModuleString(i, STRING_DEBUG), string_index)) {
-        *out_level = BLOG_DEBUG;
-    }
-    else {
-        return 0;
-    }
     
     return 1;
 }

ncd/modules/logical.c

@@ -67,12 +67,13 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
             ModuleLog(o->i, BLOG_ERROR, "wrong arity");
             goto fail0;
         }
-        if (!NCDVal_IsString(arg)) {
-            ModuleLog(o->i, BLOG_ERROR, "wrong type");
+        int arg_val;
+        if (!ncd_read_boolean(arg, &arg_val)) {
+            ModuleLog(o->i, BLOG_ERROR, "bad argument");
             goto fail0;
         }
         
-        o->value = !ncd_read_boolean(arg);
+        o->value = !arg_val;
     } else {
         o->value = (is_or ? 0 : 1);
         
@@ -81,12 +82,12 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         for (size_t j = 0; j < count; j++) {
             NCDValRef arg = NCDVal_ListGet(params->args, j);
             
-            if (!NCDVal_IsString(arg)) {
-                ModuleLog(o->i, BLOG_ERROR, "wrong type");
+            int this_value;
+            if (!ncd_read_boolean(arg, &this_value)) {
+                ModuleLog(o->i, BLOG_ERROR, "bad argument");
                 goto fail0;
             }
             
-            int this_value = ncd_read_boolean(arg);
             if (is_or) {
                 o->value = o->value || this_value;
             } else {

ncd/modules/net_dns.c

@@ -242,7 +242,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         ModuleLog(o->i, BLOG_ERROR, "wrong arity");
         goto fail1;
     }
-    if (!NCDVal_IsList(servers_arg) || !NCDVal_IsString(priority_arg)) {
+    if (!NCDVal_IsList(servers_arg)) {
         ModuleLog(o->i, BLOG_ERROR, "wrong type");
         goto fail1;
     }
@@ -314,7 +314,7 @@ static void func_new_resolvconf (void *vo, NCDModuleInst *i, const struct NCDMod
         ModuleLog(o->i, BLOG_ERROR, "wrong arity");
         goto fail1;
     }
-    if (!NCDVal_IsList(lines_arg) || !NCDVal_IsString(priority_arg)) {
+    if (!NCDVal_IsList(lines_arg)) {
         ModuleLog(o->i, BLOG_ERROR, "wrong type");
         goto fail1;
     }

ncd/modules/net_ipv4_route.c

@@ -84,7 +84,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         goto fail0;
     }
     if (!NCDVal_IsString(dest_arg) || !NCDVal_IsString(gateway_arg) ||
-        !NCDVal_IsString(metric_arg) || !NCDVal_IsStringNoNulls(ifname_arg) ||
+        !NCDVal_IsStringNoNulls(ifname_arg) ||
         (!NCDVal_IsInvalid(dest_prefix_arg) && !NCDVal_IsString(dest_prefix_arg))
     ) {
         ModuleLog(o->i, BLOG_ERROR, "wrong type");

ncd/modules/net_ipv6_route.c

@@ -86,7 +86,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         goto fail0;
     }
     if (!NCDVal_IsString(dest_arg) || !NCDVal_IsString(gateway_arg) ||
-        !NCDVal_IsString(metric_arg) || !NCDVal_IsStringNoNulls(ifname_arg) ||
+        !NCDVal_IsStringNoNulls(ifname_arg) ||
         (!NCDVal_IsInvalid(dest_prefix_arg) && !NCDVal_IsString(dest_prefix_arg))
     ) {
         ModuleLog(o->i, BLOG_ERROR, "wrong type");

ncd/modules/runonce.c

@@ -175,7 +175,10 @@ static int opts_func_unknown (void *user, NCDValRef key, NCDValRef val)
     struct instance *o = user;
     
     if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "term_on_deinit")) {
-        o->term_on_deinit = ncd_read_boolean(val);
+        if (!ncd_read_boolean(val, &o->term_on_deinit)) {
+            ModuleLog(o->i, BLOG_ERROR, "term_on_deinit: bad value");
+            return 0;
+        }
         return 1;
     }
     

ncd/modules/sleep.c

@@ -85,15 +85,11 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         ModuleLog(o->i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(ms_start_arg) || (!NCDVal_IsInvalid(ms_stop_arg) && !NCDVal_IsString(ms_stop_arg))) {
-        ModuleLog(o->i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     uintmax_t ms;
     btime_t ms_start;
     
-    if (NCDVal_StringEqualsId(ms_start_arg, NCD_STRING_EMPTY, i->params->iparams->string_index)) {
+    if (NCDVal_IsString(ms_start_arg) && NCDVal_StringEqualsId(ms_start_arg, NCD_STRING_EMPTY, i->params->iparams->string_index)) {
         ms_start = -1;
     } else {
         if (!ncd_read_uintmax(ms_start_arg, &ms) || ms > INT64_MAX) {
@@ -103,7 +99,7 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         ms_start = ms;
     }
     
-    if (NCDVal_IsInvalid(ms_stop_arg) || NCDVal_StringEqualsId(ms_stop_arg, NCD_STRING_EMPTY, i->params->iparams->string_index)) {
+    if (NCDVal_IsInvalid(ms_stop_arg) || (NCDVal_IsString(ms_stop_arg) && NCDVal_StringEqualsId(ms_stop_arg, NCD_STRING_EMPTY, i->params->iparams->string_index))) {
         o->ms_stop = -1;
     } else {
         if (!ncd_read_uintmax(ms_stop_arg, &ms) || ms > INT64_MAX) {

ncd/modules/socket.c

@@ -245,7 +245,7 @@ static int parse_options (NCDModuleInst *i, NCDValRef options, size_t *out_read_
         
         if (!NCDVal_IsInvalid(value = NCDVal_MapGetValue(options, "read_size"))) {
             uintmax_t read_size;
-            if (!NCDVal_IsString(value) || !ncd_read_uintmax(value, &read_size) || read_size > SIZE_MAX || read_size == 0) {
+            if (!ncd_read_uintmax(value, &read_size) || read_size > SIZE_MAX || read_size == 0) {
                 ModuleLog(i, BLOG_ERROR, "wrong read_size");
                 return 0;
             }

ncd/modules/substr.c

@@ -94,9 +94,7 @@ static void func_new_substr (void *vo, NCDModuleInst *i, const struct NCDModuleI
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(str_arg) || !NCDVal_IsString(start_arg) ||
-        (!NCDVal_IsInvalid(max_arg) && !NCDVal_IsString(max_arg))
-    ) {
+    if (!NCDVal_IsString(str_arg)) {
         ModuleLog(i, BLOG_ERROR, "wrong type");
         goto fail0;
     }

ncd/modules/sys_start_process.c

@@ -316,15 +316,18 @@ static int opts_func_unknown (void *user, NCDValRef key, NCDValRef val)
     struct process_instance *o = user;
     
     if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "term_on_deinit")) {
-        o->term_on_deinit = ncd_read_boolean(val);
+        if (!ncd_read_boolean(val, &o->term_on_deinit)) {
+            ModuleLog(o->i, BLOG_ERROR, "term_on_deinit: bad value");
+            return 0;
+        }
         return 1;
     }
     
     if (NCDVal_IsString(key) && NCDVal_StringEquals(key, "deinit_kill_time")) {
-        if (NCDVal_StringEquals(val, "never")) {
+        if (NCDVal_IsString(val) && NCDVal_StringEquals(val, "never")) {
             o->deinit_kill_time = -2;
         }
-        else if (NCDVal_StringEqualsId(val, NCD_STRING_EMPTY, o->i->params->iparams->string_index)) {
+        else if (NCDVal_IsString(val) && NCDVal_StringEqualsId(val, NCD_STRING_EMPTY, o->i->params->iparams->string_index)) {
             o->deinit_kill_time = -1;
         }
         else if (!ncd_read_time(val, &o->deinit_kill_time)) {

ncd/modules/timer.c

@@ -89,10 +89,6 @@ static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new
         ModuleLog(o->i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(down_time_arg) || !NCDVal_IsString(up_time_arg)) {
-        ModuleLog(o->i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     // read times
     if (!ncd_read_time(down_time_arg, &o->down_time)) {

ncd/modules/value.c

@@ -975,7 +975,7 @@ static struct value * value_get (NCDModuleInst *i, struct value *v, NCDValRef wh
         
         case NCDVAL_LIST: {
             uintmax_t index;
-            if (!NCDVal_IsString(where) || !ncd_read_uintmax(where, &index)) {
+            if (!ncd_read_uintmax(where, &index)) {
                 if (!no_error) ModuleLog(i, BLOG_ERROR, "index is not a valid number (resolving into list)");
                 goto fail;
             }
@@ -1048,7 +1048,7 @@ static struct value * value_insert (NCDModuleInst *i, struct value *v, NCDValRef
         
         case NCDVAL_LIST: {
             uintmax_t index;
-            if (!NCDVal_IsString(where) || !ncd_read_uintmax(where, &index)) {
+            if (!ncd_read_uintmax(where, &index)) {
                 ModuleLog(i, BLOG_ERROR, "index is not a valid number (inserting into list)");
                 goto fail1;
             }
@@ -1161,7 +1161,7 @@ static int value_remove (NCDModuleInst *i, struct value *v, NCDValRef where)
         
         case NCDVAL_LIST: {
             uintmax_t index;
-            if (!NCDVal_IsString(where) || !ncd_read_uintmax(where, &index)) {
+            if (!ncd_read_uintmax(where, &index)) {
                 ModuleLog(i, BLOG_ERROR, "index is not a valid number (removing from list)");
                 goto fail;
             }
@@ -1799,10 +1799,6 @@ static void func_new_substr (void *vo, NCDModuleInst *i, const struct NCDModuleI
         ModuleLog(i, BLOG_ERROR, "wrong arity");
         goto fail0;
     }
-    if (!NCDVal_IsString(start_arg) || (!NCDVal_IsInvalid(length_arg) && !NCDVal_IsString(length_arg))) {
-        ModuleLog(i, BLOG_ERROR, "wrong type");
-        goto fail0;
-    }
     
     uintmax_t start;
     if (!ncd_read_uintmax(start_arg, &start)) {