int
wsdv_keycode_translate(int eventval)
{
int tkeycode;
bool r;
char okeycode[MAX_KEY_SIZE];
if (pd == NULL)
return eventval;
snprintf(okeycode, MAX_KEY_SIZE-1, "%d", eventval);
r = prop_dictionary_get_int32(pd, okeycode, &tkeycode);
#if 0
if (!r) {
snprintf(okeycode, MAX_KEY_SIZE-1, "%x", eventval);
r = prop_dictionary_get_int32(pd, okeycode, &tkeycode);
}
#endif
if (!r) {
fprintf(stderr, "unable to map event value %s\n", okeycode);
return eventval;
}
#if WSDV_DEBUG
fprintf(stderr, "translated event value %x into %x\n", eventval,
tkeycode);
#endif
return tkeycode;
}
static int __noinline
npf_mk_singlerule(prop_dictionary_t rldict, npf_rprocset_t *rpset,
npf_rule_t **rlret, prop_dictionary_t errdict)
{
npf_rule_t *rl;
const char *rname;
prop_object_t obj;
int p, error = 0;
/* Rule - dictionary. */
if (prop_object_type(rldict) != PROP_TYPE_DICTIONARY) {
NPF_ERR_DEBUG(errdict);
return EINVAL;
}
if ((rl = npf_rule_alloc(rldict)) == NULL) {
NPF_ERR_DEBUG(errdict);
return EINVAL;
}
/* Assign rule procedure, if any. */
if (prop_dictionary_get_cstring_nocopy(rldict, "rproc", &rname)) {
npf_rproc_t *rp;
if (rpset == NULL) {
error = EINVAL;
goto err;
}
if ((rp = npf_rprocset_lookup(rpset, rname)) == NULL) {
NPF_ERR_DEBUG(errdict);
error = EINVAL;
goto err;
}
npf_rule_setrproc(rl, rp);
}
/* Filter code (binary data). */
if ((obj = prop_dictionary_get(rldict, "code")) != NULL) {
int type;
size_t len;
void *code;
prop_dictionary_get_int32(rldict, "code-type", &type);
error = npf_mk_code(obj, type, &code, &len, errdict);
if (error) {
goto err;
}
npf_rule_setcode(rl, type, code, len);
}
*rlret = rl;
return 0;
err:
npf_rule_free(rl);
prop_dictionary_get_int32(rldict, "prio", &p); /* XXX */
prop_dictionary_set_int32(errdict, "id", p);
return error;
}
void
_npf_config_error(nl_config_t *ncf, nl_error_t *ne)
{
memset(ne, 0, sizeof(*ne));
prop_dictionary_get_int32(ncf->ncf_err, "id", &ne->ne_id);
prop_dictionary_get_cstring(ncf->ncf_err,
"source-file", &ne->ne_source_file);
prop_dictionary_get_uint32(ncf->ncf_err,
"source-line", &ne->ne_source_line);
prop_dictionary_get_int32(ncf->ncf_err,
"code-error", &ne->ne_ncode_error);
prop_dictionary_get_int32(ncf->ncf_err,
"code-errat", &ne->ne_ncode_errat);
}
int
npf_nat_gettype(nl_nat_t *nt)
{
prop_dictionary_t rldict = nt->nrl_dict;
int type = 0;
prop_dictionary_get_int32(rldict, "type", &type);
return type;
}
int
npf_table_gettype(nl_table_t *tl)
{
prop_dictionary_t tldict = tl->ntl_dict;
int type = 0;
prop_dictionary_get_int32(tldict, "type", &type);
return type;
}
int
testcase_get_result(prop_dictionary_t testcase)
{
int32_t result = RESULT_NOTRUN;
prop_dictionary_t dict = testcase_get_result_dict(testcase);
prop_dictionary_get_int32(dict, "result", &result);
return (int)result;
}
static int __noinline
npf_mk_singlerule(prop_dictionary_t rldict, prop_array_t rps, npf_rule_t **rl,
prop_dictionary_t errdict)
{
const char *rnm;
npf_rproc_t *rp;
prop_object_t obj;
size_t nc_size;
void *nc;
int p, error;
/* Rule - dictionary. */
if (prop_object_type(rldict) != PROP_TYPE_DICTIONARY) {
NPF_ERR_DEBUG(errdict);
return EINVAL;
}
error = 0;
obj = prop_dictionary_get(rldict, "ncode");
if (obj) {
/* N-code (binary data). */
error = npf_mk_ncode(obj, &nc, &nc_size, errdict);
if (error) {
goto err;
}
} else {
/* No n-code. */
nc = NULL;
nc_size = 0;
}
/* Check for rule procedure. */
if (rps && prop_dictionary_get_cstring_nocopy(rldict, "rproc", &rnm)) {
rp = npf_mk_rproc(rps, rnm);
if (rp == NULL) {
if (nc) {
npf_ncode_free(nc, nc_size); /* XXX */
}
NPF_ERR_DEBUG(errdict);
error = EINVAL;
goto err;
}
} else {
rp = NULL;
}
/* Finally, allocate and return the rule. */
*rl = npf_rule_alloc(rldict, rp, nc, nc_size);
KASSERT(*rl != NULL);
return 0;
err:
prop_dictionary_get_int32(rldict, "priority", &p); /* XXX */
prop_dictionary_set_int32(errdict, "id", p);
return error;
}
int
npf_config_submit(nl_config_t *ncf, int fd)
{
const char *plist = ncf->ncf_plist;
prop_dictionary_t npf_dict;
prop_array_t rlset;
int error = 0;
npf_dict = prop_dictionary_create();
if (npf_dict == NULL) {
return ENOMEM;
}
prop_dictionary_set_uint32(npf_dict, "version", NPF_VERSION);
rlset = _npf_ruleset_transform(ncf->ncf_rules_list);
if (rlset == NULL) {
prop_object_release(npf_dict);
return ENOMEM;
}
prop_object_release(ncf->ncf_rules_list);
ncf->ncf_rules_list = rlset;
prop_dictionary_set(npf_dict, "rules", ncf->ncf_rules_list);
prop_dictionary_set(npf_dict, "algs", ncf->ncf_alg_list);
prop_dictionary_set(npf_dict, "rprocs", ncf->ncf_rproc_list);
prop_dictionary_set(npf_dict, "tables", ncf->ncf_table_list);
prop_dictionary_set(npf_dict, "translation", ncf->ncf_nat_list);
prop_dictionary_set_bool(npf_dict, "flush", ncf->ncf_flush);
if (ncf->ncf_debug) {
prop_dictionary_set(npf_dict, "debug", ncf->ncf_debug);
}
if (plist) {
if (!prop_dictionary_externalize_to_file(npf_dict, plist)) {
error = errno;
}
prop_object_release(npf_dict);
return error;
}
if (fd) {
error = prop_dictionary_sendrecv_ioctl(npf_dict, fd,
IOC_NPF_RELOAD, &ncf->ncf_err);
if (error) {
prop_object_release(npf_dict);
assert(ncf->ncf_err == NULL);
return error;
}
prop_dictionary_get_int32(ncf->ncf_err, "errno", &error);
}
prop_object_release(npf_dict);
return error;
}
int
testcase_get_signal(prop_dictionary_t testcase)
{
int32_t sig;
int r;
prop_dictionary_t dict = testcase_get_result_dict(testcase);
r = prop_dictionary_get_int32(dict, "signal", &sig);
if (r == 0)
err(1, "prop_dictionary operation failed");
return (int)sig;
}
int
testcase_get_exit_value(prop_dictionary_t testcase)
{
int32_t exitval;
int r;
prop_dictionary_t dict = testcase_get_result_dict(testcase);
r = prop_dictionary_get_int32(dict, "exit_value", &exitval);
if (r == 0)
err(1, "prop_dictionary operation failed");
return (int)exitval;
}
struct timeval *
testcase_get_timeout(prop_dictionary_t testcase)
{
static struct timeval tv;
int32_t val;
int r;
r = prop_dictionary_get_int32(prop_dictionary_get(testcase, "opts"),
"timeout_in_secs", &val);
if (r == 0)
err(1, "prop_dictionary operation failed");
tv.tv_usec = 0;
tv.tv_sec = (long)val;
return &tv;
}
static int __noinline
npf_mk_tables(npf_tableset_t *tblset, prop_array_t tables,
prop_dictionary_t errdict)
{
prop_object_iterator_t it;
prop_dictionary_t tbldict;
int error = 0;
/* Tables - array. */
if (prop_object_type(tables) != PROP_TYPE_ARRAY) {
NPF_ERR_DEBUG(errdict);
return EINVAL;
}
it = prop_array_iterator(tables);
while ((tbldict = prop_object_iterator_next(it)) != NULL) {
const char *name;
npf_table_t *t;
u_int tid;
int type;
/* Table - dictionary. */
if (prop_object_type(tbldict) != PROP_TYPE_DICTIONARY) {
NPF_ERR_DEBUG(errdict);
error = EINVAL;
break;
}
/* Table name, ID and type. Validate them. */
if (!prop_dictionary_get_cstring_nocopy(tbldict, "name", &name)) {
NPF_ERR_DEBUG(errdict);
error = EINVAL;
break;
}
prop_dictionary_get_uint32(tbldict, "id", &tid);
prop_dictionary_get_int32(tbldict, "type", &type);
error = npf_table_check(tblset, name, tid, type);
if (error) {
NPF_ERR_DEBUG(errdict);
break;
}
/* Get the entries or binary data. */
prop_array_t ents = prop_dictionary_get(tbldict, "entries");
prop_object_t obj = prop_dictionary_get(tbldict, "data");
void *blob = prop_data_data(obj);
size_t size = prop_data_size(obj);
if (type == NPF_TABLE_CDB && (blob == NULL || size == 0)) {
NPF_ERR_DEBUG(errdict);
error = EINVAL;
break;
}
if (type == NPF_TABLE_HASH) {
size = 1024; /* XXX */
}
/* Create and insert the table. */
t = npf_table_create(name, tid, type, blob, size);
if (t == NULL) {
NPF_ERR_DEBUG(errdict);
error = ENOMEM;
break;
}
error = npf_tableset_insert(tblset, t);
KASSERT(error == 0);
if (ents && (error = npf_mk_table_entries(t, ents)) != 0) {
NPF_ERR_DEBUG(errdict);
break;
}
}
prop_object_iterator_release(it);
/*
* Note: in a case of error, caller will free the tableset.
*/
return error;
}
static void
awin_tcon0_set_video(struct awin_tcon_softc *sc)
{
int32_t lcd_x, lcd_y, lcd_dclk_freq;
int32_t lcd_hbp, lcd_ht, lcd_vbp, lcd_vt;
int32_t lcd_hspw, lcd_vspw, lcd_io_cfg0;
uint32_t vblk, start_delay;
prop_dictionary_t cfg = device_properties(sc->sc_dev);
uint32_t val;
bool propb;
bool dualchan = false;
static struct videomode mode;
if (!prop_dictionary_get_int32(cfg, "lcd_x", &lcd_x)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_x\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_y", &lcd_y)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_y\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_dclk_freq", &lcd_dclk_freq)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_dclk_freq\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_hbp", &lcd_hbp)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_hbp\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_ht", &lcd_ht)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_ht\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_vbp", &lcd_vbp)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_vbp\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_vt", &lcd_vt)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_vt\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_hspw", &lcd_hspw)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_hspw\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_vspw", &lcd_vspw)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_vspw\n");
return;
}
if (!prop_dictionary_get_int32(cfg, "lcd_io_cfg0", &lcd_io_cfg0)) {
aprint_error_dev(sc->sc_dev, ": can't read lcd_io_cfg0\n");
return;
}
if (prop_dictionary_get_bool(cfg, "lvds_dual", &propb) && propb)
dualchan = true;
if (!awin_gpio_pinset_available(&awin_lvds0_pinset)) {
aprint_error_dev(sc->sc_dev, "lvds0 pins not available\n");
return;
}
if (dualchan && !awin_gpio_pinset_available(&awin_lvds1_pinset)) {
aprint_error_dev(sc->sc_dev, "lvds1 pins not available\n");
return;
}
awin_gpio_pinset_acquire(&awin_lvds0_pinset);
if (dualchan) {
awin_gpio_pinset_acquire(&awin_lvds1_pinset);
}
prop_dictionary_get_cstring_nocopy(cfg, "lcd_power_en",
&sc->sc_lcdpwr_pin_name);
if (sc->sc_lcdpwr_pin_name != NULL) {
if (!awin_gpio_pin_reserve(
sc->sc_lcdpwr_pin_name, &sc->sc_lcdpwr_pin)) {
aprint_error_dev(sc->sc_dev,
"failed to reserve GPIO \"%s\" for LCD power\n",
sc->sc_lcdpwr_pin_name);
sc->sc_lcdpwr_pin_name = NULL;
} else {
aprint_verbose_dev(sc->sc_dev,
": using GPIO \"%s\" for LCD power\n",
sc->sc_lcdpwr_pin_name);
}
}
prop_dictionary_get_cstring_nocopy(cfg, "lcd_bl_en",
&sc->sc_lcdblk_pin_name);
if (sc->sc_lcdblk_pin_name != NULL) {
if (!awin_gpio_pin_reserve(
sc->sc_lcdblk_pin_name, &sc->sc_lcdblk_pin)) {
aprint_error_dev(sc->sc_dev,
"failed to reserve GPIO \"%s\" for backlight\n",
sc->sc_lcdblk_pin_name);
sc->sc_lcdblk_pin_name = NULL;
} else {
if (sc->sc_lcdpwr_pin_name == NULL) {
aprint_verbose_dev(sc->sc_dev,
": using GPIO \"%s\" for backlight\n",
sc->sc_lcdblk_pin_name);
} else {
aprint_verbose(
", GPIO \"%s\" for backlight\n",
sc->sc_lcdblk_pin_name);
}
}
}
if (sc->sc_lcdpwr_pin_name != NULL) {
awin_gpio_pindata_write(&sc->sc_lcdpwr_pin, 1);
}
vblk = (lcd_vt / 2) - lcd_y;
start_delay = (vblk >= 32) ? 30 : (vblk - 2);
if (lcd_dclk_freq > 150) /* hardware limit ? */
lcd_dclk_freq = 150;
awin_tcon_set_pll(sc, lcd_dclk_freq * 1000, 7);
val = AWIN_TCONx_CTL_EN;
val |= __SHIFTIN(start_delay, AWIN_TCONx_CTL_START_DELAY);
/*
* the DE selector selects the primary DEBE for this tcon:
* 0 selects debe0 for tcon0 and debe1 for tcon1
*/
val |= __SHIFTIN(AWIN_TCONx_CTL_SRC_SEL_DE0,
AWIN_TCONx_CTL_SRC_SEL);
TCON_WRITE(sc, AWIN_TCON0_CTL_REG, val);
val = (lcd_x - 1) << 16 | (lcd_y - 1);
TCON_WRITE(sc, AWIN_TCON0_BASIC0_REG, val);
val = (lcd_ht - 1) << 16 | (lcd_hbp - 1);
TCON_WRITE(sc, AWIN_TCON0_BASIC1_REG, val);
val = (lcd_vt) << 16 | (lcd_vbp - 1);
TCON_WRITE(sc, AWIN_TCON0_BASIC2_REG, val);
val = ((lcd_hspw > 0) ? (lcd_hspw - 1) : 0) << 16;
val |= ((lcd_vspw > 0) ? (lcd_vspw - 1) : 0);
TCON_WRITE(sc, AWIN_TCON0_BASIC3_REG, val);
val = 0;
if (dualchan)
val |= AWIN_TCON0_LVDS_IF_DUALCHAN;
if (prop_dictionary_get_bool(cfg, "lvds_mode_jeida", &propb) && propb)
val |= AWIN_TCON0_LVDS_IF_MODE_JEIDA;
if (prop_dictionary_get_bool(cfg, "lvds_18bits", &propb) && propb)
val |= AWIN_TCON0_LVDS_IF_18BITS;
TCON_WRITE(sc, AWIN_TCON0_LVDS_IF_REG, val);
TCON_WRITE(sc, AWIN_TCON0_IO_POL_REG, lcd_io_cfg0);
TCON_WRITE(sc, AWIN_TCON0_IO_TRI_REG, 0);
TCON_WRITE(sc, AWIN_TCON_GINT1_REG,
__SHIFTIN(start_delay + 2, AWIN_TCON_GINT1_TCON0_LINENO));
val = 0xf0000000;
val &= ~AWIN_TCON0_DCLK_DIV;
val |= __SHIFTIN(sc->sc_clk_div, AWIN_TCON0_DCLK_DIV);
TCON_WRITE(sc, AWIN_TCON0_DCLK_REG, val);
mode.dot_clock = lcd_dclk_freq;
mode.hdisplay = lcd_x;
mode.hsync_start = lcd_ht - lcd_hbp;
mode.hsync_end = lcd_hspw + mode.hsync_start;
mode.htotal = lcd_ht;
mode.vdisplay = lcd_y;
mode.vsync_start = lcd_vt - lcd_vbp;
mode.vsync_end = lcd_vspw + mode.vsync_start;
mode.vtotal = lcd_vt;
mode.flags = 0;
mode.name = NULL;
awin_debe_set_videomode(sc->sc_debe_unit, &mode);
/* and finally, enable it */
awin_debe_enable(sc->sc_debe_unit, true);
delay(20000);
val = TCON_READ(sc, AWIN_TCON_GCTL_REG);
val |= AWIN_TCON_GCTL_EN;
TCON_WRITE(sc, AWIN_TCON_GCTL_REG, val);
delay(20000);
val = TCON_READ(sc, AWIN_TCON0_LVDS_IF_REG);
val |= AWIN_TCON0_LVDS_IF_EN;
TCON_WRITE(sc, AWIN_TCON0_LVDS_IF_REG, val);
/* XXX
* magic values here from linux. these are not documented
* in the A20 user manual, and other Allwiner LVDS-capable SoC
* documentation don't make sense with these values
*/
val = TCON_READ(sc, AWIN_TCON_LVDS_ANA0);
val |= 0x3F310000;
TCON_WRITE(sc, AWIN_TCON_LVDS_ANA0, val);
val = TCON_READ(sc, AWIN_TCON_LVDS_ANA0);
val |= 1 << 22;
TCON_WRITE(sc, AWIN_TCON_LVDS_ANA0, val);
delay(2);
val = TCON_READ(sc, AWIN_TCON_LVDS_ANA1);
val |= (0x1f << 26 | 0x1f << 10);
TCON_WRITE(sc, AWIN_TCON_LVDS_ANA1, val);
delay(2);
val = TCON_READ(sc, AWIN_TCON_LVDS_ANA1);
val |= (0x1f << 16 | 0x1f << 0);
TCON_WRITE(sc, AWIN_TCON_LVDS_ANA1, val);
val = TCON_READ(sc, AWIN_TCON_LVDS_ANA0);
val |= 1 << 22;
TCON_WRITE(sc, AWIN_TCON_LVDS_ANA0, val);
if (sc->sc_lcdblk_pin_name != NULL) {
awin_gpio_pindata_write(&sc->sc_lcdblk_pin, 1);
}
}
struct dm_ioctl*
nbsd_dm_dict_to_dmi(prop_dictionary_t dm_dict,const int cmd)
{
struct dm_ioctl *dmi;
prop_array_t ver;
size_t i;
int r;
char *name, *uuid;
uint32_t major,minor;
name = NULL;
uuid = NULL;
minor = 0;
nbsd_get_dm_major(&major, DM_BLOCK_MAJOR);
if (!(dmi = dm_malloc(DMI_SIZE)))
return NULL;
memset(dmi,0,DMI_SIZE);
prop_dictionary_get_int32(dm_dict, DM_IOCTL_OPEN, &dmi->open_count);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_EVENT, &dmi->event_nr);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &dmi->flags);
prop_dictionary_get_uint32(dm_dict, DM_IOCTL_TARGET_COUNT,
&dmi->target_count);
if (prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor))
dmi->dev = MKDEV(major, minor);
else
dmi->dev = 0;
/* Copy name and uuid to dm_ioctl. */
if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME,
(const char **)&name)){
strlcpy(dmi->name, name, DM_NAME_LEN);
} else
dmi->name[0] = '\0';
if (prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID,
(const char **)&uuid)){
strlcpy(dmi->uuid, uuid, DM_UUID_LEN);
} else
dmi->uuid[0] = '\0';
/* dmi parsing values, size of dmi block and offset to data. */
dmi->data_size = DMI_SIZE;
dmi->data_start = sizeof(struct dm_ioctl);
/* Get kernel version from dm_dict. */
ver = prop_dictionary_get(dm_dict,DM_IOCTL_VERSION);
for(i=0; i<3; i++)
prop_array_get_uint32(ver,i,&dmi->version[i]);
switch (cmd){
case DM_LIST_VERSIONS:
r = dm_list_versions(dm_dict,dmi);
if (r >= 0)
dmi->target_count = r;
break;
case DM_LIST_DEVICES:
r = dm_list_devices(dm_dict,dmi);
if (r >= 0)
dmi->target_count = r;
break;
case DM_TABLE_STATUS:
r = dm_table_status(dm_dict,dmi);
if (r >= 0)
dmi->target_count = r;
break;
case DM_TABLE_DEPS:
r = dm_dev_deps(dm_dict,dmi);
if (r >= 0)
dmi->target_count = r;
break;
}
return dmi;
}
/*
* Print status of each table, target arguments, start sector,
* size and target name.
*/
static int
dm_table_status(prop_dictionary_t dm_dict,struct dm_ioctl *dmi)
{
struct dm_target_spec *dmts, *odmts;
prop_array_t targets;
prop_dictionary_t target_dict;
prop_object_iterator_t iter;
char *type,*params,*params_start;
bool prm;
size_t j,plen,rec_size,next;
j = 0;
next = 0;
params = NULL;
odmts = NULL;
rec_size = 0;
plen = -1;
prm = false;
dmts = (struct dm_target_spec *)((uint8_t *)dmi + dmi->data_start);
if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){
iter = prop_array_iterator(targets);
if (!iter)
err(EXIT_FAILURE,"dm_table_status %s",__func__);
while((target_dict = prop_object_iterator_next(iter)) != NULL){
prop_dictionary_get_cstring_nocopy(target_dict,
DM_TABLE_TYPE,(const char **)&type);
prm = prop_dictionary_get_cstring_nocopy(target_dict,
DM_TABLE_PARAMS,(const char **)¶ms);
prop_dictionary_get_uint64(target_dict,DM_TABLE_START,&dmts->sector_start);
prop_dictionary_get_uint64(target_dict,DM_TABLE_LENGTH,&dmts->length);
prop_dictionary_get_int32(target_dict,DM_TABLE_STAT,&dmts->status);
if (prm)
plen = strlen(params) + 1;
rec_size = sizeof(struct dm_target_spec) + plen;
/*
* In linux when copying table status from kernel next is
* number of bytes from the start of the first dm_target_spec
* structure. I don't know why but, it has to be done this way.
*/
next += rec_size;
if (rec_size > dmi->data_size)
return -ENOMEM;
dmts->next = next;
strlcpy(dmts->target_type, type, DM_MAX_TYPE_NAME);
params_start = (char *)dmts + sizeof(struct dm_target_spec);
if (prm)
strlcpy(params_start, params, plen);
else
params_start = "\0";
odmts = dmts;
dmts = (struct dm_target_spec *)((uint8_t *)dmts + rec_size);
j++;
}
if (odmts != NULL)
odmts->next = 0;
}
prop_object_iterator_release(iter);
return j;
}
static int __noinline
npf_mk_tables(npf_tableset_t *tblset, prop_array_t tables,
prop_dictionary_t errdict)
{
prop_object_iterator_t it;
prop_dictionary_t tbldict;
int error = 0;
/* Tables - array. */
if (prop_object_type(tables) != PROP_TYPE_ARRAY) {
NPF_ERR_DEBUG(errdict);
return EINVAL;
}
it = prop_array_iterator(tables);
while ((tbldict = prop_object_iterator_next(it)) != NULL) {
prop_dictionary_t ent;
prop_object_iterator_t eit;
prop_array_t entries;
npf_table_t *t;
u_int tid;
int type;
/* Table - dictionary. */
if (prop_object_type(tbldict) != PROP_TYPE_DICTIONARY) {
NPF_ERR_DEBUG(errdict);
error = EINVAL;
break;
}
/* Table ID and type. */
prop_dictionary_get_uint32(tbldict, "id", &tid);
prop_dictionary_get_int32(tbldict, "type", &type);
/* Validate them, check for duplicate IDs. */
error = npf_table_check(tblset, tid, type);
if (error)
break;
/* Create and insert the table. */
t = npf_table_create(tid, type, 1024); /* XXX */
if (t == NULL) {
NPF_ERR_DEBUG(errdict);
error = ENOMEM;
break;
}
error = npf_tableset_insert(tblset, t);
KASSERT(error == 0);
/* Entries. */
entries = prop_dictionary_get(tbldict, "entries");
if (prop_object_type(entries) != PROP_TYPE_ARRAY) {
NPF_ERR_DEBUG(errdict);
error = EINVAL;
break;
}
eit = prop_array_iterator(entries);
while ((ent = prop_object_iterator_next(eit)) != NULL) {
const npf_addr_t *addr;
npf_netmask_t mask;
int alen;
/* Get address and mask. Add a table entry. */
prop_object_t obj = prop_dictionary_get(ent, "addr");
addr = (const npf_addr_t *)prop_data_data_nocopy(obj);
prop_dictionary_get_uint8(ent, "mask", &mask);
alen = prop_data_size(obj);
error = npf_table_insert(tblset, tid, alen, addr, mask);
if (error)
break;
}
prop_object_iterator_release(eit);
if (error)
break;
}
prop_object_iterator_release(it);
/*
* Note: in a case of error, caller will free the tableset.
*/
return error;
}