/*

 * 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) 2011, 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 <assert.h>

#include <limits.h>

#include <libscf.h>

#include <libscf_priv.h>

#include <rad/adr.h>

#include <rad/rad_modapi.h>

#include "api_smf.h"

#include "rhandle.h"

#include "smfutil.h"

#include "datatype.h"

/*

 * Routines for creating ADR data objects from SCF types or objects.

 * Consumed by the API entry points.

 */

create_SMFState(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 {

	}

}

create_DepGrouping(const char *grouping)

{

	if (strcmp(grouping, SCF_DEP_REQUIRE_ALL) == 0)

		return (&e__DepGrouping_REQUIRE_ALL);

	else if (strcmp(grouping, SCF_DEP_REQUIRE_ANY) == 0)

		return (&e__DepGrouping_REQUIRE_ANY);

	else if (strcmp(grouping, SCF_DEP_EXCLUDE_ALL) == 0)

		return (&e__DepGrouping_EXCLUDE_ALL);

	else if (strcmp(grouping, SCF_DEP_OPTIONAL_ALL) == 0)

		return (&e__DepGrouping_OPTIONAL_ALL);

	return (NULL);

}

create_DepRestart(const char *restarton)

{

	if (strcmp(restarton, SCF_DEP_RESET_ON_ERROR) == 0)

		return (&e__DepRestart_ERROR);

	if (strcmp(restarton, SCF_DEP_RESET_ON_RESTART) == 0)

		return (&e__DepRestart_RESTART);

	if (strcmp(restarton, SCF_DEP_RESET_ON_REFRESH) == 0)

		return (&e__DepRestart_REFRESH);

	if (strcmp(restarton, SCF_DEP_RESET_ON_NONE) == 0)

		return (&e__DepRestart_NONE);

	return (NULL);

}

create_PropertyType(scf_type_t type)

{

	assert(result != NULL);

	return (result);

}

scf_type_t

{

}

create_PropertyVisibility(uint8_t visibility)

{

	switch (visibility) {

	case SCF_TMPL_VISIBILITY_HIDDEN:

		return (&e__PropertyVisibility_HIDDEN);

	case SCF_TMPL_VISIBILITY_READONLY:

		return (&e__PropertyVisibility_READONLY);

	case SCF_TMPL_VISIBILITY_READWRITE:

		return (&e__PropertyVisibility_READWRITE);

	}

	return (NULL);

}

/*

 * Creates a Dependency object.

 *

 * A return value of SE_NOTFOUND implies that the property group wasn't

 * a dependency and should be skipped.

 */

svcerr_t

create_Dependency(scf_handle_t *scfhandle, scf_propertygroup_t *pg,

{

	svcerr_t se = SE_OK;

	char type[max_pgtype + 1];

	char grouping[max_value + 1];

	char restarton[max_value + 1];

	char pgname[max_name + 1];

	scf_iter_t *iter = scf_iter_create(scfhandle);

	scf_property_t *prop = scf_property_create(scfhandle);

	scf_value_t *val = scf_value_create(scfhandle);

	if (iter == NULL || prop == NULL || val == NULL) {

		se = SE_FATAL;

		goto out;

	}

	if (scf_pg_get_name(pg, pgname, sizeof (pgname)) == -1 ||

	    scf_pg_get_property(pg, SCF_PROPERTY_GROUPING, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, grouping, sizeof (grouping)) == -1 ||

	    scf_pg_get_property(pg, SCF_PROPERTY_RESTART_ON, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, restarton, sizeof (restarton)) == -1 ||

	    scf_pg_get_property(pg, SCF_PROPERTY_ENTITIES, prop) != 0 ||

	    scf_iter_property_values(iter, prop) != 0) {

		se = smfu_maperr(scf_error());

		goto out;

	}

	if (group == NULL || restart == NULL) {

		se = SE_NOTFOUND;

		goto out;

	}

	while (scf_iter_next_value(iter, val) > 0) {

		if (scf_value_get_as_string(val, type, sizeof (type)) == -1) {

			se = smfu_maperr(scf_error());

			goto out;

		}

	}

		se = SE_FATAL;

		goto out;

	}

	*ret = result;

out:

	scf_value_destroy(val);

	scf_property_destroy(prop);

	scf_iter_destroy(iter);

	return (se);

}

/*

 * Creates a Manpage object.

 *

 * A return value of SE_NOTFOUND implies that the property group wasn't

 * a man page and should be skipped.

 */

svcerr_t

{

	char manpath[max_value + 1];

	char section[max_value + 1];

	char title[max_name + 1];

	char pgname[max_name + 1];

	svcerr_t se = SE_OK;

	if (scf_pg_get_name(pg, pgname, sizeof (pgname)) == -1)

		return (smfu_maperr(scf_error()));

	if (strncmp(SCF_PG_TM_MAN_PREFIX, pgname,

	    strlen(SCF_PG_TM_MAN_PREFIX)) != 0)

		return (SE_NOTFOUND);

	scf_property_t *prop = scf_property_create(scfhandle);

	scf_value_t *val = scf_value_create(scfhandle);

	if (prop == NULL || val == NULL) {

		se = SE_FATAL;

		goto out;

	}

	if (scf_pg_get_property(pg, SCF_PROPERTY_TM_MANPATH, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, manpath, sizeof (manpath)) == -1 ||

	    scf_pg_get_property(pg, SCF_PROPERTY_TM_TITLE, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, title, sizeof (title)) == -1 ||

	    scf_pg_get_property(pg, SCF_PROPERTY_TM_SECTION, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, section, sizeof (section)) == -1) {

		se = smfu_maperr(scf_error());

		goto out;

	}

	if (strcmp(manpath, ":default") != 0) {

		if (mp == NULL) {

			se = SE_FATAL;

			goto out;

		}

	}

		se = SE_FATAL;

		goto out;

	}

	*ret = result;

out:

	scf_value_destroy(val);

	scf_property_destroy(prop);

	return (se);

}

/*

 * Creates a Doclink object.

 *

 * A return value of SE_NOTFOUND implies that the property group wasn't

 * a doclink and should be skipped.

 */

svcerr_t

{

	char name[max_value + 1];

	char uri[max_value + 1];

	char pgname[max_name + 1];

	svcerr_t se = SE_OK;

	if (scf_pg_get_name(pg, pgname, sizeof (pgname)) == -1)

		return (smfu_maperr(scf_error()));

	if (strncmp(SCF_PG_TM_DOC_PREFIX, pgname,

	    strlen(SCF_PG_TM_DOC_PREFIX)) != 0)

		return (SE_NOTFOUND);

	scf_property_t *prop = scf_property_create(scfhandle);

	scf_value_t *val = scf_value_create(scfhandle);

	if (prop == NULL || val == NULL) {

		se = SE_FATAL;

		goto out;

	}

	if (scf_pg_get_property(pg, SCF_PROPERTY_TM_NAME, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, name, sizeof (name)) == -1 ||

	    scf_pg_get_property(pg, SCF_PROPERTY_TM_URI, prop) != 0 ||

	    scf_property_get_value(prop, val) != 0 ||

	    scf_value_get_as_string(val, uri, sizeof (uri)) == -1) {

		se = smfu_maperr(scf_error());

		goto out;

	}

		se = SE_FATAL;

		goto out;

	}

	*ret = result;

out:

	scf_value_destroy(val);

	scf_property_destroy(prop);

	return (se);

}

svcerr_t

{

	char name[max_value + 1];

	char type[max_pgtype + 1];

	uint32_t flags;

	svcerr_t se = SE_OK;

	if (scf_pg_get_name(pg, name, sizeof (name)) == -1 ||

	    scf_pg_get_type(pg, type, sizeof (type)) == -1 ||

	    scf_pg_get_flags(pg, &flags) == -1) {

		se = smfu_maperr(scf_error());

		goto out;

	}

		se = SE_FATAL;

		goto out;

	}

	*ret = result;

out:

	return (se);

}

svcerr_t

create_Property(scf_property_t *prop, scf_iter_t *iter, scf_value_t *value,

{

	char name[max_name + 1];

	scf_type_t type;

	if (scf_property_get_name(prop, name, sizeof (name)) == -1 ||

	    scf_property_type(prop, &type) == -1 ||

	    scf_iter_property_values(iter, prop))

		return (smfu_maperr(scf_error()));

	int err;

	while ((err = scf_iter_next_value(iter, value)) > 0) {

		char *valstr;

		if (smfu_value_get_string(value, &valstr) != 0) {

			return (SE_FATAL);

		}

	}

	if (err != 0) {

		if (scf_error() == SCF_ERROR_PERMISSION_DENIED)

			return (error_scf(error, &e__ErrorCode_DENIED, NULL,

			    NULL, NULL));

		else

			return (smfu_maperr(scf_error()));

	}

	*ret = result;

	return (SE_OK);

}

svcerr_t

create_Properties(scf_handle_t *scfhandle, scf_propertygroup_t *pg,

{

	svcerr_t se = SE_OK;

	scf_iter_t *piter = scf_iter_create(scfhandle);

	scf_iter_t *viter = scf_iter_create(scfhandle);

	scf_value_t *value = scf_value_create(scfhandle);

	scf_property_t *prop = scf_property_create(scfhandle);

	if (piter == NULL || viter == NULL || value == NULL || prop == NULL) {

		se = SE_FATAL;

		goto out;

	}

	if (scf_iter_pg_properties(piter, pg) == -1) {

		se = smfu_maperr(scf_error());

		goto out;

	}

	int err;

	while ((err = scf_iter_next_property(piter, prop)) > 0) {

		if ((se = create_Property(prop, viter, value, &propdata,

		    error)) != SE_OK)

			goto out;

	}

	if (err != 0)

		se = smfu_maperr(scf_error());

out:

	if (se != SE_OK)

	else

		*ret = result;

	scf_iter_destroy(piter);

	scf_iter_destroy(viter);

	scf_value_destroy(value);

	scf_property_destroy(prop);

	return (se);

}

svcerr_t

create_ExtendedState(scf_handle_t *scfhandle, scf_instance_t *instance,

{

	scf_propertygroup_t *pg = scf_pg_create(scfhandle);

	scf_property_t *prop = scf_property_create(scfhandle);

	scf_value_t *value = scf_value_create(scfhandle);

	svcerr_t se = SE_FATAL;

	int serr;

	char *str;

	int64_t sec;

	int32_t nsec;

	uint64_t ctid;

	uint8_t bool;

	if (pg == NULL || prop == NULL || value == NULL)

		goto error;

	if (scf_instance_get_pg(instance, SCF_PG_RESTARTER, pg) == -1)

		goto scferror;

	if (scf_pg_get_property(pg, SCF_PROPERTY_STATE, prop) == -1 ||

	    scf_property_get_value(prop, value) == -1)

		goto scferror;

	if (smfu_value_get_string(value, &str) != 0)

		goto error;

	free(str);

	if (scf_pg_get_property(pg, SCF_PROPERTY_NEXT_STATE, prop) == -1 ||

	    scf_property_get_value(prop, value) == -1)

		goto scferror;

	if (smfu_value_get_string(value, &str) != 0)

		goto error;

	free(str);

	if (scf_pg_get_property(pg, SCF_PROPERTY_AUX_STATE, prop) == -1 ||

	    scf_property_get_value(prop, value) == -1)

		goto scferror;

	if (smfu_value_get_string(value, &str) != 0)

		goto error;

		goto error;

	if (scf_pg_get_property(pg, SCF_PROPERTY_STATE_TIMESTAMP, prop) == -1 ||

	    scf_property_get_value(prop, value) == -1 ||

	    scf_value_get_time(value, &sec, &nsec) == -1)

		goto scferror;

	if (scf_pg_get_property(pg, SCF_PROPERTY_CONTRACT, prop) == -1 ||

	    scf_property_get_value(prop, value) == -1) {

		if (scf_error() == SCF_ERROR_NOT_FOUND)

		else

			goto scferror;

	} else if (scf_value_get_count(value, &ctid) == -1) {

		goto scferror;

	} else {

	}

	if ((serr = smfu_read_enabled(instance, pg, prop, value, SCF_PG_GENERAL,

	    &bool)) != 0) {

		se = smfu_maperr(serr);

		goto error;

	}