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 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);
}
prop_dictionary_t
prop_dictionary_augment(prop_dictionary_t bottom, prop_dictionary_t top)
{
prop_object_iterator_t i;
prop_dictionary_t d;
prop_object_t ko, o;
prop_dictionary_keysym_t k;
const char *key;
d = prop_dictionary_copy_mutable(bottom);
i = prop_dictionary_iterator(top);
while ((ko = prop_object_iterator_next(i)) != NULL) {
k = (prop_dictionary_keysym_t)ko;
key = prop_dictionary_keysym_cstring_nocopy(k);
o = prop_dictionary_get_keysym(top, k);
if (o == NULL || !prop_dictionary_set(d, key, o)) {
prop_object_release((prop_object_t)d);
d = NULL;
break;
}
}
prop_object_iterator_release(i);
prop_dictionary_make_immutable(d);
return d;
}
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_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;
}
/*
* 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 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 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 int
check_binpkgs_hash(struct xbps_handle *xhp, prop_object_iterator_t iter)
{
prop_object_t obj;
const char *pkgver, *repoloc, *filen, *sha256, *trans;
const char *pkgname, *version;
char *binfile;
int rv = 0;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
prop_dictionary_get_cstring_nocopy(obj, "transaction", &trans);
if ((strcmp(trans, "remove") == 0) ||
(strcmp(trans, "configure") == 0))
continue;
prop_dictionary_get_cstring_nocopy(obj, "pkgname", &pkgname);
prop_dictionary_get_cstring_nocopy(obj, "version", &version);
prop_dictionary_get_cstring_nocopy(obj, "repository", &repoloc);
assert(repoloc != NULL);
prop_dictionary_get_cstring_nocopy(obj, "pkgver", &pkgver);
assert(pkgver != NULL);
prop_dictionary_get_cstring_nocopy(obj, "filename", &filen);
assert(filen != NULL);
prop_dictionary_get_cstring_nocopy(obj,
"filename-sha256", &sha256);
assert(sha256 != NULL);
binfile = xbps_path_from_repository_uri(xhp, obj, repoloc);
if (binfile == NULL) {
rv = EINVAL;
break;
}
xbps_set_cb_state(xhp, XBPS_STATE_VERIFY, 0, pkgname, version,
"Verifying `%s' package integrity...", filen, repoloc);
rv = xbps_file_hash_check(binfile, sha256);
if (rv != 0) {
free(binfile);
xbps_set_cb_state(xhp, XBPS_STATE_VERIFY_FAIL,
rv, pkgname, version,
"Failed to verify `%s' package integrity: %s",
filen, strerror(rv));
break;
}
free(binfile);
}
prop_object_iterator_reset(iter);
return rv;
}
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;
}
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;
}
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;
}
/*
* 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;
}
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;
}
static const char *
acpi_debug_getkey(prop_dictionary_t dict, uint32_t arg)
{
prop_object_iterator_t i;
prop_object_t obj, val;
const char *key;
uint32_t num;
i = prop_dictionary_iterator(dict);
while ((obj = prop_object_iterator_next(i)) != NULL) {
key = prop_dictionary_keysym_cstring_nocopy(obj);
val = prop_dictionary_get(dict, key);
num = prop_number_unsigned_integer_value(val);
if (arg == num)
return key;
}
return "UNKNOWN";
}
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;
}
/*
* 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);
}
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
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;
}
static
int
swsensor_init(void *arg)
{
int error, val = 0;
const char *key, *str;
prop_dictionary_t pd = (prop_dictionary_t)arg;
prop_object_t po, obj;
prop_object_iterator_t iter;
prop_type_t type;
const struct sme_descr_entry *descr;
swsensor_sme = sysmon_envsys_create();
if (swsensor_sme == NULL)
return ENOTTY;
swsensor_sme->sme_name = "swsensor";
swsensor_sme->sme_cookie = &swsensor_edata;
swsensor_sme->sme_refresh = swsensor_refresh;
swsensor_sme->sme_set_limits = NULL;
swsensor_sme->sme_get_limits = NULL;
/* Set defaults in case no prop dictionary given */
swsensor_edata.units = ENVSYS_INTEGER;
swsensor_edata.flags = 0;
sw_sensor_mode = 0;
sw_sensor_value = 0;
sw_sensor_limit = 0;
/* Iterate over the provided dictionary, if any */
if (pd != NULL) {
iter = prop_dictionary_iterator(pd);
if (iter == NULL)
return ENOMEM;
while ((obj = prop_object_iterator_next(iter)) != NULL) {
key = prop_dictionary_keysym_cstring_nocopy(obj);
po = prop_dictionary_get_keysym(pd, obj);
type = prop_object_type(po);
if (type == PROP_TYPE_NUMBER)
val = prop_number_integer_value(po);
/* Sensor type/units */
if (strcmp(key, "type") == 0) {
if (type == PROP_TYPE_NUMBER) {
descr = sme_find_table_entry(
SME_DESC_UNITS, val);
if (descr == NULL)
return EINVAL;
swsensor_edata.units = descr->type;
continue;
}
if (type != PROP_TYPE_STRING)
return EINVAL;
str = prop_string_cstring_nocopy(po);
descr = sme_find_table_desc(SME_DESC_UNITS,
str);
if (descr == NULL)
return EINVAL;
swsensor_edata.units = descr->type;
continue;
}
/* Sensor flags */
if (strcmp(key, "flags") == 0) {
if (type != PROP_TYPE_NUMBER)
return EINVAL;
swsensor_edata.flags = val;
continue;
}
/* Sensor limit behavior
* 0 - simple sensor, no hw limits
* 1 - simple sensor, hw provides initial limit
* 2 - complex sensor, hw provides settable
* limits and does its own limit checking
*/
if (strcmp(key, "mode") == 0) {
if (type != PROP_TYPE_NUMBER)
return EINVAL;
sw_sensor_mode = val;
if (sw_sensor_mode > 2)
sw_sensor_mode = 2;
else if (sw_sensor_mode < 0)
sw_sensor_mode = 0;
continue;
}
/* Grab any limit that might be specified */
if (strcmp(key, "limit") == 0) {
if (type != PROP_TYPE_NUMBER)
return EINVAL;
sw_sensor_limit = val;
continue;
}
/* Grab the initial value */
if (strcmp(key, "value") == 0) {
if (type != PROP_TYPE_NUMBER)
return EINVAL;
sw_sensor_value = val;
continue;
}
/* Grab value_min and value_max */
if (strcmp(key, "value_min") == 0) {
if (type != PROP_TYPE_NUMBER)
return EINVAL;
swsensor_edata.value_min = val;
swsensor_edata.flags |= ENVSYS_FVALID_MIN;
continue;
}
if (strcmp(key, "value_max") == 0) {
if (type != PROP_TYPE_NUMBER)
return EINVAL;
swsensor_edata.value_max = val;
swsensor_edata.flags |= ENVSYS_FVALID_MAX;
continue;
}
/* See if sensor reports percentages vs raw values */
if (strcmp(key, "percentage") == 0) {
if (type != PROP_TYPE_BOOL)
return EINVAL;
if (prop_bool_true(po))
swsensor_edata.flags |= ENVSYS_FPERCENT;
continue;
}
/* Unrecognized dicttionary object */
#ifdef DEBUG
printf("%s: unknown attribute %s\n", __func__, key);
#endif
return EINVAL;
} /* while */
prop_object_iterator_release(iter);
}
/* Initialize limit processing */
if (sw_sensor_mode >= 1)
swsensor_sme->sme_get_limits = swsensor_get_limits;
if (sw_sensor_mode == 2)
swsensor_sme->sme_set_limits = swsensor_set_limits;
if (sw_sensor_mode != 0) {
swsensor_edata.flags |= ENVSYS_FMONLIMITS;
swsensor_get_limits(swsensor_sme, &swsensor_edata,
&sw_sensor_deflims, &sw_sensor_defprops);
}
strlcpy(swsensor_edata.desc, "sensor", ENVSYS_DESCLEN);
/* Wait for refresh to validate the sensor value */
swsensor_edata.state = ENVSYS_SINVALID;
sw_sensor_state = ENVSYS_SVALID;
error = sysmon_envsys_sensor_attach(swsensor_sme, &swsensor_edata);
if (error != 0) {
aprint_error("sysmon_envsys_sensor_attach failed: %d\n", error);
return error;
}
error = sysmon_envsys_register(swsensor_sme);
if (error != 0) {
aprint_error("sysmon_envsys_register failed: %d\n", error);
return error;
}
sysctl_swsensor_setup();
aprint_normal("swsensor: initialized\n");
return 0;
}
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 __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;
}