1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Routines used by inetd to read inetd's configuration from the repository,
28 * to validate it and setup inetd's data structures appropriately based on
29 * in.
30 */
31
32 #include <stdlib.h>
33 #include <string.h>
34 #include <errno.h>
35 #include <unistd.h>
36 #include <netdb.h>
37 #include <netinet/in.h>
38 #include <libintl.h>
39 #include <nss_dbdefs.h>
40 #include <signal.h>
41 #include <wait.h>
42 #include "inetd_impl.h"
43
44
45 /* method timeout used if one isn't explicitly specified */
46 #define DEFAULT_METHOD_TIMEOUT 10
47
48
49 /* supported method properties and their attributes */
50 static inetd_prop_t method_props[] = {
51 {PR_EXEC_NAME, "", INET_TYPE_STRING, B_FALSE, IVE_UNSET, NULL, B_FALSE},
52 {PR_ARG0_NAME, "", INET_TYPE_STRING, B_TRUE, IVE_UNSET, NULL, B_FALSE},
53 {SCF_PROPERTY_TIMEOUT, "", INET_TYPE_COUNT, B_TRUE, IVE_UNSET, NULL, B_FALSE},
54 {NULL},
55 };
56
57 /* enumeration of method properties; used to index into method_props[] */
58 typedef enum {
59 MP_EXEC,
60 MP_ARG0,
61 MP_TIMEOUT
62 } method_prop_t;
63
64
65 /* handle used for repository access in read_prop() */
66 static scf_handle_t *rep_handle = NULL;
67
68 /* pool used to create proto_info_t lists (generic proto info structure) */
69 static uu_list_pool_t *proto_info_pool = NULL;
70
71 static void destroy_method_props(inetd_prop_t *);
72 static int proto_info_compare(const void *, const void *, void *);
73
74 int
config_init(void)75 config_init(void)
76 {
77 if ((rep_handle = scf_handle_create(SCF_VERSION)) == NULL) {
78 error_msg("%s: %s",
79 gettext("Failed to create repository handle"),
80 scf_strerror(scf_error()));
81 return (-1);
82 } else if (make_handle_bound(rep_handle) == -1) {
83 /* let config_fini clean-up */
84 return (-1);
85 }
86
87 if ((proto_info_pool = uu_list_pool_create("proto_info_pool",
88 sizeof (proto_info_t), offsetof(proto_info_t, link),
89 proto_info_compare, UU_LIST_POOL_DEBUG)) == NULL) {
90 error_msg(gettext("Failed to create uu list pool: %s"),
91 uu_strerror(uu_error()));
92 return (-1);
93 }
94
95 return (0);
96 }
97
98 void
config_fini(void)99 config_fini(void)
100 {
101 if (rep_handle == NULL)
102 return;
103
104 if (proto_info_pool != NULL) {
105 uu_list_pool_destroy(proto_info_pool);
106 proto_info_pool = NULL;
107 }
108
109 (void) scf_handle_unbind(rep_handle);
110 scf_handle_destroy(rep_handle);
111 rep_handle = NULL;
112 }
113
114 static void
destroy_method_info(method_info_t * mi)115 destroy_method_info(method_info_t *mi)
116 {
117 if (mi == NULL)
118 return;
119
120 if (mi->wordexp_arg0_backup != NULL) {
121 /*
122 * Return the wordexp structure back to its original
123 * state so it can be consumed by wordfree.
124 */
125 free(mi->exec_args_we.we_wordv[0]);
126 mi->exec_args_we.we_wordv[0] =
127 (char *)mi->wordexp_arg0_backup;
128 }
129
130 free(mi->exec_path);
131
132 wordfree(&mi->exec_args_we);
133
134 free(mi);
135 }
136
137 /*
138 * Transforms the properties read from the repository for a method into a
139 * method_info_t and returns a pointer to it. If expansion of the exec
140 * property fails, due to an invalid string or memory allocation failure,
141 * NULL is returned and exec_invalid is set appropriately to indicate whether
142 * it was a memory allocation failure or an invalid exec string.
143 */
144 static method_info_t *
create_method_info(const inetd_prop_t * mprops,boolean_t * exec_invalid)145 create_method_info(const inetd_prop_t *mprops, boolean_t *exec_invalid)
146 {
147 method_info_t *ret;
148 int i;
149
150 if ((ret = calloc(1, sizeof (method_info_t))) == NULL)
151 goto alloc_fail;
152
153 /* Expand the exec string. */
154 if ((i = wordexp(get_prop_value_string(mprops, PR_EXEC_NAME),
155 &ret->exec_args_we, WRDE_NOCMD|WRDE_UNDEF)) != 0) {
156 if (i == WRDE_NOSPACE)
157 goto alloc_fail;
158
159 *exec_invalid = B_TRUE;
160 free(ret);
161 return (NULL);
162 }
163
164 if ((ret->exec_path = strdup(ret->exec_args_we.we_wordv[0])) == NULL)
165 goto alloc_fail;
166
167 if (mprops[MP_ARG0].ip_error == IVE_VALID) { /* arg0 is set */
168 /*
169 * Keep a copy of arg0 of the wordexp structure so that
170 * wordfree() gets passed what wordexp() originally returned,
171 * as documented as required in the man page.
172 */
173 ret->wordexp_arg0_backup = ret->exec_args_we.we_wordv[0];
174 if ((ret->exec_args_we.we_wordv[0] =
175 strdup(get_prop_value_string(mprops, PR_ARG0_NAME)))
176 == NULL)
177 goto alloc_fail;
178 }
179
180 if (mprops[MP_TIMEOUT].ip_error == IVE_VALID) {
181 ret->timeout = get_prop_value_count(mprops,
182 SCF_PROPERTY_TIMEOUT);
183 } else {
184 ret->timeout = DEFAULT_METHOD_TIMEOUT;
185 }
186
187 /* exec_invalid not set on success */
188
189 return (ret);
190
191 alloc_fail:
192 error_msg(strerror(errno));
193 destroy_method_info(ret);
194 *exec_invalid = B_FALSE;
195 return (NULL);
196 }
197
198 /*
199 * Returns B_TRUE if the contents of the 2 method_info_t structures are
200 * equivalent, else B_FALSE.
201 */
202 boolean_t
method_info_equal(const method_info_t * mi,const method_info_t * mi2)203 method_info_equal(const method_info_t *mi, const method_info_t *mi2)
204 {
205 int i;
206
207 if ((mi == NULL) && (mi2 == NULL)) {
208 return (B_TRUE);
209 } else if (((mi == NULL) || (mi2 == NULL)) ||
210 (mi->exec_args_we.we_wordc != mi2->exec_args_we.we_wordc) ||
211 (strcmp(mi->exec_path, mi2->exec_path) != 0)) {
212 return (B_FALSE);
213 }
214
215 for (i = 0; i < mi->exec_args_we.we_wordc; i++) {
216 if (strcmp(mi->exec_args_we.we_wordv[i],
217 mi2->exec_args_we.we_wordv[i]) != 0) {
218 return (B_FALSE);
219 }
220 }
221
222 return (B_TRUE);
223 }
224
225 /*
226 * Checks if the contents of the 2 socket_info_t structures are equivalent.
227 * If 'isrpc' is false, the address components of the two structures are
228 * compared for equality as part of this. If the two structures are
229 * equivalent B_TRUE is returned, else B_FALSE.
230 */
231 boolean_t
socket_info_equal(const socket_info_t * si,const socket_info_t * si2,boolean_t isrpc)232 socket_info_equal(const socket_info_t *si, const socket_info_t *si2,
233 boolean_t isrpc)
234 {
235 return ((isrpc || (memcmp(&si->local_addr, &si2->local_addr,
236 sizeof (si->local_addr)) == 0)) &&
237 (si->type == si2->type));
238
239 }
240
241 /*
242 * proto_info_t comparison function. Returns 0 on match, else -1, as required
243 * by uu_list_find().
244 */
245 static int
proto_info_compare(const void * lv,const void * rv,void * istlx)246 proto_info_compare(const void *lv, const void *rv, void *istlx)
247 {
248 proto_info_t *pi = (proto_info_t *)lv;
249 proto_info_t *pi2 = (proto_info_t *)rv;
250
251 /* check their RPC configuration matches */
252 if (pi->ri != NULL) {
253 if ((pi2->ri == NULL) || !rpc_info_equal(pi->ri, pi2->ri))
254 return (-1);
255 } else if (pi2->ri != NULL) {
256 return (-1);
257 }
258
259 if (pi->v6only != pi2->v6only)
260 return (-1);
261
262 if (*(boolean_t *)istlx) {
263 if (tlx_info_equal((tlx_info_t *)lv, (tlx_info_t *)rv,
264 pi->ri != NULL))
265 return (0);
266 } else {
267 if (socket_info_equal((socket_info_t *)lv,
268 (socket_info_t *)rv, pi->ri != NULL))
269 return (0);
270 }
271 return (-1);
272 }
273
274 /*
275 * Returns B_TRUE if the bind configuration of the two instance_cfg_t
276 * structures are equivalent, else B_FALSE.
277 */
278 boolean_t
bind_config_equal(const basic_cfg_t * c1,const basic_cfg_t * c2)279 bind_config_equal(const basic_cfg_t *c1, const basic_cfg_t *c2)
280 {
281 proto_info_t *pi;
282
283 if ((c1->iswait != c2->iswait) ||
284 (c1->istlx != c2->istlx))
285 return (B_FALSE);
286
287 if (uu_list_numnodes(c1->proto_list) !=
288 uu_list_numnodes(c2->proto_list))
289 return (B_FALSE);
290 /*
291 * For each element in the first configuration's socket/tlx list,
292 * check there's a matching one in the other list.
293 */
294 for (pi = uu_list_first(c1->proto_list); pi != NULL;
295 pi = uu_list_next(c1->proto_list, pi)) {
296 uu_list_index_t idx;
297
298 if (uu_list_find(c2->proto_list, pi, (void *)&c1->istlx,
299 &idx) == NULL)
300 return (B_FALSE);
301 }
302
303 return (B_TRUE);
304 }
305
306 /*
307 * Write the default values contained in 'bprops', read by
308 * read_instance_props(), into 'cfg'.
309 * Returns -1 if memory allocation fails, else 0.
310 */
311 static int
populate_defaults(inetd_prop_t * bprops,basic_cfg_t * cfg)312 populate_defaults(inetd_prop_t *bprops, basic_cfg_t *cfg)
313 {
314 cfg->do_tcp_wrappers = get_prop_value_boolean(bprops,
315 PR_DO_TCP_WRAPPERS_NAME);
316 cfg->do_tcp_trace = get_prop_value_boolean(bprops,
317 PR_DO_TCP_TRACE_NAME);
318 cfg->do_tcp_keepalive = get_prop_value_boolean(bprops,
319 PR_DO_TCP_KEEPALIVE_NAME);
320 cfg->inherit_env = get_prop_value_boolean(bprops, PR_INHERIT_ENV_NAME);
321 cfg->wait_fail_cnt = get_prop_value_int(bprops,
322 PR_MAX_FAIL_RATE_CNT_NAME);
323 cfg->wait_fail_interval = get_prop_value_int(bprops,
324 PR_MAX_FAIL_RATE_INTVL_NAME);
325 cfg->max_copies = get_prop_value_int(bprops, PR_MAX_COPIES_NAME);
326 cfg->conn_rate_offline = get_prop_value_int(bprops,
327 PR_CON_RATE_OFFLINE_NAME);
328 cfg->conn_rate_max = get_prop_value_int(bprops, PR_CON_RATE_MAX_NAME);
329 cfg->bind_fail_interval = get_prop_value_int(bprops,
330 PR_BIND_FAIL_INTVL_NAME);
331 cfg->bind_fail_max = get_prop_value_int(bprops, PR_BIND_FAIL_MAX_NAME);
332 cfg->conn_backlog = get_prop_value_int(bprops,
333 PR_CONNECTION_BACKLOG_NAME);
334 if ((cfg->bind_addr =
335 strdup(get_prop_value_string(bprops, PR_BIND_ADDR_NAME))) == NULL) {
336 error_msg(strerror(errno));
337 return (-1);
338 }
339 return (0);
340 }
341
342 void
destroy_method_infos(method_info_t ** mis)343 destroy_method_infos(method_info_t **mis)
344 {
345 int i;
346
347 for (i = 0; i < NUM_METHODS; i++) {
348 destroy_method_info(mis[i]);
349 mis[i] = NULL;
350 }
351 }
352
353 /*
354 * For each method, if it was specifed convert its entry in 'mprops',
355 * into an entry in 'mis'. Returns -1 if memory allocation fails or one of the
356 * exec strings was invalid, else 0.
357 */
358 static int
create_method_infos(const char * fmri,inetd_prop_t ** mprops,method_info_t ** mis)359 create_method_infos(const char *fmri, inetd_prop_t **mprops,
360 method_info_t **mis)
361 {
362 int i;
363
364 for (i = 0; i < NUM_METHODS; i++) {
365 /*
366 * Only create a method info structure if the method properties
367 * contain an exec string, which we take to mean the method
368 * is specified.
369 */
370 if (mprops[i][MP_EXEC].ip_error == IVE_VALID) {
371 boolean_t exec_invalid;
372
373 if ((mis[i] = create_method_info(mprops[i],
374 &exec_invalid)) == NULL) {
375 if (exec_invalid) {
376 error_msg(gettext("Property %s for "
377 "method %s of instance %s is "
378 "invalid"), PR_EXEC_NAME,
379 methods[i].name, fmri);
380 }
381 return (-1);
382 }
383 }
384 }
385 return (0);
386 }
387
388 /*
389 * Try and read each of the method properties for the method 'method' of
390 * instance 'inst', and return a table containing all method properties. If an
391 * error occurs, NULL is returned, with 'err' set to indicate the cause.
392 * Otherwise, a pointer to an inetd_prop_t table is returned containing all
393 * the method properties, and each of the properties is flagged according to
394 * whether it was present or not, and if it was present its value is set in
395 * the property's entry in the table.
396 */
397 static inetd_prop_t *
read_method_props(const char * inst,instance_method_t method,scf_error_t * err)398 read_method_props(const char *inst, instance_method_t method, scf_error_t *err)
399 {
400 inetd_prop_t *ret;
401 int i;
402
403 if ((ret = calloc(1, sizeof (method_props))) == NULL) {
404 *err = SCF_ERROR_NO_MEMORY;
405 return (NULL);
406 }
407
408 (void) memcpy(ret, method_props, sizeof (method_props));
409 for (i = 0; ret[i].ip_name != NULL; i++) {
410 *err = read_prop(rep_handle, &ret[i], i, inst,
411 methods[method].name);
412 if ((*err != 0) && (*err != SCF_ERROR_NOT_FOUND)) {
413 destroy_method_props(ret);
414 return (NULL);
415 }
416 }
417
418 return (ret);
419 }
420
421 static void
destroy_method_props(inetd_prop_t * mprop)422 destroy_method_props(inetd_prop_t *mprop)
423 {
424 int i;
425
426 if (mprop == NULL)
427 return;
428
429 for (i = 0; mprop[i].ip_name != NULL; i++) {
430 if (mprop[i].ip_type == INET_TYPE_STRING &&
431 mprop[i].ip_error == IVE_VALID)
432 free(mprop[i].ip_value.iv_string);
433 }
434
435 free(mprop);
436 }
437
438 /*
439 * Destroy the basic and method properties returned by read_inst_props().
440 */
441 static void
destroy_inst_props(inetd_prop_t * bprops,inetd_prop_t ** mprops)442 destroy_inst_props(inetd_prop_t *bprops, inetd_prop_t **mprops)
443 {
444 int i;
445
446 free_instance_props(bprops);
447 for (i = 0; i < NUM_METHODS; i++)
448 destroy_method_props(mprops[i]);
449 }
450
451 /*
452 * Read all the basic and method properties for instance 'inst', as inetd_prop_t
453 * tables, into the spaces referenced by 'bprops' and 'mprops' respectively.
454 * Each of the properties in the tables are flagged to indicate if the
455 * property was present or not, and if it was the value is stored within it.
456 * If an error occurs at any time -1 is returned and 'err' is set to
457 * indicate the reason, else 0 is returned.
458 */
459 static int
read_inst_props(const char * fmri,inetd_prop_t ** bprops,inetd_prop_t ** mprops,scf_error_t * err)460 read_inst_props(const char *fmri, inetd_prop_t **bprops,
461 inetd_prop_t **mprops, scf_error_t *err)
462 {
463 size_t nprops;
464 int i;
465
466 if ((*bprops = read_instance_props(rep_handle, (char *)fmri, &nprops,
467 err)) == NULL)
468 return (-1);
469
470 for (i = 0; i < NUM_METHODS; i++) {
471 if ((mprops[i] =
472 read_method_props(fmri, (instance_method_t)i, err)) ==
473 NULL) {
474 for (i--; i >= 0; i--)
475 destroy_method_props(mprops[i]);
476 free_instance_props(*bprops);
477 return (-1);
478 }
479 }
480
481 return (0);
482 }
483
484 /*
485 * Returns B_TRUE if all required properties were read from the repository
486 * (whether taken from the defaults or directly from the instance), they
487 * all had valid values, all the required methods were present, and they
488 * each had the required properties with valid values. Else, returns B_FALSE.
489 * If the function returns B_TRUE, the storage referenced by 'cfg' is set
490 * to point at an allocated instance_cfg_t initialized based on the basic
491 * properties (not method or defaults).
492 */
493 static boolean_t
valid_inst_props(const char * fmri,inetd_prop_t * bprops,inetd_prop_t ** mprops,basic_cfg_t ** cfg)494 valid_inst_props(const char *fmri, inetd_prop_t *bprops, inetd_prop_t **mprops,
495 basic_cfg_t **cfg)
496 {
497 boolean_t valid;
498 size_t num_bprops;
499 int i;
500
501 valid = valid_props(bprops, fmri, cfg, proto_info_pool, conn_ind_pool);
502
503 /*
504 * Double check we've got all necessary properties (valid_props()
505 * doesn't enforce the presence of defaults), and output error messages
506 * for each invalid/ missing property.
507 */
508 (void) get_prop_table(&num_bprops);
509 for (i = 0; bprops[i].ip_name != NULL; i++) {
510 switch (bprops[i].ip_error) {
511 case IVE_UNSET:
512 if (!bprops[i].ip_default)
513 continue;
514 if ((i == PT_ARG0_INDEX) || (i == PT_EXEC_INDEX))
515 continue;
516 /* FALLTHROUGH */
517 case IVE_INVALID:
518 error_msg(gettext("Property '%s' of instance "
519 "%s is missing, inconsistent or invalid"),
520 bprops[i].ip_name, fmri);
521 valid = B_FALSE;
522 }
523 }
524
525 for (i = 0; i < NUM_METHODS; i++) {
526 int j;
527
528 /* check if any properties are set */
529 for (j = 0; mprops[i][j].ip_name != NULL; j++) {
530 if (mprops[i][j].ip_error != IVE_UNSET)
531 break;
532 }
533
534 if (mprops[i][j].ip_name == NULL) {
535 /* an unspecified method */
536 if ((instance_method_t)i == IM_START) {
537 error_msg(gettext(
538 "Unspecified %s method for instance %s"),
539 START_METHOD_NAME, fmri);
540 valid = B_FALSE;
541 }
542 } else if (mprops[i][MP_EXEC].ip_error == IVE_UNSET) {
543 error_msg(gettext("Missing %s property from method %s "
544 "of instance %s"), PR_EXEC_NAME,
545 methods[(instance_method_t)i].name, fmri);
546 valid = B_FALSE;
547 }
548 }
549
550 if (!valid) {
551 destroy_basic_cfg(*cfg);
552 *cfg = NULL;
553 }
554
555 return (valid);
556 }
557
558 void
destroy_instance_cfg(instance_cfg_t * cfg)559 destroy_instance_cfg(instance_cfg_t *cfg)
560 {
561 if (cfg != NULL) {
562 destroy_basic_cfg(cfg->basic);
563 destroy_method_infos(cfg->methods);
564 free(cfg);
565 }
566 }
567
568 /*
569 * Returns an allocated instance_cfg_t representation of an instance's
570 * configuration read from the repository. If the configuration is invalid, a
571 * repository error occurred, or a memory allocation occurred returns NULL,
572 * else returns a pointer to the allocated instance_cfg_t.
573 */
574 instance_cfg_t *
read_instance_cfg(const char * fmri)575 read_instance_cfg(const char *fmri)
576 {
577 uint_t retries;
578 inetd_prop_t *bprops;
579 inetd_prop_t *mprops[NUM_METHODS];
580 instance_cfg_t *ret = NULL;
581 scf_error_t err;
582
583 if ((ret = calloc(1, sizeof (instance_cfg_t))) == NULL)
584 return (NULL);
585
586 for (retries = 0; retries <= REP_OP_RETRIES; retries++) {
587 if (make_handle_bound(rep_handle) == -1) {
588 err = scf_error();
589 goto read_error;
590 }
591
592 if (read_inst_props(fmri, &bprops, mprops, &err) == 0)
593 break;
594 if (err != SCF_ERROR_CONNECTION_BROKEN)
595 goto read_error;
596 (void) scf_handle_unbind(rep_handle);
597 }
598 if (retries > REP_OP_RETRIES)
599 goto read_error;
600
601 /*
602 * Switch off validation of the start method's exec string, since
603 * during boot the filesystem it resides on may not have been
604 * mounted yet, which would result in a false validation failure.
605 * We'll catch any real errors when the start method is first run
606 * in passes_basic_exec_checks().
607 */
608 bprops[PT_EXEC_INDEX].ip_error = IVE_UNSET;
609
610 if ((!valid_inst_props(fmri, bprops, mprops, &ret->basic)) ||
611 (populate_defaults(bprops, ret->basic) != 0) ||
612 (create_method_infos(fmri, mprops, ret->methods) != 0)) {
613 destroy_instance_cfg(ret);
614 ret = NULL;
615 }
616
617 destroy_inst_props(bprops, mprops);
618 return (ret);
619
620 read_error:
621 error_msg(gettext(
622 "Failed to read the configuration of instance %s: %s"), fmri,
623 scf_strerror(err));
624 free(ret);
625 return (NULL);
626 }
627
628 /*
629 * Returns a pointer to an allocated method context for the specified method
630 * of the specified instance if it could retrieve it. Else, if there were
631 * errors retrieving it, NULL is returned and the pointer referenced by
632 * 'errstr' is set to point at an appropriate error string.
633 */
634 struct method_context *
read_method_context(const char * inst_fmri,const char * method,const char * path)635 read_method_context(const char *inst_fmri, const char *method, const char *path)
636 {
637 scf_instance_t *scf_inst = NULL;
638 struct method_context *ret;
639 uint_t retries;
640 mc_error_t *tmperr;
641 char *fail;
642
643 fail = gettext("Failed to retrieve method context for the %s method of "
644 "instance %s : %s");
645 for (retries = 0; retries <= REP_OP_RETRIES; retries++) {
646 if (make_handle_bound(rep_handle) == -1)
647 goto inst_failure;
648
649 if (((scf_inst = scf_instance_create(rep_handle)) != NULL) &&
650 (scf_handle_decode_fmri(rep_handle, inst_fmri, NULL, NULL,
651 scf_inst, NULL, NULL, SCF_DECODE_FMRI_EXACT) == 0))
652 break;
653 if (scf_error() != SCF_ERROR_CONNECTION_BROKEN) {
654 scf_instance_destroy(scf_inst);
655 goto inst_failure;
656 }
657
658 (void) scf_instance_destroy(scf_inst);
659 scf_inst = NULL;
660
661 (void) scf_handle_unbind(rep_handle);
662 }
663 if (retries > REP_OP_RETRIES)
664 goto inst_failure;
665
666 if ((tmperr = restarter_get_method_context(
667 RESTARTER_METHOD_CONTEXT_VERSION, scf_inst, NULL, method, path,
668 &ret)) != NULL) {
669 ret = NULL;
670 error_msg(fail, method, inst_fmri, tmperr->msg);
671 restarter_mc_error_destroy(tmperr);
672 }
673
674 scf_instance_destroy(scf_inst);
675 return (ret);
676
677 inst_failure:
678 /*
679 * We can rely on this string not becoming invalid
680 * since we don't call bind_textdomain_codeset() or
681 * setlocale(3C) after initialization.
682 */
683 error_msg(fail, method, inst_fmri,
684 gettext("failed to get instance from repository"));
685 return (NULL);
686 }
687
688 /*
689 * Reads the value of the enabled property from the named property group
690 * of the given instance.
691 * If an error occurs, the SCF error code is returned. The possible errors are:
692 * - SCF_ERROR_INVALID_ARGUMENT: The enabled property is not a boolean.
693 * - SCF_ERROR_NONE: No value exists for the enabled property.
694 * - SCF_ERROR_CONNECTION_BROKEN: Repository connection broken.
695 * - SCF_ERROR_NOT_FOUND: The property wasn't found.
696 * - SCF_ERROR_NO_MEMORY: allocation failure.
697 * Else 0 is returned and 'enabled' set appropriately.
698 */
699 static scf_error_t
read_enable_prop(const char * fmri,boolean_t * enabled,const char * pg)700 read_enable_prop(const char *fmri, boolean_t *enabled, const char *pg)
701 {
702 scf_simple_prop_t *sp;
703 uint8_t *u8p;
704
705 if ((sp = scf_simple_prop_get(rep_handle, fmri, pg,
706 SCF_PROPERTY_ENABLED)) == NULL)
707 return (scf_error());
708
709 if ((u8p = scf_simple_prop_next_boolean(sp)) == NULL) {
710 scf_simple_prop_free(sp);
711 return (scf_error());
712 }
713
714 *enabled = (*u8p != 0);
715 scf_simple_prop_free(sp);
716 return (0);
717 }
718
719 /*
720 * Reads the enabled value for the given instance FMRI. The read value
721 * is based on a merge of the 'standard' enabled property, and the temporary
722 * override one; the merge involves using the latter properties value if
723 * present, else resporting to the formers. If an error occurs -1 is returned,
724 * else 0 is returned and 'enabled' set approriately.
725 */
726 int
read_enable_merged(const char * fmri,boolean_t * enabled)727 read_enable_merged(const char *fmri, boolean_t *enabled)
728 {
729 uint_t retries;
730
731 for (retries = 0; retries <= REP_OP_RETRIES; retries++) {
732 if (make_handle_bound(rep_handle) == -1)
733 goto gen_fail;
734
735 switch (read_enable_prop(fmri, enabled, SCF_PG_GENERAL_OVR)) {
736 case 0:
737 debug_msg("read %d from override", *enabled);
738 return (0);
739 case SCF_ERROR_CONNECTION_BROKEN:
740 break;
741 case SCF_ERROR_NOT_FOUND:
742 case SCF_ERROR_NONE:
743 case SCF_ERROR_INVALID_ARGUMENT:
744 switch (read_enable_prop(fmri, enabled,
745 SCF_PG_GENERAL)) {
746 case 0:
747 debug_msg("read %d from non_override",
748 *enabled);
749 return (0);
750 case SCF_ERROR_CONNECTION_BROKEN:
751 break;
752 case SCF_ERROR_NOT_FOUND:
753 case SCF_ERROR_NONE:
754 case SCF_ERROR_INVALID_ARGUMENT:
755 error_msg(gettext("Missing %s property/value "
756 "for instance %s"), SCF_PROPERTY_ENABLED,
757 fmri);
758 return (-1);
759 default:
760 goto gen_fail;
761 }
762 break;
763 default:
764 goto gen_fail;
765 }
766
767 (void) scf_handle_unbind(rep_handle);
768 continue;
769 }
770
771 gen_fail:
772 error_msg(gettext("Failed to read the %s property of instance %s: %s"),
773 SCF_PROPERTY_ENABLED, fmri, scf_strerror(scf_error()));
774 return (-1);
775 }
776
777 /*
778 * Refresh the value of debug property under the property group "config"
779 * for network/inetd service.
780 */
781 void
refresh_debug_flag(void)782 refresh_debug_flag(void)
783 {
784 scf_simple_prop_t *sprop;
785 uint8_t *tmp_bool;
786
787 if ((sprop = scf_simple_prop_get(rep_handle, INETD_INSTANCE_FMRI,
788 PG_NAME_APPLICATION_CONFIG, PR_NAME_DEBUG_FLAG)) == NULL) {
789 error_msg(gettext("Unable to read %s property from %s property "
790 "group. scf_simple_prop_get() failed: %s"),
791 PR_NAME_DEBUG_FLAG, PG_NAME_APPLICATION_CONFIG,
792 scf_strerror(scf_error()));
793 return;
794 } else if ((tmp_bool = scf_simple_prop_next_boolean(sprop)) == NULL) {
795 error_msg(gettext("Unable to read %s property for %s service. "
796 "scf_simple_prop_next_boolean() failed: %s"),
797 PR_NAME_DEBUG_FLAG, INETD_INSTANCE_FMRI,
798 scf_strerror(scf_error()));
799 } else {
800 debug_enabled = ((*tmp_bool == 0) ? B_FALSE : B_TRUE);
801 }
802
803 scf_simple_prop_free(sprop);
804 }
805