?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8828 udapl: value computed is not used
[unleashed.git] / usr / src / lib / libvscan / common / libvscan.c
blob20a02c1adffd7b91697e9b74c72adfea3317dbee
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 #include <string.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <unistd.h>
30 #include <ctype.h>
31 #include <math.h>
32 #include <limits.h>
33 #include <libscf.h>
34 #include <errno.h>
35 #include <fcntl.h>
36 #include <door.h>
37 #include <pwd.h>
38 #include <auth_attr.h>
39 #include <secdb.h>
40 #include <sys/socket.h>
41 #include <arpa/inet.h>
42 #include <libintl.h>
43 #include <libvscan.h>
44
45 #define VS_DOOR_CALL_RETRIES 3
46
47 #define VS_INSTANCE_FMRI "svc:/system/filesystem/vscan:icap"
48
49 /* SMF property group and property names */
50 #define VS_PGNAME_GENERAL "vs_general"
51 #define VS_PGNAME_ENGINE_PREFIX "vs_engine_"
52 #define VS_PGNAME_ENGINE_LEN VS_SE_NAME_LEN + 16
53
54 #define VS_PNAME_MAXSIZE "maxsize"
55 #define VS_PNAME_MAXSIZE_ACTION "maxsize_action"
56 #define VS_PNAME_TYPES "types"
57 #define VS_PNAME_VLOG "viruslog"
58
59 #define VS_PNAME_SE_ENABLE "enable"
60 #define VS_PNAME_SE_HOST "host"
61 #define VS_PNAME_SE_PORT "port"
62 #define VS_PNAME_SE_MAXCONN "max_connect"
63 #define VS_PNAME_VAUTH "value_authorization"
64
65
66 /* types string processing */
67 #define VS_TYPES_SEP ','
68 #define VS_TYPES_ESCAPE '\\'
69 #define VS_TYPES_RULES "+-"
70
71
72 /*
73 * The SCF context enapsulating the SCF objects used in the
74 * repository load and store routines vs_scf_values_get()
75 * and vs_scf_values_set().
76 *
77 * The context is always opened before a get or set, then
78 * closed when finished (or on error); the open does an
79 * initial setup, while inside the get and set functions,
80 * additional objects within the context may be selectively
81 * initialized for use, depending on the actions needed and
82 * the properties being operated on.
83 */
84 typedef struct vs_scfctx {
85 scf_handle_t *vscf_handle;
86 scf_instance_t *vscf_inst;
87 scf_propertygroup_t *vscf_pgroup;
88 scf_transaction_t *vscf_tx;
89 scf_iter_t *vscf_iter;
90 scf_property_t *vscf_prop[VS_NUM_PROPIDS];
91 scf_transaction_entry_t *vscf_ent[VS_NUM_PROPIDS];
92 scf_value_t *vscf_val[VS_NUM_PROPIDS];
93 } vs_scfctx_t;
94
95 /*
96 * The vscan property definition. Maps the property id with the name
97 * and type used to store the property in the repository.
98 * A table of these definitions is defined with a single entry per
99 * property.
100 */
101 typedef struct {
102 const char *vpd_name;
103 uint64_t vpd_id;
104 scf_type_t vpd_type;
105 } vs_propdef_t;
106
107 typedef enum {
108 VS_PTYPE_GEN,
109 VS_PTYPE_SE
110 } vs_prop_type_t;
111
112 typedef struct vs_prop_hd {
113 vs_prop_type_t vp_type;
114 uint64_t vp_ids;
115 uint64_t vp_all;
116 union {
117 vs_props_t vp_gen;
118 vs_props_se_t vp_se;
119 } vp_props;
120 } vs_prop_hd_t;
121
122 #define vp_gen vp_props.vp_gen
123 #define vp_se vp_props.vp_se
124
125 /*
126 * Default values - these are used to return valid data
127 * to the caller in cases where invalid or unexpected values
128 * are found in the repository.
129 *
130 * Note: These values must be kept in sync with those defined
131 * in the service manifest.
132 */
133 static const boolean_t vs_dflt_allow = B_TRUE;
134 static const boolean_t vs_dflt_enable = B_TRUE;
135 static const char *vs_dflt_maxsize = "1GB";
136 static const char *vs_dflt_host = "";
137 static const uint16_t vs_dflt_port = 1344;
138 static const uint16_t vs_dflt_maxconn = 8;
139 static const char *vs_dflt_types = "+*";
140 static const char *vs_dflt_vlog = "";
141
142 /* Property definition table */
143 static const vs_propdef_t vs_propdefs[] = {
144 /* general properties */
145 { VS_PNAME_MAXSIZE, VS_PROPID_MAXSIZE, SCF_TYPE_ASTRING },
146 { VS_PNAME_MAXSIZE_ACTION, VS_PROPID_MAXSIZE_ACTION, SCF_TYPE_BOOLEAN },
147 { VS_PNAME_TYPES, VS_PROPID_TYPES, SCF_TYPE_ASTRING },
148 { VS_PNAME_VLOG, VS_PROPID_VLOG, SCF_TYPE_ASTRING },
149 /* scan engine properties */
150 { VS_PNAME_SE_ENABLE, VS_PROPID_SE_ENABLE, SCF_TYPE_BOOLEAN },
151 { VS_PNAME_SE_HOST, VS_PROPID_SE_HOST, SCF_TYPE_HOST },
152 { VS_PNAME_SE_PORT, VS_PROPID_SE_PORT, SCF_TYPE_INTEGER },
153 { VS_PNAME_SE_MAXCONN, VS_PROPID_SE_MAXCONN, SCF_TYPE_INTEGER },
154 { VS_PNAME_VAUTH, VS_PROPID_VALUE_AUTH, SCF_TYPE_ASTRING }
155 };
156
157 static const int vs_npropdefs = sizeof (vs_propdefs)/sizeof (vs_propdef_t);
158
159 /* Local functions */
160 static const vs_propdef_t *vs_get_propdef(uint64_t);
161 static void vs_default_value(vs_prop_hd_t *, const uint64_t);
162
163 static int vs_scf_values_get(const char *, vs_prop_hd_t *);
164 static int vs_scf_get(const vs_propdef_t *, vs_prop_hd_t *, vs_scfctx_t *, int);
165
166 static int vs_scf_values_set(const char *, vs_prop_hd_t *);
167 static int vs_scf_set(const vs_propdef_t *, vs_prop_hd_t *, vs_scfctx_t *, int);
168 static int vs_scf_pg_create(const char *, vs_prop_hd_t *);
169 static int vs_scf_pg_delete(const char *);
170
171 static int vs_scf_ctx_open(vs_scfctx_t *);
172 static void vs_scf_ctx_close(vs_scfctx_t *);
173
174 static int vs_validate(const vs_prop_hd_t *, uint64_t);
175 static int vs_is_valid_types(const char *);
176 static int vs_is_valid_host(const char *);
177 static int vs_checkauth(char *);
178 static int vs_door_call(int, door_arg_t *);
179
180 static int vs_props_get_engines(char *[], int *);
181 static void vs_engid_to_pgname(const char *, char [VS_PGNAME_ENGINE_LEN]);
182 static int vs_scf_pg_count(void);
183 static int vs_strtoshift(const char *);
184
185
186 /*
187 * vs_props_get_all
188 *
189 * Retrieves the general service properties and all properties
190 * for all scan engines from the repository.
191 *
192 * If invalid property values are found, the values are corrected to
193 * the default value.
194 *
195 * Return codes:
196 * VS_ERR_VS_ERR_NONE
197 * VS_ERR_SCF
198 * VS_ERR_SYS
199 */
200 int
201 vs_props_get_all(vs_props_all_t *va)
202 {
203 int i, rc, n;
204 char *engids[VS_SE_MAX];
205
206 (void) memset(va, 0, sizeof (vs_props_all_t));
207 if ((rc = vs_props_get(&va->va_props, VS_PROPID_GEN_ALL))
208 != VS_ERR_NONE)
209 return (rc);
210
211 n = VS_SE_MAX;
212 if ((rc = vs_props_get_engines(engids, &n)) != VS_ERR_NONE)
213 return (rc);
214
215 for (i = 0; i < n; i++) {
216 if ((rc = vs_props_se_get(engids[i],
217 &va->va_se[i], VS_PROPID_SE_ALL)) != VS_ERR_NONE)
218 break;
219 }
220
221 /* free engids allocated in vs_props_get_engines */
222 for (i = 0; i < VS_SE_MAX; i++) {
223 if (engids[i] != NULL)
224 free(engids[i]);
225 }
226
227 return (rc);
228 }
229
230
231 /*
232 * vs_props_get
233 *
234 * Retrieves values for the specified general service properties from
235 * the repository.
236 *
237 * If invalid property values are found, the values are corrected to
238 * the default value.
239 *
240 * Return codes:
241 * VS_ERR_VS_ERR_NONE
242 * VS_ERR_INVALID_PROPERTY
243 * VS_ERR_SCF
244 * VS_ERR_SYS
245 */
246 int
247 vs_props_get(vs_props_t *vp, uint64_t propids)
248 {
249 int rc;
250 vs_prop_hd_t prop_hd;
251
252 if ((propids & VS_PROPID_GEN_ALL) != propids)
253 return (VS_ERR_INVALID_PROPERTY);
254
255 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
256 prop_hd.vp_type = VS_PTYPE_GEN;
257 prop_hd.vp_ids = propids;
258 prop_hd.vp_all = VS_PROPID_GEN_ALL;
259
260 rc = vs_scf_values_get(VS_PGNAME_GENERAL, &prop_hd);
261
262 *vp = prop_hd.vp_gen;
263 return (rc);
264 }
265
266
267 /*
268 * vs_props_set
269 *
270 * Changes values for the specified general service properties
271 * in the repository.
272 *
273 * Return codes:
274 * VS_ERR_VS_ERR_NONE
275 * VS_ERR_INVALID_PROPERTY
276 * VS_ERR_INVALID_VALUE
277 * VS_ERR_SCF
278 * VS_ERR_SYS
279 */
280 int
281 vs_props_set(const vs_props_t *vp, uint64_t propids)
282 {
283 vs_prop_hd_t prop_hd;
284
285 if ((propids & VS_PROPID_GEN_ALL) != propids)
286 return (VS_ERR_INVALID_PROPERTY);
287
288 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
289 prop_hd.vp_type = VS_PTYPE_GEN;
290 prop_hd.vp_ids = propids;
291 prop_hd.vp_all = VS_PROPID_GEN_ALL;
292 prop_hd.vp_gen = *vp;
293 return (vs_scf_values_set(VS_PGNAME_GENERAL, &prop_hd));
294 }
295
296
297 /*
298 * vs_props_se_get
299 *
300 * Retrieves values for the specified scan engine properties from the
301 * repository.
302 *
303 * If the enable property is set (true), the host property is
304 * checked for validity. If it is not valid, the requested values
305 * are returned with the enable propery set to off (false)
306 *
307 * Return codes:
308 * VS_ERR_VS_ERR_NONE
309 * VS_ERR_INVALID_PROPERTY
310 * VS_ERR_SCF
311 * VS_ERR_SYS
312 */
313 int
314 vs_props_se_get(char *engid, vs_props_se_t *sep, uint64_t propids)
315 {
316 int rc;
317 char pgname[VS_PGNAME_ENGINE_LEN];
318 vs_prop_hd_t prop_hd;
319
320 /* VS_PGNAME_GENERAL is a reserved for GENERAL property group */
321 if (strcmp(engid, VS_PGNAME_GENERAL) == 0)
322 return (VS_ERR_INVALID_SE);
323
324 if ((propids & VS_PROPID_SE_ALL) != propids)
325 return (VS_ERR_INVALID_PROPERTY);
326
327 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
328 prop_hd.vp_type = VS_PTYPE_SE;
329 prop_hd.vp_ids = propids;
330 prop_hd.vp_all = VS_PROPID_SE_ALL;
331 (void) strlcpy(prop_hd.vp_se.vep_engid, engid, VS_SE_NAME_LEN);
332
333 /* If getting enable, get the host property too */
334 if ((propids & VS_PROPID_SE_ENABLE))
335 prop_hd.vp_ids |= VS_PROPID_SE_HOST;
336
337 /* Load values from the repository */
338 vs_engid_to_pgname(engid, pgname);
339 rc = vs_scf_values_get(pgname, &prop_hd);
340 if (rc != VS_ERR_NONE)
341 return (rc);
342
343 /*
344 * If the host is invalid and the enable property is on,
345 * return enable property as off
346 */
347 if ((prop_hd.vp_ids & VS_PROPID_SE_HOST) &&
348 (vs_validate(&prop_hd, VS_PROPID_SE_HOST) != VS_ERR_NONE)) {
349 prop_hd.vp_se.vep_enable = B_FALSE;
350 }
351
352 *sep = prop_hd.vp_se;
353 return (rc);
354 }
355
356
357
358 /*
359 * vs_props_se_set
360 *
361 * Changes the values for the specified scan engine properties in the
362 * repository.
363 *
364 * If the enable property is being changed to true in this operation,
365 * a host property must also be specified, or already exist in the
366 * repository.
367 *
368 * Return codes:
369 * VS_ERR_NONE
370 * VS_ERR_INVALID_PROPERTY
371 * VS_ERR_INVALID_VALUE
372 * VS_ERR_SCF
373 * VS_ERR_SYS
374 */
375 int
376 vs_props_se_set(char *engid, const vs_props_se_t *sep, uint64_t propids)
377 {
378 int rc;
379 char pgname[VS_PGNAME_ENGINE_LEN];
380 vs_prop_hd_t prop_hd;
381
382 /* VS_PGNAME_GENERAL is a reserved for GENERAL property group */
383 if (strcmp(engid, VS_PGNAME_GENERAL) == 0)
384 return (VS_ERR_INVALID_SE);
385
386 if ((propids & VS_PROPID_SE_ALL) != propids)
387 return (VS_ERR_INVALID_PROPERTY);
388
389 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
390 prop_hd.vp_type = VS_PTYPE_SE;
391 prop_hd.vp_all = VS_PROPID_SE_ALL;
392
393 vs_engid_to_pgname(engid, pgname);
394
395 /*
396 * if enabling a scan engine, ensure that a valid host
397 * is also being set, or already exists in the repository
398 */
399 if ((propids & VS_PROPID_SE_ENABLE) && (sep->vep_enable == B_TRUE) &&
400 !(propids & VS_PROPID_SE_HOST)) {
401
402 prop_hd.vp_ids = VS_PROPID_SE_HOST;
403 if ((rc = vs_scf_values_get(pgname, &prop_hd)) != VS_ERR_NONE)
404 return (rc);
405
406 if (vs_validate(&prop_hd, VS_PROPID_SE_HOST) != VS_ERR_NONE)
407 return (VS_ERR_INVALID_HOST);
408 }
409
410 prop_hd.vp_ids = propids;
411 prop_hd.vp_se = *sep;
412
413 return (vs_scf_values_set(pgname, &prop_hd));
414 }
415
416
417 /*
418 * vs_props_se_create
419 */
420 int
421 vs_props_se_create(char *engid, const vs_props_se_t *sep, uint64_t propids)
422 {
423 int n;
424 char pgname[VS_PGNAME_ENGINE_LEN];
425 vs_prop_hd_t prop_hd;
426
427 if ((propids & VS_PROPID_SE_ALL) != propids)
428 return (VS_ERR_INVALID_PROPERTY);
429
430 /* VS_PGNAME_GENERAL is a reserved for GENERAL property group */
431 if (strcmp(engid, VS_PGNAME_GENERAL) == 0)
432 return (VS_ERR_INVALID_SE);
433
434 if ((n = vs_scf_pg_count()) == -1)
435 return (VS_ERR_SCF);
436
437 if (n == VS_SE_MAX)
438 return (VS_ERR_MAX_SE);
439
440 vs_engid_to_pgname(engid, pgname);
441
442 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
443 prop_hd.vp_type = VS_PTYPE_SE;
444 prop_hd.vp_all = VS_PROPID_SE_ALL;
445 prop_hd.vp_ids = propids | VS_PROPID_VALUE_AUTH;
446 prop_hd.vp_se = *sep;
447
448 /* if hostname not specified, default it to engid */
449 if ((propids & VS_PROPID_SE_HOST) == 0) {
450 (void) strlcpy(prop_hd.vp_se.vep_host, engid, MAXHOSTNAMELEN);
451 prop_hd.vp_ids |= VS_PROPID_SE_HOST;
452 }
453
454 return (vs_scf_pg_create(pgname, &prop_hd));
455 }
456
457
458 /*
459 * vs_props_se_delete
460 */
461 int
462 vs_props_se_delete(const char *engid)
463 {
464 char pgname[VS_PGNAME_ENGINE_LEN];
465
466 /* VS_PGNAME_GENERAL is a reserved for GENERAL property group */
467 if (strcmp(engid, VS_PGNAME_GENERAL) == 0)
468 return (VS_ERR_INVALID_SE);
469
470 vs_engid_to_pgname(engid, pgname);
471
472 return (vs_scf_pg_delete(pgname));
473 }
474
475
476 /*
477 * vs_strerror
478 */
479 const char *
480 vs_strerror(int error)
481 {
482 switch (error) {
483 case VS_ERR_NONE:
484 return (gettext("no error"));
485 case VS_ERR_INVALID_PROPERTY:
486 return (gettext("invalid property id"));
487 case VS_ERR_INVALID_VALUE:
488 return (gettext("invalid property value"));
489 case VS_ERR_INVALID_HOST:
490 return (gettext("invalid host"));
491 case VS_ERR_INVALID_SE:
492 return (gettext("invalid scan engine"));
493 case VS_ERR_MAX_SE:
494 return (gettext("max scan engines exceeded"));
495 case VS_ERR_AUTH:
496 return (gettext("insufficient privileges for action"));
497 case VS_ERR_DAEMON_COMM:
498 return (gettext("unable to contact vscand"));
499 case VS_ERR_SCF:
500 return (scf_strerror(scf_error()));
501 case VS_ERR_SYS:
502 return (strerror(errno));
503 default:
504 return (gettext("unknown error"));
505 }
506 }
507
508
509 /*
510 * vs_get_propdef
511 *
512 * Finds and returns a property definition by property id.
513 */
514 static const vs_propdef_t *
515 vs_get_propdef(uint64_t propid)
516 {
517 int i;
518
519 for (i = 0; i < vs_npropdefs; i++) {
520 if (propid == vs_propdefs[i].vpd_id)
521 return (&vs_propdefs[i]);
522 }
523
524 return (NULL);
525 }
526
527
528 /*
529 * vs_default_value
530 *
531 * Sets a property value that contains invalid data to its default value.
532 *
533 * Note that this function does not alter any values in the repository
534 * This is only to enable the caller to get valid data.
535 */
536 static void
537 vs_default_value(vs_prop_hd_t *prop_hd, const uint64_t propid)
538 {
539 vs_props_t *vp = &prop_hd->vp_gen;
540 vs_props_se_t *vep = &prop_hd->vp_se;
541
542 switch (propid) {
543 case VS_PROPID_MAXSIZE:
544 (void) strlcpy(vp->vp_maxsize, vs_dflt_maxsize,
545 sizeof (vp->vp_maxsize));
546 break;
547 case VS_PROPID_MAXSIZE_ACTION:
548 vp->vp_maxsize_action = vs_dflt_allow;
549 break;
550 case VS_PROPID_TYPES:
551 (void) strlcpy(vp->vp_types, vs_dflt_types,
552 sizeof (vp->vp_types));
553 break;
554 case VS_PROPID_VLOG:
555 (void) strlcpy(vp->vp_vlog, vs_dflt_vlog,
556 sizeof (vp->vp_vlog));
557 break;
558 case VS_PROPID_SE_ENABLE:
559 vep->vep_enable = vs_dflt_enable;
560 break;
561 case VS_PROPID_SE_HOST:
562 (void) strlcpy(vep->vep_host, vs_dflt_host,
563 sizeof (vep->vep_host));
564 break;
565 case VS_PROPID_SE_PORT:
566 vep->vep_port = vs_dflt_port;
567 break;
568 case VS_PROPID_SE_MAXCONN:
569 vep->vep_maxconn = vs_dflt_maxconn;
570 break;
571 default:
572 break;
573 }
574 }
575
576
577 /*
578 * vs_scf_values_get
579 *
580 * Gets property values for one or more properties from the repository.
581 * This is the single entry point for loading SMF values.
582 *
583 * While a transaction is not used for loading property values,
584 * the operation is parameterized by a property group. All properties
585 * retrieved in this function, then, must belong to the same property
586 * group.
587 */
588 int
589 vs_scf_values_get(const char *pgname, vs_prop_hd_t *prop_hd)
590 {
591 vs_scfctx_t vsc;
592 int rc, np;
593 const vs_propdef_t *vpd;
594 uint64_t propid;
595
596 if ((vs_scf_ctx_open(&vsc)) != 0) {
597 vs_scf_ctx_close(&vsc);
598 return (VS_ERR_SCF);
599 }
600
601 if (scf_instance_get_pg(vsc.vscf_inst, pgname, vsc.vscf_pgroup) == -1) {
602 vs_scf_ctx_close(&vsc);
603 if (strcmp(pgname, "VS_PGNAME_GENERAL") != 0) {
604 rc = scf_error();
605 if ((rc == SCF_ERROR_NOT_FOUND) ||
606 (rc == SCF_ERROR_INVALID_ARGUMENT))
607 return (VS_ERR_INVALID_SE);
608 }
609 return (VS_ERR_SCF);
610 }
611
612 rc = VS_ERR_NONE;
613 np = 0;
614 for (propid = 1LL; propid <= VS_PROPID_MAX; propid <<= 1) {
615 if ((prop_hd->vp_ids & propid) == 0)
616 continue;
617
618 if ((vpd = vs_get_propdef(propid)) == NULL) {
619 rc = VS_ERR_INVALID_PROPERTY;
620 break;
621 }
622
623 vsc.vscf_prop[np] = scf_property_create(vsc.vscf_handle);
624 vsc.vscf_val[np] = scf_value_create(vsc.vscf_handle);
625
626 if (vsc.vscf_prop[np] == NULL || vsc.vscf_val[np] == NULL) {
627 rc = VS_ERR_SCF;
628 break;
629 }
630
631 if (scf_pg_get_property(vsc.vscf_pgroup, vpd->vpd_name,
632 vsc.vscf_prop[np]) == -1) {
633 if (scf_error() == SCF_ERROR_NOT_FOUND) {
634 vs_default_value(prop_hd, vpd->vpd_id);
635 continue;
636 }
637 rc = VS_ERR_SCF;
638 break;
639 }
640
641 if ((rc = vs_scf_get(vpd, prop_hd, &vsc, np)) != VS_ERR_NONE)
642 break;
643
644 ++np;
645 }
646
647
648 vs_scf_ctx_close(&vsc);
649
650 return (rc);
651 }
652
653
654 /*
655 * vs_scf_get
656 *
657 * Loads a single values from the repository into the appropriate vscan
658 * property structure member.
659 */
660 static int
661 vs_scf_get(const vs_propdef_t *vpd, vs_prop_hd_t *prop_hd,
662 vs_scfctx_t *vsc, int idx)
663 {
664 int rc;
665 int64_t port;
666 uint8_t valbool;
667 vs_props_t *vp = &prop_hd->vp_gen;
668 vs_props_se_t *vep = &prop_hd->vp_se;
669
670 if ((rc = scf_property_get_value(vsc->vscf_prop[idx],
671 vsc->vscf_val[idx])) == -1) {
672 if (rc == SCF_ERROR_CONSTRAINT_VIOLATED ||
673 rc == SCF_ERROR_NOT_FOUND) {
674 vs_default_value(prop_hd, vpd->vpd_id);
675 return (VS_ERR_NONE);
676 }
677 return (VS_ERR_SCF);
678 }
679
680 rc = VS_ERR_NONE;
681 switch (vpd->vpd_id) {
682 case VS_PROPID_MAXSIZE:
683 if ((scf_value_get_astring(vsc->vscf_val[idx],
684 vp->vp_maxsize, sizeof (vp->vp_maxsize))) == -1) {
685 return (VS_ERR_SCF);
686 }
687 break;
688 case VS_PROPID_MAXSIZE_ACTION:
689 if ((scf_value_get_boolean(vsc->vscf_val[idx],
690 &valbool)) == -1) {
691 return (VS_ERR_SCF);
692 }
693 vp->vp_maxsize_action = (valbool == 0) ? B_FALSE : B_TRUE;
694 break;
695 case VS_PROPID_TYPES:
696 if ((scf_value_get_astring(vsc->vscf_val[idx],
697 vp->vp_types, sizeof (vp->vp_types))) == -1) {
698 return (VS_ERR_SCF);
699 }
700 break;
701 case VS_PROPID_VLOG:
702 if ((scf_value_get_astring(vsc->vscf_val[idx],
703 vp->vp_vlog, sizeof (vp->vp_vlog))) == -1) {
704 return (VS_ERR_SCF);
705 }
706 break;
707 case VS_PROPID_SE_ENABLE:
708 if ((scf_value_get_boolean(vsc->vscf_val[idx],
709 &valbool)) == -1) {
710 return (VS_ERR_SCF);
711 }
712 vep->vep_enable = (valbool == 0) ? B_FALSE : B_TRUE;
713 break;
714 case VS_PROPID_SE_HOST:
715 (void) scf_value_get_as_string_typed(vsc->vscf_val[idx],
716 vpd->vpd_type, vep->vep_host, sizeof (vep->vep_host));
717 break;
718 case VS_PROPID_SE_PORT:
719 if ((scf_value_get_integer(vsc->vscf_val[idx], &port)) == -1)
720 return (VS_ERR_SCF);
721 if (port <= 0 || port >= UINT16_MAX)
722 rc = VS_ERR_INVALID_VALUE;
723 else
724 vep->vep_port = (uint16_t)port;
725 break;
726 case VS_PROPID_SE_MAXCONN:
727 if ((scf_value_get_integer(vsc->vscf_val[idx],
728 (int64_t *)&vep->vep_maxconn)) == -1) {
729 return (VS_ERR_SCF);
730 }
731 break;
732 default:
733 break;
734 }
735
736 if ((rc != VS_ERR_NONE) ||
737 (vs_validate(prop_hd, vpd->vpd_id) != VS_ERR_NONE)) {
738 vs_default_value(prop_hd, vpd->vpd_id);
739 }
740
741 return (VS_ERR_NONE);
742 }
743
744
745 /*
746 * vs_scf_pg_create
747 */
748 static int
749 vs_scf_pg_create(const char *pgname, vs_prop_hd_t *prop_hd)
750 {
751 int rc;
752 uint64_t propid;
753 vs_scfctx_t vsc;
754
755 /* ensure that caller has authorization to refresh service */
756 if ((rc = vs_checkauth(VS_ACTION_AUTH)) != VS_ERR_NONE)
757 return (rc);
758
759 if (vs_scf_ctx_open(&vsc) != 0) {
760 vs_scf_ctx_close(&vsc);
761 return (VS_ERR_SCF);
762 }
763
764 if (scf_instance_add_pg(vsc.vscf_inst, pgname,
765 SCF_GROUP_APPLICATION, 0, vsc.vscf_pgroup) == -1) {
766 vs_scf_ctx_close(&vsc);
767 if (scf_error() == SCF_ERROR_INVALID_ARGUMENT)
768 return (VS_ERR_INVALID_SE);
769 return (VS_ERR_SCF);
770 }
771 vs_scf_ctx_close(&vsc);
772
773 /* set default values for those not specified */
774 for (propid = 1LL; propid <= VS_PROPID_MAX; propid <<= 1) {
775 if ((propid & prop_hd->vp_all) && !(propid & prop_hd->vp_ids))
776 vs_default_value(prop_hd, propid);
777 }
778
779 prop_hd->vp_ids = prop_hd->vp_all;
780 prop_hd->vp_ids |= VS_PROPID_VALUE_AUTH;
781
782 rc = vs_scf_values_set(pgname, prop_hd);
783 if (rc != VS_ERR_NONE)
784 (void) vs_scf_pg_delete(pgname);
785
786 return (rc);
787 }
788
789
790 /*
791 * vs_scf_pg_delete
792 */
793 static int
794 vs_scf_pg_delete(const char *pgname)
795 {
796 int rc;
797 vs_scfctx_t vsc;
798
799 /* ensure that caller has authorization to refresh service */
800 if ((rc = vs_checkauth(VS_ACTION_AUTH)) != VS_ERR_NONE)
801 return (rc);
802
803 if (vs_scf_ctx_open(&vsc) != 0) {
804 vs_scf_ctx_close(&vsc);
805 return (VS_ERR_SCF);
806 }
807
808 if (scf_instance_get_pg(vsc.vscf_inst, pgname, vsc.vscf_pgroup) == -1) {
809 vs_scf_ctx_close(&vsc);
810 rc = scf_error();
811 if ((rc == SCF_ERROR_NOT_FOUND) ||
812 (rc == SCF_ERROR_INVALID_ARGUMENT))
813 return (VS_ERR_INVALID_SE);
814 else
815 return (VS_ERR_SCF);
816 }
817
818 if (scf_pg_delete(vsc.vscf_pgroup) == -1) {
819 vs_scf_ctx_close(&vsc);
820 rc = scf_error();
821 if ((rc == SCF_ERROR_NOT_FOUND) ||
822 (rc == SCF_ERROR_INVALID_ARGUMENT))
823 return (VS_ERR_INVALID_SE);
824
825 return (VS_ERR_SCF);
826 }
827
828 vs_scf_ctx_close(&vsc);
829
830 /* Notify the daemon that things have changed */
831 if ((smf_refresh_instance(VS_INSTANCE_FMRI)) == -1) {
832 return (VS_ERR_SCF);
833 }
834
835 return (VS_ERR_NONE);
836 }
837
838
839 /*
840 * vs_scf_values_set
841 *
842 * Sets property values in the repository. This is the single
843 * entry point for storing SMF values.
844 *
845 * Like loading values, this is an operation based on a single property
846 * group, so all property values changed in this function must belong
847 * to the same property group. Additionally, this operation is done in
848 * the context of a repository transaction; on any fatal error, the
849 * SCF context will be closed, destroying all SCF objects and aborting
850 * the transaction.
851 */
852 static int
853 vs_scf_values_set(const char *pgname, vs_prop_hd_t *prop_hd)
854 {
855 int rc, np;
856 const vs_propdef_t *vpd;
857 uint64_t propid;
858 vs_scfctx_t vsc;
859
860 /* ensure that caller has authorization to refresh service */
861 if ((rc = vs_checkauth(VS_ACTION_AUTH)) != VS_ERR_NONE)
862 return (rc);
863
864 if (vs_scf_ctx_open(&vsc) != 0) {
865 vs_scf_ctx_close(&vsc);
866 return (VS_ERR_SCF);
867 }
868
869 if (scf_instance_get_pg(vsc.vscf_inst, pgname, vsc.vscf_pgroup) == -1) {
870 vs_scf_ctx_close(&vsc);
871 rc = scf_error();
872 if (strcmp(pgname, "VS_PGNAME_GENERAL") != 0) {
873 if ((rc == SCF_ERROR_NOT_FOUND) ||
874 (rc == SCF_ERROR_INVALID_ARGUMENT))
875 return (VS_ERR_INVALID_SE);
876 }
877 return (VS_ERR_SCF);
878 }
879
880 if (((vsc.vscf_tx = scf_transaction_create(vsc.vscf_handle)) == NULL) ||
881 (scf_transaction_start(vsc.vscf_tx, vsc.vscf_pgroup) == -1)) {
882 vs_scf_ctx_close(&vsc);
883 return (VS_ERR_SCF);
884 }
885
886 /* Process the value change for each specified property */
887 rc = 0;
888 np = 0;
889 for (propid = 1LL; propid <= VS_PROPID_MAX; propid <<= 1) {
890 if ((prop_hd->vp_ids & propid) == 0)
891 continue;
892
893 if ((vpd = vs_get_propdef(propid)) == NULL) {
894 rc = VS_ERR_INVALID_PROPERTY;
895 break;
896 }
897
898 vsc.vscf_val[np] = scf_value_create(vsc.vscf_handle);
899 vsc.vscf_ent[np] = scf_entry_create(vsc.vscf_handle);
900
901 if (vsc.vscf_val[np] == NULL || vsc.vscf_ent[np] == NULL) {
902 rc = VS_ERR_SCF;
903 break;
904 }
905
906 if ((rc = scf_transaction_property_change(vsc.vscf_tx,
907 vsc.vscf_ent[np], vpd->vpd_name, vpd->vpd_type)) == -1) {
908 rc = scf_transaction_property_new(vsc.vscf_tx,
909 vsc.vscf_ent[np], vpd->vpd_name, vpd->vpd_type);
910 }
911 if (rc == -1) {
912 rc = VS_ERR_SCF;
913 break;
914 }
915
916 if ((rc = vs_scf_set(vpd, prop_hd, &vsc, np)) != VS_ERR_NONE)
917 break;
918
919 ++np;
920 }
921
922 if (rc != VS_ERR_NONE) {
923 vs_scf_ctx_close(&vsc);
924 return (rc);
925 }
926
927 /* Commit the transaction */
928 if (scf_transaction_commit(vsc.vscf_tx) == -1) {
929 vs_scf_ctx_close(&vsc);
930 return (VS_ERR_SCF);
931 }
932 vs_scf_ctx_close(&vsc);
933
934 /* Notify the daemon that things have changed */
935 if ((smf_refresh_instance(VS_INSTANCE_FMRI)) == -1)
936 return (VS_ERR_SCF);
937
938 return (VS_ERR_NONE);
939 }
940
941
942 /*
943 * vs_scf_set
944 *
945 * Stores a single value from the appropriate vscan property structure
946 * member into the repository.
947 *
948 * Values are set in the SCF value object, then the value object
949 * is added to the SCF property object.
950 */
951 static int
952 vs_scf_set(const vs_propdef_t *vpd, vs_prop_hd_t *prop_hd,
953 vs_scfctx_t *vsc, int idx)
954 {
955 int rc;
956 vs_props_t *vp = &prop_hd->vp_gen;
957 vs_props_se_t *vep = &prop_hd->vp_se;
958
959 if ((rc = vs_validate(prop_hd, vpd->vpd_id)) != VS_ERR_NONE)
960 return (rc);
961
962 rc = VS_ERR_NONE;
963 switch (vpd->vpd_id) {
964 case VS_PROPID_MAXSIZE:
965 if ((scf_value_set_astring(vsc->vscf_val[idx],
966 vp->vp_maxsize)) == -1) {
967 rc = VS_ERR_SCF;
968 }
969 break;
970 case VS_PROPID_MAXSIZE_ACTION:
971 scf_value_set_boolean(vsc->vscf_val[idx],
972 (uint8_t)vp->vp_maxsize_action);
973 break;
974 case VS_PROPID_TYPES:
975 if ((scf_value_set_astring(vsc->vscf_val[idx],
976 vp->vp_types)) == -1) {
977 return (VS_ERR_SCF);
978 }
979 break;
980 case VS_PROPID_SE_ENABLE:
981 scf_value_set_boolean(vsc->vscf_val[idx],
982 (uint8_t)vep->vep_enable);
983 break;
984 case VS_PROPID_SE_HOST:
985 if ((scf_value_set_from_string(vsc->vscf_val[idx],
986 vpd->vpd_type, vep->vep_host)) == -1) {
987 rc = VS_ERR_SCF;
988 }
989 break;
990 case VS_PROPID_SE_PORT:
991 scf_value_set_integer(vsc->vscf_val[idx], vep->vep_port);
992 break;
993 case VS_PROPID_SE_MAXCONN:
994 scf_value_set_integer(vsc->vscf_val[idx],
995 vep->vep_maxconn);
996 break;
997 case VS_PROPID_VALUE_AUTH:
998 if ((scf_value_set_astring(vsc->vscf_val[idx],
999 VS_VALUE_AUTH)) == -1) {
1000 return (VS_ERR_SCF);
1001 }
1002 break;
1003 default:
1004 break;
1005 }
1006
1007 if ((scf_entry_add_value(vsc->vscf_ent[idx],
1008 vsc->vscf_val[idx])) == -1) {
1009 return (VS_ERR_SCF);
1010 }
1011
1012 return (rc);
1013 }
1014
1015
1016 /*
1017 * vs_scf_ctx_open
1018 *
1019 * Opens an SCF context; creates the minumum SCF objects
1020 * for use in loading/storing from the SMF repository (meaning
1021 * vscf_property group data).
1022 *
1023 * Other SCF objects in the context may be initialized elsewher
1024 * subsequent to open, but all initialized structures are destroyed
1025 * in vs_scf_ctx_close().
1026 */
1027 static int
1028 vs_scf_ctx_open(vs_scfctx_t *vsc)
1029 {
1030 (void) memset(vsc, 0, sizeof (vs_scfctx_t));
1031
1032 if ((vsc->vscf_handle = scf_handle_create(SCF_VERSION)) == NULL)
1033 return (VS_ERR_SCF);
1034
1035 if (scf_handle_bind(vsc->vscf_handle) == -1)
1036 return (VS_ERR_SCF);
1037
1038 if ((vsc->vscf_inst = scf_instance_create(vsc->vscf_handle)) == NULL)
1039 return (VS_ERR_SCF);
1040
1041 if (scf_handle_decode_fmri(vsc->vscf_handle, VS_INSTANCE_FMRI,
1042 NULL, NULL, vsc->vscf_inst, NULL, NULL,
1043 SCF_DECODE_FMRI_EXACT) == -1) {
1044 return (VS_ERR_SCF);
1045 }
1046
1047 if ((vsc->vscf_pgroup = scf_pg_create(vsc->vscf_handle)) == NULL)
1048 return (VS_ERR_SCF);
1049
1050 return (VS_ERR_NONE);
1051 }
1052
1053
1054 /*
1055 * vs_scf_ctx_close
1056 *
1057 * Closes an SCF context; destroys all initialized SCF objects.
1058 */
1059 static void
1060 vs_scf_ctx_close(vs_scfctx_t *vsc)
1061 {
1062 int i;
1063
1064 for (i = 0; i < VS_NUM_PROPIDS; i++) {
1065 if (vsc->vscf_val[i])
1066 scf_value_destroy(vsc->vscf_val[i]);
1067 if (vsc->vscf_ent[i])
1068 scf_entry_destroy(vsc->vscf_ent[i]);
1069 if (vsc->vscf_prop[i])
1070 scf_property_destroy(vsc->vscf_prop[i]);
1071 }
1072
1073 if (vsc->vscf_iter)
1074 scf_iter_destroy(vsc->vscf_iter);
1075 if (vsc->vscf_tx)
1076 scf_transaction_destroy(vsc->vscf_tx);
1077 if (vsc->vscf_pgroup)
1078 scf_pg_destroy(vsc->vscf_pgroup);
1079 if (vsc->vscf_inst)
1080 scf_instance_destroy(vsc->vscf_inst);
1081 if (vsc->vscf_handle)
1082 scf_handle_destroy(vsc->vscf_handle);
1083 }
1084
1085
1086 /*
1087 * vs_validate
1088 *
1089 * Validate property identified in propid.
1090 *
1091 * Returns: VS_ERR_NONE
1092 * VS_ERR_INVALID_VALUE
1093 * VS_ERR_INVALID_PROPERTY
1094 */
1095 static int
1096 vs_validate(const vs_prop_hd_t *prop_hd, uint64_t propid)
1097 {
1098 uint64_t num;
1099 const vs_props_t *vp = &prop_hd->vp_gen;
1100 const vs_props_se_t *vep = &prop_hd->vp_se;
1101
1102 switch (propid) {
1103 case VS_PROPID_MAXSIZE:
1104 if ((vs_strtonum(vp->vp_maxsize, &num) != 0) || (num == 0))
1105 return (VS_ERR_INVALID_VALUE);
1106 break;
1107 case VS_PROPID_MAXSIZE_ACTION:
1108 break;
1109 case VS_PROPID_TYPES:
1110 if (!vs_is_valid_types(vp->vp_types))
1111 return (VS_ERR_INVALID_VALUE);
1112 break;
1113 case VS_PROPID_SE_ENABLE:
1114 break;
1115 case VS_PROPID_SE_PORT:
1116 if (vep->vep_port == 0)
1117 return (VS_ERR_INVALID_VALUE);
1118 break;
1119 case VS_PROPID_SE_HOST:
1120 if (!vs_is_valid_host(vep->vep_host))
1121 return (VS_ERR_INVALID_VALUE);
1122 break;
1123 case VS_PROPID_SE_MAXCONN:
1124 if (vep->vep_maxconn < VS_VAL_SE_MAXCONN_MIN ||
1125 vep->vep_maxconn > VS_VAL_SE_MAXCONN_MAX)
1126 return (VS_ERR_INVALID_VALUE);
1127 break;
1128 case VS_PROPID_VALUE_AUTH:
1129 case VS_PROPID_VLOG:
1130 break;
1131 default:
1132 return (VS_ERR_INVALID_PROPERTY);
1133 }
1134
1135 return (VS_ERR_NONE);
1136 }
1137
1138
1139 /*
1140 * vs_props_validate
1141 *
1142 * Validate properties identified in propids.
1143 *
1144 * Returns: VS_ERR_NONE
1145 * VS_ERR_INVALID_VALUE
1146 * VS_ERR_INVALID_PROPERTY
1147 */
1148 int
1149 vs_props_validate(const vs_props_t *props, uint64_t propids)
1150 {
1151 uint64_t propid;
1152 vs_prop_hd_t prop_hd;
1153
1154 if ((propids & VS_PROPID_GEN_ALL) != propids)
1155 return (VS_ERR_INVALID_PROPERTY);
1156
1157 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
1158 prop_hd.vp_gen = *props;
1159 prop_hd.vp_type = VS_PTYPE_GEN;
1160 prop_hd.vp_ids = propids;
1161 prop_hd.vp_all = VS_PROPID_GEN_ALL;
1162
1163 for (propid = 1LL; propid <= VS_PROPID_MAX; propid <<= 1) {
1164 if ((propids & propid) == 0)
1165 continue;
1166
1167 if (vs_validate(&prop_hd, propid) != VS_ERR_NONE)
1168 return (VS_ERR_INVALID_VALUE);
1169 }
1170
1171 return (VS_ERR_NONE);
1172 }
1173
1174
1175 /*
1176 * vs_props_se_validate
1177 *
1178 * Validate properties identified in propids.
1179 *
1180 * Returns: VS_ERR_NONE
1181 * VS_ERR_INVALID_VALUE
1182 * VS_ERR_INVALID_PROPERTY
1183 */
1184 int
1185 vs_props_se_validate(const vs_props_se_t *se_props, uint64_t propids)
1186 {
1187 uint64_t propid;
1188 vs_prop_hd_t prop_hd;
1189
1190 if ((propids & VS_PROPID_SE_ALL) != propids)
1191 return (VS_ERR_INVALID_PROPERTY);
1192
1193 (void) memset(&prop_hd, 0, sizeof (vs_prop_hd_t));
1194 prop_hd.vp_se = *se_props;
1195 prop_hd.vp_type = VS_PTYPE_SE;
1196 prop_hd.vp_ids = propids;
1197 prop_hd.vp_all = VS_PROPID_SE_ALL;
1198
1199 for (propid = 1LL; propid <= VS_PROPID_MAX; propid <<= 1) {
1200 if ((propids & propid) == 0)
1201 continue;
1202
1203 if (vs_validate(&prop_hd, propid) != VS_ERR_NONE)
1204 return (VS_ERR_INVALID_VALUE);
1205 }
1206
1207 return (VS_ERR_NONE);
1208 }
1209
1210
1211 /*
1212 * vs_is_valid_types
1213 *
1214 * Checks that types property is a valid format:
1215 * - doesn't exceed VS_VAL_TYPES_MAX
1216 * - doesn't contain VS_VAL_TYPES_INVALID_CHARS
1217 * - is correctly formatted - passes the parsing tests
1218 *
1219 * Returns 1 on success, 0 on failure
1220 */
1221 static int
1222 vs_is_valid_types(const char *types)
1223 {
1224 char buf[VS_VAL_TYPES_LEN];
1225 uint32_t len = VS_VAL_TYPES_LEN;
1226
1227 if (strlen(types) > VS_VAL_TYPES_LEN)
1228 return (0);
1229
1230 if (strpbrk(types, VS_VAL_TYPES_INVALID_CHARS) != NULL)
1231 return (0);
1232
1233 if (vs_parse_types(types, buf, &len) != 0)
1234 return (0);
1235
1236 return (1);
1237 }
1238
1239
1240 /*
1241 * vs_is_valid_host
1242 *
1243 * Returns 1 on success, 0 on failure
1244 */
1245 static int
1246 vs_is_valid_host(const char *host)
1247 {
1248 long naddr;
1249 const char *p;
1250
1251 if (!host || *host == '\0')
1252 return (0);
1253
1254 if ('0' <= host[0] && host[0] <= '9') {
1255 /* ip address */
1256 if ((inet_pton(AF_INET, host, &naddr)) == 0)
1257 return (0);
1258 if ((naddr & IN_CLASSA_NET) == 0)
1259 return (0);
1260 if ((naddr & IN_CLASSC_HOST) == 0)
1261 return (0);
1262 } else {
1263 /* hostname */
1264 p = host;
1265 while (*p != '\0') {
1266 if (!isascii(*p))
1267 return (0);
1268
1269 if (isalnum(*p) ||
1270 (*p == '.') || (*p == '-') || (*p == '_')) {
1271 ++p;
1272 } else {
1273 return (0);
1274 }
1275 }
1276 }
1277
1278 return (1);
1279 }
1280
1281
1282 /*
1283 * vs_parse_types
1284 *
1285 * Replace comma separators with '\0'.
1286 *
1287 * Types contains comma separated rules each beginning with +|-
1288 * - embedded commas are escaped by backslash
1289 * - backslash is escaped by backslash
1290 * - a single backslash not followed by comma is illegal
1291 *
1292 * On entry to the function len must contain the length of
1293 * the buffer. On sucecssful exit len will contain the length
1294 * of the parsed data within the buffer.
1295 *
1296 * Returns 0 on success, -1 on failure
1297 */
1298 int
1299 vs_parse_types(const char *types, char *buf, uint32_t *len)
1300 {
1301 char *p = (char *)types;
1302 char *b = buf;
1303
1304 if (strlen(types) > *len)
1305 return (-1);
1306
1307 if (strchr(VS_TYPES_RULES, *p) == NULL)
1308 return (-1);
1309
1310 (void) memset(buf, 0, *len);
1311
1312 while (*p) {
1313 switch (*p) {
1314 case VS_TYPES_SEP:
1315 if (*(p + 1) &&
1316 (strchr(VS_TYPES_RULES, *(p + 1))) == NULL)
1317 return (-1);
1318 *b = '\0';
1319 break;
1320 case VS_TYPES_ESCAPE:
1321 ++p;
1322 if (*p == VS_TYPES_ESCAPE || *p == VS_TYPES_SEP)
1323 *b = *p;
1324 else
1325 return (-1);
1326 break;
1327 default:
1328 *b = *p;
1329 }
1330 ++p;
1331 ++b;
1332 }
1333
1334 *len = (b - buf) + 1;
1335
1336 return (0);
1337 }
1338
1339
1340 /*
1341 * vs_statistics
1342 */
1343 int
1344 vs_statistics(vs_stats_t *stats)
1345 {
1346 int door_fd, rc = VS_ERR_NONE;
1347 vs_stats_req_t *req;
1348 vs_stats_rsp_t *rsp;
1349 door_arg_t arg;
1350
1351 if ((req = calloc(1, sizeof (vs_stats_req_t))) == NULL)
1352 return (VS_ERR_SYS);
1353
1354 if ((rsp = calloc(1, sizeof (vs_stats_rsp_t))) == NULL) {
1355 free(req);
1356 return (VS_ERR_SYS);
1357 }
1358
1359 if ((door_fd = open(VS_STATS_DOOR_NAME, O_RDONLY)) < 0) {
1360 free(req);
1361 free(rsp);
1362 return (VS_ERR_DAEMON_COMM);
1363 }
1364
1365 req->vsr_magic = VS_STATS_DOOR_MAGIC;
1366 req->vsr_id = VS_STATS_GET;
1367
1368 arg.data_ptr = (char *)req;
1369 arg.data_size = sizeof (vs_stats_req_t);
1370 arg.desc_ptr = NULL;
1371 arg.desc_num = 0;
1372 arg.rbuf = (char *)rsp;
1373 arg.rsize = sizeof (vs_stats_rsp_t);
1374
1375 rc = vs_door_call(door_fd, &arg);
1376
1377 if ((rc == VS_ERR_NONE) && (rsp->vsr_magic == VS_STATS_DOOR_MAGIC))
1378 *stats = rsp->vsr_stats;
1379 else
1380 rc = VS_ERR_DAEMON_COMM;
1381
1382 (void) close(door_fd);
1383
1384 free(req);
1385 free(rsp);
1386 return (rc);
1387 }
1388
1389
1390 /*
1391 * vs_statistics_reset
1392 */
1393 int
1394 vs_statistics_reset()
1395 {
1396 int door_fd, rc;
1397 vs_stats_req_t *req;
1398 door_arg_t arg;
1399
1400 /* ensure that caller has authorization to reset stats */
1401 if ((rc = vs_checkauth(VS_VALUE_AUTH)) != VS_ERR_NONE)
1402 return (rc);
1403
1404 if ((req = calloc(1, sizeof (vs_stats_req_t))) == NULL)
1405 return (VS_ERR_SYS);
1406
1407 if ((door_fd = open(VS_STATS_DOOR_NAME, O_RDONLY)) < 0) {
1408 free(req);
1409 return (VS_ERR_DAEMON_COMM);
1410 }
1411
1412 req->vsr_magic = VS_STATS_DOOR_MAGIC;
1413 req->vsr_id = VS_STATS_RESET;
1414
1415 arg.data_ptr = (char *)req;
1416 arg.data_size = sizeof (vs_stats_req_t);
1417 arg.desc_ptr = NULL;
1418 arg.desc_num = 0;
1419 arg.rbuf = NULL;
1420 arg.rsize = 0;
1421
1422 rc = vs_door_call(door_fd, &arg);
1423
1424 (void) close(door_fd);
1425 free(req);
1426 return (rc);
1427 }
1428
1429 /*
1430 * Door call with retries.
1431 *
1432 * Returns VS_ERR_NONE on success, otherwise VS_ERR_DAEMON_COMM.
1433 */
1434 static int
1435 vs_door_call(int fd, door_arg_t *arg)
1436 {
1437 int rc = -1;
1438 int i;
1439
1440 for (i = 0; i < VS_DOOR_CALL_RETRIES; ++i) {
1441 errno = 0;
1442
1443 if ((rc = door_call(fd, arg)) == 0)
1444 break;
1445
1446 if (errno != EAGAIN && errno != EINTR)
1447 break;
1448 }
1449
1450 return ((rc == 0) ? VS_ERR_NONE : VS_ERR_DAEMON_COMM);
1451 }
1452
1453 /*
1454 * vs_checkauth
1455 */
1456 static int
1457 vs_checkauth(char *auth)
1458 {
1459 struct passwd *pw;
1460 uid_t uid;
1461
1462 uid = getuid();
1463
1464 if ((pw = getpwuid(uid)) == NULL)
1465 return (VS_ERR_SYS);
1466
1467 if (chkauthattr(auth, pw->pw_name) != 1) {
1468 return (VS_ERR_AUTH);
1469 }
1470
1471 return (VS_ERR_NONE);
1472 }
1473
1474
1475 /*
1476 * vs_props_get_engines
1477 *
1478 * On input, count specifies the maximum number of engine ids to
1479 * return. engids must be an array with count entries.
1480 * On return, count specifies the number of engine ids being
1481 * returned in engids.
1482 *
1483 * Caller is responsible for free'ing the engids allocated herein.
1484 */
1485 static int
1486 vs_props_get_engines(char *engids[], int *count)
1487 {
1488 int i, prefix_len;
1489 char pgname[VS_PGNAME_ENGINE_LEN];
1490 vs_scfctx_t vsc;
1491
1492
1493 if (((vs_scf_ctx_open(&vsc)) != 0) ||
1494 ((vsc.vscf_iter = scf_iter_create(vsc.vscf_handle)) == NULL) ||
1495 (scf_iter_instance_pgs_typed(vsc.vscf_iter, vsc.vscf_inst,
1496 SCF_GROUP_APPLICATION) != 0)) {
1497 vs_scf_ctx_close(&vsc);
1498 return (VS_ERR_SCF);
1499 }
1500
1501 for (i = 0; i < *count; i++)
1502 engids[i] = NULL;
1503
1504 i = 0;
1505 prefix_len = sizeof (VS_PGNAME_ENGINE_PREFIX) - 1;
1506
1507 while ((i < VS_SE_MAX) &&
1508 (scf_iter_next_pg(vsc.vscf_iter, vsc.vscf_pgroup) == 1)) {
1509 if (scf_pg_get_name(vsc.vscf_pgroup, pgname,
1510 VS_PGNAME_ENGINE_LEN) < 0) {
1511 vs_scf_ctx_close(&vsc);
1512 return (VS_ERR_SCF);
1513 }
1514
1515 if (strncmp(pgname, VS_PGNAME_ENGINE_PREFIX, prefix_len) == 0) {
1516 if ((engids[i] = strdup(pgname + prefix_len)) != NULL) {
1517 if (++i == *count)
1518 break;
1519 }
1520 }
1521 }
1522 vs_scf_ctx_close(&vsc);
1523
1524 *count = i;
1525 return (VS_ERR_NONE);
1526 }
1527
1528
1529 /*
1530 * vs_scf_pg_count
1531 */
1532 static int
1533 vs_scf_pg_count(void)
1534 {
1535 int count = 0;
1536 vs_scfctx_t vsc;
1537
1538 if ((vs_scf_ctx_open(&vsc) != 0) ||
1539 ((vsc.vscf_iter = scf_iter_create(vsc.vscf_handle)) == NULL) ||
1540 (scf_iter_instance_pgs_typed(vsc.vscf_iter, vsc.vscf_inst,
1541 SCF_GROUP_APPLICATION) != 0)) {
1542 vs_scf_ctx_close(&vsc);
1543 return (-1);
1544 }
1545
1546 while (scf_iter_next_pg(vsc.vscf_iter, vsc.vscf_pgroup) == 1)
1547 ++count;
1548
1549 vs_scf_ctx_close(&vsc);
1550
1551 return (count);
1552 }
1553
1554
1555 /*
1556 * vs_engid_to_pgname
1557 *
1558 * To convert an engine id (engid) to a property group name (pgname),
1559 * the engine id is prefixed with VS_PGNAME_ENGINE_PREFIX.
1560 */
1561 static void
1562 vs_engid_to_pgname(const char *engid, char pgname[VS_PGNAME_ENGINE_LEN])
1563 {
1564 (void) snprintf(pgname, VS_PGNAME_ENGINE_LEN, "%s%s",
1565 VS_PGNAME_ENGINE_PREFIX, engid);
1566 }
1567
1568
1569 /*
1570 * vs_strtonum
1571 *
1572 * Converts a size string in the format into an integer.
1573 *
1574 * A size string is a numeric value followed by an optional unit
1575 * specifier which is used as a multiplier to calculate a raw
1576 * number.
1577 * The size string format is: N[.N][KMGTP][B]
1578 *
1579 * The numeric value can contain a decimal portion. Unit specifiers
1580 * are either a one-character or two-character string; i.e. "K" or
1581 * "KB" for kilobytes. Unit specifiers must follow the numeric portion
1582 * immediately, and are not case-sensitive.
1583 *
1584 * If either "B" is specified, or there is no unit specifier portion
1585 * in the string, the numeric value is calculated with no multiplier
1586 * (assumes a basic unit of "bytes").
1587 *
1588 * Returns:
1589 * -1: Failure; errno set to specify the error.
1590 * 0: Success.
1591 */
1592 int
1593 vs_strtonum(const char *value, uint64_t *num)
1594 {
1595 char *end;
1596 int shift;
1597 double fval;
1598
1599 *num = 0;
1600
1601 /* Check to see if this looks like a number. */
1602 if ((value[0] < '0' || value[0] > '9') && value[0] != '.') {
1603 errno = EINVAL;
1604 return (-1);
1605 }
1606
1607 /* Rely on stroll() to process the numeric portion. */
1608 errno = 0;
1609 *num = strtoll(value, &end, 10);
1610
1611 /*
1612 * Check for ERANGE, which indicates that the value is too large to
1613 * fit in a 64-bit value.
1614 */
1615 if (errno != 0)
1616 return (-1);
1617
1618 /*
1619 * If we have a decimal value, then do the computation with floating
1620 * point arithmetic. Otherwise, use standard arithmetic.
1621 */
1622 if (*end == '.') {
1623 fval = strtod(value, &end);
1624
1625 if ((shift = vs_strtoshift(end)) == -1)
1626 return (-1); /* errno set */
1627
1628 fval *= pow(2, shift);
1629 if (fval > UINT64_MAX) {
1630 errno = ERANGE;
1631 return (-1);
1632 }
1633
1634 *num = (uint64_t)fval;
1635 } else {
1636 if ((shift = vs_strtoshift(end)) == -1)
1637 return (-1); /* errno set */
1638
1639 /* Check for overflow */
1640 if (shift >= 64 || (*num << shift) >> shift != *num) {
1641 errno = ERANGE;
1642 return (-1);
1643 }
1644
1645 *num <<= shift;
1646 }
1647
1648 return (0);
1649 }
1650
1651
1652 /*
1653 * vs_strtoshift
1654 *
1655 * Converts a unit specifier string into a number of bits that
1656 * a numeric value must be shifted.
1657 *
1658 * Returns:
1659 * -1: Failure; errno set to specify the error.
1660 * >-1: Success; the shift count.
1661 *
1662 */
1663 static int
1664 vs_strtoshift(const char *buf)
1665 {
1666 const char *ends = "BKMGTPEZ";
1667 int i;
1668
1669 if (buf[0] == '\0')
1670 return (0);
1671 for (i = 0; i < strlen(ends); i++) {
1672 if (toupper(buf[0]) == ends[i])
1673 break;
1674 }
1675 if (i == strlen(ends)) {
1676 errno = EINVAL;
1677 return (-1);
1678 }
1679
1680 /* Allow trailing 'b' characters except in the case of 'BB'. */
1681 if (buf[1] == '\0' || (toupper(buf[1]) == 'B' && buf[2] == '\0' &&
1682 toupper(buf[0]) != 'B')) {
1683 return (10 * i);
1684 }
1685
1686 errno = EINVAL;
1687 return (-1);
1688 }
Unleashed OS