/*

 * 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) 2010, 2012, Oracle and/or its affiliates. All rights reserved.

 */

#include <sys/list.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <stddef.h>

#include <unistd.h>

#include <fcntl.h>

#include <libscf.h>

#include <libscf_priv.h>

#include <rad/adr.h>

#include <rad/rad_modapi.h>

#include "api_smf_old.h"

#include "propvec.h"

static pthread_mutex_t service_lock = PTHREAD_MUTEX_INITIALIZER;

static list_t service_list;

static list_t instance_list;

static rad_instance_t *agg_inst;

static int service_count = 0;

static int instance_count = 0;

static const char *aggregator_pattern =

	"com.oracle.solaris.vp.panel.common.api.smf_old:type=Aggregator";

typedef struct servinst {

	char *sname;		/* Service name */

	char *iname;		/* Instance name */

	char *fmri;		/* FMRI */

	rad_instance_t *inst;	/* rad object instance */

	boolean_t instance;

	int ninstances;

	list_t instances;	/* A service's instances */

	list_node_t node;	/* Membership in the global list */

	list_node_t snode;	/* An instance's membership in its service */

} servinst_t;

static const char *framework_pgtypes[] = {

	SCF_GROUP_FRAMEWORK,

	SCF_GROUP_DEPENDENCY,

	SCF_GROUP_METHOD,

	SCF_GROUP_TEMPLATE,

	SCF_GROUP_TEMPLATE_PG_PATTERN,

	SCF_GROUP_TEMPLATE_PROP_PATTERN,

	NULL

};

static conerr_t

error_scf(data_t **error, int code)

{

	if (error != NULL) {

		data_t *e = data_new_struct(&t__SmfError);

		struct_set(e, "error", data_new_enum(&t__SmfErrorCode, code));

		struct_set(e, "message",

		    data_new_string(scf_strerror(code), lt_const));

		*error = data_purify(e);

	}

	return (ce_object);

}

static conerr_t

simple_scf(data_t **error, int result)

{

	if (result == 0)

		return (ce_ok);

	return (error_scf(error, scf_error()));

}

static boolean_t

strinset(const char **set, const char *str)

{

	for (; *set != NULL; set++)

		if (strcmp(*set, str) == 0)

			return (B_TRUE);

	return (B_FALSE);

}

static boolean_t

strnotinset(const char **set, const char *str)

{

	return (!strinset(set, str));

}

scf_handle_t *

handle_create(void)

{

	scf_handle_t *h = scf_handle_create(SCF_VERSION);

	if (h == NULL)

		return (NULL);

	if (scf_handle_bind(h) == -1) {

		scf_handle_destroy(h);

		return (NULL);

	}

	return (h);

}

static int getpgs(servinst_t *si, data_t **data, boolean_t namesonly,

    boolean_t(*fp)(const char **, const char *), const char **set,

    data_t **error)

{

	conerr_t err = ce_ok;

	scf_handle_t *scfhandle = handle_create();

	scf_service_t *service = scf_service_create(scfhandle);

	scf_instance_t *instance = scf_instance_create(scfhandle);

	scf_snapshot_t *snap = scf_snapshot_create(scfhandle);

	scf_iter_t *iter = scf_iter_create(scfhandle);

	scf_propertygroup_t *pg = scf_pg_create(scfhandle);

	if (scf_handle_decode_fmri(scfhandle, si->fmri, NULL, service,

	    instance, NULL, NULL, 0) != SCF_SUCCESS) {

		rad_log(RL_WARN, "Couldn't decode '%s': %s\n", si->fmri,

		    scf_strerror(scf_error()));

		err = error_scf(error, scf_error());

		goto out;

	}

	if (si->instance) {

		if (scf_instance_get_snapshot(instance, "running", snap) != 0 ||

		    scf_iter_instance_pgs_composed(iter, instance, snap)

		    != SCF_SUCCESS) {

			err = error_scf(error, scf_error());

			goto out;

		}

	} else {

		if (scf_iter_service_pgs(iter, service) != SCF_SUCCESS) {

			rad_log(RL_WARN, "failed to initialize iterator: %s\n",

			    scf_strerror(scf_error()));

			err = error_scf(error, scf_error());

			goto out;

		}

	}

	data_t *result = namesonly ? data_new_array(&t_array_string, 5) :

	    data_new_array(&t_array__PropertyGroup, 5);

	while (scf_iter_next_pg(iter, pg) > 0) {

		char nbuf[1000];

		char tbuf[1000];

		(void) scf_pg_get_name(pg, nbuf, 1000);

		(void) scf_pg_get_type(pg, tbuf, 1000);

		if (fp(set, tbuf)) {

			if (namesonly) {

				(void) array_add(result,

				    data_new_string(nbuf, lt_copy));

			} else {

				data_t *pgdata =

				    data_new_struct(&t__PropertyGroup);

				struct_set(pgdata, "name",

				    data_new_string(nbuf, lt_copy));

				struct_set(pgdata, "type",

				    data_new_string(tbuf, lt_copy));

				(void) array_add(result, pgdata);

			}

		}

	}

	*data = result;

out:

	scf_pg_destroy(pg);

	scf_snapshot_destroy(snap);

	scf_iter_destroy(iter);

	scf_instance_destroy(instance);

	scf_service_destroy(service);

	scf_handle_destroy(scfhandle);

	return (err);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_fmri(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	*data = data_new_string(si->fmri, lt_copy);

	return (ce_ok);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_methodNames(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	const char *pgtypes[] = { SCF_GROUP_METHOD, NULL };

	return (getpgs(instance_getdata(inst), data, B_TRUE, strinset, pgtypes,

	    error));

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_dependencyNames(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	const char *pgtypes[] = { SCF_GROUP_DEPENDENCY, NULL };

	return (getpgs(instance_getdata(inst), data, B_TRUE, strinset, pgtypes,

	    error));

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_propertyGroups(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	return (getpgs(instance_getdata(inst), data, B_FALSE, strnotinset,

	    framework_pgtypes, error));

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_manpages(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	char *title, *section, *path;

	rad_propvec_t *badprop;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_TM_MANPATH, NULL, SCF_TYPE_USTRING, &path, 0 },

		{ SCF_PROPERTY_TM_TITLE, NULL, SCF_TYPE_USTRING, &title, 0 },

		{ SCF_PROPERTY_TM_SECTION, NULL, SCF_TYPE_USTRING, &section,

		0 },

		{ NULL }

	};

	const char *pgtypes[] = {

		SCF_GROUP_TEMPLATE,

		NULL

	};

	data_t *pgs;

	conerr_t err = getpgs(si, &pgs, B_TRUE, strinset, pgtypes, error);

	if (err != ce_ok)

		return (err);

	data_t *result = data_new_array(&t_array__Manpage, 5);

	for (int i = 0; i < array_size(pgs); i++) {

		const char *str = data_to_string(array_get(pgs, i));

		if (strncmp(str, SCF_PG_TM_MAN_PREFIX,

		    strlen(SCF_PG_TM_MAN_PREFIX)) != 0) {

			continue;

		}

		if (rad_read_propvec(si->fmri, str, B_FALSE, evec,

		    &badprop) != 0)

			continue;

		data_t *mp = data_new_struct(&t__Manpage);

		struct_set(mp, "title", data_new_string(title, lt_copy));

		struct_set(mp, "section", data_new_string(section, lt_copy));

		struct_set(mp, "path", data_new_string(path, lt_copy));

		(void) array_add(result, mp);

		rad_clean_propvec(evec);

	}

	data_free(pgs);

	*data = result;

	return (ce_ok);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_doclinks(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	char *uri;

	rad_propvec_t *badprop;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_TM_URI, NULL, SCF_TYPE_USTRING, &uri, 0 },

		{ NULL }

	};

	const char *pgtypes[] = {

		SCF_GROUP_TEMPLATE,

		NULL

	};

	data_t *pgs;

	conerr_t err = getpgs(si, &pgs, B_TRUE, strinset, pgtypes, error);

	if (err != ce_ok)

		return (err);

	data_t *result = data_new_array(&t_array_string, 5);

	for (int i = 0; i < array_size(pgs); i++) {

		const char *str = data_to_string(array_get(pgs, i));

		if (strncmp(str, SCF_PG_TM_DOC_PREFIX,

		    strlen(SCF_PG_TM_DOC_PREFIX)) != 0) {

			continue;

		}

		if (rad_read_propvec(si->fmri, str, B_FALSE, evec,

		    &badprop) == 0) {

			(void) array_add(result, data_new_string(uri, lt_copy));

			rad_clean_propvec(evec);

		}

	}

	data_free(pgs);

	*data = result;

	return (ce_ok);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_persistentlyEnabled(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));

	boolean_t enabled;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_ENABLED, NULL, SCF_TYPE_BOOLEAN, &enabled, 0 },

		{ NULL }

	};

	rad_propvec_t *badprop;

	int scferr = rad_read_propvec(si->fmri, SCF_PG_GENERAL, B_FALSE,

	    evec, &badprop);

	if (scferr != 0)

		return (error_scf(error, scferr));

	rad_clean_propvec(evec);

	*data = data_new_boolean(enabled);

	return (ce_ok);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_temporarilyEnabled(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));

	boolean_t enabled;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_ENABLED, NULL, SCF_TYPE_BOOLEAN, &enabled, 0 },

		{ NULL }

	};

	rad_propvec_t *badprop;

	if (rad_read_propvec(si->fmri, SCF_PG_GENERAL_OVR, B_FALSE, evec,

	    &badprop) != 0)

		return (interface_ServiceInfo_read_persistentlyEnabled(

		    inst, attr, data, error));

	rad_clean_propvec(evec);

	*data = data_new_boolean(enabled);

	return (ce_ok);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_enabled(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	/*

	 * XXX: The java version always had the same implementation for both.

	 */

	return (interface_ServiceInfo_read_persistentlyEnabled(inst, attr, data,

	    error));

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_instance(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	*data = data_new_boolean(si->instance);

	return (ce_ok);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_restarter(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));

	char *fmri = NULL;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_RESTARTER, NULL, SCF_TYPE_USTRING, &fmri, 0 },

		{ NULL }

	};

	rad_propvec_t *badprop;

	if (rad_read_propvec(si->fmri, SCF_PG_GENERAL, B_FALSE, evec,

	    &badprop) == 0) {

		*data = data_new_string(fmri, lt_copy);

		rad_clean_propvec(evec);

	} else {

		*data = data_new_fstring("svc:/%s:%s",

		    "system/svc/restarter", "default");

	}

	return (*data != NULL ? ce_ok : ce_system);

}

static data_t *

state2enum(const char *state)

{

	if (strcmp(state, SCF_STATE_STRING_UNINIT) == 0) {

		return (&e__SmfState_UNINIT);

	} else if (strcmp(state, SCF_STATE_STRING_MAINT) == 0) {

		return (&e__SmfState_MAINT);

	} else if (strcmp(state, SCF_STATE_STRING_LEGACY) == 0) {

		return (&e__SmfState_LEGACY);

	} else {

		return (data_new_enum_byname(&t__SmfState, state));

	}

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_state(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));

	char *state = smf_get_state(si->fmri);

	if (state == NULL)

		return (error_scf(error, scf_error()));

	*data = state2enum(state);

	free(state);

	return (*data != NULL ? ce_ok : ce_system);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_nextState(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));

	char *state = NULL;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_NEXT_STATE, NULL, SCF_TYPE_ASTRING, &state, 0 },

		{ NULL }

	};

	rad_propvec_t *badprop;

	int scferr = rad_read_propvec(si->fmri, SCF_PG_RESTARTER, B_FALSE, evec,

	    &badprop);

	if (scferr != 0)

		return (error_scf(error, scferr));

	*data = state2enum(state);

	rad_clean_propvec(evec);

	return (*data != NULL ? ce_ok : ce_system);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_auxiliaryState(rad_instance_t *inst,

    adr_attribute_t *attr, data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));

	char *aux;

	rad_propvec_t evec[] = {

		{ SCF_PROPERTY_AUX_STATE, NULL, SCF_TYPE_ASTRING, &aux, 0 },

		{ NULL }

	};

	rad_propvec_t *badprop;

	int scferr = rad_read_propvec(si->fmri, SCF_PG_RESTARTER, B_FALSE, evec,

	    &badprop);

	if (scferr != 0) {

		if (scferr == SCF_ERROR_NOT_FOUND) {

			*data = NULL;

			return (ce_ok);

		}

		return (error_scf(error, scferr));

	}

	*data = data_new_string(aux, lt_copy);

	rad_clean_propvec(evec);

	return (*data != NULL ? ce_ok : ce_system);

}

/* ARGSUSED */

conerr_t

interface_ServiceInfo_read_stime(rad_instance_t *inst, adr_attribute_t *attr,

    data_t **data, data_t **error)

{

	servinst_t *si = instance_getdata(inst);

	if (!si->instance)

		return (error_scf(error, SCF_ERROR_INVALID_ARGUMENT));