int
internal_attach_entity(entity_t *svc, entity_t *ent)
{
if (ent->sc_etype == SVCCFG_TEMPLATE_OBJECT) {
svc->sc_u.sc_service.sc_service_template = ent;
return (0);
}
if (svc->sc_etype != SVCCFG_SERVICE_OBJECT)
uu_die(gettext("bad entity attach: %s is not a service\n"),
svc->sc_name);
if (uu_list_find(svc->sc_u.sc_service.sc_service_instances, ent, NULL,
NULL) != NULL) {
semerr(gettext("Multiple definitions of entity %s in service "
"%s.\n"), ent->sc_name, svc->sc_name);
return (-1);
}
(void) uu_list_prepend(svc->sc_u.sc_service.sc_service_instances, ent);
ent->sc_parent = svc;
ent->sc_fmri = uu_msprintf("%s:%s", svc->sc_fmri, ent->sc_name);
if (ent->sc_fmri == NULL)
uu_die(gettext("couldn't allocate memory"));
return (0);
}
int
internal_attach_service(bundle_t *bndl, entity_t *svc)
{
if (uu_list_find(bndl->sc_bundle_services, svc, NULL, NULL) != NULL) {
semerr(gettext("Multiple definitions for service %s in "
"bundle %s.\n"), svc->sc_name, bndl->sc_bundle_name);
return (-1);
}
(void) uu_list_append(bndl->sc_bundle_services, svc);
return (0);
}
int
internal_attach_dependent(entity_t *ent, pgroup_t *pg)
{
if (uu_list_find(ent->sc_dependents, pg, NULL, NULL) != NULL) {
semerr(gettext("Multiple definitions of dependent %s in "
"entity %s.\n"), pg->sc_pgroup_name, ent->sc_name);
return (-1);
}
(void) uu_list_append(ent->sc_dependents, pg);
pg->sc_parent = ent;
return (0);
}
int
internal_attach_pgroup(entity_t *ent, pgroup_t *pgrp)
{
if (uu_list_find(ent->sc_pgroups, pgrp, NULL, NULL) != NULL) {
semerr(gettext("Multiple definitions of property group %s in "
"entity %s.\n"), pgrp->sc_pgroup_name, ent->sc_name);
return (-1);
}
(void) uu_list_append(ent->sc_pgroups, pgrp);
pgrp->sc_parent = ent;
return (0);
}
/*
* Returns
* 0 - success
* -1 - prop already exists in pgrp
*/
int
internal_attach_property(pgroup_t *pgrp, property_t *prop)
{
uu_list_index_t idx;
if (uu_list_find(pgrp->sc_pgroup_props, prop, NULL, &idx) != NULL) {
semerr(gettext("Multiple definitions for property %s in "
"property group %s.\n"), prop->sc_property_name,
pgrp->sc_pgroup_name);
return (-1);
}
uu_list_insert(pgrp->sc_pgroup_props, prop, idx);
return (0);
}
int
engine_apply(const char *file)
{
int ret;
bundle_t *b;
char *pname;
uchar_t hash[MHASH_SIZE];
lscf_prep_hndl();
ret = mhash_test_file(g_hndl, file, 1, &pname, hash);
if (ret != MHASH_NEWFILE)
return (ret);
b = internal_bundle_new();
if (lxml_get_bundle_file(b, file, 1) != 0) {
internal_bundle_free(b);
return (-1);
}
if (lscf_bundle_apply(b) != 0) {
internal_bundle_free(b);
return (-1);
}
internal_bundle_free(b);
if (pname) {
char *errstr;
if (mhash_store_entry(g_hndl, pname, hash, &errstr))
semerr(errstr);
free(pname);
}
return (0);
}
/* release a semaphore */
STATUS
Vsem(
CS_SEMAPHORE *sp)
{
STATUS rv;
#ifdef EX_DEBUG
EX_CONTEXT context;
if (EXdeclare(ex_handler, &context) != OK) {
/* some exception was raised */
SIfprintf( stderr,"Error: unexpected exception in Vsem()...");
EXdelete();
return FAIL;
}
#endif
if( rv = CSv_semaphore( sp ) )
semerr( rv, sp, "Vsem" );
#ifdef EX_DEBUG
EXdelete();
#endif
return( rv );
}
int
engine_import(uu_list_t *args)
{
int ret, argc, i, o;
bundle_t *b;
char *file, *pname;
uchar_t hash[MHASH_SIZE];
char **argv;
string_list_t *slp;
boolean_t verify = B_FALSE;
uint_t flags = SCI_GENERALLAST;
argc = uu_list_numnodes(args);
if (argc < 1)
return (-2);
argv = calloc(argc + 1, sizeof (char *));
if (argv == NULL)
uu_die(gettext("Out of memory.\n"));
for (slp = uu_list_first(args), i = 0;
slp != NULL;
slp = uu_list_next(args, slp), ++i)
argv[i] = slp->str;
argv[i] = NULL;
opterr = 0;
optind = 0; /* Remember, no argv[0]. */
for (;;) {
o = getopt(argc, argv, "nV");
if (o == -1)
break;
switch (o) {
case 'n':
flags |= SCI_NOREFRESH;
break;
case 'V':
verify = B_TRUE;
break;
case '?':
free(argv);
return (-2);
default:
bad_error("getopt", o);
}
}
argc -= optind;
if (argc != 1) {
free(argv);
return (-2);
}
file = argv[optind];
free(argv);
lscf_prep_hndl();
ret = mhash_test_file(g_hndl, file, 0, &pname, hash);
if (ret != MHASH_NEWFILE)
return (ret);
/* Load */
b = internal_bundle_new();
if (lxml_get_bundle_file(b, file, 0) != 0) {
internal_bundle_free(b);
return (-1);
}
/* Import */
if (lscf_bundle_import(b, file, flags) != 0) {
internal_bundle_free(b);
return (-1);
}
internal_bundle_free(b);
if (g_verbose)
warn(gettext("Successful import.\n"));
if (pname) {
char *errstr;
if (mhash_store_entry(g_hndl, pname, hash, &errstr)) {
if (errstr)
semerr(errstr);
else
semerr(gettext("Unknown error from "
"mhash_store_entry()\n"));
}
free(pname);
}
/* Verify */
if (verify)
warn(gettext("import -V not implemented.\n"));
return (0);
}
int
engine_source(const char *name, boolean_t dont_exit)
{
engine_state_t *old = est;
struct stat st;
int ret;
est = uu_zalloc(sizeof (engine_state_t));
/* first, copy the stuff set up in engine_init */
est->sc_repo_pid = old->sc_repo_pid;
if (old->sc_repo_filename != NULL)
est->sc_repo_filename = safe_strdup(old->sc_repo_filename);
if (old->sc_repo_doordir != NULL)
est->sc_repo_doordir = safe_strdup(old->sc_repo_doordir);
if (old->sc_repo_doorname != NULL)
est->sc_repo_doorname = safe_strdup(old->sc_repo_doorname);
if (old->sc_repo_server != NULL)
est->sc_repo_server = safe_strdup(old->sc_repo_server);
/* set up the new guy */
est->sc_cmd_lineno = 1;
if (dont_exit)
est->sc_cmd_flags |= SC_CMD_DONT_EXIT;
if (strcmp(name, "-") == 0) {
est->sc_cmd_file = stdin;
est->sc_cmd_filename = "<stdin>";
} else {
errno = 0;
est->sc_cmd_filename = name;
est->sc_cmd_file = fopen(name, "r");
if (est->sc_cmd_file == NULL) {
if (errno == 0)
semerr(gettext("No free stdio streams.\n"));
else
semerr(gettext("Could not open %s"), name);
ret = -1;
goto fail;
}
do
ret = fstat(fileno(est->sc_cmd_file), &st);
while (ret != 0 && errno == EINTR);
if (ret != 0) {
(void) fclose(est->sc_cmd_file);
est->sc_cmd_file = NULL; /* for semerr() */
semerr(gettext("Could not stat %s"), name);
ret = -1;
goto fail;
}
if (!S_ISREG(st.st_mode)) {
(void) fclose(est->sc_cmd_file);
est->sc_cmd_file = NULL; /* for semerr() */
semerr(gettext("%s is not a regular file.\n"), name);
ret = -1;
goto fail;
}
}
(void) yyparse();
if (est->sc_cmd_file != stdin)
(void) fclose(est->sc_cmd_file);
ret = 0;
fail:
if (est->sc_repo_pid != old->sc_repo_pid)
lscf_cleanup(); /* clean up any new repository */
if (est->sc_repo_filename != NULL)
free((void *)est->sc_repo_filename);
if (est->sc_repo_doordir != NULL)
free((void *)est->sc_repo_doordir);
if (est->sc_repo_doorname != NULL)
free((void *)est->sc_repo_doorname);
if (est->sc_repo_server != NULL)
free((void *)est->sc_repo_server);
free(est);
est = old;
return (ret);
}
