nl_config_t * npf_config_retrieve(int fd, bool *active, bool *loaded) { prop_dictionary_t npf_dict; nl_config_t *ncf; int error; error = prop_dictionary_recv_ioctl(fd, IOC_NPF_GETCONF, &npf_dict); if (error) { return NULL; } ncf = calloc(1, sizeof(*ncf)); if (ncf == NULL) { prop_object_release(npf_dict); return NULL; } ncf->ncf_dict = npf_dict; ncf->ncf_alg_list = prop_dictionary_get(npf_dict, "algs"); ncf->ncf_rules_list = prop_dictionary_get(npf_dict, "rules"); ncf->ncf_rproc_list = prop_dictionary_get(npf_dict, "rprocs"); ncf->ncf_table_list = prop_dictionary_get(npf_dict, "tables"); ncf->ncf_nat_list = prop_dictionary_get(npf_dict, "translation"); prop_dictionary_get_bool(npf_dict, "active", active); *loaded = (ncf->ncf_rules_list != NULL); return ncf; }
static int settunnel(prop_dictionary_t env, prop_dictionary_t oenv) { const struct paddr_prefix *srcpfx, *dstpfx; struct if_laddrreq req; prop_data_t srcdata, dstdata; srcdata = (prop_data_t)prop_dictionary_get(env, "tunsrc"); dstdata = (prop_data_t)prop_dictionary_get(env, "tundst"); if (srcdata == NULL || dstdata == NULL) { warnx("%s.%d", __func__, __LINE__); errno = ENOENT; return -1; } srcpfx = prop_data_data_nocopy(srcdata); dstpfx = prop_data_data_nocopy(dstdata); if (srcpfx->pfx_addr.sa_family != dstpfx->pfx_addr.sa_family) errx(EXIT_FAILURE, "source and destination address families do not match"); memset(&req, 0, sizeof(req)); memcpy(&req.addr, &srcpfx->pfx_addr, MIN(sizeof(req.addr), srcpfx->pfx_addr.sa_len)); memcpy(&req.dstaddr, &dstpfx->pfx_addr, MIN(sizeof(req.dstaddr), dstpfx->pfx_addr.sa_len)); #ifdef INET6 if (req.addr.ss_family == AF_INET6) { struct sockaddr_in6 *s6, *d; s6 = (struct sockaddr_in6 *)&req.addr; d = (struct sockaddr_in6 *)&req.dstaddr; if (s6->sin6_scope_id != d->sin6_scope_id) { errx(EXIT_FAILURE, "scope mismatch"); /* NOTREACHED */ } if (IN6_IS_ADDR_MULTICAST(&d->sin6_addr) || IN6_IS_ADDR_MULTICAST(&s6->sin6_addr)) errx(EXIT_FAILURE, "tunnel src/dst is multicast"); /* embed scopeid */ if (s6->sin6_scope_id && IN6_IS_ADDR_LINKLOCAL(&s6->sin6_addr)) { *(u_int16_t *)&s6->sin6_addr.s6_addr[2] = htons(s6->sin6_scope_id); } if (d->sin6_scope_id && IN6_IS_ADDR_LINKLOCAL(&d->sin6_addr)) { *(u_int16_t *)&d->sin6_addr.s6_addr[2] = htons(d->sin6_scope_id); } } #endif /* INET6 */ if (direct_ioctl(env, SIOCSLIFPHYADDR, &req) == -1) warn("SIOCSLIFPHYADDR"); return 0; }
static int __noinline npf_mk_natlist(npf_ruleset_t *nset, prop_array_t natlist, prop_dictionary_t errdict) { prop_object_iterator_t it; prop_dictionary_t natdict; int error; /* NAT policies - array. */ if (prop_object_type(natlist) != PROP_TYPE_ARRAY) { NPF_ERR_DEBUG(errdict); return EINVAL; } error = 0; it = prop_array_iterator(natlist); while ((natdict = prop_object_iterator_next(it)) != NULL) { npf_rule_t *rl = NULL; npf_natpolicy_t *np; /* NAT policy - dictionary. */ if (prop_object_type(natdict) != PROP_TYPE_DICTIONARY) { NPF_ERR_DEBUG(errdict); error = EINVAL; break; } /* * NAT policies are standard rules, plus additional * information for translation. Make a rule. */ error = npf_mk_singlerule(natdict, NULL, &rl, errdict); if (error) { break; } npf_ruleset_insert(nset, rl); /* If rule is named, it is a group with NAT policies. */ if (prop_dictionary_get(natdict, "name") && prop_dictionary_get(natdict, "subrules")) { continue; } /* Allocate a new NAT policy and assign to the rule. */ np = npf_nat_newpolicy(natdict, nset); if (np == NULL) { NPF_ERR_DEBUG(errdict); error = ENOMEM; break; } npf_rule_setnat(rl, np); } prop_object_iterator_release(it); /* * Note: in a case of error, caller will free entire NAT ruleset * with assigned NAT policies. */ return error; }
static int __noinline npf_mk_rules(npf_ruleset_t *rlset, prop_array_t rules, prop_array_t rprocs, prop_dictionary_t errdict) { prop_object_iterator_t it; prop_dictionary_t rldict, rpdict; int error; /* Rule procedures and the ruleset - arrays. */ if (prop_object_type(rprocs) != PROP_TYPE_ARRAY || prop_object_type(rules) != PROP_TYPE_ARRAY) { NPF_ERR_DEBUG(errdict); return EINVAL; } it = prop_array_iterator(rprocs); while ((rpdict = prop_object_iterator_next(it)) != NULL) { if (prop_dictionary_get(rpdict, "rproc-ptr")) { prop_object_iterator_release(it); NPF_ERR_DEBUG(errdict); return EINVAL; } } prop_object_iterator_release(it); error = 0; it = prop_array_iterator(rules); while ((rldict = prop_object_iterator_next(it)) != NULL) { prop_array_t subrules; npf_ruleset_t *rlsetsub; npf_rule_t *rl; /* Generate a single rule. */ error = npf_mk_singlerule(rldict, rprocs, &rl, errdict); if (error) { break; } npf_ruleset_insert(rlset, rl); /* Check for sub-rules and generate, if any. */ subrules = prop_dictionary_get(rldict, "subrules"); if (subrules == NULL) { /* No subrules, next.. */ continue; } rlsetsub = npf_rule_subset(rl); error = npf_mk_subrules(rlsetsub, subrules, rprocs, errdict); if (error) break; } prop_object_iterator_release(it); /* * Note: in a case of error, caller will free the ruleset. */ return error; }
void HIDDEN xbps_pkg_find_conflicts(struct xbps_handle *xhp, prop_dictionary_t pkg_repod) { prop_array_t pkg_cflicts, trans_cflicts; prop_dictionary_t pkgd; const char *cfpkg, *repopkgver, *pkgver; char *buf; size_t i; pkg_cflicts = prop_dictionary_get(pkg_repod, "conflicts"); if (pkg_cflicts == NULL || prop_array_count(pkg_cflicts) == 0) return; trans_cflicts = prop_dictionary_get(xhp->transd, "conflicts"); prop_dictionary_get_cstring_nocopy(pkg_repod, "pkgver", &repopkgver); for (i = 0; i < prop_array_count(pkg_cflicts); i++) { prop_array_get_cstring_nocopy(pkg_cflicts, i, &cfpkg); /* * Check if current pkg conflicts with an installed package. */ if ((pkgd = xbps_pkgdb_get_pkgd(xhp, cfpkg, true))) { prop_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver); buf = xbps_xasprintf("%s conflicts with " "installed pkg %s", repopkgver, pkgver); assert(buf != NULL); prop_array_add_cstring(trans_cflicts, buf); free(buf); continue; } /* * Check if current pkg conflicts with any pkg in transaction. */ pkgd = xbps_find_pkg_in_dict_by_pattern(xhp, xhp->transd, "unsorted_deps", cfpkg); if (pkgd != NULL) { prop_dictionary_get_cstring_nocopy(pkgd, "pkgver", &pkgver); buf = xbps_xasprintf("%s conflicts with " "%s in transaction", repopkgver, pkgver); assert(buf != NULL); prop_array_add_cstring(trans_cflicts, buf); free(buf); continue; } } }
/* * Get the sector size from an _open_ device. */ static int _get_block_size(struct device *dev, unsigned int *size) { const char *name = dev_name(dev); #ifdef __NetBSD__ struct disklabel lab; prop_dictionary_t disk_dict, geom_dict; uint32_t secsize; #endif if ((dev->block_size == -1)) { #ifdef __NetBSD__ if (prop_dictionary_recv_ioctl(dev_fd(dev), DIOCGDISKINFO, &disk_dict)) { if (ioctl(dev_fd(dev), DIOCGDINFO, &lab) < 0) { dev->block_size = DEV_BSIZE; } else dev->block_size = lab.d_secsize; } else { geom_dict = prop_dictionary_get(disk_dict, "geometry"); prop_dictionary_get_uint32(geom_dict, "sector-size", &secsize); dev->block_size = secsize; } #else if (ioctl(dev_fd(dev), BLKBSZGET, &dev->block_size) < 0) { log_sys_error("ioctl BLKBSZGET", name); return 0; } #endif log_debug("%s: block size is %u bytes", name, dev->block_size); } *size = (unsigned int) dev->block_size; return 1; }
static int acpi_debug_sysctl_level(SYSCTLFN_ARGS) { char buf[ACPI_DEBUG_MAX]; struct sysctlnode node; prop_object_t obj; int error; node = *rnode; node.sysctl_data = buf; (void)memcpy(node.sysctl_data, rnode->sysctl_data, ACPI_DEBUG_MAX); error = sysctl_lookup(SYSCTLFN_CALL(&node)); if (error || newp == NULL) return error; obj = prop_dictionary_get(acpi_debug_level_d, node.sysctl_data); if (obj == NULL) return EINVAL; AcpiDbgLevel = prop_number_unsigned_integer_value(obj); (void)memcpy(rnode->sysctl_data, node.sysctl_data, ACPI_DEBUG_MAX); return 0; }
static void cpsw_attach(device_t parent, device_t self, void *aux) { struct obio_attach_args * const oa = aux; struct cpsw_softc * const sc = device_private(self); prop_dictionary_t dict = device_properties(self); struct ethercom * const ec = &sc->sc_ec; struct ifnet * const ifp = &ec->ec_if; int error; u_int i; KERNHIST_INIT(cpswhist, 4096); sc->sc_dev = self; aprint_normal(": TI CPSW Ethernet\n"); aprint_naive("\n"); callout_init(&sc->sc_tick_ch, 0); callout_setfunc(&sc->sc_tick_ch, cpsw_tick, sc); prop_data_t eaprop = prop_dictionary_get(dict, "mac-address"); if (eaprop == NULL) { /* grab mac_id0 from AM335x control module */ uint32_t reg_lo, reg_hi; if (sitara_cm_reg_read_4(OMAP2SCM_MAC_ID0_LO, ®_lo) == 0 && sitara_cm_reg_read_4(OMAP2SCM_MAC_ID0_HI, ®_hi) == 0) { sc->sc_enaddr[0] = (reg_hi >> 0) & 0xff; sc->sc_enaddr[1] = (reg_hi >> 8) & 0xff; sc->sc_enaddr[2] = (reg_hi >> 16) & 0xff; sc->sc_enaddr[3] = (reg_hi >> 24) & 0xff; sc->sc_enaddr[4] = (reg_lo >> 0) & 0xff; sc->sc_enaddr[5] = (reg_lo >> 8) & 0xff; } else {
/* * Translate command sent from libdevmapper to func. */ static int dm_cmd_to_fun(prop_dictionary_t dm_dict) { int i, r; prop_string_t command; r = 0; if ((command = prop_dictionary_get(dm_dict, DM_IOCTL_COMMAND)) == NULL) return EINVAL; for(i = 0; cmd_fn[i].cmd != NULL; i++) if (prop_string_equals_cstring(command, cmd_fn[i].cmd)) break; if (!cmd_fn[i].allowed && (r = kauth_authorize_system(kauth_cred_get(), KAUTH_SYSTEM_DEVMAPPER, 0, NULL, NULL, NULL)) != 0) return r; if (cmd_fn[i].cmd == NULL) return EINVAL; aprint_debug("ioctl %s called\n", cmd_fn[i].cmd); r = cmd_fn[i].fn(dm_dict); return r; }
/* * npfctl_sessions_load: import a list of sessions, reconstruct them and load. */ int npfctl_sessions_load(u_long cmd, void *data) { const struct plistref *pref = data; npf_sehash_t *sehasht = NULL; prop_dictionary_t sesdict, sedict; prop_object_iterator_t it; prop_array_t selist; int error; /* Retrieve the dictionary containing session and NAT policy lists. */ error = prop_dictionary_copyin_ioctl(pref, cmd, &sesdict); if (error) return error; /* * Note: session objects contain the references to the NAT policy * entries. Therefore, no need to directly access it. */ selist = prop_dictionary_get(sesdict, "session-list"); if (prop_object_type(selist) != PROP_TYPE_ARRAY) { error = EINVAL; goto fail; } /* Create a session hash table. */ sehasht = sess_htable_create(); if (sehasht == NULL) { error = ENOMEM; goto fail; } /* * Iterate through and construct each session. */ error = 0; it = prop_array_iterator(selist); npf_core_enter(); while ((sedict = prop_object_iterator_next(it)) != NULL) { /* Session - dictionary. */ if (prop_object_type(sedict) != PROP_TYPE_DICTIONARY) { error = EINVAL; goto fail; } /* Construct and insert real session structure. */ error = npf_session_restore(sehasht, sedict); if (error) { goto fail; } } npf_core_exit(); sess_htable_reload(sehasht); fail: prop_object_release(selist); if (error && sehasht) { /* Destroy session table. */ sess_htable_destroy(sehasht); } return error; }
int npfctl_remove_rule(u_long cmd, void *data) { struct plistref *pref = data; prop_dictionary_t dict, errdict; prop_object_t obj; const char *name; int error, numrules; /* Retrieve and construct the rule. */ error = prop_dictionary_copyin_ioctl(pref, cmd, &dict); if (error) { return error; } /* Dictionary for error reporting. */ errdict = prop_dictionary_create(); obj = prop_dictionary_get(dict, "name"); name = prop_string_cstring_nocopy(obj); npf_rule_t *rl; error = npf_mk_singlerule(dict, prop_array_create(), &rl, errdict); npf_core_enter(); numrules = npf_named_ruleset_remove(name, npf_core_ruleset(), rl); npf_core_exit(); prop_object_release(dict); /* Error report. */ prop_dictionary_set_int32(errdict, "errno", error); prop_dictionary_set_int32(errdict, "numrules", numrules); prop_dictionary_copyout_ioctl(pref, cmd, errdict); prop_object_release(errdict); return error; }
static void _npf_ruleset_transform1(prop_array_t rlset, prop_array_t rules) { prop_object_iterator_t it; prop_dictionary_t rldict; prop_array_t subrlset; it = prop_array_iterator(rules); while ((rldict = prop_object_iterator_next(it)) != NULL) { unsigned idx; /* Add rules to the array (reference is retained). */ prop_array_add(rlset, rldict); subrlset = prop_dictionary_get(rldict, "subrules"); if (subrlset) { /* Process subrules recursively. */ _npf_ruleset_transform1(rlset, subrlset); /* Add the skip-to position. */ idx = prop_array_count(rlset); prop_dictionary_set_uint32(rldict, "skip-to", idx); prop_dictionary_remove(rldict, "subrules"); } } prop_object_iterator_release(it); }
static int __noinline npf_mk_table_entries(npf_table_t *t, prop_array_t entries) { prop_object_iterator_t eit; prop_dictionary_t ent; int error = 0; if (prop_object_type(entries) != PROP_TYPE_ARRAY) { return EINVAL; } 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(t, alen, addr, mask); if (error) break; } prop_object_iterator_release(eit); return error; }
static npf_rproc_t * npf_mk_singlerproc(prop_dictionary_t rpdict) { prop_object_iterator_t it; prop_dictionary_t extdict; prop_array_t extlist; npf_rproc_t *rp; extlist = prop_dictionary_get(rpdict, "extcalls"); if (prop_object_type(extlist) != PROP_TYPE_ARRAY) { return NULL; } rp = npf_rproc_create(rpdict); if (rp == NULL) { return NULL; } it = prop_array_iterator(extlist); while ((extdict = prop_object_iterator_next(it)) != NULL) { const char *name; if (!prop_dictionary_get_cstring_nocopy(extdict, "name", &name) || npf_ext_construct(name, rp, extdict)) { npf_rproc_release(rp); rp = NULL; break; } } prop_object_iterator_release(it); return rp; }
static void via_mapchan(const struct pci_attach_args *pa, struct pciide_channel *cp, pcireg_t interface, int (*pci_intr)(void *)) { struct ata_channel *wdc_cp; struct pciide_softc *sc; prop_bool_t compat_nat_enable; wdc_cp = &cp->ata_channel; sc = CHAN_TO_PCIIDE(&cp->ata_channel); compat_nat_enable = prop_dictionary_get( device_properties(sc->sc_wdcdev.sc_atac.atac_dev), "use-compat-native-irq"); if (interface & PCIIDE_INTERFACE_PCI(wdc_cp->ch_channel)) { /* native mode with irq 14/15 requested? */ if (compat_nat_enable != NULL && prop_bool_true(compat_nat_enable)) via_mapregs_compat_native(pa, cp); else pciide_mapregs_native(pa, cp, pci_intr); } else { pciide_mapregs_compat(pa, cp, wdc_cp->ch_channel); if ((cp->ata_channel.ch_flags & ATACH_DISABLED) == 0) pciide_map_compat_intr(pa, cp, wdc_cp->ch_channel); } wdcattach(wdc_cp); }
static void epe_attach(device_t parent, device_t self, void *aux) { struct epe_softc *sc = device_private(self); struct epsoc_attach_args *sa; prop_data_t enaddr; aprint_normal("\n"); sa = aux; sc->sc_dev = self; sc->sc_iot = sa->sa_iot; sc->sc_intr = sa->sa_intr; sc->sc_dmat = sa->sa_dmat; if (bus_space_map(sa->sa_iot, sa->sa_addr, sa->sa_size, 0, &sc->sc_ioh)) panic("%s: Cannot map registers", device_xname(self)); /* Fetch the Ethernet address from property if set. */ enaddr = prop_dictionary_get(device_properties(self), "mac-address"); if (enaddr != NULL) { KASSERT(prop_object_type(enaddr) == PROP_TYPE_DATA); KASSERT(prop_data_size(enaddr) == ETHER_ADDR_LEN); memcpy(sc->sc_enaddr, prop_data_data_nocopy(enaddr), ETHER_ADDR_LEN); bus_space_write_4(sc->sc_iot, sc->sc_ioh, EPE_AFP, 0); bus_space_write_region_1(sc->sc_iot, sc->sc_ioh, EPE_IndAd, sc->sc_enaddr, ETHER_ADDR_LEN); } ep93xx_intr_establish(sc->sc_intr, IPL_NET, epe_intr, sc); epe_init(sc); }
void ibm4xx_device_register(struct device *dev, void *aux) { struct device *parent = device_parent(dev); if (device_is_a(dev, "emac") && device_is_a(parent, "opb")) { /* Set the mac-addr of the on-chip Ethernet. */ struct opb_attach_args *oaa = aux; if (oaa->opb_instance < 10) { prop_data_t pd; unsigned char prop_name[15]; snprintf(prop_name, sizeof(prop_name), "emac%d-mac-addr", oaa->opb_instance); pd = prop_dictionary_get(board_properties, prop_name); if (pd == NULL) { printf("WARNING: unable to get mac-addr " "property from board properties\n"); return; } if (prop_dictionary_set(device_properties(dev), "mac-addr", pd) == false) { printf("WARNING: unable to set mac-addr " "property for %s\n", dev->dv_xname); } } return; } }
int _npf_ruleset_list(int fd, const char *rname, nl_config_t *ncf) { prop_dictionary_t rldict, ret; int error; rldict = prop_dictionary_create(); if (rldict == NULL) { return ENOMEM; } prop_dictionary_set_cstring(rldict, "ruleset-name", rname); prop_dictionary_set_uint32(rldict, "command", NPF_CMD_RULE_LIST); error = prop_dictionary_sendrecv_ioctl(rldict, fd, IOC_NPF_RULE, &ret); if (!error) { prop_array_t rules; rules = prop_dictionary_get(ret, "rules"); if (rules == NULL) { return EINVAL; } prop_object_release(ncf->ncf_rules_list); ncf->ncf_rules_list = rules; } return error; }
/* * npfctl_update_rule: reload a specific rule identified by the name. */ int npfctl_update_rule(u_long cmd, void *data) { struct plistref *pref = data; prop_dictionary_t dict, errdict; prop_array_t subrules; prop_object_t obj; npf_ruleset_t *rlset; const char *name; int error; /* Retrieve and construct the rule. */ error = prop_dictionary_copyin_ioctl(pref, cmd, &dict); if (error) { return error; } /* Dictionary for error reporting. */ errdict = prop_dictionary_create(); /* Create the ruleset and construct sub-rules. */ rlset = npf_ruleset_create(); subrules = prop_dictionary_get(dict, "subrules"); error = npf_mk_subrules(rlset, subrules, NULL, errdict); if (error) { goto out; } /* Lookup the rule by name, and replace its subset (sub-rules). */ obj = prop_dictionary_get(dict, "name"); name = prop_string_cstring_nocopy(obj); if (npf_ruleset_replace(name, rlset) == NULL) { /* Not found. */ error = ENOENT; out: /* Error path. */ npf_ruleset_destroy(rlset); } prop_object_release(dict); /* Error report. */ prop_dictionary_set_int32(errdict, "errno", error); prop_dictionary_copyout_ioctl(pref, cmd, errdict); prop_object_release(errdict); return error; }
const void * npf_rule_getinfo(nl_rule_t *rl, size_t *len) { prop_dictionary_t rldict = rl->nrl_dict; prop_object_t obj = prop_dictionary_get(rldict, "info"); *len = prop_data_size(obj); return prop_data_data_nocopy(obj); }
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; }
/* * Rename selected devices old name is in struct dm_ioctl. * newname is taken from dictionary * * <key>cmd_data</key> * <array> * <string>...</string> * </array> */ int dm_dev_rename_ioctl(prop_dictionary_t dm_dict) { #if 0 prop_array_t cmd_array; dm_dev_t *dmv; const char *name, *uuid, *n_name; uint32_t flags, minor; name = NULL; uuid = NULL; minor = 0; /* Get needed values from dictionary. */ prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_NAME, &name); prop_dictionary_get_cstring_nocopy(dm_dict, DM_IOCTL_UUID, &uuid); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_FLAGS, &flags); prop_dictionary_get_uint32(dm_dict, DM_IOCTL_MINOR, &minor); dm_dbg_print_flags(flags); cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA); prop_array_get_cstring_nocopy(cmd_array, 0, &n_name); if (strlen(n_name) + 1 > DM_NAME_LEN) return EINVAL; if ((dmv = dm_dev_rem(NULL, name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } /* change device name */ /* * XXX How to deal with this change, name only used in * dm_dev_routines, should I add dm_dev_change_name which will run * under the dm_dev_list mutex ? */ strlcpy(dmv->name, n_name, DM_NAME_LEN); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_OPEN, dmv->table_head.io_cnt); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); prop_dictionary_set_cstring(dm_dict, DM_IOCTL_UUID, dmv->uuid); dm_dev_insert(dmv); #endif /* * XXX: the rename is not yet implemented. The main complication * here is devfs. We'd probably need a new function, rename_dev() * that would trigger a node rename in devfs. */ kprintf("dm_dev_rename_ioctl called, but not implemented!\n"); return 0; }
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; }
static void dispatch_power_event_state_change(int fd, power_event_t *pev) { prop_dictionary_t dict; prop_object_t obj; const char *argv[6]; char *buf = NULL; int error; error = prop_dictionary_recv_ioctl(fd, POWER_EVENT_RECVDICT, &dict); if (error) { if (debug) printf("%s: prop_dictionary_recv_ioctl error=%d\n", __func__, error); return; } if (debug) { buf = prop_dictionary_externalize(dict); printf("%s", buf); free(buf); } obj = prop_dictionary_get(dict, "powerd-script-name"); argv[0] = prop_string_cstring_nocopy(obj); obj = prop_dictionary_get(dict, "driver-name"); argv[1] = prop_string_cstring_nocopy(obj); obj = prop_dictionary_get(dict, "powerd-event-name"); argv[2] = prop_string_cstring_nocopy(obj); obj = prop_dictionary_get(dict, "sensor-name"); argv[3] = prop_string_cstring_nocopy(obj); obj = prop_dictionary_get(dict, "state-description"); argv[4] = prop_string_cstring_nocopy(obj); argv[5] = NULL; run_script(argv); }
bool prop_dictionary_get_dict(prop_dictionary_t dict, const char *key, prop_dictionary_t *dp) { prop_object_t o; o = prop_dictionary_get(dict, key); if (o == NULL || prop_object_type(o) != PROP_TYPE_DICTIONARY) return false; *dp = o; return true; }
static int bthidev_match(device_t self, struct cfdata *cfdata, void *aux) { prop_dictionary_t dict = aux; prop_object_t obj; obj = prop_dictionary_get(dict, BTDEVservice); if (prop_string_equals_cstring(obj, "HID")) return 1; return 0; }
void npf_nat_getmap(nl_nat_t *nt, npf_addr_t *addr, size_t *alen, in_port_t *port) { prop_dictionary_t rldict = nt->nrl_dict; prop_object_t obj = prop_dictionary_get(rldict, "translation-ip"); *alen = prop_data_size(obj); memcpy(addr, prop_data_data_nocopy(obj), *alen); *port = 0; prop_dictionary_get_uint16(rldict, "translation-port", port); }
int match_dev_dict(prop_dictionary_t dict, prop_dictionary_t match_dict) { prop_number_t pn, pn2; prop_string_t ps, ps2; if (dict == NULL) return 0; if ((ps = prop_dictionary_get(dict, "name")) == NULL) return 0; if ((ps2 = prop_dictionary_get(match_dict, "name")) == NULL) return 0; if (!prop_string_equals(ps, ps2)) return 0; if ((pn = prop_dictionary_get(dict, "devnum")) == NULL) return 0; if ((pn2 = prop_dictionary_get(match_dict, "devnum")) == NULL) return 0; if (!prop_number_equals(pn, pn2)) return 0; if ((pn = prop_dictionary_get(dict, "kptr")) == NULL) return 0; if ((pn2 = prop_dictionary_get(match_dict, "kptr")) == NULL) return 0; if (!prop_number_equals(pn, pn2)) return 0; return 1; }
static void emac_attach(device_t parent, device_t self, void *aux) { struct emac_softc *sc = device_private(self); struct at91bus_attach_args *sa = aux; prop_data_t enaddr; uint32_t u; printf("\n"); sc->sc_dev = self; sc->sc_iot = sa->sa_iot; sc->sc_pid = sa->sa_pid; sc->sc_dmat = sa->sa_dmat; if (bus_space_map(sa->sa_iot, sa->sa_addr, sa->sa_size, 0, &sc->sc_ioh)) panic("%s: Cannot map registers", device_xname(self)); /* enable peripheral clock */ at91_peripheral_clock(sc->sc_pid, 1); /* configure emac: */ EMAC_WRITE(ETH_CTL, 0); // disable everything EMAC_WRITE(ETH_IDR, -1); // disable interrupts EMAC_WRITE(ETH_RBQP, 0); // clear receive EMAC_WRITE(ETH_CFG, ETH_CFG_CLK_32 | ETH_CFG_SPD | ETH_CFG_FD | ETH_CFG_BIG); EMAC_WRITE(ETH_TCR, 0); // send nothing //(void)EMAC_READ(ETH_ISR); u = EMAC_READ(ETH_TSR); EMAC_WRITE(ETH_TSR, (u & (ETH_TSR_UND | ETH_TSR_COMP | ETH_TSR_BNQ | ETH_TSR_IDLE | ETH_TSR_RLE | ETH_TSR_COL|ETH_TSR_OVR))); u = EMAC_READ(ETH_RSR); EMAC_WRITE(ETH_RSR, (u & (ETH_RSR_OVR|ETH_RSR_REC|ETH_RSR_BNA))); /* Fetch the Ethernet address from property if set. */ enaddr = prop_dictionary_get(device_properties(self), "mac-addr"); if (enaddr != NULL) { KASSERT(prop_object_type(enaddr) == PROP_TYPE_DATA); KASSERT(prop_data_size(enaddr) == ETHER_ADDR_LEN); memcpy(sc->sc_enaddr, prop_data_data_nocopy(enaddr), ETHER_ADDR_LEN); } else { static const uint8_t hardcoded[ETHER_ADDR_LEN] = { 0x00, 0x0d, 0x10, 0x81, 0x0c, 0x94 }; memcpy(sc->sc_enaddr, hardcoded, ETHER_ADDR_LEN); } at91_intr_establish(sc->sc_pid, IPL_NET, INTR_HIGH_LEVEL, emac_intr, sc); emac_init(sc); }
const char * testcase_get_make_cmd(prop_dictionary_t testcase) { const char *str; int r; r = prop_dictionary_get_cstring_nocopy( prop_dictionary_get(testcase, "opts"), "make_cmd", &str); if (r == 0) err(1, "prop_dictionary operation failed"); return str; }