libscf - zygaena/hammerhead

root / base / usr / src / lib / libscf
libscf Plain Text 4506 lines 117.6 KB
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#

#
# Note we build a native version of libscf.so.1 out of tools/svc.
#

include		../Makefile.lib

# Hammerhead: amd64-only
SUBDIRS = $(MACH64)

all : TARGET= all
clean : TARGET= clean
clobber : TARGET= clobber
install : TARGET= install

HDRDIR =	inc
HDRS =		libscf.h libscf_priv.h

#
# only error descriptions are internationalized, but they aren't directly
# surrounded by gettext(), so we use '-a' to grab all strings.
#
MSGFILES =	common/error.c
POFILE =	libscf.po
XGETFLAGS +=	-a

.KEEP_STATE:

all clean clobber install: $(SUBDIRS)

$(POFILE):	pofile_MSGFILES

install_h: $(ROOTHDRS)

check: $(CHECKHDRS)

_msg:		$(MSGDOMAINPOFILE)

$(SUBDIRS): FRC
	@cd $@; pwd; $(MAKE) $(TARGET)

FRC:

include ../Makefile.targ
include ../../Makefile.msg.targ
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
#
# Copyright (c) 2018, Joyent, Inc.

include $(SRC)/lib/Makefile.lib
include ../Makefile.shared.com
include $(SRC)/lib/Makefile.rootfs

LDLIBS +=	-lc

SRCDIR =	../common
COMDIR =	../../../common/svc

CPPFLAGS +=	-I$(SRC)/lib/libscf/inc -I$(SRC)/lib/libscf/common/inc \
	-I$(COMDIR) -I$(ROOTHDRDIR)

.KEEP_STATE:

all:

include $(SRC)/lib/Makefile.targ
#
# This file and its contents are supplied under the terms of the
# Common Development and Distribution License ("CDDL"), version 1.0.
# You may only use this file in accordance with the terms of version
# 1.0 of the CDDL.
#
# A full copy of the text of the CDDL should have accompanied this
# source.  A copy of the CDDL is also available via the Internet at
# http://www.illumos.org/license/CDDL.
#

LIBRARY =	libscf.a
VERS =		.1

OBJECTS =		\
	error.o		\
	libscf-stub.o

include $(SRC)/lib/Makefile.lib

LIBS = $(DYNLIB)

CERRWARN +=	-Wno-switch
CERRWARN +=	-Wno-char-subscripts
CERRWARN +=	-Wno-parentheses
CERRWARN +=	$(CNOWARN_UNINIT)

# Hammerhead: Ensure PIC is used for shared library objects
# (Target-specific variable in Makefile.lib may not work correctly with GNU Make)
CFLAGS += -fpic
CFLAGS64 += -fpic

# not linted
SMATCH=off
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License, Version 1.0 only
# (the "License").  You may not use this file except in compliance
# with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#

include ../Makefile.com
include ../../Makefile.lib.64

all: $(LIBS)

install: all $(ROOTLIBS64) $(ROOTLINKS64) $(ROOTCOMPATLINKS64)
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2013 Joyent, Inc.  All rights reserved.
 * Copyright 2017 OmniOS Community Edition (OmniOSce) Association.
 */

#include "libscf_impl.h"

#include <assert.h>
#include <dlfcn.h>
#include <libintl.h>
#include <pthread.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/machelf.h>
#include <thread.h>

#include <ucontext.h>

extern int ndebug;

static struct scf_error_info {
	scf_error_t	ei_code;
	const char	*ei_desc;
} scf_errors[] = {
	{SCF_ERROR_NONE,		"no error"},
	{SCF_ERROR_NOT_BOUND,		"handle not bound"},
	{SCF_ERROR_NOT_SET,		"cannot use unset argument"},
	{SCF_ERROR_NOT_FOUND,		"entity not found"},
	{SCF_ERROR_TYPE_MISMATCH,	"type does not match value"},
	{SCF_ERROR_IN_USE,		"cannot modify while in-use"},
	{SCF_ERROR_CONNECTION_BROKEN,	"connection to repository broken"},
	{SCF_ERROR_INVALID_ARGUMENT,	"invalid argument"},
	{SCF_ERROR_NO_MEMORY,		"no memory available"},
	{SCF_ERROR_CONSTRAINT_VIOLATED,	"required constraint not met"},
	{SCF_ERROR_EXISTS,		"object already exists"},
	{SCF_ERROR_NO_SERVER,		"repository server unavailable"},
	{SCF_ERROR_NO_RESOURCES,	"server has insufficient resources"},
	{SCF_ERROR_PERMISSION_DENIED,	"insufficient privileges for action"},
	{SCF_ERROR_BACKEND_ACCESS,	"backend refused access"},
	{SCF_ERROR_BACKEND_READONLY,	"backend is read-only"},
	{SCF_ERROR_HANDLE_MISMATCH,	"mismatched SCF handles"},
	{SCF_ERROR_HANDLE_DESTROYED,	"object bound to destroyed handle"},
	{SCF_ERROR_VERSION_MISMATCH,	"incompatible SCF version"},
	{SCF_ERROR_DELETED,		"object has been deleted"},
	{SCF_ERROR_TEMPLATE_INVALID,	"template data is invalid"},

	{SCF_ERROR_CALLBACK_FAILED,	"user callback function failed"},

	{SCF_ERROR_INTERNAL,		"internal error"}
};
#define	SCF_NUM_ERRORS	(sizeof (scf_errors) / sizeof (*scf_errors))

/* a SWAG just in case things get out of sync, we can notice */
#define	LOOKS_VALID(e)	\
	((e) >= scf_errors[0].ei_code && \
	    (e) < scf_errors[SCF_NUM_ERRORS - 1].ei_code + 10)

static scf_error_t	_scf_fallback_error = SCF_ERROR_NONE;

#if defined(PTHREAD_ONCE_KEY_NP)

static pthread_key_t	scf_error_key = PTHREAD_ONCE_KEY_NP;

int
scf_setup_error(void)
{
	return (pthread_key_create_once_np(&scf_error_key, NULL) == 0);
}

#else	/* PTHREAD_ONCE_KEY_NP */

/*
 * This old code is here to enable the building of a native version
 * of libscf.so when the build machine has not yet been upgraded
 * to a version of libc that provides pthread_key_create_once_np().
 * It should be deleted when solaris_nevada ships.
 * This code is not MT-safe in a relaxed memory model.
 */

static pthread_key_t	scf_error_key = 0;

int
scf_setup_error(void)
{
	static pthread_mutex_t scf_key_lock = PTHREAD_MUTEX_INITIALIZER;
	static volatile int scf_error_key_setup = 0;

	if (scf_error_key_setup == 0) {
		(void) pthread_mutex_lock(&scf_key_lock);
		if (scf_error_key_setup == 0) {
			if (pthread_key_create(&scf_error_key, NULL) == 0)
				scf_error_key_setup = 1;
		}
		(void) pthread_mutex_unlock(&scf_key_lock);
	}

	return (scf_error_key_setup == 1);
}

#endif	/* PTHREAD_ONCE_KEY_NP */

int
scf_set_error(scf_error_t code)
{
	assert(LOOKS_VALID(code));

	if (scf_setup_error())
		(void) pthread_setspecific(scf_error_key, (void *)code);
	else
		_scf_fallback_error = code;
	return (-1);
}

scf_error_t
scf_error(void)
{
	scf_error_t ret;

	ret = (scf_error_t)pthread_getspecific(scf_error_key);
	if (ret == 0)
		return (_scf_fallback_error);
	assert(LOOKS_VALID(ret));
	return (ret);
}

const char *
scf_strerror(scf_error_t code)
{
	struct scf_error_info *cur, *end;

	cur = scf_errors;
	end = cur + SCF_NUM_ERRORS;

	for (; cur < end; cur++)
		if (code == cur->ei_code)
			return (dgettext(TEXT_DOMAIN, cur->ei_desc));

	return (dgettext(TEXT_DOMAIN, "unknown error"));
}

const char *
scf_get_msg(scf_msg_t msg)
{
	switch (msg) {
	case SCF_MSG_ARGTOOLONG:
		return (dgettext(TEXT_DOMAIN,
		    "Argument '%s' is too long, ignoring\n"));

	case SCF_MSG_PATTERN_NOINSTANCE:
		return (dgettext(TEXT_DOMAIN,
		    "Pattern '%s' doesn't match any instances\n"));

	case SCF_MSG_PATTERN_NOINSTSVC:
		return (dgettext(TEXT_DOMAIN,
		    "Pattern '%s' doesn't match any instances or services\n"));

	case SCF_MSG_PATTERN_NOSERVICE:
		return (dgettext(TEXT_DOMAIN,
		    "Pattern '%s' doesn't match any services\n"));

	case SCF_MSG_PATTERN_NOENTITY:
		return (dgettext(TEXT_DOMAIN,
		    "Pattern '%s' doesn't match any entities\n"));

	case SCF_MSG_PATTERN_MULTIMATCH:
		return (dgettext(TEXT_DOMAIN,
		    "Pattern '%s' matches multiple instances:\n"));

	case SCF_MSG_PATTERN_POSSIBLE:
		return (dgettext(TEXT_DOMAIN, "    %s\n"));

	case SCF_MSG_PATTERN_LEGACY:
		return (dgettext(TEXT_DOMAIN,
		    "Operation not supported for legacy service '%s'\n"));

	case SCF_MSG_PATTERN_MULTIPARTIAL:
		return (dgettext(TEXT_DOMAIN,
		    "Partial FMRI '%s' matches multiple instances:\n"));

	default:
		abort();
		/* NOTREACHED */
	}

}
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2026 Hammerhead / Zygaena project.
 */

/*
 * libscf-stub.c -- SMF-removed stub of libscf for Hammerhead.
 *
 * Hammerhead has removed the Service Management Framework (Phases A/B/C):
 * svc.startd, svc.configd, svccfg, svcadm, svcs, svcprop, manifest installs
 * and the librestart layer are gone. libscf is the SMF *client* library that
 * many existing illumos binaries still link against (`-lscf`). To preserve
 * the link-time ABI without dragging in a 21k-line repository client, this
 * file replaces the original lowlevel/midlevel/highlevel/notify_params/
 * scf_tmpl/scf_type implementation with no-op stubs.
 *
 * All 285 versioned symbols from common/mapfile-vers remain resolvable.
 * scf_error and scf_strerror live in error.c (which keeps thread-local error
 * storage so callers see a stable errno-like value); the remaining 283
 * symbols are stubbed here. Runtime calls return SCF_ERROR_NO_SERVER
 * ("repository server unavailable" -- the truthful state now that configd
 * is gone) so consumers degrade gracefully:
 *
 *   - pointer returners                : scf_set_error + return NULL
 *   - int returners                    : return scf_set_error()  (which is -1)
 *   - ssize_t returners                : scf_set_error + return -1
 *   - void returners                   : no-op
 *   - scf_type_t returners             : return SCF_TYPE_INVALID
 *   - scf_walk_fmri (scf_error_t)      : return SCF_ERROR_NO_SERVER
 *   - ismember                         : real implementation (stateless)
 *
 * This file MUST stay synchronised with mapfile-vers; symbols are grouped
 * here in mapfile section order (ILLUMOS_0.1, SUNW_1.2, SUNW_1.1,
 * SUNWprivate_1.1) and alphabetised within each section so symbol-version
 * review is mechanical.
 *
 * Reference: docs/roadmap/SMF_PHASE_D_PLAN.md
 */

#include <stddef.h>
#include <stdlib.h>
#include <string.h>

#include <libscf.h>
#include <libscf_priv.h>

#include "libscf_impl.h"

/* Provided by error.c */
extern int scf_set_error(scf_error_t);

/* ===== ILLUMOS_0.1 ===== */

int
smf_disable_instance_with_comment(const char *, int, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

/* ===== SUNW_1.2 ===== */

void
scf_count_ranges_destroy(scf_count_ranges_t *)
{
}

void
scf_int_ranges_destroy(scf_int_ranges_t *)
{
}

scf_type_t
scf_string_to_type(const char *)
{
	return (SCF_TYPE_INVALID);
}

int
scf_tmpl_error_pg(const scf_tmpl_error_t *, char **, char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_error_pg_tmpl(const scf_tmpl_error_t *, char **, char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_error_prop(const scf_tmpl_error_t *, char **, char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_error_prop_tmpl(const scf_tmpl_error_t *, char **, char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_error_type(const scf_tmpl_error_t *, scf_tmpl_error_type_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_error_value(const scf_tmpl_error_t *, char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_tmpl_errors_destroy(scf_tmpl_errors_t *)
{
}

int
scf_tmpl_get_by_pg(scf_propertygroup_t *, scf_pg_tmpl_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_get_by_pg_name(const char *, const char *, const char *, const char *, scf_pg_tmpl_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_get_by_prop(scf_pg_tmpl_t *, const char *, scf_prop_tmpl_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_iter_pgs(scf_pg_tmpl_t *, const char *, const char *, const char *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_iter_props(scf_pg_tmpl_t *, scf_prop_tmpl_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_tmpl_error_t *
scf_tmpl_next_error(scf_tmpl_errors_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_tmpl_pg_common_name(const scf_pg_tmpl_t *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

scf_pg_tmpl_t *
scf_tmpl_pg_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_tmpl_pg_description(const scf_pg_tmpl_t *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

void
scf_tmpl_pg_destroy(scf_pg_tmpl_t *)
{
}

ssize_t
scf_tmpl_pg_name(const scf_pg_tmpl_t *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_tmpl_pg_required(const scf_pg_tmpl_t *, uint8_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_tmpl_pg_reset(scf_pg_tmpl_t *)
{
}

ssize_t
scf_tmpl_pg_target(const scf_pg_tmpl_t *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

ssize_t
scf_tmpl_pg_type(const scf_pg_tmpl_t *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_tmpl_prop_cardinality(const scf_prop_tmpl_t *, uint64_t *, uint64_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_tmpl_prop_common_name(const scf_prop_tmpl_t *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

scf_prop_tmpl_t *
scf_tmpl_prop_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_tmpl_prop_description(const scf_prop_tmpl_t *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

void
scf_tmpl_prop_destroy(scf_prop_tmpl_t *)
{
}

int
scf_tmpl_prop_internal_seps(const scf_prop_tmpl_t *, scf_values_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_tmpl_prop_name(const scf_prop_tmpl_t *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_tmpl_prop_required(const scf_prop_tmpl_t *, uint8_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_tmpl_prop_reset(scf_prop_tmpl_t *)
{
}

int
scf_tmpl_prop_type(const scf_prop_tmpl_t *, scf_type_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_tmpl_prop_units(const scf_prop_tmpl_t *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_tmpl_prop_visibility(const scf_prop_tmpl_t *, uint8_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_tmpl_reset_errors(scf_tmpl_errors_t *)
{
}

int
scf_tmpl_strerror(scf_tmpl_error_t *, char *, size_t, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_validate_fmri(scf_handle_t *, const char *, const char *, scf_tmpl_errors_t **, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_tmpl_value_common_name(const scf_prop_tmpl_t *, const char *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_tmpl_value_count_range_choices(const scf_prop_tmpl_t *, scf_count_ranges_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_value_count_range_constraints(const scf_prop_tmpl_t *, scf_count_ranges_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_tmpl_value_description(const scf_prop_tmpl_t *, const char *, const char *, char **)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_tmpl_value_in_constraint(const scf_prop_tmpl_t *, scf_value_t *, scf_tmpl_errors_t **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_value_int_range_choices(const scf_prop_tmpl_t *, scf_int_ranges_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_value_int_range_constraints(const scf_prop_tmpl_t *, scf_int_ranges_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_value_name_choices(const scf_prop_tmpl_t *, scf_values_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_tmpl_value_name_constraints(const scf_prop_tmpl_t *, scf_values_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

const char *
scf_tmpl_visibility_to_string(uint8_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

const char *
scf_type_to_string(scf_type_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_values_destroy(scf_values_t *)
{
}

int
smf_notify_del_params(const char *, const char *, int32_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_notify_get_params(nvlist_t **, nvlist_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_notify_set_params(const char *, nvlist_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int32_t
smf_state_from_string(const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

const char *
smf_state_to_string(int32_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

/* ===== SUNW_1.1 ===== */

int
scf_entry_add_value(scf_transaction_entry_t *, scf_value_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_transaction_entry_t *
scf_entry_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_entry_destroy(scf_transaction_entry_t *)
{
}

void
scf_entry_destroy_children(scf_transaction_entry_t *)
{
}

scf_handle_t *
scf_entry_handle(const scf_transaction_entry_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_entry_reset(scf_transaction_entry_t *)
{
}

int
scf_handle_bind(scf_handle_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_handle_create(scf_version_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_handle_decode_fmri(scf_handle_t *, const char *, scf_scope_t *, scf_service_t *, scf_instance_t *, scf_propertygroup_t *, scf_property_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_handle_decorate(scf_handle_t *, const char *, scf_value_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_handle_destroy(scf_handle_t *)
{
}

int
scf_handle_get_scope(scf_handle_t *, const char *, scf_scope_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_handle_unbind(scf_handle_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_instance_add_pg(const scf_instance_t *, const char *, const char *, uint32_t, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_instance_t *
scf_instance_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_instance_delete(scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_instance_destroy(scf_instance_t *)
{
}

ssize_t
scf_instance_get_name(const scf_instance_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_instance_get_parent(const scf_instance_t *, scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_instance_get_pg(const scf_instance_t *, const char *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_instance_get_pg_composed(const scf_instance_t *, const scf_snapshot_t *, const char *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_instance_get_snapshot(const scf_instance_t *, const char *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_instance_handle(const scf_instance_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_instance_to_fmri(const scf_instance_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

scf_iter_t *
scf_iter_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_iter_destroy(scf_iter_t *)
{
}

scf_handle_t *
scf_iter_handle(const scf_iter_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_iter_handle_scopes(scf_iter_t *, const scf_handle_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_instance_pgs(scf_iter_t *, const scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_instance_pgs_composed(scf_iter_t *, const scf_instance_t *, const scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_instance_pgs_typed(scf_iter_t *, const scf_instance_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_instance_pgs_typed_composed(scf_iter_t *, const scf_instance_t *, const scf_snapshot_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_instance_snapshots(scf_iter_t *, const scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_instance(scf_iter_t *, scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_pg(scf_iter_t *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_property(scf_iter_t *, scf_property_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_scope(scf_iter_t *, scf_scope_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_service(scf_iter_t *, scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_snapshot(scf_iter_t *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_next_value(scf_iter_t *, scf_value_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_pg_properties(scf_iter_t *, const scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_property_values(scf_iter_t *, const scf_property_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_iter_reset(scf_iter_t *)
{
}

int
scf_iter_scope_services(scf_iter_t *, const scf_scope_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_service_instances(scf_iter_t *, const scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_service_pgs(scf_iter_t *, const scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_service_pgs_typed(scf_iter_t *, const scf_service_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_snaplevel_pgs(scf_iter_t *, const scf_snaplevel_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_iter_snaplevel_pgs_typed(scf_iter_t *, const scf_snaplevel_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_limit(uint32_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

ssize_t
scf_myname(scf_handle_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

scf_propertygroup_t *
scf_pg_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_pg_delete(scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_pg_destroy(scf_propertygroup_t *)
{
}

int
scf_pg_get_flags(const scf_propertygroup_t *, uint32_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_pg_get_name(const scf_propertygroup_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_pg_get_parent_instance(const scf_propertygroup_t *, scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_pg_get_parent_service(const scf_propertygroup_t *, scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_pg_get_parent_snaplevel(const scf_propertygroup_t *, scf_snaplevel_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_pg_get_property(const scf_propertygroup_t *, const char *, scf_property_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_pg_get_type(const scf_propertygroup_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_pg_get_underlying_pg(const scf_propertygroup_t *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_pg_handle(const scf_propertygroup_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_pg_to_fmri(const scf_propertygroup_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_pg_update(scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_property_t *
scf_property_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_property_destroy(scf_property_t *)
{
}

ssize_t
scf_property_get_name(const scf_property_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_property_get_value(const scf_property_t *, scf_value_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_property_handle(const scf_property_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_property_is_type(const scf_property_t *, scf_type_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_property_to_fmri(const scf_property_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_property_type(const scf_property_t *, scf_type_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_scope_add_service(const scf_scope_t *, const char *, scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_scope_t *
scf_scope_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_scope_destroy(scf_scope_t *)
{
}

ssize_t
scf_scope_get_name(const scf_scope_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_scope_get_parent(const scf_scope_t *, scf_scope_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_scope_get_service(const scf_scope_t *, const char *, scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_scope_handle(const scf_scope_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_scope_to_fmri(const scf_scope_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_service_add_instance(const scf_service_t *, const char *, scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_service_add_pg(const scf_service_t *, const char *, const char *, uint32_t, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_service_t *
scf_service_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_service_delete(scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_service_destroy(scf_service_t *)
{
}

int
scf_service_get_instance(const scf_service_t *, const char *, scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_service_get_name(const scf_service_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_service_get_parent(const scf_service_t *, scf_scope_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_service_get_pg(const scf_service_t *, const char *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_service_handle(const scf_service_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_service_to_fmri(const scf_service_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

void
scf_simple_app_props_free(scf_simple_app_props_t *)
{
}

scf_simple_app_props_t *
scf_simple_app_props_get(scf_handle_t *, const char *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

const scf_simple_prop_t *
scf_simple_app_props_next(const scf_simple_app_props_t *, scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

const scf_simple_prop_t *
scf_simple_app_props_search(const scf_simple_app_props_t *, const char *, const char *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_simple_prop_free(scf_simple_prop_t *)
{
}

scf_simple_prop_t *
scf_simple_prop_get(scf_handle_t *, const char *, const char *, const char *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

char *
scf_simple_prop_name(const scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

char *
scf_simple_prop_next_astring(scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

uint8_t *
scf_simple_prop_next_boolean(scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

uint64_t *
scf_simple_prop_next_count(scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int64_t *
scf_simple_prop_next_integer(scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void *
scf_simple_prop_next_opaque(scf_simple_prop_t *, size_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_simple_prop_next_reset(scf_simple_prop_t *)
{
}

int64_t *
scf_simple_prop_next_time(scf_simple_prop_t *, int32_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

char *
scf_simple_prop_next_ustring(scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

ssize_t
scf_simple_prop_numvalues(const scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

char *
scf_simple_prop_pgname(const scf_simple_prop_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

scf_type_t
scf_simple_prop_type(const scf_simple_prop_t *)
{
	return (SCF_TYPE_INVALID);
}

int
scf_simple_walk_instances(uint_t, void *, int (*)(scf_handle_t *, scf_instance_t *, void *))
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_snaplevel_t *
scf_snaplevel_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_snaplevel_destroy(scf_snaplevel_t *)
{
}

ssize_t
scf_snaplevel_get_instance_name(const scf_snaplevel_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_snaplevel_get_next_snaplevel(const scf_snaplevel_t *, scf_snaplevel_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_snaplevel_get_parent(const scf_snaplevel_t *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_snaplevel_get_pg(const scf_snaplevel_t *, const char *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_snaplevel_get_scope_name(const scf_snaplevel_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

ssize_t
scf_snaplevel_get_service_name(const scf_snaplevel_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

scf_handle_t *
scf_snaplevel_handle(const scf_snaplevel_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

scf_snapshot_t *
scf_snapshot_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_snapshot_destroy(scf_snapshot_t *)
{
}

int
scf_snapshot_get_base_snaplevel(const scf_snapshot_t *, scf_snaplevel_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_snapshot_get_name(const scf_snapshot_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_snapshot_get_parent(const scf_snapshot_t *, scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
scf_snapshot_handle(const scf_snapshot_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_snapshot_update(scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_transaction_commit(scf_transaction_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_transaction_t *
scf_transaction_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_transaction_destroy(scf_transaction_t *)
{
}

void
scf_transaction_destroy_children(scf_transaction_t *)
{
}

scf_handle_t *
scf_transaction_handle(const scf_transaction_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_transaction_property_change(scf_transaction_t *, scf_transaction_entry_t *, const char *, scf_type_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_transaction_property_change_type(scf_transaction_t *, scf_transaction_entry_t *, const char *, scf_type_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_transaction_property_delete(scf_transaction_t *, scf_transaction_entry_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_transaction_property_new(scf_transaction_t *, scf_transaction_entry_t *, const char *, scf_type_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_transaction_reset(scf_transaction_t *)
{
}

void
scf_transaction_reset_all(scf_transaction_t *)
{
}

int
scf_transaction_start(scf_transaction_t *, scf_propertygroup_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_type_base_type(scf_type_t, scf_type_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_type_t
scf_value_base_type(const scf_value_t *)
{
	return (SCF_TYPE_INVALID);
}

scf_value_t *
scf_value_create(scf_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_value_destroy(scf_value_t *)
{
}

ssize_t
scf_value_get_as_string(const scf_value_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

ssize_t
scf_value_get_as_string_typed(const scf_value_t *, scf_type_t, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

ssize_t
scf_value_get_astring(const scf_value_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_value_get_boolean(const scf_value_t *, uint8_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_value_get_count(const scf_value_t *, uint64_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_value_get_integer(const scf_value_t *, int64_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_value_get_opaque(const scf_value_t *, void *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

int
scf_value_get_time(const scf_value_t *, int64_t *, int32_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

ssize_t
scf_value_get_ustring(const scf_value_t *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

scf_handle_t *
scf_value_handle(const scf_value_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
scf_value_is_type(const scf_value_t *, scf_type_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_value_reset(scf_value_t *)
{
}

int
scf_value_set_astring(scf_value_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_value_set_boolean(scf_value_t *, uint8_t)
{
}

void
scf_value_set_count(scf_value_t *, uint64_t)
{
}

int
scf_value_set_from_string(scf_value_t *, scf_type_t, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_value_set_integer(scf_value_t *, int64_t)
{
}

int
scf_value_set_opaque(scf_value_t *, const void *, size_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_value_set_time(scf_value_t *, int64_t, int32_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_value_set_ustring(scf_value_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_type_t
scf_value_type(const scf_value_t *)
{
	return (SCF_TYPE_INVALID);
}

int
smf_degrade_instance(const char *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_disable_instance(const char *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_enable_instance(const char *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

char *
smf_get_state(const char *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
smf_maintain_instance(const char *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_refresh_instance(const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_restart_instance(const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
smf_restore_instance(const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

/* ===== SUNWprivate_1.1 ===== */

void
_check_services(char **)
{
}

scf_tmpl_errors_t *
_scf_create_errors(const char *, int)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
_scf_get_fma_notify_params(const char *, nvlist_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_get_svc_notify_params(const char *, nvlist_t *, int32_t, int, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_handle_t *
_scf_handle_create_and_bind(scf_version_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
_scf_handle_decorations(scf_handle_t *, scf_decoration_func *, scf_value_t *, void *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_notify_add_pgname(scf_handle_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_notify_add_pgtype(scf_handle_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_notify_get_params(scf_propertygroup_t *, nvlist_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_notify_wait(scf_propertygroup_t *, char *, size_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_pg_is_read_protected(const scf_propertygroup_t *, boolean_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_pg_wait(scf_propertygroup_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

char *
_scf_read_single_astring_from_pg(scf_propertygroup_t *, const char *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

char *
_scf_read_tmpl_prop_type_as_string(const scf_prop_tmpl_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

int
_scf_repository_switch(scf_handle_t *, int)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_request_backup(scf_handle_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
_scf_sanitize_locale(char *)
{
}

int
_scf_set_annotation(scf_handle_t *, const char *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_snapshot_attach(scf_snapshot_t *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_snapshot_delete(scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_snapshot_take_attach(scf_instance_t *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_snapshot_take_new(scf_instance_t *, const char *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_snapshot_take_new_named(scf_instance_t *, const char *, const char *, const char *, scf_snapshot_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_tmpl_add_error(scf_tmpl_errors_t *, scf_tmpl_error_type_t, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_scf_tmpl_error_set_prefix(scf_tmpl_errors_t *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_smf_refresh_all_instances(scf_service_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
_smf_refresh_instance_i(scf_instance_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
gen_filenms_from_fmri(const char *, const char *, char *, char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
ismember(const scf_error_t e, const scf_error_t arr[])
{
	int i;

	for (i = 0; arr[i] != 0; i++) {
		if (arr[i] == e)
			return (1);
	}
	return (0);
}

ssize_t
scf_canonify_fmri(const char *, char *, size_t)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return ((ssize_t)-1);
}

void
scf_clean_propvec(scf_propvec_t *)
{
}

int
scf_cmp_pattern(char *, scf_pattern_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_decode32(const char *, size_t, char *, size_t, size_t *, char)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

#if !defined(NATIVE_BUILD)
int
scf_default_secflags(scf_handle_t *, scf_secflags_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}
#endif

int
scf_encode32(const char *, size_t, char *, size_t, size_t *, char)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_fastreboot_default_set_transient(boolean_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_simple_handle_t *
scf_general_pg_setup(const char *, const char *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

void
scf_get_boot_config(uint8_t *)
{
}

void
scf_get_boot_config_ovr(uint8_t *)
{
}

int
scf_instance_delete_prop(scf_instance_t *, const char *, const char *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_is_compatible_type(scf_type_t, scf_type_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_is_fastboot_default(void)
{
	return (0);
}

int
scf_parse_file_fmri(char *, const char **, const char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_parse_fmri(char *, int *, const char **, const char **, const char **, const char **, const char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_parse_svc_fmri(char *, const char **, const char **, const char **, const char **, const char **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_read_count_property(scf_simple_handle_t *, char *, uint64_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_read_propvec(const char *, const char *, boolean_t, scf_propvec_t *, scf_propvec_t **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

int
scf_set_count_property(scf_transaction_t *, char *, uint64_t, boolean_t)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

void
scf_simple_handle_destroy(scf_simple_handle_t *)
{
}

int
scf_transaction_restart(scf_simple_handle_t *, scf_transaction_t *)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}

scf_transaction_t *
scf_transaction_setup(scf_simple_handle_t *)
{
	(void) scf_set_error(SCF_ERROR_NO_SERVER);
	return (NULL);
}

scf_error_t
scf_walk_fmri(scf_handle_t *, int, char **, int, scf_walk_callback, void *, int *, void (*)(const char *, ...))
{
	return (SCF_ERROR_NO_SERVER);
}

int
scf_write_propvec(const char *, const char *, scf_propvec_t *, scf_propvec_t **)
{
	return (scf_set_error(SCF_ERROR_NO_SERVER));
}
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2013, Joyent, Inc. All rights reserved.
 */

#ifndef	_LIBSCF_IMPL_H
#define	_LIBSCF_IMPL_H

#include <libscf.h>
#include <libscf_priv.h>

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * This macro must be extended if additional FMRI prefixes are defined
 */
#define	SCF_FMRI_PREFIX_MAX_LEN		(sizeof (SCF_FMRI_SVC_PREFIX) > \
					    sizeof (SCF_FMRI_FILE_PREFIX) ? \
					    sizeof (SCF_FMRI_SVC_PREFIX) - 1 : \
					    sizeof (SCF_FMRI_FILE_PREFIX) - 1)

int scf_setup_error(void);
int scf_set_error(scf_error_t);			/* returns -1 */

typedef enum {
	SCF_MSG_ARGTOOLONG,
	SCF_MSG_PATTERN_NOINSTANCE,
	SCF_MSG_PATTERN_NOINSTSVC,
	SCF_MSG_PATTERN_NOSERVICE,
	SCF_MSG_PATTERN_NOENTITY,
	SCF_MSG_PATTERN_MULTIMATCH,
	SCF_MSG_PATTERN_POSSIBLE,
	SCF_MSG_PATTERN_LEGACY,
	SCF_MSG_PATTERN_MULTIPARTIAL
} scf_msg_t;

scf_type_t scf_true_base_type(scf_type_t);
const char *scf_get_msg(scf_msg_t);
int ismember(const scf_error_t, const scf_error_t[]);
int32_t state_from_string(const char *, size_t);

#ifdef	__cplusplus
}
#endif

#endif	/* _LIBSCF_IMPL_H */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef	_LOWLEVEL_IMPL_H
#define	_LOWLEVEL_IMPL_H

#include "libscf_impl.h"

#include <door.h>
#include <libuutil.h>
#include <limits.h>
#include <pthread.h>
#include <stddef.h>

#include <sys/zone.h>

#include "repcache_protocol.h"

#ifdef	__cplusplus
extern "C" {
#endif

typedef struct scf_datael {
	scf_handle_t	*rd_handle;
	uint32_t	rd_entity;
	uint32_t	rd_type;
	uint32_t	rd_reset;
	uu_list_node_t	rd_node;
} scf_datael_t;
#define	DATAEL_VALID		0x0001

/*
 * Handle structure.
 *
 * Access to handles is serialized -- access to and modification of a handle
 * and all of its children is protected by rh_lock.
 *
 * Different handles don't interfere with each other.
 */
struct scf_handle {
	pthread_mutex_t	rh_lock;
	pthread_cond_t	rh_cv;

	uint32_t	rh_nextiter;
	uint32_t	rh_nextentity;
	uint32_t	rh_nextchangeid;

	int		rh_doorfd;
	int		rh_doorfd_old;	/* fd to close once rh_fd_users == 0 */
	door_id_t	rh_doorid;
	pid_t		rh_doorpid;	/* pid at bind time */

	uid_t		rh_uid;
	uint32_t	rh_debug;
	uint32_t	rh_flags;	/* HANDLE_*, below */
	uint32_t	rh_fd_users;	/* non-locked users of rh_doorfd */

	uu_list_t	*rh_dataels;
	uu_list_t	*rh_iters;
	long		rh_entries;
	long		rh_values;

	long		rh_extrefs;	/* user-created subhandle count */
	long		rh_intrefs;	/* handle-internal subhandle count */

	char		rh_doorpath[PATH_MAX + 1];
	zoneid_t	rh_zoneid;	/* expected zone ID for door server */

	pthread_t	rh_holder;		/* thread using subhandles */
	uint32_t	rh_hold_flags;		/* which are in use */

	scf_iter_t		*rh_iter;
	scf_scope_t		*rh_scope;
	scf_service_t		*rh_service;
	scf_instance_t		*rh_instance;
	scf_snapshot_t		*rh_snapshot;
	scf_snaplevel_t		*rh_snaplvl;
	scf_propertygroup_t	*rh_pg;
	scf_property_t		*rh_property;
	scf_value_t		*rh_value;
};
#define	HANDLE_DEAD		0x0001
#define	HANDLE_UNREFED		0x0002
#define	HANDLE_WRAPPED_ENTITY	0x0004
#define	HANDLE_WRAPPED_ITER	0x0008

#define	RH_HOLD_ITER		0x0001
#define	RH_HOLD_SCOPE		0x0002
#define	RH_HOLD_SERVICE		0x0004
#define	RH_HOLD_INSTANCE	0x0008
#define	RH_HOLD_SNAPSHOT	0x0010
#define	RH_HOLD_SNAPLVL		0x0020
#define	RH_HOLD_PG		0x0040
#define	RH_HOLD_PROPERTY	0x0080
#define	RH_HOLD_VALUE		0x0100

#define	RH_HOLD_ALL		0x01ff

struct scf_scope {
	scf_datael_t	rd_d;
};

struct scf_service {
	scf_datael_t	rd_d;
};

struct scf_instance {
	scf_datael_t	rd_d;
};

struct scf_snapshot {
	scf_datael_t	rd_d;
};

/*
 * note: be careful of adding more state here -- snaplevel_next() relies on
 * the fact that the entityid is the only library-level state.
 */
struct scf_snaplevel {
	scf_datael_t	rd_d;
};

struct scf_propertygroup {
	scf_datael_t	rd_d;
};

struct scf_property {
	scf_datael_t	rd_d;
};

struct scf_value {
	scf_handle_t		*value_handle;
	scf_value_t		*value_next;
	scf_transaction_entry_t	*value_tx;

	rep_protocol_value_type_t value_type;
	size_t			value_size;	/* only for opaque values */
	char			value_value[REP_PROTOCOL_VALUE_LEN];
};

enum scf_entry_state {
	ENTRY_STATE_INVALID,
	ENTRY_STATE_IN_TX_ACTION
};
struct scf_transaction_entry {
	const char	*entry_property;
	scf_handle_t	*entry_handle;
	scf_transaction_t *entry_tx;
	enum scf_entry_state entry_state;
	uu_list_node_t	entry_link;		/* for property name list */

	scf_value_t	*entry_head;
	scf_value_t	*entry_tail;		/* for linked values */

	enum rep_protocol_transaction_action	entry_action;
	rep_protocol_value_type_t		entry_type;
	char		entry_namebuf[REP_PROTOCOL_NAME_LEN];
};

enum scf_tx_state {
	TRAN_STATE_NEW,
	TRAN_STATE_SETUP,
	TRAN_STATE_COMMITTED
};

struct scf_transaction {
	enum scf_tx_state	tran_state;
	scf_propertygroup_t	tran_pg;
	int			tran_invalid;
	uu_list_t		*tran_props;
};

struct scf_iter {
	scf_handle_t	*iter_handle;
	int		iter_type;
	uint32_t	iter_id;
	uint32_t	iter_sequence;
	uu_list_node_t	iter_node;
};

#ifdef	__cplusplus
}
#endif

#endif	/* _LOWLEVEL_IMPL_H */
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License (the "License").
# You may not use this file except in compliance with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved.
# Copyright 2020 Joyent, Inc.
#

#
# MAPFILE HEADER START
#
# WARNING:  STOP NOW.  DO NOT MODIFY THIS FILE.
# Object versioning must comply with the rules detailed in
#
#	usr/src/lib/README.mapfiles
#
# You should not be making modifications here until you've read the most current
# copy of that file. If you need help, contact a gatekeeper for guidance.
#
# MAPFILE HEADER END
#

$mapfile_version 2

SYMBOL_VERSION ILLUMOS_0.2 {
    global:
	smf_refresh_all_instances;
	smf_enable_instance_by_instance;
	smf_disable_instance_by_instance;
	smf_refresh_instance_by_instance;
	smf_restart_instance_by_instance;
	smf_maintain_instance_by_instance;
	smf_degrade_instance_by_instance;
	smf_restore_instance_by_instance;
	smf_get_state_by_instance;
} ILLUMOS_0.1;

SYMBOL_VERSION ILLUMOS_0.1 {
    global:
	smf_disable_instance_with_comment;
} SUNW_1.2;

SYMBOL_VERSION SUNW_1.2 {
    global:
        scf_count_ranges_destroy;
	scf_int_ranges_destroy;
	scf_string_to_type;
	scf_tmpl_error_pg;
	scf_tmpl_error_pg_tmpl;
	scf_tmpl_error_prop;
	scf_tmpl_error_prop_tmpl;
	scf_tmpl_error_type;
	scf_tmpl_error_value;
	scf_tmpl_errors_destroy;
	scf_tmpl_get_by_pg;
	scf_tmpl_get_by_prop;
	scf_tmpl_get_by_pg_name;
	scf_tmpl_iter_pgs;
	scf_tmpl_iter_props;
	scf_tmpl_next_error;
	scf_tmpl_pg_common_name;
	scf_tmpl_pg_create;
	scf_tmpl_pg_description;
	scf_tmpl_pg_destroy;
	scf_tmpl_pg_name;
	scf_tmpl_pg_required;
	scf_tmpl_pg_reset;
	scf_tmpl_pg_target;
	scf_tmpl_pg_type;
	scf_tmpl_prop_cardinality;
	scf_tmpl_prop_common_name;
	scf_tmpl_prop_create;
	scf_tmpl_prop_description;
	scf_tmpl_prop_destroy;
	scf_tmpl_prop_internal_seps;
	scf_tmpl_prop_name;
	scf_tmpl_prop_required;
	scf_tmpl_prop_reset;
	scf_tmpl_prop_type;
	scf_tmpl_prop_units;
	scf_tmpl_prop_visibility;
	scf_tmpl_reset_errors;
	scf_tmpl_strerror;
	scf_tmpl_validate_fmri;
	scf_tmpl_value_common_name;
	scf_tmpl_value_count_range_choices;
	scf_tmpl_value_count_range_constraints;
	scf_tmpl_value_description;
	scf_tmpl_value_in_constraint;
	scf_tmpl_value_int_range_constraints;
	scf_tmpl_value_name_choices;
	scf_tmpl_value_name_constraints;
	scf_tmpl_value_int_range_choices;
	scf_tmpl_visibility_to_string;
	scf_type_to_string;
	scf_values_destroy;
	smf_notify_del_params;
	smf_notify_get_params;
	smf_notify_set_params;
	smf_state_from_string;
	smf_state_to_string;
} SUNW_1.1;

SYMBOL_VERSION SUNW_1.1 {
    global:
	scf_entry_add_value;
	scf_entry_create;
	scf_entry_destroy;
	scf_entry_destroy_children;
	scf_entry_handle;
	scf_entry_reset;
	scf_error;
	scf_handle_bind;
	scf_handle_create;
	scf_handle_decode_fmri;
	scf_handle_decorate;
	scf_handle_destroy;
	scf_handle_get_scope;
	scf_handle_unbind;
	scf_instance_add_pg;
	scf_instance_create;
	scf_instance_delete;
	scf_instance_destroy;
	scf_instance_get_name;
	scf_instance_get_parent;
	scf_instance_get_pg;
	scf_instance_get_pg_composed;
	scf_instance_get_snapshot;
	scf_instance_handle;
	scf_instance_to_fmri;
	scf_iter_create;
	scf_iter_destroy;
	scf_iter_handle;
	scf_iter_handle_scopes;
	scf_iter_instance_pgs;
	scf_iter_instance_pgs_composed;
	scf_iter_instance_pgs_typed;
	scf_iter_instance_pgs_typed_composed;
	scf_iter_instance_snapshots;
	scf_iter_next_instance;
	scf_iter_next_pg;
	scf_iter_next_property;
	scf_iter_next_scope;
	scf_iter_next_service;
	scf_iter_next_snapshot;
	scf_iter_next_value;
	scf_iter_pg_properties;
	scf_iter_property_values;
	scf_iter_reset;
	scf_iter_scope_services;
	scf_iter_service_instances;
	scf_iter_service_pgs;
	scf_iter_service_pgs_typed;
	scf_iter_snaplevel_pgs;
	scf_iter_snaplevel_pgs_typed;
	scf_limit;
	scf_myname;
	scf_pg_create;
	scf_pg_delete;
	scf_pg_destroy;
	scf_pg_get_flags;
	scf_pg_get_name;
	scf_pg_get_parent_instance;
	scf_pg_get_parent_service;
	scf_pg_get_parent_snaplevel;
	scf_pg_get_property;
	scf_pg_get_type;
	scf_pg_get_underlying_pg;
	scf_pg_handle;
	scf_pg_to_fmri;
	scf_pg_update;
	scf_property_create;
	scf_property_destroy;
	scf_property_get_name;
	scf_property_get_value;
	scf_property_handle;
	scf_property_is_type;
	scf_property_to_fmri;
	scf_property_type;
	scf_scope_add_service;
	scf_scope_create;
	scf_scope_destroy;
	scf_scope_get_name;
	scf_scope_get_parent;
	scf_scope_get_service;
	scf_scope_handle;
	scf_scope_to_fmri;
	scf_service_add_instance;
	scf_service_add_pg;
	scf_service_create;
	scf_service_delete;
	scf_service_destroy;
	scf_service_get_instance;
	scf_service_get_name;
	scf_service_get_parent;
	scf_service_get_pg;
	scf_service_handle;
	scf_service_to_fmri;
	scf_simple_app_props_free;
	scf_simple_app_props_get;
	scf_simple_app_props_next;
	scf_simple_app_props_search;
	scf_simple_prop_free;
	scf_simple_prop_get;
	scf_simple_prop_name;
	scf_simple_prop_next_astring;
	scf_simple_prop_next_boolean;
	scf_simple_prop_next_count;
	scf_simple_prop_next_integer;
	scf_simple_prop_next_opaque;
	scf_simple_prop_next_reset;
	scf_simple_prop_next_time;
	scf_simple_prop_next_ustring;
	scf_simple_prop_numvalues;
	scf_simple_prop_pgname;
	scf_simple_prop_type;
	scf_simple_walk_instances;
	scf_snaplevel_create;
	scf_snaplevel_destroy;
	scf_snaplevel_get_instance_name;
	scf_snaplevel_get_next_snaplevel;
	scf_snaplevel_get_parent;
	scf_snaplevel_get_pg;
	scf_snaplevel_get_scope_name;
	scf_snaplevel_get_service_name;
	scf_snaplevel_handle;
	scf_snapshot_create;
	scf_snapshot_destroy;
	scf_snapshot_get_base_snaplevel;
	scf_snapshot_get_name;
	scf_snapshot_get_parent;
	scf_snapshot_handle;
	scf_snapshot_update;
	scf_strerror;
	scf_transaction_commit;
	scf_transaction_create;
	scf_transaction_destroy;
	scf_transaction_destroy_children;
	scf_transaction_handle;
	scf_transaction_property_change;
	scf_transaction_property_change_type;
	scf_transaction_property_delete;
	scf_transaction_property_new;
	scf_transaction_reset;
	scf_transaction_reset_all;
	scf_transaction_start;
	scf_type_base_type;
	scf_value_base_type;
	scf_value_create;
	scf_value_destroy;
	scf_value_get_as_string;
	scf_value_get_as_string_typed;
	scf_value_get_astring;
	scf_value_get_boolean;
	scf_value_get_count;
	scf_value_get_integer;
	scf_value_get_opaque;
	scf_value_get_time;
	scf_value_get_ustring;
	scf_value_handle;
	scf_value_is_type;
	scf_value_reset;
	scf_value_set_astring;
	scf_value_set_boolean;
	scf_value_set_count;
	scf_value_set_from_string;
	scf_value_set_integer;
	scf_value_set_opaque;
	scf_value_set_time;
	scf_value_set_ustring;
	scf_value_type;
	smf_degrade_instance;
	smf_disable_instance;
	smf_enable_instance;
	smf_get_state;
	smf_maintain_instance;
	smf_refresh_instance;
	smf_restart_instance;
	smf_restore_instance;
};

SYMBOL_VERSION SUNWprivate_1.1 {
    global:
	gen_filenms_from_fmri;
	ismember;
	scf_canonify_fmri;
	scf_cmp_pattern;
	_scf_create_errors;
        scf_decode32;
	scf_encode32;
	scf_general_pg_setup;
	_scf_get_fma_notify_params;
	_scf_get_svc_notify_params;
	_scf_handle_decorations;
	scf_is_compatible_type;
	_scf_notify_add_pgname;
	_scf_notify_add_pgtype;
	_scf_notify_get_params;
	_scf_notify_wait;
	scf_parse_file_fmri;
	scf_parse_fmri;
	scf_parse_svc_fmri;
	_scf_pg_is_read_protected;
	_scf_pg_wait;
	scf_read_count_property;
	_scf_read_single_astring_from_pg;
	_scf_read_tmpl_prop_type_as_string;
	_scf_repository_switch;
	_scf_request_backup;
	_scf_sanitize_locale;
	_scf_set_annotation;
	scf_set_count_property;
	scf_simple_handle_destroy;
	_scf_snapshot_attach;
	_scf_snapshot_delete;
	_scf_snapshot_take_attach;
	_scf_snapshot_take_new;
	_scf_snapshot_take_new_named;
	_scf_tmpl_add_error;
	_scf_tmpl_error_set_prefix;
	scf_transaction_setup;
	scf_transaction_restart;
	scf_walk_fmri;
	_smf_refresh_instance_i;
	scf_read_propvec;
	scf_write_propvec;
	scf_clean_propvec;
	scf_instance_delete_prop;
	scf_get_boot_config;
	scf_get_boot_config_ovr;
	scf_is_fastboot_default;
	scf_fastreboot_default_set_transient;
	scf_default_secflags;
	_check_services;
	_scf_handle_create_and_bind;
    local:
	*;
};
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef	_MIDLEVEL_IMPL_H
#define	_MIDLEVEL_IMPL_H

#include "libscf_impl.h"

#ifdef	__cplusplus
extern "C" {
#endif

union scf_simple_prop_val {
	uint8_t		pv_bool;
	uint64_t	pv_uint;
	int64_t		pv_int;
	char 		*pv_str;
	struct pv_time {
		int64_t	t_sec;
		int32_t	t_nsec;
	} pv_time;
	struct pv_opaque {
		void 	*o_value;
		size_t	o_size;
	} pv_opaque;
};

struct scf_simple_prop {
	uint32_t			pr_numvalues;
	uint32_t			pr_iter;
	scf_type_t			pr_type;
	char				*pr_propname;
	char				*pr_pgname;
	union scf_simple_prop_val	*pr_vallist;
	scf_simple_prop_t		*pr_next;
	struct scf_simple_pg		*pr_pg;
};

struct scf_simple_pg {
	char			*pg_name;
	scf_simple_prop_t	*pg_proplist;
	struct scf_simple_pg	*pg_next;
};

struct scf_simple_app_props {
	char 			*ap_fmri;
	struct scf_simple_pg	*ap_pglist;
};

#ifdef	__cplusplus
}
#endif

#endif	/* _MIDLEVEL_IMPL_H */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef	_SCF_TYPE_H
#define	_SCF_TYPE_H

#include <repcache_protocol.h>

#ifdef	__cplusplus
extern "C" {
#endif

int scf_validate_encoded_value(rep_protocol_value_type_t, const char *);

rep_protocol_value_type_t scf_proto_underlying_type(rep_protocol_value_type_t);

int scf_is_compatible_protocol_type(rep_protocol_value_type_t,
    rep_protocol_value_type_t);

#ifdef	__cplusplus
}
#endif

#endif	/* _SCF_TYPE_H */
#!/bin/sh
#
# CDDL HEADER START
#
# The contents of this file are subject to the terms of the
# Common Development and Distribution License, Version 1.0 only
# (the "License").  You may not use this file except in compliance
# with the License.
#
# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
# or http://www.opensolaris.org/os/licensing.
# See the License for the specific language governing permissions
# and limitations under the License.
#
# When distributing Covered Code, include this CDDL HEADER in each
# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
# If applicable, add the following below this CDDL HEADER, with the
# fields enclosed by brackets "[]" replaced with your own identifying
# information: Portions Copyright [yyyy] [name of copyright owner]
#
# CDDL HEADER END
#
#
# Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
# Use is subject to license terms.
#
# ident	"%Z%%M%	%I%	%E% SMI"
#

find_files "s.*" usr/src/common/svc
find_files "s.*" usr/src/lib/libuutil

exec_file usr/src/lib/libuutil/inc.flg
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2016 RackTop Systems.
 * Copyright 2020 Joyent, Inc.
 * Copyright 2026 Oxide Computer Company
 */

#ifndef	_LIBSCF_H
#define	_LIBSCF_H


#include <stddef.h>
#include <libnvpair.h>

#ifndef NATIVE_BUILD
#include <sys/secflags.h>
#endif	/* NATIVE_BUILD */
#include <sys/types.h>

#ifdef	__cplusplus
extern "C" {
#endif

typedef unsigned long scf_version_t;
#define	SCF_VERSION		1UL

/*
 * Opaque structures
 */
typedef struct scf_handle scf_handle_t;
typedef struct scf_scope scf_scope_t;
typedef struct scf_service scf_service_t;
typedef struct scf_instance scf_instance_t;
typedef struct scf_propertygroup scf_propertygroup_t;
typedef struct scf_property scf_property_t;

typedef struct scf_snapshot scf_snapshot_t;
typedef struct scf_snaplevel scf_snaplevel_t;

typedef struct scf_transaction scf_transaction_t;
typedef struct scf_transaction_entry scf_transaction_entry_t;
typedef struct scf_value scf_value_t;

typedef struct scf_iter scf_iter_t;

typedef struct scf_pg_tmpl scf_pg_tmpl_t;
typedef struct scf_prop_tmpl scf_prop_tmpl_t;
typedef struct scf_tmpl_errors scf_tmpl_errors_t;

typedef struct scf_simple_app_props scf_simple_app_props_t;
typedef struct scf_simple_prop scf_simple_prop_t;

/*
 * Types
 */
typedef enum {
	SCF_TYPE_INVALID = 0,

	SCF_TYPE_BOOLEAN,
	SCF_TYPE_COUNT,
	SCF_TYPE_INTEGER,
	SCF_TYPE_TIME,
	SCF_TYPE_ASTRING,
	SCF_TYPE_OPAQUE,

	SCF_TYPE_USTRING = 100,

	SCF_TYPE_URI = 200,
	SCF_TYPE_FMRI,

	SCF_TYPE_HOST = 300,
	SCF_TYPE_HOSTNAME,
	SCF_TYPE_NET_ADDR_V4,
	SCF_TYPE_NET_ADDR_V6,
	SCF_TYPE_NET_ADDR
} scf_type_t;

/*
 * Values returned by scf_type_to_string
 */
#define	SCF_TYPE_STRING_BOOLEAN		"boolean"
#define	SCF_TYPE_STRING_COUNT		"count"
#define	SCF_TYPE_STRING_INTEGER		"integer"
#define	SCF_TYPE_STRING_TIME		"time"
#define	SCF_TYPE_STRING_ASTRING		"astring"
#define	SCF_TYPE_STRING_OPAQUE		"opaque"
#define	SCF_TYPE_STRING_USTRING		"ustring"
#define	SCF_TYPE_STRING_URI		"uri"
#define	SCF_TYPE_STRING_FMRI		"fmri"
#define	SCF_TYPE_STRING_HOST		"host"
#define	SCF_TYPE_STRING_HOSTNAME	"hostname"
#define	SCF_TYPE_STRING_NET_ADDR	"net_address"
#define	SCF_TYPE_STRING_NET_ADDR_V4	"net_address_v4"
#define	SCF_TYPE_STRING_NET_ADDR_V6	"net_address_v6"

typedef struct scf_time {
	int64_t		t_seconds;
	int32_t		t_ns;
} scf_time_t;

/*
 * There is no explicit initializer for this structure.  Functions
 * which set or populate this structure assume that it is either
 * uninitialized or destroyed.
 */
typedef struct scf_values {
	scf_type_t		value_type;
	void			*reserved;	/* reserved for future use */
	int			value_count;
	char			**values_as_strings;
	union {
		uint64_t	*v_count;
		uint8_t		*v_boolean;
		int64_t		*v_integer;
		char		**v_astring;
		char		**v_ustring;
		char		**v_opaque;
		scf_time_t	*v_time;
	} values;
} scf_values_t;

typedef struct scf_count_ranges {
	int		scr_num_ranges;
	uint64_t	*scr_min;
	uint64_t	*scr_max;
} scf_count_ranges_t;

typedef struct scf_int_ranges {
	int		sir_num_ranges;
	int64_t		*sir_min;
	int64_t		*sir_max;
} scf_int_ranges_t;

/*
 * Return codes
 */
#define	SCF_SUCCESS			0
#define	SCF_COMPLETE			1
#define	SCF_FAILED			-1

typedef enum scf_error {
	SCF_ERROR_NONE = 1000,		/* no error */
	SCF_ERROR_NOT_BOUND,		/* handle not bound */
	SCF_ERROR_NOT_SET,		/* cannot use unset argument */
	SCF_ERROR_NOT_FOUND,		/* nothing of that name found */
	SCF_ERROR_TYPE_MISMATCH,	/* type does not match value */
	SCF_ERROR_IN_USE,		/* cannot modify while in-use */
	SCF_ERROR_CONNECTION_BROKEN,	/* repository connection gone */
	SCF_ERROR_INVALID_ARGUMENT,	/* bad argument */
	SCF_ERROR_NO_MEMORY,		/* no memory available */
	SCF_ERROR_CONSTRAINT_VIOLATED,	/* required constraint not met */
	SCF_ERROR_EXISTS,		/* object already exists */
	SCF_ERROR_NO_SERVER,		/* repository server unavailable */
	SCF_ERROR_NO_RESOURCES,		/* server has insufficient resources */
	SCF_ERROR_PERMISSION_DENIED,	/* insufficient privileges for action */
	SCF_ERROR_BACKEND_ACCESS,	/* backend refused access */
	SCF_ERROR_HANDLE_MISMATCH,	/* mismatched SCF handles */
	SCF_ERROR_HANDLE_DESTROYED,	/* object bound to destroyed handle */
	SCF_ERROR_VERSION_MISMATCH,	/* incompatible SCF version */
	SCF_ERROR_BACKEND_READONLY,	/* backend is read-only */
	SCF_ERROR_DELETED,		/* object has been deleted */
	SCF_ERROR_TEMPLATE_INVALID,	/* template data is invalid */

	SCF_ERROR_CALLBACK_FAILED = 1080, /* user callback function failed */

	SCF_ERROR_INTERNAL = 1101	/* internal error */
} scf_error_t;

/*
 * This enum MUST be kept in sync with
 * struct _scf_tmpl_error_desc em_desc() in scf_tmpl.c
 */
typedef enum scf_tmpl_error_type {
	SCF_TERR_MISSING_PG,		/* property group missing */
	SCF_TERR_WRONG_PG_TYPE,		/* property group type incorrect */
	SCF_TERR_MISSING_PROP,		/* missing required property */
	SCF_TERR_WRONG_PROP_TYPE,	/* property type incorrect */
	SCF_TERR_CARDINALITY_VIOLATION,	/* wrong number of values */
	SCF_TERR_VALUE_CONSTRAINT_VIOLATED, /* constraint violated for value */
	SCF_TERR_RANGE_VIOLATION,	/* value violated specified range */
	SCF_TERR_PG_REDEFINE,		/* global or restarter pg_pattern */
					/* redefined by the instance */
	SCF_TERR_PROP_TYPE_MISMATCH,	/* property and value type mismatch */
	SCF_TERR_VALUE_OUT_OF_RANGE,	/* value is out of range in template */
	SCF_TERR_INVALID_VALUE,		/* value is not valid for the */
					/* template */
	SCF_TERR_PG_PATTERN_CONFLICT,	/* pg_pattern conflicts with higher */
					/* level definition */
	SCF_TERR_PROP_PATTERN_CONFLICT,	/* prop_pattern conflicts with higher */
					/* level definition */
	SCF_TERR_GENERAL_REDEFINE,	/* global or restarter template */
					/* redefined */
	SCF_TERR_INCLUDE_VALUES,	/* No supporting constraints or */
					/* values for include_values */
	SCF_TERR_PG_PATTERN_INCOMPLETE,	/* Required pg_pattern is missing */
					/* name or type attribute. */
	SCF_TERR_PROP_PATTERN_INCOMPLETE    /* Required prop_pattern is */
					    /* missing a type attribute. */
} scf_tmpl_error_type_t;

typedef struct scf_tmpl_error scf_tmpl_error_t;

/*
 * This unfortunately needs to be public, because consumers of librestart must
 * deal with it
 */
typedef struct {
#ifndef NATIVE_BUILD
	secflagdelta_t ss_default;
	secflagdelta_t ss_lower;
	secflagdelta_t ss_upper;
#else
	/*
	 * This is never used, but is necessary for bootstrapping.
	 * Not even the size matters.
	 */
	void *ss_default;
	void *ss_lower;
	void *ss_upper;
#endif /* NATIVE_BUILD */
} scf_secflags_t;

/*
 * scf_tmpl_strerror() human readable flag
 */
#define	SCF_TMPL_STRERROR_HUMAN	0x1

/*
 * Standard services
 */
#define	SCF_SERVICE_CONFIGD	"svc:/system/svc/repository:default"
#define	SCF_INSTANCE_GLOBAL	"svc:/system/svc/global:default"
#define	SCF_SERVICE_GLOBAL	"svc:/system/svc/global"
#define	SCF_SERVICE_STARTD	"svc:/system/svc/restarter:default"
#define	SCF_INSTANCE_EMI	"svc:/system/early-manifest-import:default"
#define	SCF_INSTANCE_FS_MINIMAL	"svc:/system/filesystem/minimal:default"
#define	SCF_INSTANCE_MI		"svc:/system/manifest-import:default"

/*
 * Major milestones
 */
#define	SCF_MILESTONE_SINGLE_USER	"svc:/milestone/single-user:default"
#define	SCF_MILESTONE_MULTI_USER	"svc:/milestone/multi-user:default"
#define	SCF_MILESTONE_MULTI_USER_SERVER \
	"svc:/milestone/multi-user-server:default"

/*
 * standard scope names
 */
#define	SCF_SCOPE_LOCAL			"localhost"

/*
 * Property group types
 */
#define	SCF_GROUP_APPLICATION		"application"
#define	SCF_GROUP_FRAMEWORK		"framework"
#define	SCF_GROUP_DEPENDENCY		"dependency"
#define	SCF_GROUP_METHOD		"method"
#define	SCF_GROUP_TEMPLATE		"template"
#define	SCF_GROUP_TEMPLATE_PG_PATTERN	"template_pg_pattern"
#define	SCF_GROUP_TEMPLATE_PROP_PATTERN	"template_prop_pattern"

/*
 * Dependency types
 */
#define	SCF_DEP_REQUIRE_ALL		"require_all"
#define	SCF_DEP_REQUIRE_ANY		"require_any"
#define	SCF_DEP_EXCLUDE_ALL		"exclude_all"
#define	SCF_DEP_OPTIONAL_ALL		"optional_all"

#define	SCF_DEP_RESET_ON_ERROR		"error"
#define	SCF_DEP_RESET_ON_RESTART	"restart"
#define	SCF_DEP_RESET_ON_REFRESH	"refresh"
#define	SCF_DEP_RESET_ON_NONE		"none"

/*
 * Standard property group names
 */
#define	SCF_PG_GENERAL			"general"
#define	SCF_PG_GENERAL_OVR		"general_ovr"
#define	SCF_PG_RESTARTER		"restarter"
#define	SCF_PG_RESTARTER_ACTIONS	"restarter_actions"
#define	SCF_PG_METHOD_CONTEXT		"method_context"
#define	SCF_PG_APP_DEFAULT		"application"
#define	SCF_PG_DEPENDENTS		"dependents"
#define	SCF_PG_OPTIONS			"options"
#define	SCF_PG_OPTIONS_OVR		"options_ovr"
#define	SCF_PG_STARTD			"startd"
#define	SCF_PG_STARTD_PRIVATE		"svc-startd-private"
#define	SCF_PG_DEATHROW			"deathrow"
#define	SCF_PG_MANIFESTFILES		"manifestfiles"

/*
 * Template property group names and prefixes
 */
#define	SCF_PG_TM_COMMON_NAME		"tm_common_name"
#define	SCF_PG_TM_DESCRIPTION		"tm_description"

#define	SCF_PG_TM_MAN_PREFIX		"tm_man_"
#define	SCF_PG_TM_DOC_PREFIX		"tm_doc_"

/*
 * Standard property names
 */
#define	SCF_PROPERTY_ACTIVE_POSTFIX		"active"
#define	SCF_PROPERTY_AUX_STATE			"auxiliary_state"
#define	SCF_PROPERTY_AUX_FMRI			"auxiliary_fmri"
#define	SCF_PROPERTY_AUX_TTY			"auxiliary_tty"
#define	SCF_PROPERTY_COMMENT			"comment"
#define	SCF_PROPERTY_CONTRACT			"contract"
#define	SCF_PROPERTY_COREFILE_PATTERN		"corefile_pattern"
#define	SCF_PROPERTY_DEGRADED			"degraded"
#define	SCF_PROPERTY_DEGRADE_IMMEDIATE		"degrade_immediate"
#define	SCF_PROPERTY_DODUMP			"do_dump"
#define	SCF_PROPERTY_DURATION			"duration"
#define	SCF_PROPERTY_ENABLED			"enabled"
#define	SCF_PROPERTY_DEATHROW			"deathrow"
#define	SCF_PROPERTY_ENTITY_STABILITY		"entity_stability"
#define	SCF_PROPERTY_ENTITIES			"entities"
#define	SCF_PROPERTY_EXEC			"exec"
#define	SCF_PROPERTY_GROUP			"group"
#define	SCF_PROPERTY_GROUPING			"grouping"
#define	SCF_PROPERTY_IGNORE			"ignore_error"
#define	SCF_PROPERTY_INTERNAL_SEPARATORS	"internal_separators"
#define	SCF_PROPERTY_LIMIT_PRIVILEGES		"limit_privileges"
#define	SCF_PROPERTY_MAINT_OFF			"maint_off"
#define	SCF_PROPERTY_MAINT_ON			"maint_on"
#define	SCF_PROPERTY_MAINT_ON_IMMEDIATE		"maint_on_immediate"
#define	SCF_PROPERTY_MAINT_ON_IMMTEMP		"maint_on_immtemp"
#define	SCF_PROPERTY_MAINT_ON_TEMPORARY		"maint_on_temporary"
#define	SCF_PROPERTY_METHOD_PID			"method_pid"
#define	SCF_PROPERTY_MILESTONE			"milestone"
#define	SCF_PROPERTY_NEED_SESSION		"need_session"
#define	SCF_PROPERTY_NEXT_STATE			"next_state"
#define	SCF_PROPERTY_PACKAGE			"package"
#define	SCF_PROPERTY_PRIVILEGES			"privileges"
#define	SCF_PROPERTY_PROFILE			"profile"
#define	SCF_PROPERTY_PROJECT			"project"
#define	SCF_PROPERTY_REFRESH			"refresh"
#define	SCF_PROPERTY_RESOURCE_POOL		"resource_pool"
#define	SCF_PROPERTY_ENVIRONMENT		"environment"
#define	SCF_PROPERTY_RESTART			"restart"
#define	SCF_PROPERTY_RESTARTER			"restarter"
#define	SCF_PROPERTY_RESTART_INTERVAL		"restart_interval"
#define	SCF_PROPERTY_RESTART_ON			"restart_on"
#define	SCF_PROPERTY_RESTORE			"restore"
#define	SCF_PROPERTY_SECFLAGS			"security_flags"
#define	SCF_PROPERTY_SINGLE_INSTANCE		"single_instance"
#define	SCF_PROPERTY_START_METHOD_TIMESTAMP	"start_method_timestamp"
#define	SCF_PROPERTY_START_METHOD_WAITSTATUS	"start_method_waitstatus"
#define	SCF_PROPERTY_START_PID			"start_pid"
#define	SCF_PROPERTY_STATE			"state"
#define	SCF_PROPERTY_STABILITY			"stability"
#define	SCF_PROPERTY_STATE_TIMESTAMP		"state_timestamp"
#define	SCF_PROPERTY_SUPP_GROUPS		"supp_groups"
#define	SCF_PROPERTY_TIMEOUT			"timeout_seconds"
#define	SCF_PROPERTY_TIMEOUT_RETRY		"timeout_retry"
#define	SCF_PROPERTY_TRANSIENT_CONTRACT		"transient_contract"
#define	SCF_PROPERTY_TYPE			"type"
#define	SCF_PROPERTY_USE_PROFILE		"use_profile"
#define	SCF_PROPERTY_USER			"user"
#define	SCF_PROPERTY_UTMPX_PREFIX		"utmpx_prefix"
#define	SCF_PROPERTY_WORKING_DIRECTORY		"working_directory"

/*
 * Template property names
 */
#define	SCF_PROPERTY_TM_CARDINALITY_MIN		"cardinality_min"
#define	SCF_PROPERTY_TM_CARDINALITY_MAX		"cardinality_max"
#define	SCF_PROPERTY_TM_CHOICES_INCLUDE_VALUES	"choices_include_values"
#define	SCF_PROPERTY_TM_CHOICES_NAME		"choices_name"
#define	SCF_PROPERTY_TM_CHOICES_RANGE		"choices_range"
#define	SCF_PROPERTY_TM_CONSTRAINT_NAME		"constraint_name"
#define	SCF_PROPERTY_TM_CONSTRAINT_RANGE	"constraint_range"
#define	SCF_PROPERTY_TM_MANPATH			"manpath"
#define	SCF_PROPERTY_TM_NAME			"name"
#define	SCF_PROPERTY_TM_PG_PATTERN		"pg_pattern"
#define	SCF_PROPERTY_TM_REQUIRED		"required"
#define	SCF_PROPERTY_TM_SECTION			"section"
#define	SCF_PROPERTY_TM_TARGET			"target"
#define	SCF_PROPERTY_TM_TITLE			"title"
#define	SCF_PROPERTY_TM_TYPE			"type"
#define	SCF_PROPERTY_TM_URI			"uri"
#define	SCF_PROPERTY_TM_VALUE_PREFIX		"value_"
#define	SCF_PROPERTY_TM_VALUES_NAME		"values_name"
#define	SCF_PROPERTY_TM_VISIBILITY		"visibility"
#define	SCF_PROPERTY_TM_COMMON_NAME_PREFIX	"common_name_"
#define	SCF_PROPERTY_TM_DESCRIPTION_PREFIX	"description_"
#define	SCF_PROPERTY_TM_UNITS_PREFIX		"units_"

/*
 * Templates wildcard string
 */
#define	SCF_TMPL_WILDCARD		"*"

/*
 * Strings used by restarters for state and next_state properties.
 * MAX_SCF_STATE_STRING holds the max length of a state string, including the
 * terminating null.
 */

#define	MAX_SCF_STATE_STRING_SZ		14

#define	SCF_STATE_STRING_NONE		"none"
#define	SCF_STATE_STRING_UNINIT		"uninitialized"
#define	SCF_STATE_STRING_MAINT		"maintenance"
#define	SCF_STATE_STRING_OFFLINE	"offline"
#define	SCF_STATE_STRING_DISABLED	"disabled"
#define	SCF_STATE_STRING_ONLINE		"online"
#define	SCF_STATE_STRING_DEGRADED	"degraded"
#define	SCF_STATE_STRING_LEGACY		"legacy_run"

#define	SCF_STATE_UNINIT		0x00000001
#define	SCF_STATE_MAINT			0x00000002
#define	SCF_STATE_OFFLINE		0x00000004
#define	SCF_STATE_DISABLED		0x00000008
#define	SCF_STATE_ONLINE		0x00000010
#define	SCF_STATE_DEGRADED		0x00000020
#define	SCF_STATE_ALL			0x0000003F

/*
 * software fma svc-transition class
 */
#define	SCF_NOTIFY_PARAMS_VERSION	0X0
#define	SCF_NOTIFY_NAME_FMRI		"fmri"
#define	SCF_NOTIFY_NAME_VERSION		"version"
#define	SCF_NOTIFY_NAME_TSET		"tset"
#define	SCF_NOTIFY_PG_POSTFIX		"fmnotify"
#define	SCF_NOTIFY_PARAMS		"notify-params"
#define	SCF_NOTIFY_PARAMS_INST		"svc:/system/fm/notify-params:default"
#define	SCF_SVC_TRANSITION_CLASS	"ireport.os.smf.state-transition"
#define	SCF_NOTIFY_PARAMS_PG_TYPE	"notify_params"

/*
 * Useful transition macros
 */
#define	SCF_TRANS_SHIFT_INITIAL_STATE(s)	((s) << 16)
#define	SCF_TRANSITION_ALL \
	(SCF_TRANS_SHIFT_INITIAL_STATE(SCF_STATE_ALL) | SCF_STATE_ALL)
#define	SCF_TRANS(f, t)	(SCF_TRANS_SHIFT_INITIAL_STATE(f) | (t))
#define	SCF_TRANS_VALID(t)	(!((t) & ~SCF_TRANSITION_ALL))
#define	SCF_TRANS_INITIAL_STATE(t)	((t) >> 16 & SCF_STATE_ALL)
#define	SCF_TRANS_FINAL_STATE(t)	((t) & SCF_STATE_ALL)

/*
 * Prefixes for states in state transition notification
 */
#define	SCF_STN_PREFIX_FROM		"from-"
#define	SCF_STN_PREFIX_TO		"to-"

#define	SCF_PG_FLAG_NONPERSISTENT	0x1

#define	SCF_TRACE_LIBRARY		0x1
#define	SCF_TRACE_DAEMON		0x2

#define	SMF_IMMEDIATE			0x1
#define	SMF_TEMPORARY			0x2
#define	SMF_AT_NEXT_BOOT		0x4

scf_error_t scf_error(void);
const char *scf_strerror(scf_error_t);

ssize_t scf_limit(uint32_t code);
#define	SCF_LIMIT_MAX_NAME_LENGTH	-2000U
#define	SCF_LIMIT_MAX_VALUE_LENGTH	-2001U
#define	SCF_LIMIT_MAX_PG_TYPE_LENGTH	-2002U
#define	SCF_LIMIT_MAX_FMRI_LENGTH	-2003U


#define	SCF_COMMENT_MAX_LENGTH		(1024)

scf_handle_t *scf_handle_create(scf_version_t);

int scf_handle_decorate(scf_handle_t *, const char *, scf_value_t *);
#define	SCF_DECORATE_CLEAR	((scf_value_t *)0)

int scf_handle_bind(scf_handle_t *);
int scf_handle_unbind(scf_handle_t *);
void scf_handle_destroy(scf_handle_t *);

int scf_type_base_type(scf_type_t type, scf_type_t *out);
const char *scf_type_to_string(scf_type_t);
scf_type_t scf_string_to_type(const char *);

/* values */
scf_value_t *scf_value_create(scf_handle_t *);
scf_handle_t *scf_value_handle(const scf_value_t *);
void scf_value_destroy(scf_value_t *);

scf_type_t scf_value_base_type(const scf_value_t *);
scf_type_t scf_value_type(const scf_value_t *);
int scf_value_is_type(const scf_value_t *, scf_type_t);

void scf_value_reset(scf_value_t *);

int scf_value_get_boolean(const scf_value_t *, uint8_t *);
int scf_value_get_count(const scf_value_t *, uint64_t *);
int scf_value_get_integer(const scf_value_t *, int64_t *);
int scf_value_get_time(const scf_value_t *, int64_t *, int32_t *);
ssize_t scf_value_get_astring(const scf_value_t *, char *, size_t);
ssize_t scf_value_get_ustring(const scf_value_t *, char *, size_t);
ssize_t scf_value_get_opaque(const scf_value_t *, void *, size_t);

void scf_value_set_boolean(scf_value_t *, uint8_t);
void scf_value_set_count(scf_value_t *, uint64_t);
void scf_value_set_integer(scf_value_t *, int64_t);
int scf_value_set_time(scf_value_t *, int64_t, int32_t);
int scf_value_set_astring(scf_value_t *, const char *);
int scf_value_set_ustring(scf_value_t *, const char *);
int scf_value_set_opaque(scf_value_t *, const void *, size_t);

ssize_t scf_value_get_as_string(const scf_value_t *, char *, size_t);
ssize_t scf_value_get_as_string_typed(const scf_value_t *, scf_type_t,
    char *, size_t);
int scf_value_set_from_string(scf_value_t *, scf_type_t, const char *);

scf_iter_t *scf_iter_create(scf_handle_t *);
scf_handle_t *scf_iter_handle(const scf_iter_t *);
void scf_iter_reset(scf_iter_t *);
void scf_iter_destroy(scf_iter_t *);

int scf_iter_handle_scopes(scf_iter_t *, const scf_handle_t *);
int scf_iter_scope_services(scf_iter_t *, const scf_scope_t *);
int scf_iter_service_instances(scf_iter_t *, const scf_service_t *);
int scf_iter_service_pgs(scf_iter_t *, const scf_service_t *);
int scf_iter_instance_pgs(scf_iter_t *, const scf_instance_t *);
int scf_iter_instance_pgs_composed(scf_iter_t *, const scf_instance_t *,
    const scf_snapshot_t *);
int scf_iter_service_pgs_typed(scf_iter_t *, const scf_service_t *,
    const char *);
int scf_iter_instance_pgs_typed(scf_iter_t *, const scf_instance_t *,
    const char *);
int scf_iter_instance_pgs_typed_composed(scf_iter_t *, const scf_instance_t *,
    const scf_snapshot_t *, const char *);
int scf_iter_snaplevel_pgs(scf_iter_t *, const scf_snaplevel_t *);
int scf_iter_snaplevel_pgs_typed(scf_iter_t *, const scf_snaplevel_t *,
    const char *);
int scf_iter_instance_snapshots(scf_iter_t *, const scf_instance_t *);
int scf_iter_pg_properties(scf_iter_t *, const scf_propertygroup_t *);
int scf_iter_property_values(scf_iter_t *, const scf_property_t *);

int scf_iter_next_scope(scf_iter_t *, scf_scope_t *);
int scf_iter_next_service(scf_iter_t *, scf_service_t *);
int scf_iter_next_instance(scf_iter_t *, scf_instance_t *);
int scf_iter_next_pg(scf_iter_t *, scf_propertygroup_t *);
int scf_iter_next_property(scf_iter_t *, scf_property_t *);
int scf_iter_next_snapshot(scf_iter_t *, scf_snapshot_t *);
int scf_iter_next_value(scf_iter_t *, scf_value_t *);

scf_scope_t *scf_scope_create(scf_handle_t *);
scf_handle_t *scf_scope_handle(const scf_scope_t *);

/* XXX eventually remove this */
#define	scf_handle_get_local_scope(h, s) \
	scf_handle_get_scope((h), SCF_SCOPE_LOCAL, (s))

int scf_handle_get_scope(scf_handle_t *, const char *, scf_scope_t *);
void scf_scope_destroy(scf_scope_t *);
ssize_t scf_scope_get_name(const scf_scope_t *, char *, size_t);

ssize_t scf_scope_to_fmri(const scf_scope_t *, char *, size_t);

scf_service_t *scf_service_create(scf_handle_t *);
scf_handle_t *scf_service_handle(const scf_service_t *);
void scf_service_destroy(scf_service_t *);
int scf_scope_get_parent(const scf_scope_t *, scf_scope_t *);
ssize_t scf_service_get_name(const scf_service_t *, char *, size_t);
ssize_t scf_service_to_fmri(const scf_service_t *, char *, size_t);
int scf_service_get_parent(const scf_service_t *, scf_scope_t *);
int scf_scope_get_service(const scf_scope_t *, const char *, scf_service_t *);
int scf_scope_add_service(const scf_scope_t *, const char *, scf_service_t *);
int scf_service_delete(scf_service_t *);

scf_instance_t *scf_instance_create(scf_handle_t *);
scf_handle_t *scf_instance_handle(const scf_instance_t *);
void scf_instance_destroy(scf_instance_t *);
ssize_t scf_instance_get_name(const scf_instance_t *, char *, size_t);
ssize_t scf_instance_to_fmri(const scf_instance_t *, char *, size_t);
int scf_service_get_instance(const scf_service_t *, const char *,
    scf_instance_t *);
int scf_service_add_instance(const scf_service_t *, const char *,
    scf_instance_t *);
int scf_instance_delete(scf_instance_t *);

scf_snapshot_t *scf_snapshot_create(scf_handle_t *);
scf_handle_t *scf_snapshot_handle(const scf_snapshot_t *);
void scf_snapshot_destroy(scf_snapshot_t *);
ssize_t scf_snapshot_get_name(const scf_snapshot_t *, char *, size_t);
int scf_snapshot_get_parent(const scf_snapshot_t *, scf_instance_t *);
int scf_instance_get_snapshot(const scf_instance_t *, const char *,
    scf_snapshot_t *);
int scf_snapshot_update(scf_snapshot_t *);

scf_snaplevel_t *scf_snaplevel_create(scf_handle_t *);
scf_handle_t *scf_snaplevel_handle(const scf_snaplevel_t *);
void scf_snaplevel_destroy(scf_snaplevel_t *);
int scf_snaplevel_get_parent(const scf_snaplevel_t *, scf_snapshot_t *);
ssize_t scf_snaplevel_get_scope_name(const scf_snaplevel_t *, char *, size_t);
ssize_t scf_snaplevel_get_service_name(const scf_snaplevel_t *, char *, size_t);
ssize_t scf_snaplevel_get_instance_name(const scf_snaplevel_t *, char *,
    size_t);
int scf_snaplevel_get_pg(const scf_snaplevel_t *, const char *,
    scf_propertygroup_t *pg);
int scf_snapshot_get_base_snaplevel(const scf_snapshot_t *, scf_snaplevel_t *);
int scf_snaplevel_get_next_snaplevel(const scf_snaplevel_t *,
    scf_snaplevel_t *);

scf_propertygroup_t *scf_pg_create(scf_handle_t *);
scf_handle_t *scf_pg_handle(const scf_propertygroup_t *);
void scf_pg_destroy(scf_propertygroup_t *);
ssize_t scf_pg_to_fmri(const scf_propertygroup_t *,  char *, size_t);
ssize_t scf_pg_get_name(const scf_propertygroup_t *, char *, size_t);
ssize_t scf_pg_get_type(const scf_propertygroup_t *, char *, size_t);
int scf_pg_get_flags(const scf_propertygroup_t *, uint32_t *);
int scf_pg_get_parent_service(const scf_propertygroup_t *, scf_service_t *);
int scf_pg_get_parent_instance(const scf_propertygroup_t *, scf_instance_t *);
int scf_pg_get_parent_snaplevel(const scf_propertygroup_t *, scf_snaplevel_t *);
int scf_service_get_pg(const scf_service_t *, const char *,
    scf_propertygroup_t *);
int scf_instance_get_pg(const scf_instance_t *, const char *,
    scf_propertygroup_t *);
int scf_instance_get_pg_composed(const scf_instance_t *, const scf_snapshot_t *,
    const char *, scf_propertygroup_t *);
int scf_service_add_pg(const scf_service_t *,  const char *, const char *,
    uint32_t, scf_propertygroup_t *);
int scf_instance_add_pg(const scf_instance_t *,  const char *, const char *,
    uint32_t, scf_propertygroup_t *);
int scf_pg_delete(scf_propertygroup_t *);

int scf_pg_get_underlying_pg(const scf_propertygroup_t *,
    scf_propertygroup_t *);
int scf_instance_get_parent(const scf_instance_t *, scf_service_t *);

int scf_pg_update(scf_propertygroup_t *);

scf_property_t *scf_property_create(scf_handle_t *);
scf_handle_t *scf_property_handle(const scf_property_t *);
void scf_property_destroy(scf_property_t *);
int scf_property_is_type(const scf_property_t *, scf_type_t);
int scf_property_type(const scf_property_t *, scf_type_t *);
ssize_t scf_property_get_name(const scf_property_t *, char *, size_t);
int scf_property_get_value(const scf_property_t *, scf_value_t *);
ssize_t scf_property_to_fmri(const scf_property_t *, char *, size_t);
int scf_pg_get_property(const scf_propertygroup_t *,  const char *,
    scf_property_t *);

scf_transaction_t *scf_transaction_create(scf_handle_t *);
scf_handle_t *scf_transaction_handle(const scf_transaction_t *);
int scf_transaction_start(scf_transaction_t *, scf_propertygroup_t *);
void scf_transaction_destroy(scf_transaction_t *);
void scf_transaction_destroy_children(scf_transaction_t *);

void scf_transaction_reset(scf_transaction_t *);
void scf_transaction_reset_all(scf_transaction_t *);

int scf_transaction_commit(scf_transaction_t *);

scf_transaction_entry_t *scf_entry_create(scf_handle_t *);
scf_handle_t *scf_entry_handle(const scf_transaction_entry_t *);
void scf_entry_reset(scf_transaction_entry_t *);
void scf_entry_destroy(scf_transaction_entry_t *);
void scf_entry_destroy_children(scf_transaction_entry_t *);

int scf_transaction_property_change(scf_transaction_t *,
    scf_transaction_entry_t *, const char *, scf_type_t);
int scf_transaction_property_delete(scf_transaction_t *,
    scf_transaction_entry_t *, const char *);
int scf_transaction_property_new(scf_transaction_t *,
    scf_transaction_entry_t *, const char *, scf_type_t);
int scf_transaction_property_change_type(scf_transaction_t *,
    scf_transaction_entry_t *, const char *, scf_type_t);

int scf_entry_add_value(scf_transaction_entry_t *, scf_value_t *);

int scf_handle_decode_fmri(scf_handle_t *, const char *, scf_scope_t *,
    scf_service_t *, scf_instance_t *, scf_propertygroup_t *, scf_property_t *,
    int);
#define	SCF_DECODE_FMRI_EXACT			0x00000001
#define	SCF_DECODE_FMRI_TRUNCATE		0x00000002
#define	SCF_DECODE_FMRI_REQUIRE_INSTANCE	0x00000004
#define	SCF_DECODE_FMRI_REQUIRE_NO_INSTANCE	0x00000008

ssize_t scf_myname(scf_handle_t *, char *, size_t);

/*
 * Property group template interfaces.
 */
scf_pg_tmpl_t *scf_tmpl_pg_create(scf_handle_t *);
void scf_tmpl_pg_destroy(scf_pg_tmpl_t *);
void scf_tmpl_pg_reset(scf_pg_tmpl_t *);
int scf_tmpl_get_by_pg(scf_propertygroup_t *, scf_pg_tmpl_t *, int);
int scf_tmpl_get_by_pg_name(const char *, const char *,
    const char *, const char *, scf_pg_tmpl_t *, int);
int scf_tmpl_iter_pgs(scf_pg_tmpl_t *, const char *, const char *,
    const char *, int);
#define	SCF_PG_TMPL_FLAG_REQUIRED	0x1
#define	SCF_PG_TMPL_FLAG_EXACT		0x2
#define	SCF_PG_TMPL_FLAG_CURRENT	0x4

ssize_t scf_tmpl_pg_name(const scf_pg_tmpl_t *, char **);
ssize_t scf_tmpl_pg_common_name(const scf_pg_tmpl_t *, const char *, char **);
ssize_t scf_tmpl_pg_description(const scf_pg_tmpl_t *, const char *, char **);
ssize_t scf_tmpl_pg_type(const scf_pg_tmpl_t *, char **);

ssize_t scf_tmpl_pg_target(const scf_pg_tmpl_t *, char **);
#define	SCF_TM_TARGET_ALL		((const char *)"all")
#define	SCF_TM_TARGET_DELEGATE		((const char *)"delegate")
#define	SCF_TM_TARGET_INSTANCE		((const char *)"instance")
#define	SCF_TM_TARGET_THIS		((const char *)"this")

int scf_tmpl_pg_required(const scf_pg_tmpl_t *, uint8_t *);

/*
 * Property template interfaces.
 */
scf_prop_tmpl_t *scf_tmpl_prop_create(scf_handle_t *);
void scf_tmpl_prop_destroy(scf_prop_tmpl_t *);
void scf_tmpl_prop_reset(scf_prop_tmpl_t *);
int scf_tmpl_get_by_prop(scf_pg_tmpl_t *, const char *,
    scf_prop_tmpl_t *, int);
int scf_tmpl_iter_props(scf_pg_tmpl_t *, scf_prop_tmpl_t *, int);
#define	SCF_PROP_TMPL_FLAG_REQUIRED	0x1

ssize_t scf_tmpl_prop_name(const scf_prop_tmpl_t *, char **);
int scf_tmpl_prop_type(const scf_prop_tmpl_t *, scf_type_t *);
int scf_tmpl_prop_required(const scf_prop_tmpl_t *, uint8_t *);
ssize_t scf_tmpl_prop_common_name(const scf_prop_tmpl_t *, const char *,
    char **);
ssize_t scf_tmpl_prop_description(const scf_prop_tmpl_t *, const char *,
    char **);
ssize_t scf_tmpl_prop_units(const scf_prop_tmpl_t *, const char *, char **);
int scf_tmpl_prop_cardinality(const scf_prop_tmpl_t *prop, uint64_t *,
    uint64_t *);
int scf_tmpl_prop_internal_seps(const scf_prop_tmpl_t *, scf_values_t *);

int scf_tmpl_prop_visibility(const scf_prop_tmpl_t *, uint8_t *);
#define	SCF_TMPL_VISIBILITY_HIDDEN		1
#define	SCF_TMPL_VISIBILITY_READONLY		2
#define	SCF_TMPL_VISIBILITY_READWRITE		3

const char *scf_tmpl_visibility_to_string(uint8_t);
#define	SCF_TM_VISIBILITY_HIDDEN	((const char *)"hidden")
#define	SCF_TM_VISIBILITY_READONLY	((const char *)"readonly")
#define	SCF_TM_VISIBILITY_READWRITE	((const char *)"readwrite")

int scf_tmpl_value_name_constraints(const scf_prop_tmpl_t *prop,
    scf_values_t *vals);
void scf_count_ranges_destroy(scf_count_ranges_t *);
void scf_int_ranges_destroy(scf_int_ranges_t *);
int scf_tmpl_value_count_range_constraints(const scf_prop_tmpl_t *,
    scf_count_ranges_t *);
int scf_tmpl_value_int_range_constraints(const scf_prop_tmpl_t *,
    scf_int_ranges_t *);
int scf_tmpl_value_count_range_choices(const scf_prop_tmpl_t *,
    scf_count_ranges_t *);
int scf_tmpl_value_int_range_choices(const scf_prop_tmpl_t *,
    scf_int_ranges_t *);
int scf_tmpl_value_name_choices(const scf_prop_tmpl_t *prop,
    scf_values_t *vals);

void scf_values_destroy(scf_values_t *);

ssize_t scf_tmpl_value_common_name(const scf_prop_tmpl_t *, const char *,
    const char *, char **);
ssize_t scf_tmpl_value_description(const scf_prop_tmpl_t *, const char *,
    const char *, char **);

int scf_tmpl_value_in_constraint(const scf_prop_tmpl_t *pt, scf_value_t *value,
    scf_tmpl_errors_t **errs);

/*
 * Template validation interfaces
 */
int scf_tmpl_validate_fmri(scf_handle_t *, const char *,
    const char *, scf_tmpl_errors_t **, int);
#define	SCF_TMPL_VALIDATE_FLAG_CURRENT	0x1

void scf_tmpl_errors_destroy(scf_tmpl_errors_t *errs);
scf_tmpl_error_t *scf_tmpl_next_error(scf_tmpl_errors_t *);
void scf_tmpl_reset_errors(scf_tmpl_errors_t *errs);
int scf_tmpl_strerror(scf_tmpl_error_t *err, char *s, size_t n, int flag);
int scf_tmpl_error_source_fmri(const scf_tmpl_error_t *, char **);
int scf_tmpl_error_type(const scf_tmpl_error_t *, scf_tmpl_error_type_t *);
int scf_tmpl_error_pg_tmpl(const scf_tmpl_error_t *, char **, char **);
int scf_tmpl_error_pg(const scf_tmpl_error_t *, char **, char **);
int scf_tmpl_error_prop_tmpl(const scf_tmpl_error_t *, char **, char **);
int scf_tmpl_error_prop(const scf_tmpl_error_t *, char **, char **);
int scf_tmpl_error_value(const scf_tmpl_error_t *, char **);

/*
 * Simplified calls that operate on the service and instance.
 */
int smf_refresh_all_instances(scf_service_t *);
int smf_enable_instance_by_instance(scf_instance_t *, int, const char *);
int smf_disable_instance_by_instance(scf_instance_t *, int, const char *);
int smf_refresh_instance_by_instance(scf_instance_t *);
int smf_restart_instance_by_instance(scf_instance_t *);
int smf_maintain_instance_by_instance(scf_instance_t *, int);
int smf_degrade_instance_by_instance(scf_instance_t *, int);
int smf_restore_instance_by_instance(scf_instance_t *);
char *smf_get_state_by_instance(scf_instance_t *);

/*
 * Simplified calls
 */
int smf_enable_instance(const char *, int);
int smf_disable_instance_with_comment(const char *, int, const char *);
int smf_disable_instance(const char *, int);
int smf_refresh_instance(const char *);
int smf_restart_instance(const char *);
int smf_maintain_instance(const char *, int);
int smf_degrade_instance(const char *, int);
int smf_restore_instance(const char *);
char *smf_get_state(const char *);

int scf_simple_walk_instances(uint_t, void *,
    int (*inst_callback)(scf_handle_t *, scf_instance_t *, void *));

scf_simple_prop_t *scf_simple_prop_get(scf_handle_t *, const char *,
    const char *, const char *);
void scf_simple_prop_free(scf_simple_prop_t *);
scf_simple_app_props_t *scf_simple_app_props_get(scf_handle_t *, const char *);
void scf_simple_app_props_free(scf_simple_app_props_t *);
const scf_simple_prop_t *scf_simple_app_props_next(
    const scf_simple_app_props_t *, scf_simple_prop_t *);
const scf_simple_prop_t *scf_simple_app_props_search(
    const scf_simple_app_props_t *, const char *, const char *);
ssize_t scf_simple_prop_numvalues(const scf_simple_prop_t *);
scf_type_t scf_simple_prop_type(const scf_simple_prop_t *);
char *scf_simple_prop_name(const scf_simple_prop_t *);
char *scf_simple_prop_pgname(const scf_simple_prop_t *);
uint8_t *scf_simple_prop_next_boolean(scf_simple_prop_t *);
uint64_t *scf_simple_prop_next_count(scf_simple_prop_t *);
int64_t *scf_simple_prop_next_integer(scf_simple_prop_t *);
int64_t *scf_simple_prop_next_time(scf_simple_prop_t *, int32_t *);
char *scf_simple_prop_next_astring(scf_simple_prop_t *);
char *scf_simple_prop_next_ustring(scf_simple_prop_t *);
void *scf_simple_prop_next_opaque(scf_simple_prop_t *, size_t *);
void scf_simple_prop_next_reset(scf_simple_prop_t *);

/*
 * smf_state_from_string()
 * return SCF_STATE_* value for the input
 * -1 on error. String "all" maps to SCF_STATE_ALL macro
 */
int32_t smf_state_from_string(const char *);

/*
 * smf_state_to_string()
 * return SCF_STATE_STRING* value for the input
 * NULL on error.
 */
const char *smf_state_to_string(int32_t);

/*
 * Notification interfaces
 */
int smf_notify_set_params(const char *, nvlist_t *);
int smf_notify_get_params(nvlist_t **, nvlist_t *);
int smf_notify_del_params(const char *, const char *, int32_t);

/*
 * SMF exit status definitions
 *
 * The SMF_EXIT_NODAEMON exit status should be used when a method does not
 * need to run any persistent process. This indicates success, abandons the
 * contract, and allows dependencies to be met.
 */
#define	SMF_EXIT_OK		  0
#define	SMF_EXIT_NODAEMON	 94
#define	SMF_EXIT_ERR_FATAL	 95
#define	SMF_EXIT_ERR_CONFIG	 96
#define	SMF_EXIT_MON_DEGRADE	 97
#define	SMF_EXIT_MON_OFFLINE	 98
#define	SMF_EXIT_ERR_NOSMF	 99
#define	SMF_EXIT_ERR_PERM	100

#ifdef	__cplusplus
}
#endif

#endif	/* _LIBSCF_H */
/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2013, Joyent, Inc. All rights reserved.
 */

#ifndef	_LIBSCF_PRIV_H
#define	_LIBSCF_PRIV_H


#include <libscf.h>
#include <unistd.h>
#if !defined(NATIVE_BUILD)
#include <sys/secflags.h>
#endif

#ifdef	__cplusplus
extern "C" {
#endif

/*
 * NOTE
 *
 * The contents of this file are private to the implementation of Solaris
 * and are subject to change at any time without notice.
 */

#define	SCF_PG_GENERAL_TYPE		SCF_GROUP_FRAMEWORK
#define	SCF_PG_GENERAL_FLAGS		0

#define	SCF_PG_GENERAL_OVR_TYPE		SCF_GROUP_FRAMEWORK
#define	SCF_PG_GENERAL_OVR_FLAGS	SCF_PG_FLAG_NONPERSISTENT

#define	SCF_PG_DEATHROW_TYPE		SCF_GROUP_FRAMEWORK
#define	SCF_PG_DEATHROW_FLAGS		SCF_PG_FLAG_NONPERSISTENT

#define	SCF_PG_OPTIONS_TYPE		SCF_GROUP_FRAMEWORK
#define	SCF_PG_OPTIONS_FLAGS		0

#define	SCF_PG_OPTIONS_OVR_TYPE		SCF_GROUP_FRAMEWORK
#define	SCF_PG_OPTIONS_OVR_FLAGS	SCF_PG_FLAG_NONPERSISTENT

#define	SCF_PG_RESTARTER_TYPE		SCF_GROUP_FRAMEWORK
#define	SCF_PG_RESTARTER_FLAGS		SCF_PG_FLAG_NONPERSISTENT

#define	SCF_PG_RESTARTER_ACTIONS_TYPE	SCF_GROUP_FRAMEWORK
#define	SCF_PG_RESTARTER_ACTIONS_FLAGS	SCF_PG_FLAG_NONPERSISTENT

#define	SCF_PROPERTY_CLEAR		((const char *)"maint_off")
#define	SCF_PROPERTY_MAINTENANCE	((const char *)"maint_on")

#define	SCF_PROPERTY_LOGFILE		((const char *)"logfile")
#define	SCF_PROPERTY_ALT_LOGFILE	((const char *)"alt_logfile")

#define	SCF_LEGACY_SERVICE		((const char *)"smf/legacy_run")

#define	SCF_LEGACY_PROPERTY_NAME	((const char *)"name")
#define	SCF_LEGACY_PROPERTY_INODE	((const char *)"inode")
#define	SCF_LEGACY_PROPERTY_SUFFIX	((const char *)"suffix")

#define	SCF_FMRI_TYPE_SVC		0x1
#define	SCF_FMRI_TYPE_FILE		0x2

/*
 * Strings for use in constructing FMRIs
 */
#define	SCF_FMRI_SVC_PREFIX		"svc:"
#define	SCF_FMRI_FILE_PREFIX		"file:"
#define	SCF_FMRI_SCOPE_PREFIX		"//"
#define	SCF_FMRI_LOCAL_SCOPE		"localhost"
#define	SCF_FMRI_SCOPE_SUFFIX		"@localhost"
#define	SCF_FMRI_SERVICE_PREFIX		"/"
#define	SCF_FMRI_INSTANCE_PREFIX	":"
#define	SCF_FMRI_PROPERTYGRP_PREFIX	"/:properties/"
#define	SCF_FMRI_PROPERTY_PREFIX	"/"
#define	SCF_FMRI_LEGACY_PREFIX		"lrc:"

/*
 * sulogin Service FMRI
 */
#define	SVC_SULOGIN_FMRI ((const char *)"svc:/system/sulogin")

typedef struct scf_decoration_info {
	const char *sdi_name;
	scf_type_t sdi_type;
	scf_value_t *sdi_value;		/* can be SCF_DECORATE_CLEAR */
} scf_decoration_info_t;

typedef int (*scf_decoration_func)(const scf_decoration_info_t *, void *);

/*
 * calls a callback function for each decoration on the handle.  If the
 * callback returns 0, the iteration stops and returns 0.  If the callback
 * returns a non-zero value, the iteration continues.  After full completion,
 * 1 is returned.  On error, -1 is returned.
 */
int _scf_handle_decorations(scf_handle_t *, scf_decoration_func *,
    scf_value_t *, void *);

/*
 * wait for a change to the propertygroup -- may return early.
 * For now, only one of these can be outstanding at a time.
 *
 * The second argument is how long, in seconds, to wait for a response.
 *
 * Returns SCF_COMPLETE on timeout, -1 on error, and SCF_SUCCESS in every
 * other case.  You must call scf_pg_update() to see if the object has
 * actually changed.
 */
int _scf_pg_wait(scf_propertygroup_t *, int);

/*
 * set up notifications for changes to a class of property groups (by name
 * and type)
 *
 * Only one thread can be sleeping in _scf_notify_wait() -- others will
 * fail.  Deletions give an fmri in the output path.
 *
 * These do not survive unbind()->bind() -- in fact, that is currently the
 * only way to clear them.
 */
int _scf_notify_add_pgname(scf_handle_t *, const char *);
int _scf_notify_add_pgtype(scf_handle_t *, const char *);
int _scf_notify_wait(scf_propertygroup_t *, char *, size_t);

/*
 * Internal interfaces for snapshot creation:
 *	_scf_snapshot_take_new(), _scf_snapshot_take_new_named(), and
 *	_scf_snapshot_take_attach() create a set of snaplevels
 *	containing frozen versions of both the instance's property groups and
 *	its parent service's property groups. _scf_snapshot_take_new() and
 *	_scf_snapshot_take_new_named() create a new snapshot to which the
 *	new snaplevels are attached, while _scf_snapshot_take_attach()
 *	attaches the new snaplevels to a pre-existing snapshot.
 *
 *	_scf_snapshot_take_new_named() records the passed in names into the
 *	snaplevel instead of the instance and service name.  This creates
 *	an inconsistency, which should be resolved by using
 *	_scf_snapshot_attach() to attach the new snaplevels to a snapshot
 *	underneath the appropriate instance.  The first snapshot can
 *	then be deleted.
 *
 *	_scf_snapshot_attach(snap1, snap2) points snap2 at the snaplevels
 *	pointed to by snap1.  After a call to either
 *	_scf_snapshot_take_attach(snap1, snap2) or
 *	_scf_snapshot_attach(inst, snap), scf_snapshot_update() will be
 *	required for any open references to snap or snap2 to see the new
 *	snaplevels.
 *
 *	_scf_snapshot_delete() deletes the snapshot object.  While
 *	snaplevels, being only loosely connected to snapshots, stay
 *	around until they are no longer referenced, any references *through
 *	this snapshot object* will be invalidated.
 *
 * _scf_snapshot_take_new() can fail with at least _HANDLE_MISMATCH,
 * _CONNECTION_BROKEN, _INVALID_ARGUMENT, _NO_RESOURCES, _PERMISSION_DENIED,
 * _NOT_SET, _EXISTS.
 *
 * _scf_snapshot_take_new_named() can fail with at least _HANDLE_MISMATCH,
 * _CONNECTION_BROKEN, _INVALID_ARGUMENT, _NO_RESOURCES, _PERMISSION_DENIED,
 * _NOT_SET, _EXISTS.
 *
 * _scf_snapshot_take_attach() can fail with _CONNECTION_BROKEN, _NOT_SET,
 * _PERMISSION_DENIED, _NO_RESOURCES, _INVALID_ARGUMENT.
 *
 * _scf_snapshot_attach() can fail with _HANDLE_MISMATCH, _CONNECTION_BROKEN,
 * _NOT_SET, _NO_RESOURCES, _PERMISSION_DENIED.
 */
int _scf_snapshot_take_new(scf_instance_t *, const char *, scf_snapshot_t *);
int _scf_snapshot_take_new_named(scf_instance_t *,
    const char *, const char *, const char *, scf_snapshot_t *);
int _scf_snapshot_take_attach(scf_instance_t *, scf_snapshot_t *);
int _scf_snapshot_attach(scf_snapshot_t *, scf_snapshot_t *);
int _scf_snapshot_delete(scf_snapshot_t *);

/*
 * Destructively portions up the first argument into the different portions
 * of a svc: fmri, and returns pointers to the applicable portions.  Omitted
 * portions are set to NULL, except for the scope, which is set to the
 * default local scope if not specified.
 *
 * Parsing is attempted in the order of: svc:, file:. The identified type
 * of the service is returned in the second argument and may take a value
 * of: SCF_FMRI_TYPE_SVC or SCF_FMRI_TYPE_FILE.
 *
 * Note that some of the returned pointers (in particular the scope) may not
 * point into the passed buffer.
 */
int scf_parse_fmri(char *, int *, const char **, const char **, const char **,
    const char **, const char **);

int scf_parse_svc_fmri(char *, const char **, const char **, const char **,
    const char **, const char **);

int scf_parse_file_fmri(char *fmri, const char **scope, const char **path);

ssize_t scf_canonify_fmri(const char *, char *, size_t);

int _smf_refresh_instance_i(scf_instance_t *);

typedef struct scf_simple_handle {
	scf_handle_t		*h;
	scf_snapshot_t		*snap;
	scf_instance_t		*inst;
	scf_propertygroup_t	*running_pg;
	scf_propertygroup_t	*editing_pg;
} scf_simple_handle_t;

void scf_simple_handle_destroy(scf_simple_handle_t *);
scf_simple_handle_t *scf_general_pg_setup(const char *, const char *);
scf_transaction_t *scf_transaction_setup(scf_simple_handle_t *);
int scf_transaction_restart(scf_simple_handle_t *, scf_transaction_t *);
int scf_read_count_property(scf_simple_handle_t *, char *, uint64_t *);
int scf_set_count_property(scf_transaction_t *, char *, uint64_t, boolean_t);

/*
 * Walks all the instances matching a given fmri list.  Each fmri in the array
 * can be one of the following:
 *
 *	- Full instance name
 *	- Full service name
 *	- Full property group or property name
 *	- Partial service or instance name
 *	- A globbed pattern
 *
 * The matching rules for partial fmris are a slightly more complex.  We allow
 * for any substring anchored at the end of the instance or service name,
 * provided it begins with a complete element in the fmri.  For example, given
 * the fmri "svc:/system/filesystem/local:default", any of the following would
 * be acceptable matches: 'default', 'local', 'local:default',
 * 'filesystem/local'.  The following would not be acceptable:
 * 'system/filesystem', 'filesystem/loc', 'system/local'.  Possible flag values:
 *
 *	SCF_WALK_MULTIPLE	Allow individual arguments to correspond to
 *				multiple instances.
 *
 *	SCF_WALK_LEGACY		Walk legacy services (indicated by a non-NULL
 *				propery group).
 *
 *	SCF_WALK_SERVICE	If the user specifies a service, pass the
 *				service to the callback without iterating over
 *				its instances.
 *
 *	SCF_WALK_PROPERTY	Allow FMRIs which match property groups or
 *				individual properties.  Incompatible with
 *				SCF_WALK_LEGACY.
 *
 *	SCF_WALK_NOINSTANCE	Walk only services.  Must be used in
 *				conjunction with SCF_WALK_SERVICE.
 *
 *	SCF_WALK_EXPLICIT	Walk only services if the match is exact
 *				else return instances. Must be used in
 *				conjunction with SCF_WALK_SERVICE.
 *
 *	SCF_WALK_UNIPARTIAL	Can be combined with SCF_WALK_MULTIPLE
 *				so that an error is returned if a partial
 *				fmri matches multiple instances, unless
 *				a wildcard match is also used.
 *
 * If no arguments are given, then all instances in the service graph are
 * walked.
 *
 * The second to last parameter is set to UU_EXIT_FATAL if one of the arguments
 * is an invalid FMRI or matches multiple FMRIs when SCF_WALK_MULTIPLE is not
 * set.
 *
 * The last parameter is a user-supplied error function that is called when
 * reporting invalid arguments.
 */

#define	SCF_WALK_MULTIPLE	0x01
#define	SCF_WALK_LEGACY		0x02
#define	SCF_WALK_SERVICE	0x04
#define	SCF_WALK_PROPERTY	0x08
#define	SCF_WALK_NOINSTANCE	0x10
#define	SCF_WALK_EXPLICIT	0x20
#define	SCF_WALK_UNIPARTIAL	0x40

/*
 * The default locations of the repository dbs
 */
#define	REPOSITORY_DB		"/etc/svc/repository.db"
#define	NONPERSIST_DB		"/etc/svc/volatile/svc_nonpersist.db"
#define	FAST_REPOSITORY_DB	"/etc/svc/volatile/fast_repository.db"
#define	REPOSITORY_CHECKPOINT	"/etc/svc/volatile/checkpoint_repository.db"


typedef struct scf_walkinfo {
	const char		*fmri;
	scf_scope_t		*scope;
	scf_service_t		*svc;
	scf_instance_t		*inst;
	scf_propertygroup_t	*pg;
	scf_property_t		*prop;
	int			count;	/* svcprop special */
} scf_walkinfo_t;

typedef int (*scf_walk_callback)(void *, scf_walkinfo_t *);

scf_error_t scf_walk_fmri(scf_handle_t *, int, char **, int,
    scf_walk_callback, void *, int *, void (*)(const char *, ...));

/*
 * Requests a backup of the repository with a particular name, which
 * can be any alphabetic string.  Only privileged users can do this.
 *
 * Can fail with:
 *	_NOT_BOUND, _CONNECTION_BROKEN, _PERMISSION_DENIED, _INVALID_ARGUMENT,
 *	_INTERNAL (path too long, or the backup failed for an odd reason),
 *	_BACKEND_READONLY (filesystem is still read-only)
 */
int _scf_request_backup(scf_handle_t *, const char *);

/*
 * Repository switch client
 */
int _scf_repository_switch(scf_handle_t *, int);

/*
 * Determines whether a property group requires authorization to read; this
 * does not in any way reflect whether the caller has that authorization.
 * To determine that, the caller must attempt to read the value of one of the
 * group's properties.
 *
 * Can fail with:
 *	_NOT_BOUND, _CONNECTION_BROKEN, _INVALID_ARGUMENT, _INTERNAL,
 *	_NO_RESOURCES, _CONSTRAINT_VIOLATED, _DELETED.
 */
int _scf_pg_is_read_protected(const scf_propertygroup_t *, boolean_t *);

/*
 * Sets annotation data for SMF audit logging.  Once this function has been
 * set, the next audit record will be preceded by an ADT_smf_annotation
 * with the information provided in this function.  This function is used
 * to mark operations which comprise multiple primitive operations such as
 * svccfg import.
 */
int _scf_set_annotation(scf_handle_t *h, const char *operation,
    const char *file);

/*
 * scf_pattern_t
 */
typedef struct scf_pattern {
	enum	{
		PATTERN_INVALID,	/* Uninitialized state */
		PATTERN_EXACT,
		PATTERN_GLOB,
		PATTERN_PARTIAL
	} sp_type;
	char			*sp_arg;	/* Original argument */
	struct scf_match	*sp_matches;	/* List of matches */
	int			sp_matchcount;	/* # of matches */
} scf_pattern_t;

int scf_cmp_pattern(char *, scf_pattern_t *);

int gen_filenms_from_fmri(const char *, const char *, char *, char *);

/*
 * Interfaces for bulk access to SMF-stored configuration.
 *
 * Each scf_propvec_t represents a single property to be read (with
 * scf_read_propvec) or written (with scf_write_propvec).
 *
 * The fields of a scf_propvec_t have the following meanings:
 *
 *   pv_prop - the name of the property
 *   pv_desc - a description string (optional; to be consumed by the caller)
 *   pv_type - the type of the property
 *   pv_ptr  - where to store the data read, or a pointer to the data to
 *             be written
 *   pv_aux  - additional data influencing the interpretation of pv_ptr
 *
 * The meaning of pv_ptr and pv_aux depends on the type of property.  For:
 *
 *   boolean - if pv_aux is 0, pv_ptr is a pointer to a boolean_t
 *             if pv_aux is non-0, pv_ptr is a pointer to a uint64_t,
 *             where pv_aux indicates the bit holding the truth value.
 *   count   - pv_ptr is a pointer to a uint64_t; pv_aux is unused
 *   integer - pv_ptr is a pointer to an int64_t; pv_aux is unused
 *   time    - pv_ptr is a pointer to an scf_time_t; pv_aux is unused
 *   opaque  - pv_ptr is a pointer to an scf_opaque_t; pv_aux is unused
 *   strings - (scf_read_propvec) pv_ptr is a pointer to a char *
 *             (scf_write_propvec) pv_ptr is a pointer to an array of char
 *             (both) pv_aux is unused
 */
typedef struct {
	void	*so_addr;
	size_t	so_size;
} scf_opaque_t;

typedef struct {
	const char	*pv_prop;
	const char	*pv_desc;
	scf_type_t	pv_type;
	void		*pv_ptr;
	uint64_t	pv_aux;
} scf_propvec_t;

void scf_clean_propvec(scf_propvec_t *);
int scf_read_propvec(const char *, const char *, boolean_t, scf_propvec_t *,
    scf_propvec_t **);
int scf_write_propvec(const char *, const char *, scf_propvec_t *,
    scf_propvec_t **);

scf_tmpl_errors_t *_scf_create_errors(const char *, int);
int _scf_tmpl_add_error(scf_tmpl_errors_t *errs, scf_tmpl_error_type_t type,
    const char *pg_name, const char *prop_name,
    const char *ev1, const char *ev2, const char *actual,
    const char *tmpl_fmri, const char *tmpl_pg_name, const char *tmpl_pg_type,
    const char *tmpl_prop_name, const char *tmpl_prop_type);
int _scf_tmpl_error_set_prefix(scf_tmpl_errors_t *, const char *);

/*
 * Templates definitions
 */

/*
 * For CARDINALITY_VIOLATION and RANGE_VIOLATION, te_ev1 holds
 * the min value and te_ev2 holds the max value
 *
 * For MISSING_PG te_ev1 should hold the expected pg_name and
 * expected2 holds the expected pg_type.
 *
 * For SCF_TERR_PG_PATTERN_CONFLICT and SCF_TERR_GENERAL_REDEFINE te_ev1 is
 * the FMRI holding the conflicting pg_pattern.  te_ev2 is the name of the
 * conflicting pg_pattern, and actual is the type of the conflicting
 * pg_pattern.
 *
 * SCF_TERR_PROP_PATTERN_CONFLICT te_ev1 is the FMRI holding the
 * conflicting prop_pattern.  te_ev2 is the name of the conflicting
 * prop_pattern, and actual is the type of the conflicting prop_pattern.
 *
 * For SCF_TERR_INCLUDE_VALUES te_ev1 is the type specified for the
 * include_values element.
 *
 * For all other errors, te_ev1 should hold the expected value and
 * te_ev2 is ignored
 *
 * te_actual holds the current value of the property
 */

struct scf_tmpl_error {
	scf_tmpl_errors_t		*te_errs;
	scf_tmpl_error_type_t		te_type;
	const char			*te_pg_name;
	const char			*te_prop_name;
	const char			*te_ev1;
	const char			*te_ev2;
	const char			*te_actual;
	const char			*te_tmpl_fmri;
	const char			*te_tmpl_pg_name;
	const char			*te_tmpl_pg_type;
	const char			*te_tmpl_prop_name;
	const char			*te_tmpl_prop_type;
};

/*
 * The pg_pattern element has two optional attributes that play a part in
 * selecting the appropriate prefix for the name of the pg_pattern property
 * group. The two attributes are name and type.  The appropriate prefix
 * encodes the presence are absence of these attributes.
 *
 *	SCF_PG_TM_PG_PATTERN_PREFIX	neither attribute
 *	SCF_PG_TM_PG_PATTERN_N_PREFIX	name only
 *	SCF_PG_TM_PG_PATTERN_T_PREFIX	type only
 *	SCF_PG_TM_PG_PATTERN_NT_PREFIX	both name and type
 */
#define	SCF_PG_TM_PG_PAT_BASE		"tm_pgpat"
#define	SCF_PG_TM_PG_PATTERN_PREFIX	((const char *)SCF_PG_TM_PG_PAT_BASE \
	"_")
#define	SCF_PG_TM_PG_PATTERN_N_PREFIX	((const char *)SCF_PG_TM_PG_PAT_BASE \
	"n_")
#define	SCF_PG_TM_PG_PATTERN_T_PREFIX	((const char *)SCF_PG_TM_PG_PAT_BASE \
	"t_")
#define	SCF_PG_TM_PG_PATTERN_NT_PREFIX	((const char *)SCF_PG_TM_PG_PAT_BASE \
	"nt_")
#define	SCF_PG_TM_PROP_PATTERN_PREFIX	((const char *)"tm_proppat_")

/*
 * Pad character to use when encoding strings for property names.
 */
#define	SCF_ENCODE32_PAD		('-')

/*
 * Functions for base 32 encoding/decoding
 */
int scf_decode32(const char *, size_t, char *, size_t, size_t *, char);
int scf_encode32(const char *, size_t, char *, size_t, size_t *, char);

/*
 * handy functions
 */
/*
 * _scf_sanitize_locale
 * Make sure a locale string has only alpha-numeric or '_' characters
 */
void _scf_sanitize_locale(char *);

/*
 * _scf_read_tmpl_prop_type_as_string()
 * Handy function to get template property type as a string
 */
char *_scf_read_tmpl_prop_type_as_string(const scf_prop_tmpl_t *);
/*
 * _scf_read_single_astring_from_pg()
 * Given a property group (pg) and a property name (pn), this function
 * retrives an astring value from pg/pn.
 */
char *_scf_read_single_astring_from_pg(scf_propertygroup_t *, const char *);

/*
 * scf_instance_delete_prop()
 * Given instance, property group, and property, delete the property.
 */
int
scf_instance_delete_prop(scf_instance_t *, const char *, const char *);

/*
 * Functions to extract boot config information from FMRI_BOOT_CONFIG
 */
void scf_get_boot_config(uint8_t *);
void scf_get_boot_config_ovr(uint8_t *);
int scf_is_fastboot_default(void);

/*
 * Set value of "config_ovr/fastreboot_default".
 */
int scf_fastreboot_default_set_transient(boolean_t);

/*
 * scf_is_compatible_type()
 * Return true if the second type is the same type, or a subtype of the
 * first.
 */
int scf_is_compatible_type(scf_type_t, scf_type_t);

/*
 * Check an array of services and enable any that don't have the
 * "application/auto_enable" property set to "false", which is
 * the interface to turn off this behaviour (see PSARC 2004/739).
 */
void _check_services(char **);

/*
 * _scf_handle_create_and_bind()
 * convenience function that creates and binds a handle
 */
scf_handle_t *_scf_handle_create_and_bind(scf_version_t);

/*
 * _scf_get_fma_notify_params()
 * Specialized fuction to get fma notifitation parameters
 */
int _scf_get_fma_notify_params(const char *, nvlist_t *, int);

/*
 * _scf_get_svc_notify_params()
 * Specialized function to get SMF state transition notification parameters
 */
int _scf_get_svc_notify_params(const char *, nvlist_t *, int32_t, int, int);

/*
 * _scf_notify_get_params()
 * Specialized function to get notification parametes from a pg into an
 * nvlist_t
 */
int _scf_notify_get_params(scf_propertygroup_t *, nvlist_t *);

#if !defined(NATIVE_BUILD)
int scf_default_secflags(scf_handle_t *, scf_secflags_t *);
#endif

#define	SCF_NOTIFY_PARAMS_SOURCE_NAME	((const char *)"preference_source")

#ifdef	__cplusplus
}
#endif

#endif	/* _LIBSCF_PRIV_H */