static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef ifname_arg;
NCDValRef addr_arg;
NCDValRef prefix_arg = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 2, &ifname_arg, &addr_arg) &&
!NCDVal_ListRead(params->args, 3, &ifname_arg, &addr_arg, &prefix_arg)
) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsStringNoNulls(ifname_arg) || !NCDVal_IsString(addr_arg) ||
(!NCDVal_IsInvalid(prefix_arg) && !NCDVal_IsString(prefix_arg))
) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
// null terminate ifname
if (!NCDVal_StringNullTerminate(ifname_arg, &o->ifname_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail0;
}
if (NCDVal_IsInvalid(prefix_arg)) {
if (!ipaddr_parse_ipv4_ifaddr_bin(NCDVal_StringData(addr_arg), NCDVal_StringLength(addr_arg), &o->ifaddr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong CIDR notation address");
goto fail1;
}
} else {
if (!ipaddr_parse_ipv4_addr_bin(NCDVal_StringData(addr_arg), NCDVal_StringLength(addr_arg), &o->ifaddr.addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong address");
goto fail1;
}
if (!ipaddr_parse_ipv4_prefix_bin(NCDVal_StringData(prefix_arg), NCDVal_StringLength(prefix_arg), &o->ifaddr.prefix)) {
ModuleLog(o->i, BLOG_ERROR, "wrong prefix");
goto fail1;
}
}
// add address
if (!NCDIfConfig_add_ipv4_addr(o->ifname_nts.data, o->ifaddr)) {
ModuleLog(o->i, BLOG_ERROR, "failed to add IP address");
goto fail1;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail1:
NCDValNullTermString_Free(&o->ifname_nts);
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef target_arg;
if (!NCDVal_ListRead(params->args, 1, &target_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(target_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
// parse name string
if (!AliasNames_InitNames(o, i->params->iparams->string_index, NCDVal_StringData(target_arg), NCDVal_StringLength(target_arg))) {
ModuleLog(i, BLOG_ERROR, "make_names failed");
goto fail0;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef arg_ifname;
NCDValRef arg_addr;
if (!NCDVal_ListRead(params->args, 2, &arg_ifname, &arg_addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsStringNoNulls(arg_ifname) || !NCDVal_IsString(arg_addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
// parse address
uint32_t addr;
if (!ipaddr_parse_ipv4_addr_bin(NCDVal_StringData(arg_addr), NCDVal_StringLength(arg_addr), &addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong address");
goto fail0;
}
// null terminate ifname
NCDValNullTermString ifname_nts;
if (!NCDVal_StringNullTerminate(arg_ifname, &ifname_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail0;
}
// init arpprobe
int res = BArpProbe_Init(&o->arpprobe, ifname_nts.data, addr, i->params->iparams->reactor, o, (BArpProbe_handler)arpprobe_handler);
NCDValNullTermString_Free(&ifname_nts);
if (!res) {
ModuleLog(o->i, BLOG_ERROR, "BArpProbe_Init failed");
goto fail0;
}
// set state unknown
o->state = STATE_UNKNOWN;
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void perchar_eval (NCDCall call, perchar_func func)
{
if (NCDCall_ArgCount(&call) != 1) {
return FunctionLog(&call, BLOG_ERROR, "tolower: need one argument");
}
NCDValRef arg = NCDCall_EvalArg(&call, 0, NCDCall_ResMem(&call));
if (NCDVal_IsInvalid(arg)) {
return;
}
if (!NCDVal_IsString(arg)) {
return FunctionLog(&call, BLOG_ERROR, "tolower: argument not a string");
}
NCDValRef value = NCDVal_NewStringUninitialized(NCDCall_ResMem(&call), NCDVal_StringLength(arg));
if (NCDVal_IsInvalid(value)) {
return;
}
char *out_data = (char *)NCDVal_StringData(value);
MEMREF_LOOP_CHARS(NCDVal_StringMemRef(arg), i, ch, {
out_data[i] = func(ch);
})
static void func_new_common (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params, int is_ifnot)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef arg_addr;
NCDValRef arg_net_addr;
NCDValRef arg_net_prefix = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 2, &arg_addr, &arg_net_addr) &&
!NCDVal_ListRead(params->args, 3, &arg_addr, &arg_net_addr, &arg_net_prefix)
) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(arg_addr) || !NCDVal_IsString(arg_net_addr) ||
(!NCDVal_IsInvalid(arg_net_prefix) && !NCDVal_IsString(arg_net_prefix))
) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
// parse addr
struct ipv6_addr addr;
if (!ipaddr6_parse_ipv6_addr_bin(NCDVal_StringData(arg_addr), NCDVal_StringLength(arg_addr), &addr)) {
ModuleLog(o->i, BLOG_ERROR, "bad address");
goto fail0;
}
// parse network
struct ipv6_ifaddr network;
if (NCDVal_IsInvalid(arg_net_prefix)) {
if (!ipaddr6_parse_ipv6_ifaddr_bin(NCDVal_StringData(arg_net_addr), NCDVal_StringLength(arg_net_addr), &network)) {
ModuleLog(o->i, BLOG_ERROR, "bad network in CIDR notation");
goto fail0;
}
} else {
if (!ipaddr6_parse_ipv6_addr_bin(NCDVal_StringData(arg_net_addr), NCDVal_StringLength(arg_net_addr), &network.addr)) {
ModuleLog(o->i, BLOG_ERROR, "bad network address");
goto fail0;
}
if (!ipaddr6_parse_ipv6_prefix_bin(NCDVal_StringData(arg_net_prefix), NCDVal_StringLength(arg_net_prefix), &network.prefix)) {
ModuleLog(o->i, BLOG_ERROR, "bad network prefix");
goto fail0;
}
}
// test
o->value = ipaddr6_ipv6_addrs_in_network(addr, network.addr, network.prefix);
if (is_ifnot && o->value) {
ModuleLog(o->i, BLOG_ERROR, "addresses belong to same subnet, not proceeding");
}
// signal up
if (!is_ifnot || !o->value) {
NCDModuleInst_Backend_Up(o->i);
}
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef delimiter_arg;
NCDValRef input_arg;
NCDValRef limit_arg = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 2, &delimiter_arg, &input_arg) && !NCDVal_ListRead(params->args, 3, &delimiter_arg, &input_arg, &limit_arg)) {
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))) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
size_t limit = SIZE_MAX;
if (!NCDVal_IsInvalid(limit_arg)) {
uintmax_t n;
if (!ncd_read_uintmax(limit_arg, &n) || n == 0) {
ModuleLog(i, BLOG_ERROR, "bad limit argument");
goto fail0;
}
n--;
limit = (n <= SIZE_MAX ? n : SIZE_MAX);
}
const char *del_data = NCDVal_StringData(delimiter_arg);
size_t del_len = NCDVal_StringLength(delimiter_arg);
if (del_len == 0) {
ModuleLog(i, BLOG_ERROR, "delimiter must be nonempty");
goto fail0;
}
size_t *table = BAllocArray(del_len, sizeof(table[0]));
if (!table) {
ModuleLog(i, BLOG_ERROR, "ExpArray_init failed");
goto fail0;
}
build_substring_backtrack_table(del_data, del_len, table);
if (!ExpArray_init(&o->arr, sizeof(struct substring), 8)) {
ModuleLog(i, BLOG_ERROR, "ExpArray_init failed");
goto fail1;
}
o->num = 0;
const char *data = NCDVal_StringData(input_arg);
size_t len = NCDVal_StringLength(input_arg);
while (1) {
size_t start;
int is_end = 0;
if (limit == 0 || !find_substring(data, len, del_data, del_len, table, &start)) {
start = len;
is_end = 1;
}
if (!ExpArray_resize(&o->arr, o->num + 1)) {
ModuleLog(i, BLOG_ERROR, "ExpArray_init failed");
goto fail2;
}
struct substring *elem = &((struct substring *)o->arr.v)[o->num];
if (!(elem->data = BAlloc(start))) {
ModuleLog(i, BLOG_ERROR, "BAlloc failed");
goto fail2;
}
memcpy(elem->data, data, start);
elem->len = start;
o->num++;
if (is_end) {
break;
}
data += start + del_len;
len -= start + del_len;
limit--;
}
BFree(table);
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail2:
while (o->num-- > 0) {
BFree(((struct substring *)o->arr.v)[o->num].data);
}
free(o->arr.v);
fail1:
BFree(table);
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef glue_arg;
NCDValRef pieces_arg;
if (!NCDVal_ListRead(params->args, 2, &glue_arg, &pieces_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(glue_arg) || !NCDVal_IsList(pieces_arg)) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
// init result string
ExpString str;
if (!ExpString_Init(&str)) {
ModuleLog(i, BLOG_ERROR, "ExpString_Init failed");
goto fail0;
}
size_t count = NCDVal_ListCount(pieces_arg);
for (size_t j = 0; j < count; j++) {
NCDValRef piece = NCDVal_ListGet(pieces_arg, j);
// check piece type
if (!NCDVal_IsString(piece)) {
ModuleLog(i, BLOG_ERROR, "wrong piece type");
goto fail1;
}
// append glue
if (j > 0) {
if (!ExpString_AppendBinary(&str, (const uint8_t *)NCDVal_StringData(glue_arg), NCDVal_StringLength(glue_arg))) {
ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinary failed");
goto fail1;
}
}
// append piece
if (!ExpString_AppendBinary(&str, (const uint8_t *)NCDVal_StringData(piece), NCDVal_StringLength(piece))) {
ModuleLog(i, BLOG_ERROR, "ExpString_AppendBinary failed");
goto fail1;
}
}
// store result
o->result = ExpString_Get(&str);
o->result_len = ExpString_Length(&str);
// signal up
NCDModuleInst_Backend_Up(i);
return;
fail1:
ExpString_Free(&str);
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new_substr (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
NCDValRef str_arg;
NCDValRef start_arg;
NCDValRef max_arg = NCDVal_NewInvalid();
if (!NCDVal_ListRead(params->args, 2, &str_arg, &start_arg) &&
!NCDVal_ListRead(params->args, 3, &str_arg, &start_arg, &max_arg)
) {
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))
) {
ModuleLog(i, BLOG_ERROR, "wrong type");
goto fail0;
}
uintmax_t start;
if (!ncd_read_uintmax(start_arg, &start) || start > SIZE_MAX) {
ModuleLog(i, BLOG_ERROR, "wrong size");
goto fail0;
}
uintmax_t max = SIZE_MAX;
if (!NCDVal_IsInvalid(max_arg)) {
if (!ncd_read_uintmax(max_arg, &max) || max > SIZE_MAX) {
ModuleLog(i, BLOG_ERROR, "wrong max");
goto fail0;
}
}
const char *str_data = NCDVal_StringData(str_arg);
size_t str_length = NCDVal_StringLength(str_arg);
if (start > str_length) {
ModuleLog(i, BLOG_ERROR, "start is beyond the end of the string");
goto fail0;
}
const char *sub_data = str_data + start;
size_t sub_length = str_length - start;
if (sub_length > max) {
sub_length = max;
}
int is_external = 0;
BRefTarget *external_ref_target = NULL;
if (NCDVal_IsExternalString(str_arg)) {
is_external = 1;
external_ref_target = NCDVal_ExternalStringTarget(str_arg);
}
else if (NCDVal_IsIdString(str_arg)) {
is_external = 1;
}
substr_func_new_common(vo, i, sub_data, sub_length, is_external, external_ref_target);
return;
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct instance *o = vo;
o->i = i;
// read arguments
NCDValRef dest_arg;
NCDValRef dest_prefix_arg = NCDVal_NewInvalid();
NCDValRef gateway_arg;
NCDValRef metric_arg;
NCDValRef ifname_arg;
if (!NCDVal_ListRead(params->args, 4, &dest_arg, &gateway_arg, &metric_arg, &ifname_arg) &&
!NCDVal_ListRead(params->args, 5, &dest_arg, &dest_prefix_arg, &gateway_arg, &metric_arg, &ifname_arg)
) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail0;
}
if (!NCDVal_IsString(dest_arg) || !NCDVal_IsString(gateway_arg) ||
!NCDVal_IsStringNoNulls(ifname_arg) ||
(!NCDVal_IsInvalid(dest_prefix_arg) && !NCDVal_IsString(dest_prefix_arg))
) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail0;
}
// read dest
if (NCDVal_IsInvalid(dest_prefix_arg)) {
if (!ipaddr6_parse_ipv6_ifaddr_bin(NCDVal_StringData(dest_arg), NCDVal_StringLength(dest_arg), &o->dest)) {
ModuleLog(o->i, BLOG_ERROR, "wrong CIDR notation dest");
goto fail0;
}
} else {
if (!ipaddr6_parse_ipv6_addr_bin(NCDVal_StringData(dest_arg), NCDVal_StringLength(dest_arg), &o->dest.addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong dest addr");
goto fail0;
}
if (!ipaddr6_parse_ipv6_prefix_bin(NCDVal_StringData(dest_prefix_arg), NCDVal_StringLength(dest_prefix_arg), &o->dest.prefix)) {
ModuleLog(o->i, BLOG_ERROR, "wrong dest prefix");
goto fail0;
}
}
// read gateway and choose type
if (NCDVal_StringEquals(gateway_arg, "none")) {
o->type = TYPE_IFONLY;
}
else if (NCDVal_StringEquals(gateway_arg, "blackhole")) {
o->type = TYPE_BLACKHOLE;
} else {
if (!ipaddr6_parse_ipv6_addr_bin(NCDVal_StringData(gateway_arg), NCDVal_StringLength(gateway_arg), &o->gateway)) {
ModuleLog(o->i, BLOG_ERROR, "wrong gateway");
goto fail0;
}
o->type = TYPE_NORMAL;
}
// read metric
uintmax_t metric;
if (!ncd_read_uintmax(metric_arg, &metric) || metric > INT_MAX) {
ModuleLog(i, BLOG_ERROR, "bad metric");
goto fail0;
}
o->metric = metric;
// null terminate ifname
if (!NCDVal_StringNullTerminate(ifname_arg, &o->ifname_nts)) {
ModuleLog(i, BLOG_ERROR, "NCDVal_StringNullTerminate failed");
goto fail0;
}
// add route
int res = 0; // to remove warning
switch (o->type) {
case TYPE_NORMAL:
res = NCDIfConfig_add_ipv6_route(o->dest, &o->gateway, o->metric, o->ifname_nts.data);
break;
case TYPE_IFONLY:
res = NCDIfConfig_add_ipv6_route(o->dest, NULL, o->metric, o->ifname_nts.data);
break;
case TYPE_BLACKHOLE:
res = NCDIfConfig_add_ipv6_blackhole_route(o->dest, o->metric);
break;
default: ASSERT(0);
}
if (!res) {
ModuleLog(o->i, BLOG_ERROR, "failed to add route");
goto fail1;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail1:
NCDValNullTermString_Free(&o->ifname_nts);
fail0:
NCDModuleInst_Backend_DeadError(i);
}
static void func_new (void *vo, NCDModuleInst *i, const struct NCDModuleInst_new_params *params)
{
struct global *g = ModuleGlobal(i);
struct instance *o = vo;
o->i = i;
// init servers list
LinkedList1_Init(&o->entries);
// get arguments
NCDValRef servers_arg;
NCDValRef priority_arg;
if (!NCDVal_ListRead(params->args, 2, &servers_arg, &priority_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong arity");
goto fail1;
}
if (!NCDVal_IsList(servers_arg) || !NCDVal_IsString(priority_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail1;
}
uintmax_t priority;
if (!ncd_read_uintmax(priority_arg, &priority) || priority > INT_MAX) {
ModuleLog(o->i, BLOG_ERROR, "wrong priority");
goto fail1;
}
// read servers
size_t count = NCDVal_ListCount(servers_arg);
for (size_t j = 0; j < count; j++) {
NCDValRef server_arg = NCDVal_ListGet(servers_arg, j);
if (!NCDVal_IsString(server_arg)) {
ModuleLog(o->i, BLOG_ERROR, "wrong type");
goto fail1;
}
uint32_t addr;
if (!ipaddr_parse_ipv4_addr_bin((char *)NCDVal_StringData(server_arg), NCDVal_StringLength(server_arg), &addr)) {
ModuleLog(o->i, BLOG_ERROR, "wrong addr");
goto fail1;
}
char addr_str[IPADDR_PRINT_MAX];
ipaddr_print_addr(addr, addr_str);
if (!add_dns_entry(o, "nameserver", addr_str, priority)) {
ModuleLog(o->i, BLOG_ERROR, "failed to add dns entry");
goto fail1;
}
}
// add to instances
LinkedList1_Append(&g->instances, &o->instances_node);
// set servers
if (!set_servers(g)) {
ModuleLog(o->i, BLOG_ERROR, "failed to set DNS servers");
goto fail2;
}
// signal up
NCDModuleInst_Backend_Up(o->i);
return;
fail2:
LinkedList1_Remove(&g->instances, &o->instances_node);
fail1:
remove_entries(o);
NCDModuleInst_Backend_DeadError(i);
}
