+/*

+ * smf probe:

+ *

+ * fmri

+ * service_name

+ * service_state

+ * protocol

+ * server_executable

+ * server_arguements

+ * exec_as_user

+ */

+

+#include <stdlib.h>

+#include <string.h>

+#include <stdio.h>

+#include <errno.h>

+#include <sys/stat.h>

+#include <ctype.h>

+#include <sys/types.h>

+#include <limits.h>

+#include <unistd.h>

+#include <libscf.h>

+#include <libscf_priv.h>

+#include "seap.h"

+#include "probe/entcmp.h"

+#include "alloc.h"

+#include "common/debug_priv.h"

+

+#ifndef SCF_PG_START

+#define	SCF_PG_START	"start"

+#endif

+

+/* Convenience structure for the results being reported */

+struct result_info {

+	const char *fmri;

+	char *service_name;

+	char *service_state;

+	char *protocol;

+	char *server_executable;

+	char *server_arguments;

+	char *exec_as_user;

+};

+static void

+toUpperCase(char *str)

+{

+	int i = 0;

+

+	if (str != NULL) {

+		while (str[i] != '\0') {

+			str[i] = toupper(str[i]);

+			i++;

+		}

+	}

+}

+

+static char *

+strdup_check(char *p)

+	char *ret;

+

+	if ((ret = strdup(p)) == NULL) {

+		oscap_dlprintf(DBG_E, "Error: Out of Memory error.\n");

+		exit(PROBE_ENOMEM);

+	}

+	return (ret);

+}

+

+    const char *prop_grp_name, const char *prop_name, char **val)

+{

+	scf_simple_prop_t *prop;

+	*val = NULL;

+

+	if ((prop = scf_simple_prop_get(h, fmri, prop_grp_name,

+	    prop_name)) == NULL) {

+			oscap_dlprintf(DBG_E, "Error: Specified service "

+			    " %s has no %s/%s property.\n",

+			    fmri, prop_grp_name, prop_name);

+		}

+	} else {

+		    scf_simple_prop_next_astring(prop)) == NULL) {

+			oscap_dlprintf(DBG_E,

+			    "Error: Could not read "

+			    " %s/%s property of %s.\n",

+			    prop_grp_name,

+			    prop_name,

+			    fmri);

+		}

+		scf_simple_prop_free(prop);

+	}

+}

+

+

+static void

+report_finding(struct result_info *res, probe_ctx *ctx)

+{

+	SEXP_t *item;

+

+	oscap_dlprintf(DBG_I, "In report_finding.\n");

+	item = probe_item_create(OVAL_SOLARIS_SMF, NULL,

+	    "fmri", OVAL_DATATYPE_STRING, res->fmri,

+	    "service_name", OVAL_DATATYPE_STRING, res->service_name,

+	    "service_state", OVAL_DATATYPE_STRING, res->service_state,

+	    "protocol", OVAL_DATATYPE_STRING, res->protocol,

+	    "server_executable", OVAL_DATATYPE_STRING,

+	    res->server_executable,

+	    "server_arguments", OVAL_DATATYPE_STRING,

+	    res->server_arguments,

+	    "exec_as_user", OVAL_DATATYPE_STRING, res->exec_as_user,

+	    NULL);

+	probe_item_collect(ctx, item);

+}

+

+static int

+collect_smf_info(char *fmri, probe_ctx *ctx)

+{

+	struct result_info r;

+	const char *service, *instance, *scope, *propgrp, *prop;

+	char *tmp;

+

+	oscap_dlprintf(DBG_I, "In collect_smf_info.\n");

+	memset(&r, 0, sizeof (r));

+	r.service_name = strdup_check(fmri);

+	tmp = r.service_name;

+	scf_parse_fmri(r.service_name, &type, &scope, &service,

+	    &instance, &propgrp, &prop);

+	if (scf_error() == SCF_ERROR_INVALID_ARGUMENT) {

+	}

+	if (instance == NULL)

+		r.service_name = strdup(service);

+	else /* service name is service:instance */

+		asprintf(&r.service_name, "%s:%s", service, instance);

+	if (r.service_name == NULL)

+		exit(PROBE_ENOMEM);

+	free(tmp);

+	r.fmri = fmri;

+	}

+	report_finding(&r, ctx);

+	free(r.protocol);

+	free(r.service_state);

+	free(r.server_executable);

+	free(r.server_arguments);

+	free(r.exec_as_user);

+}

+

+int

+probe_main(probe_ctx *ctx, void *arg)

+{

+	SEXP_t *fmri, *fmri_val, *probe_in;

+	char *fmri_str;

+	int rc;

+

+	probe_in = probe_ctx_getobject(ctx);

+	if (probe_in == NULL) {

+		oscap_dlprintf(DBG_E, "No object in context.\n");

+		return (PROBE_ENOVAL);

+	}

+	fmri = probe_obj_getent(probe_in, "fmri", 1);

+	if (fmri == NULL) {

+		oscap_dlprintf(DBG_E, "No fmri in context.\n");

+		return (PROBE_ENOVAL);

+	}

+	fmri_val = probe_ent_getval(fmri);

+	fmri_str = SEXP_string_cstr(fmri_val);

+	oscap_dlprintf(DBG_I, "fmri in context: %s.\n", fmri_str);

+	rc = collect_smf_info(fmri_str, ctx);

+	free(fmri_str);

+	SEXP_free(fmri_val);

+	SEXP_free(fmri);

+	return (rc);

 }