static scf_propertygroup_t *
add_property_group_to_instance(scf_handle_t *handle, scf_instance_t *instance,
const char *pg_name, const char *pg_type)
{
scf_propertygroup_t *pg;
pg = scf_pg_create(handle);
if (pg == NULL) {
KSSL_DEBUG("scf_pg_create failed: %s\n",
scf_strerror(scf_error()));
(void) fprintf(stderr, gettext(
"Unexpected fatal libscf error: %s. Exiting.\n"),
scf_strerror(scf_error()));
return (NULL);
}
if (scf_instance_add_pg(instance, pg_name, pg_type, 0, pg) != 0) {
KSSL_DEBUG("ERROR: scf_instance_add_pg failed: %s\n",
scf_strerror(scf_error()));
if (scf_error() == SCF_ERROR_EXISTS)
(void) fprintf(stderr, gettext(
"Error: another process is modifying this instance."
" Exiting.\n"));
else
(void) fprintf(stderr, gettext(
"Unexpected fatal libscf error: %s. Exiting.\n"),
scf_strerror(scf_error()));
scf_pg_destroy(pg);
return (NULL);
} else {
KSSL_DEBUG("property group created\n");
}
return (pg);
}
static void
delete_prop(const scf_instance_t *inst, const char *pg, const char *prop)
{
scf_transaction_t *tx;
scf_transaction_entry_t *ent;
scf_propertygroup_t *gpg;
scf_property_t *eprop;
int ret;
if ((gpg = scf_pg_create(h)) == NULL ||
(eprop = scf_property_create(h)) == NULL ||
(tx = scf_transaction_create(h)) == NULL ||
(ent = scf_entry_create(h)) == NULL)
scfdie();
if (scf_instance_get_pg(inst, pg, gpg) != SCF_SUCCESS) {
if (scf_error() != SCF_ERROR_NOT_FOUND)
scfdie();
uu_die(gettext("Error: \"%s\" property group missing.\n"), pg);
}
do {
if (scf_transaction_start(tx, gpg) != SCF_SUCCESS) {
if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
scfdie();
uu_die(gettext("Error: Permission denied.\n"));
}
if (scf_transaction_property_delete(tx, ent,
prop) != SCF_SUCCESS) {
if (scf_error() != SCF_ERROR_NOT_FOUND)
scfdie();
uu_die(
gettext("Error: \"%s\" property does not exist.\n"),
prop);
}
ret = scf_transaction_commit(tx);
if (ret < 0) {
if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
scfdie();
uu_die(gettext("Error: Permission denied.\n"));
}
if (ret == 0) {
scf_transaction_reset(tx);
if (scf_pg_update(gpg) == -1)
scfdie();
}
} while (ret == 0);
(void) scf_entry_destroy(ent);
scf_transaction_destroy(tx);
scf_property_destroy(eprop);
scf_pg_destroy(gpg);
}
/*
* smb_smf_scf_init()
*
* must be called before using any of the SCF functions.
* Returns smb_scfhandle_t pointer if success.
*/
smb_scfhandle_t *
smb_smf_scf_init(char *svc_name)
{
smb_scfhandle_t *handle;
handle = malloc(sizeof (smb_scfhandle_t));
if (handle != NULL) {
bzero((char *)handle, sizeof (smb_scfhandle_t));
handle->scf_state = SCH_STATE_INITIALIZING;
handle->scf_handle = scf_handle_create(SCF_VERSION);
if (handle->scf_handle != NULL) {
if (scf_handle_bind(handle->scf_handle) == 0) {
handle->scf_scope =
scf_scope_create(handle->scf_handle);
if (handle->scf_scope == NULL)
goto err;
if (scf_handle_get_local_scope(
handle->scf_handle, handle->scf_scope) != 0)
goto err;
handle->scf_service =
scf_service_create(handle->scf_handle);
if (handle->scf_service == NULL)
goto err;
if (scf_scope_get_service(handle->scf_scope,
svc_name, handle->scf_service)
!= SCF_SUCCESS) {
goto err;
}
handle->scf_pg =
scf_pg_create(handle->scf_handle);
if (handle->scf_pg == NULL)
goto err;
handle->scf_state = SCH_STATE_INIT;
} else {
goto err;
}
} else {
free(handle);
handle = NULL;
smb_smf_scf_log_error("Could not access SMF "
"repository: %s\n");
}
}
return (handle);
/* error handling/unwinding */
err:
(void) smb_smf_scf_fini(handle);
(void) smb_smf_scf_log_error("SMF initialization problem: %s\n");
return (NULL);
}
conerr_t
smfu_get_property(char *fmri, char *pgname, char *propname, char *value,
size_t n)
{
conerr_t err = ce_ok;
scf_handle_t *scfhandle = handle_create();
scf_service_t *service = scf_service_create(scfhandle);
scf_instance_t *instance = scf_instance_create(scfhandle);
scf_propertygroup_t *pg = scf_pg_create(scfhandle);
scf_property_t *prop = scf_property_create(scfhandle);
scf_iter_t *iter = scf_iter_create(scfhandle);
scf_value_t *val = scf_value_create(scfhandle);
if (scfhandle == NULL || service == NULL || instance == NULL ||
pg == NULL || prop == NULL || iter == NULL || val == NULL) {
err = ce_nomem;
goto out;
}
if (scf_handle_decode_fmri(scfhandle, fmri, NULL, service, instance,
NULL, NULL, 0) != SCF_SUCCESS) {
rad_log(RL_ERROR, "couldn't decode '%s': %s\n", fmri,
scf_strerror(scf_error()));
err = maperr(scf_error());
goto out;
}
if (scf_instance_get_pg(instance, pgname, pg) != 0 ||
scf_pg_get_property(pg, propname, prop) != 0 ||
scf_iter_property_values(iter, prop) != 0) {
rad_log(RL_ERROR, "couldn't get property: '%s/%s/%s': %s\n",
fmri, pgname, propname, scf_strerror(scf_error()));
err = maperr(scf_error());
goto out;
}
if (scf_iter_next_value(iter, val) > 0 &&
scf_value_get_as_string(val, value, n) == -1) {
rad_log(RL_ERROR,
"couldn't get property value: '%s/%s/%s': %s\n", fmri,
pgname, propname, scf_strerror(scf_error()));
err = maperr(scf_error());
goto out;
}
out:
scf_value_destroy(val);
scf_property_destroy(prop);
scf_pg_destroy(pg);
scf_iter_destroy(iter);
scf_instance_destroy(instance);
scf_service_destroy(service);
scf_handle_destroy(scfhandle);
return (err);
}
fs_smfhandle_t *
fs_smf_init(char *fmri, char *instance)
{
fs_smfhandle_t *handle = NULL;
char *svcname, srv[MAXPATHLEN];
/*
* svc name is of the form svc://network/fs/server:instance1
* FMRI portion is /network/fs/server
*/
snprintf(srv, MAXPATHLEN, "%s", fmri + strlen("svc:/"));
svcname = strrchr(srv, ':');
if (svcname != NULL)
*svcname = '\0';
svcname = srv;
handle = calloc(1, sizeof (fs_smfhandle_t));
if (handle != NULL) {
handle->fs_handle = scf_handle_create(SCF_VERSION);
if (handle->fs_handle == NULL)
goto out;
if (scf_handle_bind(handle->fs_handle) != 0)
goto out;
handle->fs_service =
scf_service_create(handle->fs_handle);
handle->fs_scope =
scf_scope_create(handle->fs_handle);
if (scf_handle_get_local_scope(handle->fs_handle,
handle->fs_scope) != 0)
goto out;
if (scf_scope_get_service(handle->fs_scope,
svcname, handle->fs_service) != SCF_SUCCESS) {
goto out;
}
handle->fs_pg =
scf_pg_create(handle->fs_handle);
handle->fs_instance =
scf_instance_create(handle->fs_handle);
handle->fs_property =
scf_property_create(handle->fs_handle);
handle->fs_value =
scf_value_create(handle->fs_handle);
} else {
fprintf(stderr,
gettext("Cannot access SMF repository: %s\n"), fmri);
}
return (handle);
out:
fs_smf_fini(handle);
fprintf(stderr, gettext("SMF Initialization problems..%s\n"), fmri);
return (NULL);
}
targ_scf_t *
mgmt_handle_init(void)
{
targ_scf_t *h;
h = calloc(1, sizeof (targ_scf_t));
if (h == NULL)
return (NULL);
h->t_handle = scf_handle_create(SCF_VERSION);
if (h->t_handle != NULL) {
if (scf_handle_bind(h->t_handle) == 0) {
h->t_scope = scf_scope_create(h->t_handle);
h->t_service = scf_service_create(h->t_handle);
h->t_pg = scf_pg_create(h->t_handle);
h->t_instance = scf_instance_create(h->t_handle);
if (scf_handle_get_scope(h->t_handle, SCF_SCOPE_LOCAL,
h->t_scope) == 0) {
if (scf_scope_get_service(h->t_scope,
SA_TARGET_SVC_NAME, h->t_service) != 0)
goto error;
} else {
syslog(LOG_ERR,
"Got local scope which is wrong\n");
goto error;
}
} else
goto error;
} else {
free(h);
h = NULL;
syslog(LOG_ERR,
"iscsitgt could not access SMF repository: %s\n",
scf_strerror(scf_error()));
}
return (h);
error:
mgmt_handle_fini(h);
free(h);
syslog(LOG_ERR, "iscsitgt SMF initialization problem: %s\n",
scf_strerror(scf_error()));
return (NULL);
}
/*
* smb_smf_delete_instance_pgroup(handle, pgroup)
*
* remove the property group from the current instance.
* but only if it actually exists.
*/
int
smb_smf_delete_instance_pgroup(smb_scfhandle_t *handle, char *pgroup)
{
int ret = SMBC_SMF_OK;
int err;
if (handle == NULL) {
return (SMBC_SMF_SYSTEM_ERR);
}
/*
* only create a handle if it doesn't exist. It is ok to exist
* since the pg handle will be set as a side effect.
*/
if (handle->scf_pg == NULL) {
handle->scf_pg = scf_pg_create(handle->scf_handle);
}
/*
* only delete if it does exist.
*/
if (scf_instance_get_pg(handle->scf_instance,
pgroup, handle->scf_pg) == 0) {
/* does exist so delete it */
if (scf_pg_delete(handle->scf_pg) != 0) {
ret = SMBC_SMF_SYSTEM_ERR;
err = scf_error();
if (err != SCF_ERROR_NONE) {
smb_smf_scf_log_error("SMF delpg "
"problem: %s\n");
}
}
} else {
err = scf_error();
if (err != SCF_ERROR_NONE)
smb_smf_scf_log_error("SMF getpg problem: %s\n");
ret = SMBC_SMF_SYSTEM_ERR;
}
if (ret == SMBC_SMF_SYSTEM_ERR &&
scf_error() == SCF_ERROR_PERMISSION_DENIED) {
ret = SMBC_SMF_NO_PERMISSION;
}
return (ret);
}
int
main()
{
if (daemonize_self() == 1)
return (1);
max_scf_fmri_size = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH) + 1;
max_scf_name_size = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
assert(max_scf_fmri_size > 0);
assert(max_scf_name_size > 0);
if ((h = scf_handle_create(SCF_VERSION)) == NULL) {
syslog(LOG_ERR | LOG_DAEMON, "scf_handle_create failed: %s\n",
scf_strerror(scf_error()));
return (1);
}
repository_rebind(h);
scratch_fmri = umem_alloc(max_scf_fmri_size, UMEM_DEFAULT);
scratch_name = umem_alloc(max_scf_name_size, UMEM_DEFAULT);
if (scratch_fmri == NULL || scratch_name == NULL) {
syslog(LOG_ERR | LOG_DAEMON, "Out of memory");
return (1);
}
inst = scf_instance_create(h);
snap = scf_snapshot_create(h);
scratch_pg = scf_pg_create(h);
scratch_prop = scf_property_create(h);
scratch_v = scf_value_create(h);
if (inst == NULL || snap == NULL || scratch_pg == NULL ||
scratch_prop == NULL || scratch_v == NULL) {
syslog(LOG_ERR | LOG_DAEMON, "Initialization failed: %s\n",
scf_strerror(scf_error()));
return (1);
}
return (repository_event_wait());
}
/*
* smb_smf_create_service_pgroup(handle, pgroup)
*
* create a new property group at service level.
*/
int
smb_smf_create_service_pgroup(smb_scfhandle_t *handle, char *pgroup)
{
int ret = SMBD_SMF_OK;
int err;
if (handle == NULL)
return (SMBD_SMF_SYSTEM_ERR);
/*
* only create a handle if it doesn't exist. It is ok to exist
* since the pg handle will be set as a side effect.
*/
if (handle->scf_pg == NULL)
if ((handle->scf_pg =
scf_pg_create(handle->scf_handle)) == NULL)
return (SMBD_SMF_SYSTEM_ERR);
/*
* if the pgroup exists, we are done. If it doesn't, then we
* need to actually add one to the service instance.
*/
if (scf_service_get_pg(handle->scf_service,
pgroup, handle->scf_pg) != 0) {
/* doesn't exist so create one */
if (scf_service_add_pg(handle->scf_service, pgroup,
SCF_GROUP_APPLICATION, 0, handle->scf_pg) != 0) {
err = scf_error();
if (err != SCF_ERROR_NONE)
smb_smf_scf_log_error(NULL);
switch (err) {
case SCF_ERROR_PERMISSION_DENIED:
ret = SMBD_SMF_NO_PERMISSION;
break;
default:
ret = SMBD_SMF_SYSTEM_ERR;
break;
}
}
}
return (ret);
}
/*
* Initialize the global state for the load_*() routines.
* Returns
* 0 - success
* ENOMEM - out of memory
*/
int
load_init(void)
{
loadbuf_sz = ((max_scf_value_len > max_scf_pg_type_len) ?
max_scf_value_len : max_scf_pg_type_len) + 1;
loadbuf = malloc(loadbuf_sz);
if (loadbuf == NULL)
return (ENOMEM);
if ((load_prop = scf_property_create(g_hndl)) == NULL ||
(load_val = scf_value_create(g_hndl)) == NULL ||
(load_pgroup = scf_pg_create(g_hndl)) == NULL ||
(load_pgiter = scf_iter_create(g_hndl)) == NULL ||
(load_propiter = scf_iter_create(g_hndl)) == NULL ||
(load_valiter = scf_iter_create(g_hndl)) == NULL) {
load_fini();
return (ENOMEM);
}
return (0);
}
/*
* Inputs:
* lpg is the property group to look up
* lprop is the property within that group to look up
* Outputs:
* res is a pointer to an scf_resources_t. This is an internal
* structure that holds all the handles needed to get a specific
* property from the running snapshot; on a successful return it
* contains the scf_value_t that should be passed to the desired
* scf_value_get_foo() function, and must be freed after use by
* calling release_scf_resources(). On a failure return, any
* resources that may have been assigned to res are released, so
* the caller does not need to do any cleanup in the failure case.
* Returns:
* 0 on success
* -1 on failure
*/
static int
get_property_value(const char *lpg, const char *lprop, scf_resources_t *res)
{
res->sr_inst = NULL;
res->sr_snap = NULL;
res->sr_pg = NULL;
res->sr_prop = NULL;
res->sr_val = NULL;
if ((res->sr_handle = scf_handle_create(SCF_VERSION)) == NULL) {
syslog(LOG_ERR, "scf_handle_create() failed: %s",
scf_strerror(scf_error()));
return (-1);
}
if (scf_handle_bind(res->sr_handle) != 0) {
scf_handle_destroy(res->sr_handle);
syslog(LOG_ERR, "scf_handle_destroy() failed: %s",
scf_strerror(scf_error()));
return (-1);
}
if ((res->sr_inst = scf_instance_create(res->sr_handle)) == NULL) {
syslog(LOG_ERR, "scf_instance_create() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if (scf_handle_decode_fmri(res->sr_handle, OUR_FMRI, NULL, NULL,
res->sr_inst, NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0) {
syslog(LOG_ERR, "scf_handle_decode_fmri() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if ((res->sr_snap = scf_snapshot_create(res->sr_handle)) == NULL) {
syslog(LOG_ERR, "scf_snapshot_create() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if (scf_instance_get_snapshot(res->sr_inst, "running",
res->sr_snap) != 0) {
syslog(LOG_ERR, "scf_instance_get_snapshot() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if ((res->sr_pg = scf_pg_create(res->sr_handle)) == NULL) {
syslog(LOG_ERR, "scf_pg_create() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if (scf_instance_get_pg_composed(res->sr_inst, res->sr_snap, lpg,
res->sr_pg) != 0) {
syslog(LOG_ERR, "scf_instance_get_pg_composed(%s) failed: %s",
lpg, scf_strerror(scf_error()));
goto failure;
}
if ((res->sr_prop = scf_property_create(res->sr_handle)) == NULL) {
syslog(LOG_ERR, "scf_property_create() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if (scf_pg_get_property(res->sr_pg, lprop, res->sr_prop) != 0) {
syslog(LOG_ERR, "scf_pg_get_property(%s) failed: %s",
lprop, scf_strerror(scf_error()));
goto failure;
}
if ((res->sr_val = scf_value_create(res->sr_handle)) == NULL) {
syslog(LOG_ERR, "scf_value_create() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
if (scf_property_get_value(res->sr_prop, res->sr_val) != 0) {
syslog(LOG_ERR, "scf_property_get_value() failed: %s",
scf_strerror(scf_error()));
goto failure;
}
return (0);
failure:
release_scf_resources(res);
return (-1);
}
static int
repository_event_wait()
{
scf_propertygroup_t *pg;
char *fmri, *scratch;
const char *inst_name, *pg_name;
ssize_t res;
if ((fmri = umem_alloc(max_scf_fmri_size, UMEM_DEFAULT)) == NULL) {
syslog(LOG_ERR | LOG_DAEMON, "Out of memory");
return (1);
}
if ((scratch = umem_alloc(max_scf_fmri_size, UMEM_DEFAULT)) == NULL) {
syslog(LOG_ERR | LOG_DAEMON, "Out of memory");
return (1);
}
if ((pg = scf_pg_create(h)) == NULL) {
syslog(LOG_ERR | LOG_DAEMON, "scf_pg_create failed: %s\n",
scf_strerror(scf_error()));
return (1);
}
repository_notify_setup(h);
for (;;) {
/*
* Calling _scf_notify_wait which will block this thread
* until it's notified of a framework event.
*
* Note: fmri is only set on delete events.
*/
res = _scf_notify_wait(pg, fmri, max_scf_fmri_size);
if (res < 0) {
syslog(LOG_ERR | LOG_DAEMON, "_scf_notify_wait "
"failed: %s\n", scf_strerror(scf_error()));
repository_setup();
} else if (res == 0) {
if (repository_event_process(pg))
syslog(LOG_ERR | LOG_DAEMON, "Service may have "
"incorrect IPfilter configuration\n");
} else {
/*
* The received event is a deletion of a service,
* instance or pg. If it's a deletion of an instance,
* update the instance's IPfilter configuration.
*/
syslog(LOG_DEBUG | LOG_DAEMON, "Deleted: %s", fmri);
(void) strlcpy(scratch, fmri, max_scf_fmri_size);
if (scf_parse_svc_fmri(scratch, NULL, NULL, &inst_name,
&pg_name, NULL) != SCF_SUCCESS)
continue;
if (inst_name != NULL && pg_name == NULL) {
(void) ipfilter_update(fmri);
}
}
}
/*NOTREACHED*/
}
Status osDaemonIsEnabled( int inQuiet )
{
Status isEnabled = sStatusNotEnabled;
scf_handle_t * theHandle = scf_handle_create( SCF_VERSION );
if (inQuiet == 0) { writeInitialMessage( sOpIsEnabled ); }
if ( theHandle != 0 )
{
if ( scf_handle_bind( theHandle ) == 0 )
{
scf_instance_t * theInstance = scf_instance_create( theHandle );
if ( theInstance != 0 )
{
if ( scf_handle_decode_fmri(
theHandle,
sInstanceName,
0,
0,
theInstance,
0,
0,
SCF_DECODE_FMRI_EXACT ) != -1 )
{
scf_handle_t * theInstanceHandle =
scf_instance_handle( theInstance );
if ( theInstanceHandle != 0 )
{
uint8_t theEnabled;
scf_propertygroup_t * theGroup =
scf_pg_create( theInstanceHandle );
scf_property_t * theProp =
scf_property_create( theInstanceHandle );
scf_value_t * theValue =
scf_value_create( theInstanceHandle );
if ( theGroup != 0 && theProp != 0 && theValue != 0 )
{
if ( scf_instance_get_pg( theInstance,
SCF_PG_GENERAL,
theGroup ) == 0 &&
scf_pg_get_property( theGroup,
SCF_PROPERTY_ENABLED,
theProp ) == 0 &&
scf_property_get_value( theProp,
theValue ) == 0 &&
scf_value_get_boolean( theValue,
&theEnabled ) == 0 )
{
isEnabled = theEnabled == 1 ?
sStatusEnabled : sStatusNotEnabled;
}
}
scf_pg_destroy( theGroup );
scf_property_destroy( theProp );
scf_value_destroy( theValue );
}
}
scf_instance_destroy( theInstance );
}
}
scf_handle_destroy( theHandle );
}
if (inQuiet == 0) { writeFinalMessage( sOpIsEnabled, isEnabled ); }
return isEnabled;
}
static void
modify_prop(const scf_instance_t *inst, const char *pg, const char *prop,
scf_type_t type, void *value)
{
scf_transaction_t *tx;
scf_transaction_entry_t *ent;
scf_propertygroup_t *gpg;
scf_property_t *eprop;
scf_value_t *v;
int ret, create = 0;
char *fmri;
ssize_t max_fmri_len;
if ((gpg = scf_pg_create(h)) == NULL ||
(eprop = scf_property_create(h)) == NULL ||
(v = scf_value_create(h)) == NULL)
scfdie();
/* Get the property group or create it if it is missing. */
if (scf_instance_get_pg(inst, pg, gpg) == -1) {
if (scf_error() != SCF_ERROR_NOT_FOUND)
scfdie();
max_fmri_len = scf_limit(SCF_LIMIT_MAX_FMRI_LENGTH);
if ((fmri = malloc(max_fmri_len + 1)) == NULL)
uu_die(gettext("Error: Out of memory.\n"));
if (scf_instance_to_fmri(inst, fmri, max_fmri_len + 1) < 0)
scfdie();
syslog(LOG_NOTICE, "inetadm: Property group \"%s\" missing "
"from \"%s\", attempting to add it.\n", pg, fmri);
free(fmri);
if (scf_instance_add_pg(inst, pg, SCF_GROUP_FRAMEWORK, 0,
gpg) == -1) {
switch (scf_error()) {
case SCF_ERROR_EXISTS:
break;
case SCF_ERROR_PERMISSION_DENIED:
uu_die(gettext("Error: Permission denied.\n"));
default:
scfdie();
}
}
}
if (scf_pg_get_property(gpg, prop, eprop) == -1) {
if (scf_error() != SCF_ERROR_NOT_FOUND)
scfdie();
create = 1;
}
if ((tx = scf_transaction_create(h)) == NULL ||
(ent = scf_entry_create(h)) == NULL)
scfdie();
do {
uu_list_t *sv_list;
if (scf_transaction_start(tx, gpg) == -1) {
if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
scfdie();
uu_die(gettext("Error: Permission denied.\n"));
}
/* Modify the property or create it if it is missing */
if (create)
ret = scf_transaction_property_new(tx, ent, prop, type);
else
ret = scf_transaction_property_change_type(tx, ent,
prop, type);
if (ret == -1)
scfdie();
switch (type) {
case SCF_TYPE_BOOLEAN:
scf_value_set_boolean(v, *(uint8_t *)value);
break;
case SCF_TYPE_INTEGER:
scf_value_set_integer(v, *(int64_t *)value);
break;
case SCF_TYPE_ASTRING:
if (strcmp(prop, PR_PROTO_NAME) == 0) {
add_proto_list(ent, h, (char **)value,
&sv_list);
} else if (scf_value_set_astring(v, value) == -1) {
scfdie();
}
break;
default:
uu_die(gettext("Error: Internal inetadm error"));
}
if ((strcmp(prop, PR_PROTO_NAME) != 0) &&
(scf_entry_add_value(ent, v) == -1))
scfdie();
ret = scf_transaction_commit(tx);
if (ret == -1) {
if (scf_error() != SCF_ERROR_PERMISSION_DENIED)
scfdie();
uu_die(gettext("Error: Permission denied.\n"));
}
scf_transaction_reset(tx);
if (ret == 0) {
if (scf_pg_update(gpg) == -1)
scfdie();
}
if (strcmp(prop, PR_PROTO_NAME) == 0)
remove_proto_list(ent, sv_list);
} while (ret == 0);
scf_value_destroy(v);
scf_entry_destroy(ent);
scf_transaction_destroy(tx);
scf_property_destroy(eprop);
scf_pg_destroy(gpg);
}
void
read_scf_proto_cfg(const char *proto, scf_cfg_t *cfg)
{
scf_handle_t *handle = NULL;
scf_scope_t *sc = NULL;
scf_service_t *svc = NULL;
scf_propertygroup_t *pg = NULL;
scf_property_t *prop = NULL;
scf_value_t *value = NULL;
scf_iter_t *value_iter = NULL;
uint64_t val;
char *str;
size_t slen;
int i;
handle = scf_handle_create(SCF_VERSION);
sc = scf_scope_create(handle);
svc = scf_service_create(handle);
pg = scf_pg_create(handle);
prop = scf_property_create(handle);
value = scf_value_create(handle);
value_iter = scf_iter_create(handle);
if (handle == NULL || sc == NULL || svc == NULL || pg == NULL ||
prop == NULL || value == NULL || value_iter == NULL) {
DMSG(D_OP, "%s: unable to create smf(5) handles.", proto);
goto done;
}
if (scf_handle_bind(handle) != 0) {
DMSG(D_OP, "%s: unable to bind smf(5) handle: %s", proto,
scf_strerror(scf_error()));
goto done;
}
if (scf_handle_decode_fmri(handle, fmri, sc, svc, NULL, NULL, NULL,
0) != 0) {
DMSG(D_OP, "%s: unable to decode fmri '%s': %s", fmri,
scf_strerror(scf_error()));
goto done;
}
if (scf_service_get_pg(svc, proto, pg) != 0 &&
scf_error() != SCF_ERROR_NOT_FOUND) {
DMSG(D_OP, "%s: unable to read '%s' property group: %s",
proto, proto, scf_strerror(scf_error()));
goto done;
}
for (i = 0; cfg[i].name != NULL; i++) {
scf_cfg_t *c = &cfg[i];
if (scf_pg_get_property(pg, c->name, prop) != 0) {
if (scf_error() != SCF_ERROR_NOT_FOUND)
DMSG(D_OP, "%s: unable to read %s/%s from "
"smf: %s", proto, proto, c->name,
scf_strerror(scf_error()));
continue;
}
if (scf_property_is_type(prop, c->type) != 0) {
scf_type_t type;
if (scf_error() != SCF_ERROR_TYPE_MISMATCH) {
DMSG(D_OP, "%s: unable to validate "
"type of '%s/%s' smf property: %s",
proto, proto, c->name,
scf_strerror(scf_error()));
continue;
}
if (scf_property_type(prop, &type) != 0) {
DMSG(D_OP, "%s: unable to obtain "
"type of '%s/%s' smf property: %s",
proto, proto, c->name,
scf_strerror(scf_error()));
continue;
}
DMSG(D_OP, "%s: property '%s/%s' has an unexpected "
"type:\n"
" expected type: %s\n"
" actual type: %s\n",
proto, proto, c->name,
scf_type_to_string(c->type),
scf_type_to_string(type));
continue;
}
if (scf_property_get_value(prop, value) != 0) {
if (scf_error() != SCF_ERROR_NOT_SET)
DMSG(D_OP, "%s: unable to get value of "
"'%s/%s' smf property: %s", proto,
proto, c->name, scf_strerror(scf_error()));
continue;
}
switch (c->type) {
case SCF_TYPE_COUNT:
if (scf_value_get_count(value, &val) != 0) {
DMSG(D_OP, "%s: unable to read value of "
"'%s/%s' smf property: %s", proto, proto,
c->name, scf_strerror(scf_error()));
continue;
}
if (val > c->max) {
DMSG(D_OP, "%s: value of '%s/%s' smf property "
"(%'llu) is out of range (0 - %'zu).",
proto, proto, c->name, val, c->max);
continue;
}
*((uint32_t *)c->val) = (uint32_t)val;
break;
case SCF_TYPE_ASTRING:
{
char **valp = (char **)c->val;
ssize_t len;
slen = c->max + 1;
if ((str = malloc(slen)) == NULL) {
/* XXX message */
continue;
}
if ((len = scf_value_get_astring(value, str,
slen)) >= slen)
DMSG(D_OP, "%s: length of '%s/%s' "
"(%'zd bytes) exceeds maximum "
"allowable length (%zu bytes). The string"
" will be truncated.", proto, proto,
c->name, len, c->max);
free(*valp);
*valp = str;
break;
}
default:
VERIFY(0);
}
}
done:
scf_iter_destroy(value_iter);
scf_value_destroy(value);
scf_property_destroy(prop);
scf_pg_destroy(pg);
scf_service_destroy(svc);
scf_scope_destroy(sc);
scf_handle_destroy(handle);
}
static void
kbd_defaults(int kbd)
{
scf_handle_t *h = NULL;
scf_snapshot_t *snap = NULL;
scf_instance_t *inst = NULL;
scf_propertygroup_t *pg = NULL;
scf_property_t *prop = NULL;
scf_value_t *val = NULL;
int layout_num;
char *val_layout = NULL, *val_abort = NULL;
uint8_t val_click;
int64_t val_delay, val_rate;
int64_t val_kbd_beeper, val_console_beeper;
if ((h = scf_handle_create(SCF_VERSION)) == NULL ||
scf_handle_bind(h) != 0 ||
(inst = scf_instance_create(h)) == NULL ||
(snap = scf_snapshot_create(h)) == NULL ||
(pg = scf_pg_create(h)) == NULL ||
(prop = scf_property_create(h)) == NULL ||
(val = scf_value_create(h)) == NULL) {
goto out;
}
if (scf_handle_decode_fmri(h, KBD_FMRI, NULL, NULL, inst,
NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) != 0) {
goto out;
}
if (scf_instance_get_snapshot(inst, "running", snap) != 0) {
scf_snapshot_destroy(snap);
snap = NULL;
}
if (scf_instance_get_pg_composed(inst, snap, KBD_PG, pg) != 0) {
goto out;
}
if ((val_abort = malloc(KBD_MAX_NAME_LEN)) == NULL) {
(void) fprintf(stderr,
"Can not alloc memory for keyboard properties\n");
goto out;
}
if ((val_layout = malloc(KBD_MAX_NAME_LEN)) == NULL) {
(void) fprintf(stderr,
"Can not alloc memory for keyboard properties\n");
goto out;
}
if (scf_pg_get_property(pg, KBD_PROP_KEYCLICK, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_boolean(val, &val_click) == -1) {
(void) fprintf(stderr, "Can not get KEYCLICK\n");
}
if (val_click == 1)
(void) click("on", kbd);
else if (val_click == 0)
(void) click("off", kbd);
else
(void) fprintf(stderr,
BAD_DEFAULT_INT, KBD_PROP_KEYCLICK, val_click);
if (scf_pg_get_property(pg, KBD_PROP_KEYBOARD_ABORT, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_astring(val, val_abort, KBD_MAX_NAME_LEN) == -1) {
(void) fprintf(stderr, "Can not get KEYBOARD_ABORT\n");
}
if (*val_abort != '\0') {
/*
* ABORT must equal "enable", "disable" or "alternate"
*/
if ((strcmp(val_abort, "enable") == 0) ||
(strcmp(val_abort, "alternate") == 0) ||
(strcmp(val_abort, "disable") == 0))
(void) abort_enable(val_abort, kbd);
else
(void) fprintf(stderr, BAD_DEFAULT_STR,
KBD_PROP_KEYBOARD_ABORT, val_abort);
}
if (scf_pg_get_property(pg, KBD_PROP_RPTDELAY, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_integer(val, &val_delay) == -1) {
(void) fprintf(stderr, "Can not get RPTDELAY\n");
}
if (val_delay > 0)
(void) set_rptdelay(val_delay, kbd);
else
(void) fprintf(stderr,
BAD_DEFAULT_LLINT, KBD_PROP_RPTDELAY, val_delay);
if (scf_pg_get_property(pg, KBD_PROP_RPTRATE, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_integer(val, &val_rate) == -1) {
(void) fprintf(stderr, "Can not get RPTRATE\n");
}
if (val_rate > 0)
(void) set_rptrate(val_rate, kbd);
else
(void) fprintf(stderr,
BAD_DEFAULT_LLINT, KBD_PROP_RPTRATE, val_rate);
if (scf_pg_get_property(pg, KBD_PROP_LAYOUT, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_astring(val, val_layout, KBD_MAX_NAME_LEN) == -1) {
(void) fprintf(stderr, "Can not get LAYOUT\n");
}
if (*val_layout != '\0') {
/*
* LAYOUT must be one of the layouts supported in kbd_layouts
*/
if (get_layouts() != 0)
goto out;
if ((layout_num = get_layout_number(val_layout)) == -1) {
(void) fprintf(stderr,
BAD_DEFAULT_STR, KBD_PROP_LAYOUT, val_layout);
goto out;
}
(void) set_layout(kbd, layout_num);
}
if (scf_pg_get_property(pg, KBD_PROP_FREQ, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_integer(val, &val_kbd_beeper) == -1) {
(void) fprintf(stderr, "Can not get FREQ\n");
}
if (val_kbd_beeper >= 0 && val_kbd_beeper <= INT16_MAX)
(void) set_beep_freq(kbd, "keyboard", val_kbd_beeper);
else
(void) fprintf(stderr,
BAD_DEFAULT_LLINT, KBD_PROP_FREQ, val_kbd_beeper);
if (scf_pg_get_property(pg, KBD_PROP_CONSFREQ, prop) != 0 ||
scf_property_get_value(prop, val) != 0 ||
scf_value_get_integer(val, &val_console_beeper) == -1) {
(void) fprintf(stderr, "Can not get CONSFREQ\n");
}
if (val_console_beeper >= 0 && val_console_beeper <= INT16_MAX)
(void) set_beep_freq(kbd, "console", val_console_beeper);
else
(void) fprintf(stderr,
BAD_DEFAULT_LLINT, KBD_PROP_CONSFREQ, val_console_beeper);
out:
if (val_layout != NULL)
free(val_layout);
if (val_abort != NULL)
free(val_abort);
if (snap != NULL)
scf_snapshot_destroy(snap);
scf_value_destroy(val);
scf_property_destroy(prop);
scf_pg_destroy(pg);
scf_instance_destroy(inst);
scf_handle_destroy(h);
}
conerr_t
smfu_set_property(char *fmri, char *pgname, char *propname, char *value)
{
conerr_t err = ce_ok;
scf_handle_t *scfhandle = handle_create();
scf_service_t *service = scf_service_create(scfhandle);
scf_instance_t *instance = scf_instance_create(scfhandle);
scf_propertygroup_t *pg = scf_pg_create(scfhandle);
scf_property_t *prop = scf_property_create(scfhandle);
scf_value_t *val = scf_value_create(scfhandle);
scf_transaction_t *tx = scf_transaction_create(scfhandle);
scf_transaction_entry_t *ent = scf_entry_create(scfhandle);
scf_type_t type;
if (scfhandle == NULL || service == NULL || instance == NULL ||
pg == NULL || prop == NULL || tx == NULL || ent == NULL ||
val == NULL) {
err = ce_nomem;
goto out;
}
if (scf_handle_decode_fmri(scfhandle, fmri, NULL, service, instance,
NULL, NULL, 0) != SCF_SUCCESS) {
rad_log(RL_ERROR, "couldn't decode '%s': %s\n", fmri,
scf_strerror(scf_error()));
err = maperr(scf_error());
goto out;
}
if (scf_instance_get_pg(instance, pgname, pg) != 0 ||
scf_pg_get_property(pg, propname, prop) != 0 ||
scf_property_type(prop, &type) != 0) {
rad_log(RL_ERROR, "couldn't get property: '%s/%s/%s': %s\n",
fmri, pgname, propname, scf_strerror(scf_error()));
err = maperr(scf_error());
goto out;
}
top:
if (scf_transaction_start(tx, pg) == -1 ||
scf_transaction_property_change(tx, ent, propname, type) != 0 ||
scf_value_set_from_string(val, type, value) != 0 ||
scf_entry_add_value(ent, val) != 0) {
rad_log(RL_ERROR, "couldn't set property: '%s/%s/%s': %s\n",
fmri, pgname, propname, scf_strerror(scf_error()));
err = maperr(scf_error());
goto out;
}
switch (scf_transaction_commit(tx)) {
/* success */
case 1:
if (smf_refresh_instance(fmri) != 0) {
err = maperr(scf_error());
goto out;
}
break;
/* retry */
case 0:
if (scf_pg_update(pg) != 0) {
err = maperr(scf_error());
goto out;
}
scf_transaction_reset(tx);
goto top;
default:
err = maperr(scf_error());
goto out;
}
out:
scf_entry_destroy(ent);
scf_transaction_destroy(tx);
scf_value_destroy(val);
scf_property_destroy(prop);
scf_pg_destroy(pg);
scf_instance_destroy(instance);
scf_service_destroy(service);
scf_handle_destroy(scfhandle);
return (err);
}
/*
* Returns a zone ID of Solaris when the TZ value is "localtime".
* First, it tries scf. If scf fails, it looks for the same file as
* /usr/share/lib/zoneinfo/localtime under /usr/share/lib/zoneinfo/.
*/
static char *
getSolarisDefaultZoneID() {
char *tz = NULL;
struct stat statbuf;
size_t size;
char *buf;
int fd;
/* scf specific variables */
scf_handle_t *h = NULL;
scf_snapshot_t *snap = NULL;
scf_instance_t *inst = NULL;
scf_propertygroup_t *pg = NULL;
scf_property_t *prop = NULL;
scf_value_t *val = NULL;
if ((h = scf_handle_create(SCF_VERSION)) != NULL
&& scf_handle_bind(h) == 0
&& (inst = scf_instance_create(h)) != NULL
&& (snap = scf_snapshot_create(h)) != NULL
&& (pg = scf_pg_create(h)) != NULL
&& (prop = scf_property_create(h)) != NULL
&& (val = scf_value_create(h)) != NULL
&& scf_handle_decode_fmri(h, TIMEZONE_FMRI, NULL, NULL, inst,
NULL, NULL, SCF_DECODE_FMRI_REQUIRE_INSTANCE) == 0
&& scf_instance_get_snapshot(inst, "running", snap) == 0
&& scf_instance_get_pg_composed(inst, snap, TIMEZONE_PG, pg) == 0
&& scf_pg_get_property(pg, LOCALTIME_PROP, prop) == 0
&& scf_property_get_value(prop, val) == 0) {
ssize_t len;
/* Gets the length of the zone ID string */
len = scf_value_get_astring(val, NULL, 0);
if (len != -1) {
tz = malloc(++len); /* +1 for a null byte */
if (tz != NULL && scf_value_get_astring(val, tz, len) != -1) {
cleanupScf(h, snap, inst, pg, prop, val, NULL);
return tz;
}
}
}
cleanupScf(h, snap, inst, pg, prop, val, tz);
if (stat(DEFAULT_ZONEINFO_FILE, &statbuf) == -1) {
return NULL;
}
size = (size_t) statbuf.st_size;
buf = malloc(size);
if (buf == NULL) {
return NULL;
}
if ((fd = open(DEFAULT_ZONEINFO_FILE, O_RDONLY)) == -1) {
free((void *) buf);
return NULL;
}
if (read(fd, buf, size) != (ssize_t) size) {
(void) close(fd);
free((void *) buf);
return NULL;
}
(void) close(fd);
tz = findZoneinfoFile(buf, size, ZONEINFO_DIR);
free((void *) buf);
return tz;
}
/*
* Entity (service or instance): If there are -p options,
* display_{pg,prop}() the named property groups and/or properties. Otherwise
* display_pg() all property groups.
*/
static void
process_ent(scf_entityp_t ent)
{
scf_snapshot_t *snap = NULL;
scf_propertygroup_t *pg;
scf_property_t *prop;
scf_iter_t *iter;
svcprop_prop_node_t *spn;
int ret, err;
if (uu_list_numnodes(prop_list) == 0) {
if (quiet)
return;
if ((pg = scf_pg_create(hndl)) == NULL ||
(iter = scf_iter_create(hndl)) == NULL)
scfdie();
if (cflag || Cflag || ent.type != ENT_INSTANCE) {
if (scf_iter_entity_pgs(iter, ent) == -1)
scfdie();
} else {
if (snapshot != NULL)
snap = get_snapshot(ent.u.inst, snapshot);
if (scf_iter_instance_pgs_composed(iter, ent.u.inst,
snap) == -1)
scfdie();
if (snap)
scf_snapshot_destroy(snap);
}
while ((ret = scf_iter_next_pg(iter, pg)) == 1)
display_pg(pg);
if (ret == -1)
scfdie();
/*
* In normal usage, i.e. against the running snapshot,
* we must iterate over the current non-persistent
* pg's.
*/
if (sflag == 0 && snap != NULL) {
scf_iter_reset(iter);
if (scf_iter_instance_pgs_composed(iter, ent.u.inst,
NULL) == -1)
scfdie();
while ((ret = scf_iter_next_pg(iter, pg)) == 1) {
uint32_t flags;
if (scf_pg_get_flags(pg, &flags) == -1)
scfdie();
if (flags & SCF_PG_FLAG_NONPERSISTENT)
display_pg(pg);
}
}
if (ret == -1)
scfdie();
scf_iter_destroy(iter);
scf_pg_destroy(pg);
return;
}
if ((pg = scf_pg_create(hndl)) == NULL ||
(prop = scf_property_create(hndl)) == NULL)
scfdie();
if (ent.type == ENT_INSTANCE && snapshot != NULL)
snap = get_snapshot(ent.u.inst, snapshot);
for (spn = uu_list_first(prop_list);
spn != NULL;
spn = uu_list_next(prop_list, spn)) {
if (ent.type == ENT_INSTANCE) {
if (Cflag)
ret = scf_instance_get_pg(ent.u.inst,
spn->spn_comp1, pg);
else
ret = scf_instance_get_pg_composed(ent.u.inst,
snap, spn->spn_comp1, pg);
err = scf_error();
/*
* If we didn't find it in the specified snapshot, use
* the current values if the pg is nonpersistent.
*/
if (ret == -1 && !Cflag &&snap != NULL && err ==
SCF_ERROR_NOT_FOUND) {
ret = scf_instance_get_pg_composed(
ent.u.inst, NULL, spn->spn_comp1,
pg);
if (ret == 0) {
uint32_t flags;
if (scf_pg_get_flags(pg, &flags) == -1)
scfdie();
if ((flags & SCF_PG_FLAG_NONPERSISTENT)
== 0) {
ret = -1;
}
}
}
} else {
/*
* If we are displaying properties for a service,
* treat it as though it were a composed, current
* lookup. (implicit cflag) However, if a snapshot
* was specified, fail.
*/
if (sflag)
die(gettext("Only instances have "
"snapshots.\n"));
ret = scf_entity_get_pg(ent, spn->spn_comp1, pg);
err = scf_error();
}
if (ret == -1) {
if (err != SCF_ERROR_NOT_FOUND)
scfdie();
if (PRINT_NOPROP_ERRORS) {
char *buf;
buf = safe_malloc(max_scf_fmri_length + 1);
if (scf_entity_to_fmri(ent, buf,
max_scf_fmri_length + 1) == -1)
scfdie();
uu_warn(gettext("Couldn't find property group "
"`%s' for %s `%s'.\n"), spn->spn_comp1,
SCF_ENTITY_TYPE_NAME(ent), buf);
free(buf);
}
noprop_common_action();
continue;
}
if (spn->spn_comp2 == NULL) {
if (!quiet)
display_pg(pg);
continue;
}
if (scf_pg_get_property(pg, spn->spn_comp2, prop) == -1) {
if (scf_error() != SCF_ERROR_NOT_FOUND)
scfdie();
if (PRINT_NOPROP_ERRORS) {
char *buf;
buf = safe_malloc(max_scf_fmri_length + 1);
if (scf_entity_to_fmri(ent, buf,
max_scf_fmri_length + 1) == -1)
scfdie();
/* FMRI syntax knowledge */
uu_warn(gettext("Couldn't find property "
"`%s/%s' for %s `%s'.\n"), spn->spn_comp1,
spn->spn_comp2, SCF_ENTITY_TYPE_NAME(ent),
buf);
free(buf);
}
noprop_common_action();
continue;
}
if (!quiet)
display_prop(pg, prop);
}
scf_property_destroy(prop);
scf_pg_destroy(pg);
if (snap)
scf_snapshot_destroy(snap);
}
/*
* store_inetd_hash stores the string hash in inetd's configuration file hash
* in the repository. On success, SCF_ERROR_NONE is returned. Otherwise, the
* scf_error value is returned.
*/
scf_error_t
store_inetd_hash(const char *hash)
{
int ret;
scf_error_t rval = SCF_ERROR_NONE;
scf_handle_t *h;
scf_propertygroup_t *pg = NULL;
scf_instance_t *inst = NULL;
scf_transaction_t *tx = NULL;
scf_transaction_entry_t *txent = NULL;
scf_property_t *prop = NULL;
scf_value_t *val = NULL;
if ((h = scf_handle_create(SCF_VERSION)) == NULL ||
scf_handle_bind(h) == -1)
goto error;
if ((pg = scf_pg_create(h)) == NULL ||
(inst = scf_instance_create(h)) == NULL ||
scf_handle_decode_fmri(h, INETD_INSTANCE_FMRI, NULL, NULL, inst,
NULL, NULL, SCF_DECODE_FMRI_EXACT) == -1)
goto error;
if (scf_instance_get_pg(inst, HASH_PG, pg) == -1) {
if (scf_error() != SCF_ERROR_NOT_FOUND ||
scf_instance_add_pg(inst, HASH_PG, SCF_GROUP_APPLICATION,
0, pg) == -1)
goto error;
}
if ((tx = scf_transaction_create(h)) == NULL ||
(txent = scf_entry_create(h)) == NULL ||
(prop = scf_property_create(h)) == NULL ||
(val = scf_value_create(h)) == NULL)
goto error;
do {
if (scf_transaction_start(tx, pg) == -1)
goto error;
if (scf_transaction_property_new(tx, txent, HASH_PROP,
SCF_TYPE_ASTRING) == -1 &&
scf_transaction_property_change_type(tx, txent, HASH_PROP,
SCF_TYPE_ASTRING) == -1)
goto error;
if (scf_value_set_astring(val, hash) == -1 ||
scf_entry_add_value(txent, val) == -1)
goto error;
if ((ret = scf_transaction_commit(tx)) == -1)
goto error;
if (ret == 0) {
scf_transaction_reset(tx);
if (scf_pg_update(pg) == -1)
goto error;
}
} while (ret == 0);
goto success;
error:
rval = scf_error();
success:
scf_value_destroy(val);
scf_property_destroy(prop);
scf_entry_destroy(txent);
scf_transaction_destroy(tx);
scf_instance_destroy(inst);
scf_pg_destroy(pg);
scf_handle_destroy(h);
return (rval);
}
/* ARGSUSED */
static int
do_wait(void *unused, scf_walkinfo_t *wip)
{
scf_property_t *prop;
scf_propertygroup_t *lpg, *pg;
const char *propname;
svcprop_prop_node_t *p;
const char *emsg_not_found = gettext("Not found.\n");
if ((lpg = scf_pg_create(hndl)) == NULL ||
(prop = scf_property_create(hndl)) == NULL)
scfdie();
if (wip->prop != NULL) {
if (uu_list_numnodes(prop_list) > 0)
uu_xdie(UU_EXIT_USAGE, gettext("-p cannot be used with "
"property FMRIs.\n"));
pg = wip->pg;
assert(strrchr(wip->fmri, '/') != NULL);
propname = strrchr(wip->fmri, '/') + 1;
} else if (wip->pg != NULL) {
p = uu_list_first(prop_list);
if (p != NULL) {
if (p->spn_comp2 != NULL)
uu_xdie(UU_EXIT_USAGE, gettext("-p argument "
"\"%s/%s\" has too many components for "
"property group %s.\n"),
p->spn_comp1, p->spn_comp2, wip->fmri);
propname = p->spn_comp1;
if (scf_pg_get_property(wip->pg, propname, prop) !=
SCF_SUCCESS) {
switch (scf_error()) {
case SCF_ERROR_INVALID_ARGUMENT:
uu_xdie(UU_EXIT_USAGE,
gettext("Invalid property name "
"\"%s\".\n"), propname);
/* NOTREACHED */
case SCF_ERROR_NOT_FOUND:
die(emsg_not_found);
/* NOTREACHED */
default:
scfdie();
}
}
} else {
propname = NULL;
}
pg = wip->pg;
} else if (wip->inst != NULL) {
p = uu_list_first(prop_list);
if (p == NULL)
uu_xdie(UU_EXIT_USAGE,
gettext("Cannot wait for an instance.\n"));
if (scf_instance_get_pg(wip->inst, p->spn_comp1, lpg) !=
SCF_SUCCESS) {
switch (scf_error()) {
case SCF_ERROR_INVALID_ARGUMENT:
uu_xdie(UU_EXIT_USAGE, gettext("Invalid "
"property group name \"%s\".\n"),
p->spn_comp1);
case SCF_ERROR_NOT_FOUND:
die(emsg_not_found);
/* NOTREACHED */
default:
scfdie();
}
}
propname = p->spn_comp2;
if (propname != NULL) {
if (scf_pg_get_property(lpg, propname, prop) !=
SCF_SUCCESS) {
switch (scf_error()) {
case SCF_ERROR_INVALID_ARGUMENT:
uu_xdie(UU_EXIT_USAGE,
gettext("Invalid property name "
"\"%s\".\n"), propname);
case SCF_ERROR_NOT_FOUND:
die(emsg_not_found);
/* NOTREACHED */
default:
scfdie();
}
}
}
pg = lpg;
} else if (wip->svc != NULL) {
p = uu_list_first(prop_list);
if (p == NULL)
uu_xdie(UU_EXIT_USAGE,
gettext("Cannot wait for a service.\n"));
if (scf_service_get_pg(wip->svc, p->spn_comp1, lpg) !=
SCF_SUCCESS) {
switch (scf_error()) {
case SCF_ERROR_INVALID_ARGUMENT:
uu_xdie(UU_EXIT_USAGE, gettext("Invalid "
"property group name \"%s\".\n"),
p->spn_comp1);
case SCF_ERROR_NOT_FOUND:
die(emsg_not_found);
default:
scfdie();
}
}
propname = p->spn_comp2;
if (propname != NULL) {
if (scf_pg_get_property(lpg, propname, prop) !=
SCF_SUCCESS) {
switch (scf_error()) {
case SCF_ERROR_INVALID_ARGUMENT:
uu_xdie(UU_EXIT_USAGE,
gettext("Invalid property name "
"\"%s\".\n"), propname);
/* NOTREACHED */
case SCF_ERROR_NOT_FOUND:
die(emsg_not_found);
/* NOTREACHED */
default:
scfdie();
}
}
}
pg = lpg;
} else {
uu_xdie(UU_EXIT_USAGE, gettext("FMRI must specify an entity, "
"property group, or property.\n"));
}
for (;;) {
int ret;
ret = _scf_pg_wait(pg, -1);
if (ret != SCF_SUCCESS)
scfdie();
ret = scf_pg_update(pg);
if (ret < 0) {
if (scf_error() != SCF_ERROR_DELETED)
scfdie();
die(emsg_not_found);
}
if (ret == SCF_COMPLETE)
break;
}
if (propname != NULL) {
if (scf_pg_get_property(pg, propname, prop) == SCF_SUCCESS) {
if (!quiet)
display_prop(pg, prop);
} else {
if (scf_error() != SCF_ERROR_NOT_FOUND)
scfdie();
if (PRINT_NOPROP_ERRORS)
uu_warn(emsg_not_found);
return_code = UU_EXIT_FATAL;
}
} else {
if (!quiet)
display_pg(pg);
}
scf_property_destroy(prop);
scf_pg_destroy(lpg);
return (0);
}
