static int ippctl_attach_modname_array( nvlist_t *nvlp, char **modname_array, int nelt) { /* * Add a module name array to an nvlist for passing back to user * space. */ return (nvlist_add_string_array(nvlp, IPPCTL_MODNAME_ARRAY, modname_array, nelt)); }
static int ippctl_attach_aname_array( nvlist_t *nvlp, char **aname_array, int nelt) { /* * Add an action name array to an nvlist for passing back to user * space. */ return (nvlist_add_string_array(nvlp, IPPCTL_ANAME_ARRAY, aname_array, nelt)); }
/* * Set the named string array from the given nvlist_t. * * @param attrs * the nvlist_t to search * * @param which * the string key for this element in the list * * @param val * the value of the requested string array * * @param nelem * the number of elements in the array * * @return 0 * if successful * * @return EINVAL * if there is an invalid argument * * @return ENOMEM * if there is insufficient memory */ int set_string_array( nvlist_t *attrs, char *which, char **val, uint_t nelem) { int error = 0; if ((error = nvlist_add_string_array( attrs, which, val, nelem)) != 0) { volume_set_error( gettext("nvlist_add_string_array(%s) failed: %d.\n"), which, error); } return (error); }
static int ch_add_string(list_wrap_t **lw, boolean_t array, int argc, char **argv) { nvlist_t *nvl = (*lw)->lw_nvl[(*lw)->lw_pos]; if (array) { if (nvlist_add_string_array(nvl, argv[0], &argv[1], argc - 1) != 0) { (void) fprintf(stderr, "fail at " "nvlist_add_string_array\n"); return (-1); } } else { if (nvlist_add_string(nvl, argv[0], argv[1]) != 0) { (void) fprintf(stderr, "fail at nvlist_add_string\n"); return (-1); } } return (0); }
/* * define a string array property */ int devctl_ddef_string_array(devctl_ddef_t ddef_hdl, char *name, int nelements, char **value) { int rv, i; if (ddef_hdl == NULL || name == NULL || *name == '\0') { errno = EINVAL; return (-1); } rv = nvlist_add_string_array((nvlist_t *)ddef_hdl, name, value, nelements); if (_libdevice_debug) { (void) printf("devctl_ddef_string_array: rv %d nvp %p " "name %s:\n", rv, (void *)ddef_hdl, name); for (i = 0; i < nelements; i++) (void) printf("\t%d: \"%s\"\n", i, value[i]); } return (rv); }
static nvlist_t * mem_fmri_create(topo_mod_t *mod, char *serial, char *label) { int err; nvlist_t *fmri; if (topo_mod_nvalloc(mod, &fmri, NV_UNIQUE_NAME) != 0) return (NULL); err = nvlist_add_uint8(fmri, FM_VERSION, FM_MEM_SCHEME_VERSION); err |= nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_MEM); if (serial != NULL) err |= nvlist_add_string_array(fmri, FM_FMRI_MEM_SERIAL_ID, &serial, 1); if (label != NULL) err |= nvlist_add_string(fmri, FM_FMRI_MEM_UNUM, label); if (err != 0) { nvlist_free(fmri); (void) topo_mod_seterrno(mod, EMOD_FMRI_NVL); return (NULL); } return (fmri); }
void fnvlist_add_string_array(nvlist_t *nvl, const char *name, char * const *val, uint_t n) { VERIFY0(nvlist_add_string_array(nvl, name, val, n)); }
/* * Pack internal format cache data to a single nvlist. * Used when writing the nvlist file. * Note this is called indirectly by the nvpflush daemon. */ static int sdev_ncache_pack_list(nvf_handle_t fd, nvlist_t **ret_nvl) { nvlist_t *nvl, *sub_nvl; nvp_devname_t *np; int rval; list_t *listp; ASSERT(fd == sdevfd_handle); ASSERT(RW_WRITE_HELD(nvf_lock(fd))); rval = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP); if (rval != 0) { nvf_error("%s: nvlist alloc error %d\n", nvf_cache_name(fd), rval); return (DDI_FAILURE); } listp = nvf_list(sdevfd_handle); if ((np = list_head(listp)) != NULL) { ASSERT(list_next(listp, np) == NULL); rval = nvlist_alloc(&sub_nvl, NV_UNIQUE_NAME, KM_SLEEP); if (rval != 0) { nvf_error("%s: nvlist alloc error %d\n", nvf_cache_name(fd), rval); sub_nvl = NULL; goto err; } rval = nvlist_add_string_array(sub_nvl, DP_DEVNAME_NCACHE_ID, np->nvp_paths, np->nvp_npaths); if (rval != 0) { nvf_error("%s: nvlist add error %d (sdev)\n", nvf_cache_name(fd), rval); goto err; } rval = nvlist_add_int32_array(sub_nvl, DP_DEVNAME_NC_EXPIRECNT_ID, np->nvp_expirecnts, np->nvp_npaths); if (rval != 0) { nvf_error("%s: nvlist add error %d (sdev)\n", nvf_cache_name(fd), rval); goto err; } rval = nvlist_add_nvlist(nvl, DP_DEVNAME_ID, sub_nvl); if (rval != 0) { nvf_error("%s: nvlist add error %d (sublist)\n", nvf_cache_name(fd), rval); goto err; } nvlist_free(sub_nvl); } *ret_nvl = nvl; return (DDI_SUCCESS); err: nvlist_free(sub_nvl); nvlist_free(nvl); *ret_nvl = NULL; return (DDI_FAILURE); }
/* * Create the storage dirs, and pass the path list to the kernel. * This requires the nfssrv module to be loaded; the _nfssys() syscall * will fail ENOTSUP if it is not. * Use libnvpair(3LIB) to pass the data to the kernel. */ static int dss_init(uint_t npaths, char **pathnames) { int i, j, nskipped, error; char *bufp; uint32_t bufsize; size_t buflen; nvlist_t *nvl; if (npaths > 1) { /* * We need to remove duplicate paths; this might be user error * in the general case, but HA-NFSv4 can also cause this. * Sort the pathnames array, and NULL out duplicates, * then write the non-NULL entries to a new array. * Sorting will also allow the kernel to optimise its searches. */ qsort(pathnames, npaths, sizeof (char *), qstrcmp); /* now NULL out any duplicates */ i = 0; j = 1; nskipped = 0; while (j < npaths) { if (strcmp(pathnames[i], pathnames[j]) == NULL) { pathnames[j] = NULL; j++; nskipped++; continue; } /* skip i over any of its NULLed duplicates */ i = j++; } /* finally, write the non-NULL entries to a new array */ if (nskipped > 0) { int nreal; size_t sz; char **tmp_pathnames; nreal = npaths - nskipped; sz = nreal * sizeof (char *); tmp_pathnames = (char **)malloc(sz); if (tmp_pathnames == NULL) { fprintf(stderr, "tmp_pathnames malloc " "failed\n"); exit(1); } for (i = 0, j = 0; i < npaths; i++) if (pathnames[i] != NULL) tmp_pathnames[j++] = pathnames[i]; free(pathnames); pathnames = tmp_pathnames; npaths = nreal; } } /* Create directories to store the distributed state files */ dss_mkleafdirs(npaths, pathnames); /* Create the name-value pair list */ error = nvlist_alloc(&nvl, NV_UNIQUE_NAME, 0); if (error) { fprintf(stderr, "nvlist_alloc failed: %s\n", strerror(errno)); return (1); } /* Add the pathnames array as a single name-value pair */ error = nvlist_add_string_array(nvl, NFS4_DSS_NVPAIR_NAME, pathnames, npaths); if (error) { fprintf(stderr, "nvlist_add_string_array failed: %s\n", strerror(errno)); nvlist_free(nvl); return (1); } /* * Pack list into contiguous memory, for passing to kernel. * nvlist_pack() will allocate the memory for the buffer, * which we should free() when no longer needed. * NV_ENCODE_XDR for safety across ILP32/LP64 kernel boundary. */ bufp = NULL; error = nvlist_pack(nvl, &bufp, &buflen, NV_ENCODE_XDR, 0); if (error) { fprintf(stderr, "nvlist_pack failed: %s\n", strerror(errno)); nvlist_free(nvl); return (1); } /* Now we have the packed buffer, we no longer need the list */ nvlist_free(nvl); /* * Let the kernel know in advance how big the buffer is. * NOTE: we cannot just pass buflen, since size_t is a long, and * thus a different size between ILP32 userland and LP64 kernel. * Use an int for the transfer, since that should be big enough; * this is a no-op at the moment, here, since nfsd is 32-bit, but * that could change. */ bufsize = (uint32_t)buflen; error = _nfssys(NFS4_DSS_SETPATHS_SIZE, &bufsize); if (error) { fprintf(stderr, "_nfssys(NFS4_DSS_SETPATHS_SIZE) failed: %s\n", strerror(errno)); free(bufp); return (1); } /* Pass the packed buffer to the kernel */ error = _nfssys(NFS4_DSS_SETPATHS, bufp); if (error) { fprintf(stderr, "_nfssys(NFS4_DSS_SETPATHS) failed: %s\n", strerror(errno)); free(bufp); return (1); } /* * The kernel has now unpacked the buffer and extracted the * pathnames array, we no longer need the buffer. */ free(bufp); return (0); }
/* * Convert a list of nvp_list_t's to a single nvlist * Used when writing the nvlist file. */ static int sdev_nvp2nvl(nvfd_t *nvfd, nvlist_t **ret_nvl) { nvlist_t *nvl, *sub_nvl; nvp_devname_t *np; int rval; ASSERT(modrootloaded); rval = nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP); if (rval != 0) { KFIOERR((CE_CONT, "%s: nvlist alloc error %d\n", nvfd->nvf_name, rval)); return (DDI_FAILURE); } if ((np = NVF_DEVNAME_LIST(nvfd)) != NULL) { ASSERT(NVP_DEVNAME_NEXT(np) == NULL); rval = nvlist_alloc(&sub_nvl, NV_UNIQUE_NAME, KM_SLEEP); if (rval != 0) { KFIOERR((CE_CONT, "%s: nvlist alloc error %d\n", nvfd->nvf_name, rval)); sub_nvl = NULL; goto err; } rval = nvlist_add_string_array(sub_nvl, DP_DEVNAME_NCACHE_ID, np->nvp_paths, np->nvp_npaths); if (rval != 0) { KFIOERR((CE_CONT, "%s: nvlist add error %d (sdev)\n", nvfd->nvf_name, rval)); goto err; } rval = nvlist_add_int32_array(sub_nvl, DP_DEVNAME_NC_EXPIRECNT_ID, np->nvp_expirecnts, np->nvp_npaths); if (rval != 0) { KFIOERR((CE_CONT, "%s: nvlist add error %d (sdev)\n", nvfd->nvf_name, rval)); goto err; } rval = nvlist_add_nvlist(nvl, DP_DEVNAME_ID, sub_nvl); if (rval != 0) { KFIOERR((CE_CONT, "%s: nvlist add error %d (sublist)\n", nvfd->nvf_name, rval)); goto err; } nvlist_free(sub_nvl); } *ret_nvl = nvl; return (DDI_SUCCESS); err: if (sub_nvl) nvlist_free(sub_nvl); nvlist_free(nvl); *ret_nvl = NULL; return (DDI_FAILURE); }
/*ARGSUSED*/ static int net_getinfo(rcm_handle_t *hd, char *rsrc, id_t id, uint_t flag, char **info, char **errstr, nvlist_t *proplist, rcm_info_t **depend_info) { int len; dladm_status_t status; char link[MAXLINKNAMELEN]; char errmsg[DLADM_STRSIZE]; char *exported; const char *info_fmt; net_cache_t *node; assert(hd != NULL); assert(rsrc != NULL); assert(id == (id_t)0); assert(info != NULL); assert(depend_info != NULL); rcm_log_message(RCM_TRACE1, _("NET: getinfo(%s)\n"), rsrc); info_fmt = _("Network interface %s"); (void) mutex_lock(&cache_lock); node = cache_lookup(rsrc); if (!node) { rcm_log_message(RCM_WARNING, _("NET: unrecognized resource %s\n"), rsrc); (void) mutex_unlock(&cache_lock); errno = ENOENT; return (RCM_FAILURE); } len = strlen(info_fmt) + MAXLINKNAMELEN + 1; if ((status = dladm_datalink_id2info(dld_handle, node->linkid, NULL, NULL, NULL, link, sizeof (link))) != DLADM_STATUS_OK) { rcm_log_message(RCM_ERROR, _("NET: usage(%s) get link name failure(%s)\n"), node->resource, dladm_status2str(status, errmsg)); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } else if ((*info = (char *)malloc(len)) == NULL) { rcm_log_message(RCM_ERROR, _("NET: malloc failure")); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } /* Fill in the string */ (void) snprintf(*info, len, info_fmt, link); len = strlen("SUNW_datalink/") + LINKID_STR_WIDTH + 1; exported = malloc(len); if (!exported) { rcm_log_message(RCM_ERROR, _("NET: allocation failure")); free(*info); (void) mutex_unlock(&cache_lock); return (RCM_FAILURE); } (void) snprintf(exported, len, "SUNW_datalink/%u", node->linkid); (void) mutex_unlock(&cache_lock); /* Get dependent info if requested */ if ((flag & RCM_INCLUDE_DEPENDENT) || (flag & RCM_INCLUDE_SUBTREE)) { (void) rcm_get_info(hd, exported, flag, depend_info); } (void) nvlist_add_string(proplist, RCM_CLIENT_NAME, "SunOS"); (void) nvlist_add_string_array(proplist, RCM_CLIENT_EXPORTS, &exported, 1); free(exported); return (RCM_SUCCESS); }
static int topo_prop_set(tnode_t *node, const char *pgname, const char *pname, topo_type_t type, int flag, void *val, int nelems, int *err) { int ret; topo_hdl_t *thp = node->tn_hdl; nvlist_t *nvl; if (topo_hdl_nvalloc(thp, &nvl, NV_UNIQUE_NAME) < 0) { *err = ETOPO_PROP_NVL; return (-1); } ret = nvlist_add_string(nvl, TOPO_PROP_VAL_NAME, pname); ret |= nvlist_add_uint32(nvl, TOPO_PROP_VAL_TYPE, type); switch (type) { case TOPO_TYPE_INT32: ret |= nvlist_add_int32(nvl, TOPO_PROP_VAL_VAL, *(int32_t *)val); break; case TOPO_TYPE_UINT32: ret |= nvlist_add_uint32(nvl, TOPO_PROP_VAL_VAL, *(uint32_t *)val); break; case TOPO_TYPE_INT64: ret |= nvlist_add_int64(nvl, TOPO_PROP_VAL_VAL, *(int64_t *)val); break; case TOPO_TYPE_UINT64: ret |= nvlist_add_uint64(nvl, TOPO_PROP_VAL_VAL, *(uint64_t *)val); break; case TOPO_TYPE_DOUBLE: ret |= nvlist_add_double(nvl, TOPO_PROP_VAL_VAL, *(double *)val); break; case TOPO_TYPE_STRING: ret |= nvlist_add_string(nvl, TOPO_PROP_VAL_VAL, (char *)val); break; case TOPO_TYPE_FMRI: ret |= nvlist_add_nvlist(nvl, TOPO_PROP_VAL_VAL, (nvlist_t *)val); break; case TOPO_TYPE_INT32_ARRAY: ret |= nvlist_add_int32_array(nvl, TOPO_PROP_VAL_VAL, (int32_t *)val, nelems); break; case TOPO_TYPE_UINT32_ARRAY: ret |= nvlist_add_uint32_array(nvl, TOPO_PROP_VAL_VAL, (uint32_t *)val, nelems); break; case TOPO_TYPE_INT64_ARRAY: ret |= nvlist_add_int64_array(nvl, TOPO_PROP_VAL_VAL, (int64_t *)val, nelems); break; case TOPO_TYPE_UINT64_ARRAY: ret |= nvlist_add_uint64_array(nvl, TOPO_PROP_VAL_VAL, (uint64_t *)val, nelems); break; case TOPO_TYPE_STRING_ARRAY: ret |= nvlist_add_string_array(nvl, TOPO_PROP_VAL_VAL, (char **)val, nelems); break; case TOPO_TYPE_FMRI_ARRAY: ret |= nvlist_add_nvlist_array(nvl, TOPO_PROP_VAL_VAL, (nvlist_t **)val, nelems); break; default: *err = ETOPO_PROP_TYPE; return (-1); } if (ret != 0) { nvlist_free(nvl); if (ret == ENOMEM) { *err = ETOPO_PROP_NOMEM; return (-1); } else { *err = ETOPO_PROP_NVL; return (-1); } } if (topo_prop_setprop(node, pgname, nvl, flag, nvl, err) != 0) { nvlist_free(nvl); return (-1); /* err set */ } nvlist_free(nvl); return (ret); }
/*ARGSUSED*/ static int sw_fmri_create(topo_mod_t *mod, tnode_t *node, topo_version_t version, nvlist_t *in, nvlist_t **out) { nvlist_t *args, *fmri = NULL, *obj = NULL, *site = NULL, *ctxt = NULL; topo_mod_errno_t moderr; int err = 0; char *obj_path, *obj_root; nvlist_t *obj_pkg; char *site_token, *site_module, *site_file, *site_func; int64_t site_line; char *ctxt_origin, *ctxt_execname, *ctxt_zone; int64_t ctxt_pid, ctxt_ctid; char **ctxt_stack; uint_t ctxt_stackdepth; if (version > TOPO_METH_FMRI_VERSION) return (topo_mod_seterrno(mod, EMOD_VER_NEW)); if (nvlist_lookup_nvlist(in, TOPO_METH_FMRI_ARG_NVL, &args) != 0) return (topo_mod_seterrno(mod, EMOD_METHOD_INVAL)); if (nvlist_lookup_string(args, "obj_path", &obj_path) != 0) return (topo_mod_seterrno(mod, EMOD_NVL_INVAL)); err |= sw_get_optl_string(args, "obj_root", &obj_root); err |= sw_get_optl_nvlist(args, "obj-pkg", &obj_pkg); err |= sw_get_optl_string(args, "site_token", &site_token); err |= sw_get_optl_string(args, "site_module", &site_module); err |= sw_get_optl_string(args, "site_file", &site_file); err |= sw_get_optl_string(args, "site_func", &site_func); err |= sw_get_optl_int64(args, "site_line", &site_line); err |= sw_get_optl_string(args, "ctxt_origin", &ctxt_origin); err |= sw_get_optl_string(args, "ctxt_execname", &ctxt_execname); err |= sw_get_optl_string(args, "ctxt_zone", &ctxt_zone); err |= sw_get_optl_int64(args, "ctxt_pid", &ctxt_pid); err |= sw_get_optl_int64(args, "ctxt_ctid", &ctxt_ctid); if (nvlist_lookup_string_array(args, "stack", &ctxt_stack, &ctxt_stackdepth) != 0) { if (errno == ENOENT) ctxt_stack = NULL; else err++; } if (err) (void) topo_mod_seterrno(mod, EMOD_FMRI_NVL); if (topo_mod_nvalloc(mod, &fmri, NV_UNIQUE_NAME) != 0 || topo_mod_nvalloc(mod, &obj, NV_UNIQUE_NAME) != 0) { moderr = EMOD_NOMEM; goto out; } /* * Add standard FMRI members 'version' and 'scheme'. */ err |= nvlist_add_uint8(fmri, FM_VERSION, FM_SW_SCHEME_VERSION); err |= nvlist_add_string(fmri, FM_FMRI_SCHEME, FM_FMRI_SCHEME_SW); /* * Build up the 'object' nvlist. */ err |= nvlist_add_string(obj, FM_FMRI_SW_OBJ_PATH, obj_path); err |= sw_add_optl_string(obj, FM_FMRI_SW_OBJ_ROOT, obj_root); if (obj_pkg) err |= nvlist_add_nvlist(obj, FM_FMRI_SW_OBJ_PKG, obj_pkg); /* * Add 'object' to the fmri. */ if (err == 0) err |= nvlist_add_nvlist(fmri, FM_FMRI_SW_OBJ, obj); if (err) { moderr = EMOD_NOMEM; goto out; } /* * Do we have anything for a 'site' nvlist? */ if (site_token == NULL && site_module == NULL && site_file == NULL && site_func == NULL && site_line == -1) goto context; /* * Allocate and build 'site' nvlist. */ if (topo_mod_nvalloc(mod, &site, NV_UNIQUE_NAME) != 0) { moderr = EMOD_NOMEM; goto out; } err |= sw_add_optl_string(site, FM_FMRI_SW_SITE_TOKEN, site_token); err |= sw_add_optl_string(site, FM_FMRI_SW_SITE_MODULE, site_module); err |= sw_add_optl_string(site, FM_FMRI_SW_SITE_FILE, site_file); err |= sw_add_optl_string(site, FM_FMRI_SW_SITE_FUNC, site_func); if ((site_token || site_module || site_file || site_func) && site_line != -1) err |= nvlist_add_int64(site, FM_FMRI_SW_SITE_LINE, site_line); /* * Add 'site' to the fmri. */ if (err == 0) err |= nvlist_add_nvlist(fmri, FM_FMRI_SW_SITE, site); if (err) { moderr = EMOD_NOMEM; goto out; } context: /* * Do we have anything for a 'context' nvlist? */ if (ctxt_origin || ctxt_execname || ctxt_zone || ctxt_pid != -1 || ctxt_ctid != -1 || ctxt_stack != NULL) goto out; /* * Allocate and build 'context' nvlist. */ if (topo_mod_nvalloc(mod, &ctxt, NV_UNIQUE_NAME) != 0) { moderr = EMOD_NOMEM; goto out; } err |= sw_add_optl_string(ctxt, FM_FMRI_SW_CTXT_ORIGIN, ctxt_origin); err |= sw_add_optl_string(ctxt, FM_FMRI_SW_CTXT_EXECNAME, ctxt_execname); err |= sw_add_optl_string(ctxt, FM_FMRI_SW_CTXT_ZONE, ctxt_zone); if (ctxt_pid != -1) err |= nvlist_add_int64(ctxt, FM_FMRI_SW_CTXT_PID, ctxt_pid); if (ctxt_ctid != -1) err |= nvlist_add_int64(ctxt, FM_FMRI_SW_CTXT_CTID, ctxt_ctid); if (ctxt_stack != NULL) err |= nvlist_add_string_array(ctxt, FM_FMRI_SW_CTXT_STACK, ctxt_stack, ctxt_stackdepth); /* * Add 'context' to the fmri. */ if (err == 0) err |= nvlist_add_nvlist(fmri, FM_FMRI_SW_CTXT, ctxt); moderr = err ? EMOD_NOMEM : 0; out: if (moderr == 0) *out = fmri; if (moderr != 0 && fmri) nvlist_free(fmri); if (obj) nvlist_free(obj); if (site) nvlist_free(site); if (ctxt) nvlist_free(ctxt); return (moderr == 0 ? 0 : topo_mod_seterrno(mod, moderr)); }
/* * Function: it_config_setprop() * * Validate the provided property list and set the global properties * for iSCSI Target. If errlist is not NULL, returns detailed * errors for each property that failed. The format for errorlist * is key = property, value = error string. * * Parameters: * * cfg The current iSCSI configuration obtained from * it_config_load() * proplist nvlist_t containing properties for this target. * errlist (optional) nvlist_t of errors encountered when * validating the properties. * * Return Values: * 0 Success * EINVAL Invalid property * */ int it_config_setprop(it_config_t *cfg, nvlist_t *proplist, nvlist_t **errlist) { int ret; nvlist_t *errs = NULL; it_portal_t *isns = NULL; it_portal_t *pnext = NULL; it_portal_t *newisnslist = NULL; char **arr; uint32_t count; uint32_t newcount; nvlist_t *cprops = NULL; char *val = NULL; if (!cfg || !proplist) { return (EINVAL); } if (errlist) { (void) nvlist_alloc(&errs, 0, 0); *errlist = errs; } /* * copy the existing properties, merge, then validate * the merged properties before committing them. */ if (cfg->config_global_properties) { ret = nvlist_dup(cfg->config_global_properties, &cprops, 0); } else { ret = nvlist_alloc(&cprops, NV_UNIQUE_NAME, 0); } if (ret != 0) { return (ret); } ret = nvlist_merge(cprops, proplist, 0); if (ret != 0) { nvlist_free(cprops); return (ret); } /* * base64 encode the radius secret, if it's changed. */ val = NULL; (void) nvlist_lookup_string(proplist, PROP_RADIUS_SECRET, &val); if (val) { char bsecret[MAX_BASE64_LEN]; ret = it_val_pass(PROP_RADIUS_SECRET, val, errs); if (ret == 0) { (void) memset(bsecret, 0, MAX_BASE64_LEN); ret = iscsi_binary_to_base64_str((uint8_t *)val, strlen(val), bsecret, MAX_BASE64_LEN); if (ret == 0) { /* replace the value in the nvlist */ ret = nvlist_add_string(cprops, PROP_RADIUS_SECRET, bsecret); } } } if (ret != 0) { nvlist_free(cprops); return (ret); } /* see if we need to remove the radius server setting */ val = NULL; (void) nvlist_lookup_string(cprops, PROP_RADIUS_SERVER, &val); if (val && (strcasecmp(val, "none") == 0)) { (void) nvlist_remove_all(cprops, PROP_RADIUS_SERVER); } /* and/or remove the alias */ val = NULL; (void) nvlist_lookup_string(cprops, PROP_ALIAS, &val); if (val && (strcasecmp(val, "none") == 0)) { (void) nvlist_remove_all(cprops, PROP_ALIAS); } ret = it_validate_configprops(cprops, errs); if (ret != 0) { if (cprops) { nvlist_free(cprops); } return (ret); } /* * Update iSNS server list, if exists in provided property list. */ ret = nvlist_lookup_string_array(proplist, PROP_ISNS_SERVER, &arr, &count); if (ret == 0) { /* special case: if "none", remove all defined */ if (strcasecmp(arr[0], "none") != 0) { ret = it_array_to_portallist(arr, count, ISNS_DEFAULT_SERVER_PORT, &newisnslist, &newcount); } else { newisnslist = NULL; newcount = 0; (void) nvlist_remove_all(cprops, PROP_ISNS_SERVER); } if (ret == 0) { isns = cfg->config_isns_svr_list; while (isns) { pnext = isns->portal_next; free(isns); isns = pnext; } cfg->config_isns_svr_list = newisnslist; cfg->config_isns_svr_count = newcount; /* * Replace the array in the nvlist to ensure * duplicates are properly removed & port numbers * are added. */ if (newcount > 0) { int i = 0; char **newarray; newarray = malloc(sizeof (char *) * newcount); if (newarray == NULL) { ret = ENOMEM; } else { for (isns = newisnslist; isns != NULL; isns = isns->portal_next) { (void) sockaddr_to_str( &(isns->portal_addr), &(newarray[i++])); } (void) nvlist_add_string_array(cprops, PROP_ISNS_SERVER, newarray, newcount); for (i = 0; i < newcount; i++) { if (newarray[i]) { free(newarray[i]); } } free(newarray); } } } } else if (ret == ENOENT) { /* not an error */ ret = 0; } if (ret == 0) { /* replace the global properties list */ nvlist_free(cfg->config_global_properties); cfg->config_global_properties = cprops; } else { if (cprops) { nvlist_free(cprops); } } if (ret == 0) free_empty_errlist(errlist); return (ret); }