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; }
static npf_rproc_t * npf_mk_rproc(prop_array_t rprocs, const char *rpname) { prop_object_iterator_t it; prop_dictionary_t rpdict; npf_rproc_t *rp; uint64_t rpval; it = prop_array_iterator(rprocs); while ((rpdict = prop_object_iterator_next(it)) != NULL) { const char *iname; prop_dictionary_get_cstring_nocopy(rpdict, "name", &iname); KASSERT(iname != NULL); if (strcmp(rpname, iname) == 0) break; } prop_object_iterator_release(it); if (rpdict == NULL) { return NULL; } CTASSERT(sizeof(uintptr_t) <= sizeof(uint64_t)); if (!prop_dictionary_get_uint64(rpdict, "rproc-ptr", &rpval)) { rp = npf_rproc_create(rpdict); rpval = (uint64_t)(uintptr_t)rp; prop_dictionary_set_uint64(rpdict, "rproc-ptr", rpval); } else { rp = (npf_rproc_t *)(uintptr_t)rpval; } return rp; }
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 int __noinline npf_mk_rules(npf_ruleset_t *rlset, prop_array_t rules, npf_rprocset_t *rpset, prop_dictionary_t errdict) { prop_object_iterator_t it; prop_dictionary_t rldict; int error; if (prop_object_type(rules) != PROP_TYPE_ARRAY) { NPF_ERR_DEBUG(errdict); return EINVAL; } error = 0; it = prop_array_iterator(rules); while ((rldict = prop_object_iterator_next(it)) != NULL) { npf_rule_t *rl = NULL; /* Generate a single rule. */ error = npf_mk_singlerule(rldict, rpset, &rl, errdict); if (error) { break; } npf_ruleset_insert(rlset, rl); } prop_object_iterator_release(it); /* * Note: in a case of error, caller will free the ruleset. */ 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 _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); }
/* * 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; }
static nl_rule_t * _npf_rule_iterate1(nl_config_t *ncf, prop_array_t rlist, unsigned *level) { prop_dictionary_t rldict; uint32_t skipto = 0; if (!ncf->ncf_rule_iter) { /* Initialise the iterator. */ ncf->ncf_rule_iter = prop_array_iterator(rlist); ncf->ncf_nlevel = 0; ncf->ncf_reduce[0] = 0; ncf->ncf_counter = 0; } rldict = prop_object_iterator_next(ncf->ncf_rule_iter); if ((ncf->ncf_cur_rule.nrl_dict = rldict) == NULL) { prop_object_iterator_release(ncf->ncf_rule_iter); ncf->ncf_rule_iter = NULL; return NULL; } *level = ncf->ncf_nlevel; prop_dictionary_get_uint32(rldict, "skip-to", &skipto); if (skipto) { ncf->ncf_nlevel++; ncf->ncf_reduce[ncf->ncf_nlevel] = skipto; } if (ncf->ncf_reduce[ncf->ncf_nlevel] == ++ncf->ncf_counter) { assert(ncf->ncf_nlevel > 0); ncf->ncf_nlevel--; } return &ncf->ncf_cur_rule; }
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 hdaudioctl_list(int fd) { prop_dictionary_t request, response; prop_dictionary_t dict; prop_object_iterator_t iter; prop_object_t obj; prop_array_t array; uint16_t nid, codecid; uint16_t vendor, product; uint32_t subsystem; const char *device = NULL; int error; request = prop_dictionary_create(); if (request == NULL) { fprintf(stderr, "out of memory\n"); return ENOMEM; } error = prop_dictionary_sendrecv_ioctl(request, fd, HDAUDIO_FGRP_INFO, &response); if (error != 0) { perror("HDAUDIO_FGRP_INFO failed"); return error; } array = prop_dictionary_get(response, "function-group-info"); iter = prop_array_iterator(array); prop_object_iterator_reset(iter); while ((obj = prop_object_iterator_next(iter)) != NULL) { dict = (prop_dictionary_t)obj; prop_dictionary_get_uint16(dict, "codecid", &codecid); prop_dictionary_get_uint16(dict, "nid", &nid); prop_dictionary_get_uint16(dict, "vendor-id", &vendor); prop_dictionary_get_uint16(dict, "product-id", &product); prop_dictionary_get_uint32(dict, "subsystem-id", &subsystem); prop_dictionary_get_cstring_nocopy(dict, "device", &device); printf("codecid 0x%02X nid 0x%02X vendor 0x%04X " "product 0x%04X subsystem 0x%08X device %s\n", codecid, nid, vendor, product, subsystem, device ? device : "<none>"); } prop_object_release(array); prop_object_release(response); prop_object_release(request); return 0; }
static bool _npf_prop_array_lookup(prop_array_t array, const char *key, const char *name) { prop_dictionary_t dict; prop_object_iterator_t it; it = prop_array_iterator(array); while ((dict = prop_object_iterator_next(it)) != NULL) { const char *lname; prop_dictionary_get_cstring_nocopy(dict, key, &lname); if (strcmp(name, lname) == 0) break; } prop_object_iterator_release(it); return dict ? true : false; }
/* * Do operations associated with quotas */ int ufs_quotactl(struct mount *mp, prop_dictionary_t dict) { struct lwp *l = curlwp; #if !defined(QUOTA) && !defined(QUOTA2) (void) mp; (void) dict; (void) l; return (EOPNOTSUPP); #else int error; prop_dictionary_t cmddict; prop_array_t commands; prop_object_iterator_t iter; /* Mark the mount busy, as we're passing it to kauth(9). */ error = vfs_busy(mp, NULL); if (error) return (error); error = quota_get_cmds(dict, &commands); if (error) goto out_vfs; iter = prop_array_iterator(commands); if (iter == NULL) { error = ENOMEM; goto out_vfs; } mutex_enter(&mp->mnt_updating); while ((cmddict = prop_object_iterator_next(iter)) != NULL) { if (prop_object_type(cmddict) != PROP_TYPE_DICTIONARY) continue; error = quota_handle_cmd(mp, l, cmddict); if (error) break; } prop_object_iterator_release(iter); mutex_exit(&mp->mnt_updating); out_vfs: vfs_unbusy(mp, false, NULL); return (error); #endif }
nl_rproc_t * npf_rproc_iterate(nl_config_t *ncf) { prop_dictionary_t rpdict; if (!ncf->ncf_rproc_iter) { /* Initialise the iterator. */ ncf->ncf_rproc_iter = prop_array_iterator(ncf->ncf_rproc_list); } rpdict = prop_object_iterator_next(ncf->ncf_rproc_iter); if ((ncf->ncf_cur_rproc.nrp_dict = rpdict) == NULL) { prop_object_iterator_release(ncf->ncf_rproc_iter); ncf->ncf_rproc_iter = NULL; return NULL; } return &ncf->ncf_cur_rproc; }
nl_table_t * npf_table_iterate(nl_config_t *ncf) { prop_dictionary_t tldict; if (!ncf->ncf_table_iter) { /* Initialise the iterator. */ ncf->ncf_table_iter = prop_array_iterator(ncf->ncf_table_list); } tldict = prop_object_iterator_next(ncf->ncf_table_iter); if ((ncf->ncf_cur_table.ntl_dict = tldict) == NULL) { prop_object_iterator_release(ncf->ncf_table_iter); ncf->ncf_table_iter = NULL; return NULL; } return &ncf->ncf_cur_table; }
static bool _npf_table_exists_p(nl_config_t *ncf, const char *name) { prop_dictionary_t tldict; prop_object_iterator_t it; it = prop_array_iterator(ncf->ncf_table_list); while ((tldict = prop_object_iterator_next(it)) != NULL) { const char *tname = NULL; if (prop_dictionary_get_cstring_nocopy(tldict, "name", &tname) && strcmp(tname, name) == 0) break; } prop_object_iterator_release(it); return tldict ? true : false; }
static int __noinline npf_mk_algs(prop_array_t alglist, prop_dictionary_t errdict) { prop_object_iterator_t it; prop_dictionary_t nadict; int error = 0; it = prop_array_iterator(alglist); while ((nadict = prop_object_iterator_next(it)) != NULL) { if (npf_mk_singlealg(nadict) == NULL) { NPF_ERR_DEBUG(errdict); error = EINVAL; break; } } prop_object_iterator_release(it); return error; }
/* * Print dm device dependiences, get minor/major number for * devices. From kernel I will receive major:minor number of * block device used with target. I have to translate it to * raw device numbers and use them, because all other parts of lvm2 * uses raw devices internaly. */ static int dm_dev_deps(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) { struct dm_target_deps *dmtd; prop_array_t targets; prop_object_iterator_t iter; uint32_t major; size_t val_len, i, j; uint64_t dev_tmp; dev_tmp = 0; j = 0; i = 0; dmtd = (struct dm_target_deps *)((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_target_deps %s", __func__); while((prop_object_iterator_next(iter)) != NULL){ prop_array_get_uint64(targets, j, &dev_tmp); dmtd->dev[j] = MKDEV(MAJOR(dev_tmp),MINOR(dev_tmp)); /* XXX: worth revisiting */ j++; } } dmtd->count = j; prop_object_iterator_release(iter); return j; }
/* * npf_mk_connlist: import a list of connections and load them. */ static int __noinline npf_mk_connlist(prop_array_t conlist, npf_ruleset_t *natlist, npf_conndb_t **conndb, prop_dictionary_t errdict) { prop_dictionary_t condict; prop_object_iterator_t it; npf_conndb_t *cd; int error = 0; /* Connection list - array */ if (prop_object_type(conlist) != PROP_TYPE_ARRAY) { NPF_ERR_DEBUG(errdict); return EINVAL; } /* Create a connection database. */ cd = npf_conndb_create(); it = prop_array_iterator(conlist); while ((condict = prop_object_iterator_next(it)) != NULL) { /* Connection - dictionary. */ if (prop_object_type(condict) != PROP_TYPE_DICTIONARY) { NPF_ERR_DEBUG(errdict); error = EINVAL; break; } /* Construct and insert the connection. */ error = npf_conn_import(cd, condict, natlist); if (error) { NPF_ERR_DEBUG(errdict); break; } } prop_object_iterator_release(it); if (error) { npf_conn_gc(cd, true, false); npf_conndb_destroy(cd); } else { *conndb = cd; } return error; }
prop_dictionary_t find_dev_dict(int64_t generation, prop_dictionary_t match_dict, int *idx) { struct pdev_array_entry *pae; prop_array_t pa; prop_object_iterator_t iter; prop_dictionary_t dict; int i = 0; if (generation == -1) pae = pdev_array_entry_get_last(); else pae = pdev_array_entry_get(generation); if (pae == NULL) return NULL; pa = pae->pdev_array; iter = prop_array_iterator(pa); if (iter == NULL) { pdev_array_entry_unref(pae); return NULL; } while ((dict = prop_object_iterator_next(iter)) != NULL) { if (match_dev_dict(dict, match_dict)) break; ++i; } prop_object_iterator_release(iter); if (idx != NULL) *idx = i; pdev_array_entry_unref(pae); return dict; }
static int __noinline npf_mk_rprocs(npf_rprocset_t *rpset, prop_array_t rprocs, prop_dictionary_t errdict) { prop_object_iterator_t it; prop_dictionary_t rpdict; int error = 0; it = prop_array_iterator(rprocs); while ((rpdict = prop_object_iterator_next(it)) != NULL) { npf_rproc_t *rp; if ((rp = npf_mk_singlerproc(rpdict)) == NULL) { NPF_ERR_DEBUG(errdict); error = EINVAL; break; } npf_rprocset_insert(rpset, rp); } prop_object_iterator_release(it); return error; }
static int __noinline npf_mk_subrules(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; int error = 0; if (prop_object_type(rules) != PROP_TYPE_ARRAY) { NPF_ERR_DEBUG(errdict); return EINVAL; } it = prop_array_iterator(rules); while ((rldict = prop_object_iterator_next(it)) != NULL) { npf_rule_t *rl; error = npf_mk_singlerule(rldict, rprocs, &rl, errdict); if (error) { break; } npf_ruleset_insert(rlset, rl); } prop_object_iterator_release(it); return error; }
static int dm_list_versions(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) { struct dm_target_versions *dmtv,*odmtv; prop_array_t targets,ver; prop_dictionary_t target_dict; prop_object_iterator_t iter; char *name; size_t j,i,slen,rec_size; odmtv = NULL; name = NULL; j = 0; dmtv = (struct dm_target_versions *)((uint8_t *)dmi + dmi->data_start); /* printf("dmi: vers: %d.%d.%d data_size: %d data_start: %d name: %s t_count: %d\n", dmi->version[0],dmi->version[1],dmi->version[2],dmi->data_size,dmi->data_start, dmi->name,dmi->target_count); printf("dmi: size: %d -- %p --- %p \n",sizeof(struct dm_ioctl),dmi,dmi+dmi->data_start); printf("dmtv: size: %p --- %p\n",dmtv,(struct dm_target_versions *)(dmi+312));*/ /* get prop_array of target_version dictionaries */ if ((targets = prop_dictionary_get(dm_dict,DM_IOCTL_CMD_DATA))){ iter = prop_array_iterator(targets); if (!iter) err(EXIT_FAILURE,"dm_list_versions %s",__func__); while((target_dict = prop_object_iterator_next(iter)) != NULL){ j++; prop_dictionary_get_cstring_nocopy(target_dict, DM_TARGETS_NAME,(const char **)&name); slen = strlen(name) + 1; rec_size = sizeof(struct dm_target_versions) + slen + 1; if (rec_size > dmi->data_size) return -ENOMEM; ver = prop_dictionary_get(target_dict,DM_TARGETS_VERSION); for (i=0; i<3; i++) prop_array_get_uint32(ver,i,&dmtv->version[i]); dmtv->next = rec_size; strlcpy(dmtv->name,name,slen); odmtv = dmtv; dmtv =(struct dm_target_versions *)((uint8_t *)dmtv + rec_size); } if (odmtv != NULL) odmtv->next = 0; } prop_object_iterator_release(iter); return j; }
/* * Load new table/tables to device. * Call apropriate target init routine open all physical pdev's and * link them to device. For other targets mirror, strip, snapshot * etc. also add dependency devices to upcalls list. * * Load table to inactive slot table are switched in dm_device_resume_ioctl. * This simulates Linux behaviour better there should not be any difference. * */ int dm_table_load_ioctl(prop_dictionary_t dm_dict) { dm_dev_t *dmv; dm_table_entry_t *table_en, *last_table; dm_table_t *tbl; dm_target_t *target; prop_object_iterator_t iter; prop_array_t cmd_array; prop_dictionary_t target_dict; const char *name, *uuid, *type; uint32_t flags, ret, minor; char *str; ret = 0; flags = 0; name = NULL; uuid = NULL; dmv = NULL; last_table = NULL; str = NULL; /* * char *xml; xml = prop_dictionary_externalize(dm_dict); * printf("%s\n",xml); */ 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); cmd_array = prop_dictionary_get(dm_dict, DM_IOCTL_CMD_DATA); iter = prop_array_iterator(cmd_array); dm_dbg_print_flags(flags); if ((dmv = dm_dev_lookup(name, uuid, minor)) == NULL) { DM_REMOVE_FLAG(flags, DM_EXISTS_FLAG); return ENOENT; } aprint_debug("Loading table to device: %s--%d\n", name, dmv->table_head.cur_active_table); /* * I have to check if this table slot is not used by another table list. * if it is used I should free them. */ if (dmv->flags & DM_INACTIVE_PRESENT_FLAG) dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE); dm_dbg_print_flags(dmv->flags); tbl = dm_table_get_entry(&dmv->table_head, DM_TABLE_INACTIVE); aprint_debug("dmv->name = %s\n", dmv->name); prop_dictionary_set_uint32(dm_dict, DM_IOCTL_MINOR, dmv->minor); while ((target_dict = prop_object_iterator_next(iter)) != NULL) { prop_dictionary_get_cstring_nocopy(target_dict, DM_TABLE_TYPE, &type); /* * If we want to deny table with 2 or more different * target we should do it here */ if (((target = dm_target_lookup(type)) == NULL) && ((target = dm_target_autoload(type)) == NULL)) { dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); dm_dev_unbusy(dmv); return ENOENT; } if ((table_en = kmalloc(sizeof(dm_table_entry_t), M_DM, M_WAITOK)) == NULL) { dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); dm_dev_unbusy(dmv); dm_target_unbusy(target); return ENOMEM; } prop_dictionary_get_uint64(target_dict, DM_TABLE_START, &table_en->start); prop_dictionary_get_uint64(target_dict, DM_TABLE_LENGTH, &table_en->length); aprint_debug("dm_ioctl.c... table_en->start = %ju, " "table_en->length = %ju\n", (uintmax_t)table_en->start, (uintmax_t)table_en->length); table_en->target = target; table_en->dm_dev = dmv; table_en->target_config = NULL; /* * There is a parameter string after dm_target_spec * structure which points to /dev/wd0a 284 part of * table. String str points to this text. This can be * null and therefore it should be checked before we try to * use it. */ prop_dictionary_get_cstring(target_dict, DM_TABLE_PARAMS, &str); if (SLIST_EMPTY(tbl)) /* insert this table to head */ SLIST_INSERT_HEAD(tbl, table_en, next); else SLIST_INSERT_AFTER(last_table, table_en, next); /* * Params string is different for every target, * therfore I have to pass it to target init * routine and parse parameters there. */ aprint_debug("DM: str passed in is: %s", str); if ((ret = target->init(dmv, &table_en->target_config, str)) != 0) { dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); dm_table_destroy(&dmv->table_head, DM_TABLE_INACTIVE); kfree(str, M_TEMP); dm_dev_unbusy(dmv); dm_target_unbusy(target); return ret; } last_table = table_en; kfree(str, M_TEMP); } prop_object_iterator_release(iter); DM_ADD_FLAG(flags, DM_INACTIVE_PRESENT_FLAG); atomic_set_int(&dmv->flags, DM_INACTIVE_PRESENT_FLAG); dm_table_release(&dmv->table_head, DM_TABLE_INACTIVE); dm_dev_unbusy(dmv); #if 0 dmsetdiskinfo(dmv->diskp, &dmv->table_head); #endif return 0; }
/* * 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 quota_handle_cmd_get(struct mount *mp, struct lwp *l, prop_dictionary_t cmddict, int type, prop_array_t datas) { prop_array_t replies; prop_object_iterator_t iter; prop_dictionary_t data; uint32_t id; struct ufsmount *ump = VFSTOUFS(mp); int error, defaultq = 0; const char *idstr; if ((ump->um_flags & (UFS_QUOTA|UFS_QUOTA2)) == 0) return EOPNOTSUPP; replies = prop_array_create(); if (replies == NULL) return ENOMEM; iter = prop_array_iterator(datas); if (iter == NULL) { prop_object_release(replies); return ENOMEM; } while ((data = prop_object_iterator_next(iter)) != NULL) { if (!prop_dictionary_get_uint32(data, "id", &id)) { if (!prop_dictionary_get_cstring_nocopy(data, "id", &idstr)) continue; if (strcmp(idstr, "default")) { error = EINVAL; goto err; } id = 0; defaultq = 1; } else { defaultq = 0; } error = quota_get_auth(mp, l, id); if (error == EPERM) continue; if (error != 0) goto err; #ifdef QUOTA if (ump->um_flags & UFS_QUOTA) error = quota1_handle_cmd_get(ump, type, id, defaultq, replies); else #endif #ifdef QUOTA2 if (ump->um_flags & UFS_QUOTA2) { error = quota2_handle_cmd_get(ump, type, id, defaultq, replies); } else #endif panic("quota_handle_cmd_get: no support ?"); if (error == ENOENT) continue; if (error != 0) goto err; } prop_object_iterator_release(iter); if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) { error = ENOMEM; } else { error = 0; } return error; err: prop_object_iterator_release(iter); prop_object_release(replies); return error; }
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; }
int main(int argc, char *argv[]) { int ch, nflag, status, x, verbose; static bstg_funcs_t bfs; char *buf; verbose = nflag = 0; while ((ch = getopt(argc, argv, "f:nv")) != -1) { switch (ch) { case 'n': nflag = 1; break; case 'v': verbose = 1; break; case '?': default: usage(); } } argv += optind-1; if (nflag) { printf("%lu\n", NFUNCS); return 0; } if (bstg_funcs_init(&bfs, verbose, 1048576)) { errx(1, "cannot init bfs"); } buf = BSTGNULLCHECK(malloc(65536)); for (x = 0; x < 128; x++) { pid_t pid; pid = fork(); if (pid == 0) { srand(x); while (*argv++) { struct archive *a; struct archive_entry *entry; a = archive_read_new(); archive_read_support_format_all(a); archive_read_support_filter_all(a); if (archive_read_open_filename(a, *argv, 10240)) { _exit(2); } while (archive_read_next_header(a, &entry) == ARCHIVE_OK) { size_t size; size = archive_entry_size(entry); buf = BSTGNULLCHECK(realloc(buf, size+1024)); if (archive_read_data(a, buf, size) == size) { prop_array_t ops; prop_number_t op; prop_object_iterator_t it; unsigned id; /* zero terminate the file from the archive */ strlcat(buf, "", 1); ops = BSTGNULLCHECK((prop_array_internalize(buf))); it = BSTGNULLCHECK(prop_array_iterator(ops)); while ((op = prop_object_iterator_next(it)) != NULL) { id = prop_number_unsigned_integer_value(op); (*bstg_fembot_funcs[id % NFUNCS]) (&bfs); } prop_object_iterator_release(it); prop_object_release(ops); } } archive_read_close(a); archive_read_free(a); } if (bstg_funcs_destroy(&bfs)) { errx(1, "cannot destroy bfs"); } _exit(1); } } while(wait(&status) > 0); while(wait(&status) > 0); while(wait(&status) > 0); if (bstg_funcs_destroy(&bfs)) { errx(1, "cannot destroy bfs"); } return 0; }
static int quota_handle_cmd_clear(struct mount *mp, struct lwp *l, prop_dictionary_t cmddict, int type, prop_array_t datas) { prop_array_t replies; prop_object_iterator_t iter; prop_dictionary_t data; uint32_t id; struct ufsmount *ump = VFSTOUFS(mp); int error, defaultq = 0; const char *idstr; if ((ump->um_flags & UFS_QUOTA2) == 0) return EOPNOTSUPP; replies = prop_array_create(); if (replies == NULL) return ENOMEM; iter = prop_array_iterator(datas); if (iter == NULL) { prop_object_release(replies); return ENOMEM; } while ((data = prop_object_iterator_next(iter)) != NULL) { if (!prop_dictionary_get_uint32(data, "id", &id)) { if (!prop_dictionary_get_cstring_nocopy(data, "id", &idstr)) continue; if (strcmp(idstr, "default")) continue; id = 0; defaultq = 1; } else { defaultq = 0; } error = kauth_authorize_system(l->l_cred, KAUTH_SYSTEM_FS_QUOTA, KAUTH_REQ_SYSTEM_FS_QUOTA_MANAGE, mp, KAUTH_ARG(id), NULL); if (error != 0) goto err; #ifdef QUOTA2 if (ump->um_flags & UFS_QUOTA2) { error = quota2_handle_cmd_clear(ump, type, id, defaultq, data); } else #endif panic("quota_handle_cmd_get: no support ?"); if (error && error != ENOENT) goto err; } prop_object_iterator_release(iter); if (!prop_dictionary_set_and_rel(cmddict, "data", replies)) { error = ENOMEM; } else { error = 0; } return error; err: prop_object_iterator_release(iter); prop_object_release(replies); return error; }
/* * Reads the CPU temperature from /sys/class/thermal/thermal_zone%d/temp (or * the user provided path) and returns the temperature in degree celcius. * */ void print_cpu_temperature_info(yajl_gen json_gen, char *buffer, int zone, const char *path, const char *format, int max_threshold) { char *outwalk = buffer; #ifdef THERMAL_ZONE const char *walk; bool colorful_output = false; char *thermal_zone; if (path == NULL) asprintf(&thermal_zone, THERMAL_ZONE, zone); else { static glob_t globbuf; if (glob(path, GLOB_NOCHECK | GLOB_TILDE, NULL, &globbuf) < 0) die("glob() failed\n"); if (globbuf.gl_pathc == 0) { /* No glob matches, the specified path does not contain a wildcard. */ asprintf(&thermal_zone, path, zone); } else { /* glob matched, we take the first match and ignore the others */ asprintf(&thermal_zone, "%s", globbuf.gl_pathv[0]); } globfree(&globbuf); } INSTANCE(thermal_zone); for (walk = format; *walk != '\0'; walk++) { if (*walk != '%') { *(outwalk++) = *walk; continue; } if (BEGINS_WITH(walk + 1, "degrees")) { #if defined(LINUX) static char buf[16]; long int temp; if (!slurp(thermal_zone, buf, sizeof(buf))) goto error; temp = strtol(buf, NULL, 10); if (temp == LONG_MIN || temp == LONG_MAX || temp <= 0) *(outwalk++) = '?'; else { if ((temp / 1000) >= max_threshold) { START_COLOR("color_bad"); colorful_output = true; } outwalk += sprintf(outwalk, "%ld", (temp / 1000)); if (colorful_output) { END_COLOR; colorful_output = false; } } #elif defined(__DragonFly__) struct sensor th_sensor; size_t th_sensorlen; th_sensorlen = sizeof(th_sensor); if (sysctlbyname(thermal_zone, &th_sensor, &th_sensorlen, NULL, 0) == -1) { perror("sysctlbyname"); goto error; } if (MUKTOC(th_sensor.value) >= max_threshold) { START_COLOR("color_bad"); colorful_output = true; } outwalk += sprintf(outwalk, "%.2f", MUKTOC(th_sensor.value)); if (colorful_output) { END_COLOR; colorful_output = false; } #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) int sysctl_rslt; size_t sysctl_size = sizeof(sysctl_rslt); if (sysctlbyname(thermal_zone, &sysctl_rslt, &sysctl_size, NULL, 0)) goto error; if (TZ_AVG(sysctl_rslt) >= max_threshold) { START_COLOR("color_bad"); colorful_output = true; } outwalk += sprintf(outwalk, "%d.%d", TZ_KELVTOC(sysctl_rslt)); if (colorful_output) { END_COLOR; colorful_output = false; } #elif defined(__OpenBSD__) struct sensordev sensordev; struct sensor sensor; size_t sdlen, slen; int dev, numt, mib[5] = {CTL_HW, HW_SENSORS, 0, 0, 0}; sdlen = sizeof(sensordev); slen = sizeof(sensor); for (dev = 0;; dev++) { mib[2] = dev; if (sysctl(mib, 3, &sensordev, &sdlen, NULL, 0) == -1) { if (errno == ENXIO) continue; if (errno == ENOENT) break; goto error; } /* 'path' is the node within the full path (defaults to acpitz0). */ if (BEGINS_WITH(sensordev.xname, thermal_zone)) { mib[3] = SENSOR_TEMP; /* Limit to temo0, but should retrieve from a full path... */ for (numt = 0; numt < 1 /*sensordev.maxnumt[SENSOR_TEMP]*/; numt++) { mib[4] = numt; if (sysctl(mib, 5, &sensor, &slen, NULL, 0) == -1) { if (errno != ENOENT) { warn("sysctl"); continue; } } if ((int)MUKTOC(sensor.value) >= max_threshold) { START_COLOR("color_bad"); colorful_output = true; } outwalk += sprintf(outwalk, "%.2f", MUKTOC(sensor.value)); if (colorful_output) { END_COLOR; colorful_output = false; } } } } #elif defined(__NetBSD__) int fd, rval; bool err = false; prop_dictionary_t dict; prop_array_t array; prop_object_iterator_t iter; prop_object_iterator_t iter2; prop_object_t obj, obj2, obj3; fd = open("/dev/sysmon", O_RDONLY); if (fd == -1) goto error; rval = prop_dictionary_recv_ioctl(fd, ENVSYS_GETDICTIONARY, &dict); if (rval == -1) { err = true; goto error_netbsd1; } /* No drivers registered? */ if (prop_dictionary_count(dict) == 0) { err = true; goto error_netbsd2; } iter = prop_dictionary_iterator(dict); if (iter == NULL) { err = true; goto error_netbsd2; } /* iterate over the dictionary returned by the kernel */ while ((obj = prop_object_iterator_next(iter)) != NULL) { /* skip this dict if it's not what we're looking for */ if ((strlen(prop_dictionary_keysym_cstring_nocopy(obj)) != strlen(thermal_zone)) || (strncmp(thermal_zone, prop_dictionary_keysym_cstring_nocopy(obj), strlen(thermal_zone)) != 0)) continue; array = prop_dictionary_get_keysym(dict, obj); if (prop_object_type(array) != PROP_TYPE_ARRAY) { err = true; goto error_netbsd3; } iter2 = prop_array_iterator(array); if (!iter2) { err = true; goto error_netbsd3; } /* iterate over array of dicts specific to target sensor */ while ((obj2 = prop_object_iterator_next(iter2)) != NULL) { obj3 = prop_dictionary_get(obj2, "cur-value"); float temp = MUKTOC(prop_number_integer_value(obj3)); if ((int)temp >= max_threshold) { START_COLOR("color_bad"); colorful_output = true; } outwalk += sprintf(outwalk, "%.2f", temp); if (colorful_output) { END_COLOR; colorful_output = false; } break; } prop_object_iterator_release(iter2); } error_netbsd3: prop_object_iterator_release(iter); error_netbsd2: prop_object_release(dict); error_netbsd1: close(fd); if (err) goto error; #endif walk += strlen("degrees"); } } free(thermal_zone); OUTPUT_FULL_TEXT(buffer); return; error: free(thermal_zone); #endif OUTPUT_FULL_TEXT("can't read temp"); (void)fputs("i3status: Cannot read temperature. Verify that you have a thermal zone in /sys/class/thermal or disable the cpu_temperature module in your i3status config.\n", stderr); }
/* * List all available dm devices in system. */ static int dm_list_devices(prop_dictionary_t dm_dict, struct dm_ioctl *dmi) { struct dm_name_list *dml,*odml; prop_array_t targets; prop_dictionary_t target_dict; prop_object_iterator_t iter; uint32_t minor; uint32_t major; char *name; size_t j,slen,rec_size; odml = NULL; name = NULL; minor = 0; j = 0; nbsd_get_dm_major(&major,DM_BLOCK_MAJOR); dml = (struct dm_name_list *)((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_list_devices %s",__func__); while((target_dict = prop_object_iterator_next(iter)) != NULL){ prop_dictionary_get_cstring_nocopy(target_dict, DM_DEV_NAME,(const char **)&name); prop_dictionary_get_uint32(target_dict,DM_DEV_DEV,&minor); dml->dev = MKDEV(major,minor); slen = strlen(name) + 1; rec_size = sizeof(struct dm_name_list) + slen + 1; if (rec_size > dmi->data_size) return -ENOMEM; dml->next = rec_size; strlcpy(dml->name,name,slen); odml = dml; dml =(struct dm_name_list *)((uint8_t *)dml + rec_size); j++; } if (odml != NULL) odml->next = 0; } prop_object_iterator_release(iter); return j; }