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 /*
23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #pragma weak _getprivimplinfo = getprivimplinfo
27 #pragma weak _priv_addset = priv_addset
28 #pragma weak _priv_allocset = priv_allocset
29 #pragma weak _priv_copyset = priv_copyset
30 #pragma weak _priv_delset = priv_delset
31 #pragma weak _priv_emptyset = priv_emptyset
32 #pragma weak _priv_basicset = priv_basicset
33 #pragma weak _priv_fillset = priv_fillset
34 #pragma weak _priv_freeset = priv_freeset
35 #pragma weak _priv_getbyname = priv_getbyname
36 #pragma weak _priv_getbynum = priv_getbynum
37 #pragma weak _priv_getsetbyname = priv_getsetbyname
38 #pragma weak _priv_getsetbynum = priv_getsetbynum
39 #pragma weak _priv_ineffect = priv_ineffect
40 #pragma weak _priv_intersect = priv_intersect
41 #pragma weak _priv_inverse = priv_inverse
42 #pragma weak _priv_isemptyset = priv_isemptyset
43 #pragma weak _priv_isequalset = priv_isequalset
44 #pragma weak _priv_isfullset = priv_isfullset
45 #pragma weak _priv_ismember = priv_ismember
46 #pragma weak _priv_issubset = priv_issubset
47 #pragma weak _priv_set = priv_set
48 #pragma weak _priv_union = priv_union
49
50 #include "lint.h"
51
52 #define _STRUCTURED_PROC 1
53
54 #include "priv_private.h"
55 #include "mtlib.h"
56 #include "libc.h"
57 #include <errno.h>
58 #include <stdarg.h>
59 #include <stdlib.h>
60 #include <unistd.h>
61 #include <strings.h>
62 #include <synch.h>
63 #include <alloca.h>
64 #include <atomic.h>
65 #include <sys/ucred.h>
66 #include <sys/procfs.h>
67 #include <sys/param.h>
68 #include <sys/corectl.h>
69 #include <priv_utils.h>
70 #include <zone.h>
71
72 /* Include each string only once - until the compiler/linker are fixed */
73 static const char *permitted = PRIV_PERMITTED;
74 static const char *effective = PRIV_EFFECTIVE;
75 static const char *limit = PRIV_LIMIT;
76 static const char *inheritable = PRIV_INHERITABLE;
77 /*
78 * Data independent privilege set operations.
79 *
80 * Only a few functions are provided that do not default to
81 * the system implementation of privileges. A limited set of
82 * interfaces is provided that accepts a priv_data_t *
83 * argument; this set of interfaces is a private interface between libc
84 * and libproc. It is delivered in order to interpret privilege sets
85 * in debuggers in a implementation independent way. As such, we
86 * don't need to provide the bulk of the interfaces, only a few
87 * boolean tests (isfull, isempty) the name<->num mappings and
88 * set pretty print functions. The boolean tests are only needed for
89 * the latter, so those aren't provided externally.
90 *
91 * Additionally, we provide the function that maps the kernel implementation
92 * structure into a libc private data structure.
93 */
94
95 priv_data_t *privdata;
96
97 static mutex_t pd_lock = DEFAULTMUTEX;
98
99 static int
100 parseninfo(priv_info_names_t *na, char ***buf, int *cp)
101 {
102 char *q;
103 int i;
104
105 *buf = libc_malloc(sizeof (char *) * na->cnt);
106
107 if (*buf == NULL)
108 return (-1);
109
110 q = na->names;
111
112 for (i = 0; i < na->cnt; i++) {
113 int l = strlen(q);
114
115 (*buf)[i] = q;
116 q += l + 1;
117 }
118 *cp = na->cnt;
119 return (0);
120 }
121
122 struct strint {
123 char *name;
124 int rank;
125 };
126
127 static int
128 strintcmp(const void *a, const void *b)
129 {
130 const struct strint *ap = a;
131 const struct strint *bp = b;
132
133 return (strcasecmp(ap->name, bp->name));
134 }
135
136 priv_data_t *
137 __priv_parse_info(priv_impl_info_t *ip)
138 {
139 priv_data_t *tmp;
140 char *x;
141 size_t size = PRIV_IMPL_INFO_SIZE(ip);
142 int i;
143
144 tmp = libc_malloc(sizeof (*tmp));
145
146 if (tmp == NULL)
147 return (NULL);
148
149 (void) memset(tmp, 0, sizeof (*tmp));
150
151 tmp->pd_pinfo = ip;
152 tmp->pd_setsize = sizeof (priv_chunk_t) * ip->priv_setsize;
153 tmp->pd_ucredsize = UCRED_SIZE(ip);
154
155 x = (char *)ip;
156 x += ip->priv_headersize;
157
158 while (x < ((char *)ip) + size) {
159 /* LINTED: alignment */
160 priv_info_names_t *na = (priv_info_names_t *)x;
161 /* LINTED: alignment */
162 priv_info_set_t *st = (priv_info_set_t *)x;
163 struct strint *tmparr;
164
165 switch (na->info.priv_info_type) {
166 case PRIV_INFO_SETNAMES:
167 if (parseninfo(na, &tmp->pd_setnames, &tmp->pd_nsets))
168 goto out;
169 break;
170 case PRIV_INFO_PRIVNAMES:
171 if (parseninfo(na, &tmp->pd_privnames, &tmp->pd_nprivs))
172 goto out;
173 /*
174 * We compute a sorted index which allows us
175 * to present a sorted list of privileges
176 * without actually having to sort it each time.
177 */
178 tmp->pd_setsort = libc_malloc(tmp->pd_nprivs *
179 sizeof (int));
180 if (tmp->pd_setsort == NULL)
181 goto out;
182
183 tmparr = libc_malloc(tmp->pd_nprivs *
184 sizeof (struct strint));
185
186 if (tmparr == NULL)
187 goto out;
188
189 for (i = 0; i < tmp->pd_nprivs; i++) {
190 tmparr[i].rank = i;
191 tmparr[i].name = tmp->pd_privnames[i];
192 }
193 qsort(tmparr, tmp->pd_nprivs, sizeof (struct strint),
194 strintcmp);
195 for (i = 0; i < tmp->pd_nprivs; i++)
196 tmp->pd_setsort[i] = tmparr[i].rank;
197 libc_free(tmparr);
198 break;
199 case PRIV_INFO_BASICPRIVS:
200 tmp->pd_basicset = (priv_set_t *)&st->set[0];
201 break;
202 default:
203 /* unknown, ignore */
204 break;
205 }
206 x += na->info.priv_info_size;
207 }
208 return (tmp);
209 out:
210 libc_free(tmp->pd_setnames);
211 libc_free(tmp->pd_privnames);
212 libc_free(tmp->pd_setsort);
213 libc_free(tmp);
214 return (NULL);
215 }
216
217 /*
218 * Caller must have allocated d->pd_pinfo and should free it,
219 * if necessary.
220 */
221 void
222 __priv_free_info(priv_data_t *d)
223 {
224 libc_free(d->pd_setnames);
225 libc_free(d->pd_privnames);
226 libc_free(d->pd_setsort);
227 libc_free(d);
228 }
229
230 /*
231 * Return with the pd_lock held and data loaded or indicate failure.
232 */
233 int
234 lock_data(void)
235 {
236 if (__priv_getdata() == NULL)
237 return (-1);
238
239 lmutex_lock(&pd_lock);
240 return (0);
241 }
242
243 boolean_t
244 refresh_data(void)
245 {
246 priv_impl_info_t *ip, ii;
247 priv_data_t *tmp;
248 char *p0, *q0;
249 int oldn, newn;
250 int i;
251
252 if (getprivinfo(&ii, sizeof (ii)) != 0 ||
253 ii.priv_max == privdata->pd_nprivs)
254 return (B_FALSE);
255
256 ip = alloca(PRIV_IMPL_INFO_SIZE(&ii));
257
258 (void) getprivinfo(ip, PRIV_IMPL_INFO_SIZE(&ii));
259
260 /* Parse the info; then copy the additional bits */
261 tmp = __priv_parse_info(ip);
262 if (tmp == NULL)
263 return (B_FALSE);
264
265 oldn = privdata->pd_nprivs;
266 p0 = privdata->pd_privnames[0];
267
268 newn = tmp->pd_nprivs;
269 q0 = tmp->pd_privnames[0];
270
271 /* copy the extra information to the old datastructure */
272 (void) memcpy((char *)privdata->pd_pinfo + sizeof (priv_impl_info_t),
273 (char *)ip + sizeof (priv_impl_info_t),
274 PRIV_IMPL_INFO_SIZE(ip) - sizeof (priv_impl_info_t));
275
276 /* Copy the first oldn pointers */
277 (void) memcpy(tmp->pd_privnames, privdata->pd_privnames,
278 oldn * sizeof (char *));
279
280 /* Adjust the rest */
281 for (i = oldn; i < newn; i++)
282 tmp->pd_privnames[i] += p0 - q0;
283
284 /* Install the larger arrays */
285 libc_free(privdata->pd_privnames);
286 privdata->pd_privnames = tmp->pd_privnames;
287 tmp->pd_privnames = NULL;
288
289 libc_free(privdata->pd_setsort);
290 privdata->pd_setsort = tmp->pd_setsort;
291 tmp->pd_setsort = NULL;
292
293 /* Copy the rest of the data */
294 *privdata->pd_pinfo = *ip;
295
296 privdata->pd_nprivs = newn;
297
298 __priv_free_info(tmp);
299 return (B_TRUE);
300 }
301
302 void
303 unlock_data(void)
304 {
305 lmutex_unlock(&pd_lock);
306 }
307
308 static priv_set_t *__priv_allocset(priv_data_t *);
309
310 priv_data_t *
311 __priv_getdata(void)
312 {
313 if (privdata == NULL) {
314 lmutex_lock(&pd_lock);
315 if (privdata == NULL) {
316 priv_data_t *tmp;
317 priv_impl_info_t *ip;
318 size_t size = sizeof (priv_impl_info_t) + 2048;
319 size_t realsize;
320 priv_impl_info_t *aip = alloca(size);
321
322 if (getprivinfo(aip, size) != 0)
323 goto out;
324
325 realsize = PRIV_IMPL_INFO_SIZE(aip);
326
327 ip = libc_malloc(realsize);
328
329 if (ip == NULL)
330 goto out;
331
332 if (realsize <= size) {
333 (void) memcpy(ip, aip, realsize);
334 } else if (getprivinfo(ip, realsize) != 0) {
335 libc_free(ip);
336 goto out;
337 }
338
339 if ((tmp = __priv_parse_info(ip)) == NULL) {
340 libc_free(ip);
341 goto out;
342 }
343
344 /* Allocate the zoneset just once, here */
345 tmp->pd_zoneset = __priv_allocset(tmp);
346 if (tmp->pd_zoneset == NULL)
347 goto clean;
348
349 if (zone_getattr(getzoneid(), ZONE_ATTR_PRIVSET,
350 tmp->pd_zoneset, tmp->pd_setsize)
351 == tmp->pd_setsize) {
352 membar_producer();
353 privdata = tmp;
354 goto out;
355 }
356
357 priv_freeset(tmp->pd_zoneset);
358 clean:
359 __priv_free_info(tmp);
360 libc_free(ip);
361 }
362 out:
363 lmutex_unlock(&pd_lock);
364 }
365 membar_consumer();
366 return (privdata);
367 }
368
369 const priv_impl_info_t *
370 getprivimplinfo(void)
371 {
372 priv_data_t *d;
373
374 LOADPRIVDATA(d);
375
376 return (d->pd_pinfo);
377 }
378
379 static priv_set_t *
380 priv_vlist(va_list ap)
381 {
382 priv_set_t *pset = priv_allocset();
383 const char *priv;
384
385 if (pset == NULL)
386 return (NULL);
387
388 priv_emptyset(pset);
389
390 while ((priv = va_arg(ap, const char *)) != NULL) {
391 if (priv_addset(pset, priv) < 0) {
392 priv_freeset(pset);
393 return (NULL);
394 }
395 }
396 return (pset);
397 }
398
399 /*
400 * priv_set(op, set, priv_id1, priv_id2, ..., NULL)
401 *
402 * Library routine to enable a user process to set a specific
403 * privilege set appropriately using a single call. User is
404 * required to terminate the list of privileges with NULL.
405 */
406 int
407 priv_set(priv_op_t op, priv_ptype_t setname, ...)
408 {
409 va_list ap;
410 priv_set_t *pset;
411 int ret;
412
413 va_start(ap, setname);
414
415 pset = priv_vlist(ap);
416
417 va_end(ap);
418
419 if (pset == NULL)
420 return (-1);
421
422 /* All sets */
423 if (setname == NULL) {
424 priv_data_t *d;
425 int set;
426
427 LOADPRIVDATA(d);
428
429 for (set = 0; set < d->pd_nsets; set++)
430 if ((ret = syscall(SYS_privsys, PRIVSYS_SETPPRIV, op,
431 set, (void *)pset, d->pd_setsize)) != 0)
432 break;
433 } else {
434 ret = setppriv(op, setname, pset);
435 }
436
437 priv_freeset(pset);
438 return (ret);
439 }
440
441 /*
442 * priv_ineffect(privilege).
443 * tests the existence of a privilege against the effective set.
444 */
445 boolean_t
446 priv_ineffect(const char *priv)
447 {
448 priv_set_t *curset;
449 boolean_t res;
450
451 curset = priv_allocset();
452
453 if (curset == NULL)
454 return (B_FALSE);
455
456 if (getppriv(effective, curset) != 0 ||
457 !priv_ismember(curset, priv))
458 res = B_FALSE;
459 else
460 res = B_TRUE;
461
462 priv_freeset(curset);
463
464 return (res);
465 }
466
467 /*
468 * The routine __init_daemon_priv() is private to Solaris and is
469 * used by daemons to limit the privileges they can use and
470 * to set the uid they run under.
471 */
472
473 static const char root_cp[] = "/core.%f.%t";
474 static const char daemon_cp[] = "/var/tmp/core.%f.%t";
475
476 int
477 __init_daemon_priv(int flags, uid_t uid, gid_t gid, ...)
478 {
479 priv_set_t *nset;
480 priv_set_t *perm = NULL;
481 va_list pa;
482 priv_data_t *d;
483 int ret = -1;
484 char buf[1024];
485
486 LOADPRIVDATA(d);
487
488 va_start(pa, gid);
489
490 nset = priv_vlist(pa);
491
492 va_end(pa);
493
494 if (nset == NULL)
495 return (-1);
496
497 /* Always add the basic set */
498 if (d->pd_basicset != NULL)
499 priv_union(d->pd_basicset, nset);
500
501 /*
502 * This is not a significant failure: it allows us to start programs
503 * with sufficient privileges and with the proper uid. We don't
504 * care enough about the extra groups in that case.
505 */
506 if (flags & PU_RESETGROUPS)
507 (void) setgroups(0, NULL);
508
509 if (gid != (gid_t)-1 && setgid(gid) != 0)
510 goto end;
511
512 perm = priv_allocset();
513 if (perm == NULL)
514 goto end;
515
516 /* E = P */
517 (void) getppriv(permitted, perm);
518 (void) setppriv(PRIV_SET, effective, perm);
519
520 /* Now reset suid and euid */
521 if (uid != (uid_t)-1 && setreuid(uid, uid) != 0)
522 goto end;
523
524 /* Check for the limit privs */
525 if ((flags & PU_LIMITPRIVS) &&
526 setppriv(PRIV_SET, limit, nset) != 0)
527 goto end;
528
529 if (flags & PU_CLEARLIMITSET) {
530 priv_emptyset(perm);
531 if (setppriv(PRIV_SET, limit, perm) != 0)
532 goto end;
533 }
534
535 /* Remove the privileges from all the other sets */
536 if (setppriv(PRIV_SET, permitted, nset) != 0)
537 goto end;
538
539 if (!(flags & PU_INHERITPRIVS))
540 priv_emptyset(nset);
541
542 ret = setppriv(PRIV_SET, inheritable, nset);
543 end:
544 priv_freeset(nset);
545 priv_freeset(perm);
546
547 if (core_get_process_path(buf, sizeof (buf), getpid()) == 0 &&
548 strcmp(buf, "core") == 0) {
549
550 if ((uid == (uid_t)-1 ? geteuid() : uid) == 0) {
551 (void) core_set_process_path(root_cp, sizeof (root_cp),
552 getpid());
553 } else {
554 (void) core_set_process_path(daemon_cp,
555 sizeof (daemon_cp), getpid());
556 }
557 }
558 (void) setpflags(__PROC_PROTECT, 0);
559
560 return (ret);
561 }
562
563 /*
564 * The routine __fini_daemon_priv() is private to Solaris and is
565 * used by daemons to clear remaining unwanted privileges and
566 * reenable core dumps.
567 */
568 void
569 __fini_daemon_priv(const char *priv, ...)
570 {
571 priv_set_t *nset;
572 va_list pa;
573
574 va_start(pa, priv);
575
576 if (priv != NULL) {
577 nset = priv_vlist(pa);
578 if (nset == NULL)
579 return;
580
581 (void) priv_addset(nset, priv);
582 (void) setppriv(PRIV_OFF, permitted, nset);
583 priv_freeset(nset);
584 }
585
586 va_end(pa);
587
588 (void) setpflags(__PROC_PROTECT, 0);
589 }
590
591 /*
592 * The routine __init_suid_priv() is private to Solaris and is
593 * used by set-uid root programs to limit the privileges acquired
594 * to those actually needed.
595 */
596
597 static priv_set_t *bracketpriv;
598
599 int
600 __init_suid_priv(int flags, ...)
601 {
602 priv_set_t *nset = NULL;
603 priv_set_t *tmpset = NULL;
604 va_list pa;
605 int r = -1;
606 uid_t ruid, euid;
607
608 euid = geteuid();
609
610 /* If we're not set-uid root, don't reset the uid */
611 if (euid == 0) {
612 ruid = getuid();
613 /* If we're running as root, keep everything */
614 if (ruid == 0)
615 return (0);
616 }
617
618 /* Can call this only once */
619 if (bracketpriv != NULL)
620 return (-1);
621
622 va_start(pa, flags);
623
624 nset = priv_vlist(pa);
625
626 va_end(pa);
627
628 if (nset == NULL)
629 goto end;
630
631 tmpset = priv_allocset();
632
633 if (tmpset == NULL)
634 goto end;
635
636 /* We cannot grow our privileges beyond P, so start there */
637 (void) getppriv(permitted, tmpset);
638
639 /* Is the privilege we need even in P? */
640 if (!priv_issubset(nset, tmpset))
641 goto end;
642
643 bracketpriv = priv_allocset();
644 if (bracketpriv == NULL)
645 goto end;
646
647 priv_copyset(nset, bracketpriv);
648
649 /* Always add the basic set */
650 priv_union(priv_basic(), nset);
651
652 /* But don't add what we don't have */
653 priv_intersect(tmpset, nset);
654
655 (void) getppriv(inheritable, tmpset);
656
657 /* And stir in the inheritable privileges */
658 priv_union(tmpset, nset);
659
660 if ((r = setppriv(PRIV_SET, effective, tmpset)) != 0)
661 goto end;
662
663 if ((r = setppriv(PRIV_SET, permitted, nset)) != 0)
664 goto end;
665
666 if (flags & PU_CLEARLIMITSET)
667 priv_emptyset(nset);
668
669 if ((flags & (PU_LIMITPRIVS|PU_CLEARLIMITSET)) != 0 &&
670 (r = setppriv(PRIV_SET, limit, nset)) != 0)
671 goto end;
672
673 if (euid == 0)
674 r = setreuid(ruid, ruid);
675
676 end:
677 priv_freeset(tmpset);
678 priv_freeset(nset);
679 if (r != 0) {
680 /* Fail without leaving uid 0 around */
681 if (euid == 0)
682 (void) setreuid(ruid, ruid);
683 priv_freeset(bracketpriv);
684 bracketpriv = NULL;
685 }
686
687 return (r);
688 }
689
690 /*
691 * Toggle privileges on/off in the effective set.
692 */
693 int
694 __priv_bracket(priv_op_t op)
695 {
696 /* We're running fully privileged or didn't check errors first time */
697 if (bracketpriv == NULL)
698 return (0);
699
700 /* Only PRIV_ON and PRIV_OFF are valid */
701 if (op == PRIV_SET)
702 return (-1);
703
704 return (setppriv(op, effective, bracketpriv));
705 }
706
707 /*
708 * Remove privileges from E & P.
709 */
710 void
711 __priv_relinquish(void)
712 {
713 if (bracketpriv != NULL) {
714 (void) setppriv(PRIV_OFF, permitted, bracketpriv);
715 priv_freeset(bracketpriv);
716 bracketpriv = NULL;
717 }
718 }
719
720 /*
721 * Use binary search on the ordered list.
722 */
723 int
724 __priv_getbyname(const priv_data_t *d, const char *name)
725 {
726 char *const *list;
727 const int *order;
728 int lo = 0;
729 int hi;
730
731 if (d == NULL)
732 return (-1);
733
734 list = d->pd_privnames;
735 order = d->pd_setsort;
736 hi = d->pd_nprivs - 1;
737
738 if (strncasecmp(name, "priv_", 5) == 0)
739 name += 5;
740
741 do {
742 int mid = (lo + hi) / 2;
743 int res = strcasecmp(name, list[order[mid]]);
744
745 if (res == 0)
746 return (order[mid]);
747 else if (res < 0)
748 hi = mid - 1;
749 else
750 lo = mid + 1;
751 } while (lo <= hi);
752
753 errno = EINVAL;
754 return (-1);
755 }
756
757 int
758 priv_getbyname(const char *name)
759 {
760 WITHPRIVLOCKED(int, -1, __priv_getbyname(GETPRIVDATA(), name))
761 }
762
763 int
764 __priv_getsetbyname(const priv_data_t *d, const char *name)
765 {
766 int i;
767 int n = d->pd_nsets;
768 char *const *list = d->pd_setnames;
769
770 if (strncasecmp(name, "priv_", 5) == 0)
771 name += 5;
772
773 for (i = 0; i < n; i++) {
774 if (strcasecmp(list[i], name) == 0)
775 return (i);
776 }
777
778 errno = EINVAL;
779 return (-1);
780 }
781
782 int
783 priv_getsetbyname(const char *name)
784 {
785 /* Not locked: sets don't change */
786 return (__priv_getsetbyname(GETPRIVDATA(), name));
787 }
788
789 static const char *
790 priv_bynum(int i, int n, char **list)
791 {
792 if (i < 0 || i >= n)
793 return (NULL);
794
795 return (list[i]);
796 }
797
798 const char *
799 __priv_getbynum(const priv_data_t *d, int num)
800 {
801 if (d == NULL)
802 return (NULL);
803 return (priv_bynum(num, d->pd_nprivs, d->pd_privnames));
804 }
805
806 const char *
807 priv_getbynum(int num)
808 {
809 WITHPRIVLOCKED(const char *, NULL, __priv_getbynum(GETPRIVDATA(), num))
810 }
811
812 const char *
813 __priv_getsetbynum(const priv_data_t *d, int num)
814 {
815 if (d == NULL)
816 return (NULL);
817 return (priv_bynum(num, d->pd_nsets, d->pd_setnames));
818 }
819
820 const char *
821 priv_getsetbynum(int num)
822 {
823 return (__priv_getsetbynum(GETPRIVDATA(), num));
824 }
825
826
827 /*
828 * Privilege manipulation functions
829 *
830 * Without knowing the details of the privilege set implementation,
831 * opaque pointers can be used to manipulate sets at will.
832 */
833
834 static priv_set_t *
835 __priv_allocset(priv_data_t *d)
836 {
837 if (d == NULL)
838 return (NULL);
839
840 return (libc_malloc(d->pd_setsize));
841 }
842
843 priv_set_t *
844 priv_allocset(void)
845 {
846 return (__priv_allocset(GETPRIVDATA()));
847 }
848
849 void
850 priv_freeset(priv_set_t *p)
851 {
852 int er = errno;
853
854 libc_free(p);
855 errno = er;
856 }
857
858 void
859 __priv_emptyset(priv_data_t *d, priv_set_t *set)
860 {
861 (void) memset(set, 0, d->pd_setsize);
862 }
863
864 void
865 priv_emptyset(priv_set_t *set)
866 {
867 __priv_emptyset(GETPRIVDATA(), set);
868 }
869
870 void
871 priv_basicset(priv_set_t *set)
872 {
873 priv_copyset(priv_basic(), set);
874 }
875
876 void
877 __priv_fillset(priv_data_t *d, priv_set_t *set)
878 {
879 (void) memset(set, ~0, d->pd_setsize);
880 }
881
882 void
883 priv_fillset(priv_set_t *set)
884 {
885 __priv_fillset(GETPRIVDATA(), set);
886 }
887
888
889 #define PRIV_TEST_BODY_D(d, test) \
890 int i; \
891 \
892 for (i = d->pd_pinfo->priv_setsize; i-- > 0; ) \
893 if (!(test)) \
894 return (B_FALSE); \
895 \
896 return (B_TRUE)
897
898 boolean_t
899 priv_isequalset(const priv_set_t *a, const priv_set_t *b)
900 {
901 priv_data_t *d;
902
903 LOADPRIVDATA(d);
904
905 return ((boolean_t)(memcmp(a, b, d->pd_setsize) == 0));
906 }
907
908 boolean_t
909 __priv_isemptyset(priv_data_t *d, const priv_set_t *set)
910 {
911 PRIV_TEST_BODY_D(d, ((priv_chunk_t *)set)[i] == 0);
912 }
913
914 boolean_t
915 priv_isemptyset(const priv_set_t *set)
916 {
917 return (__priv_isemptyset(GETPRIVDATA(), set));
918 }
919
920 boolean_t
921 __priv_isfullset(priv_data_t *d, const priv_set_t *set)
922 {
923 PRIV_TEST_BODY_D(d, ((priv_chunk_t *)set)[i] == ~(priv_chunk_t)0);
924 }
925
926 boolean_t
927 priv_isfullset(const priv_set_t *set)
928 {
929 return (__priv_isfullset(GETPRIVDATA(), set));
930 }
931
932 /*
933 * Return true if a is a subset of b
934 */
935 boolean_t
936 __priv_issubset(priv_data_t *d, const priv_set_t *a, const priv_set_t *b)
937 {
938 PRIV_TEST_BODY_D(d, (((priv_chunk_t *)a)[i] | ((priv_chunk_t *)b)[i]) ==
939 ((priv_chunk_t *)b)[i]);
940 }
941
942 boolean_t
943 priv_issubset(const priv_set_t *a, const priv_set_t *b)
944 {
945 return (__priv_issubset(GETPRIVDATA(), a, b));
946 }
947
948 #define PRIV_CHANGE_BODY(a, op, b) \
949 int i; \
950 priv_data_t *d; \
951 \
952 LOADPRIVDATA(d); \
953 \
954 for (i = 0; i < d->pd_pinfo->priv_setsize; i++) \
955 ((priv_chunk_t *)a)[i] op \
956 ((priv_chunk_t *)b)[i]
957
958 /* B = A ^ B */
959 void
960 priv_intersect(const priv_set_t *a, priv_set_t *b)
961 {
962 /* CSTYLED */
963 PRIV_CHANGE_BODY(b, &=, a);
964 }
965
966 /* B = A */
967 void
968 priv_copyset(const priv_set_t *a, priv_set_t *b)
969 {
970 /* CSTYLED */
971 PRIV_CHANGE_BODY(b, =, a);
972 }
973
974 /* B = A v B */
975 void
976 priv_union(const priv_set_t *a, priv_set_t *b)
977 {
978 /* CSTYLED */
979 PRIV_CHANGE_BODY(b, |=, a);
980 }
981
982 /* A = ! A */
983 void
984 priv_inverse(priv_set_t *a)
985 {
986 PRIV_CHANGE_BODY(a, = ~, a);
987 }
988
989 /*
990 * Manipulating single privileges.
991 */
992
993 int
994 priv_addset(priv_set_t *a, const char *p)
995 {
996 int priv = priv_getbyname(p);
997
998 if (priv < 0)
999 return (-1);
1000
1001 PRIV_ADDSET(a, priv);
1002
1003 return (0);
1004 }
1005
1006 int
1007 priv_delset(priv_set_t *a, const char *p)
1008 {
1009 int priv = priv_getbyname(p);
1010
1011 if (priv < 0)
1012 return (-1);
1013
1014 PRIV_DELSET(a, priv);
1015 return (0);
1016 }
1017
1018 boolean_t
1019 priv_ismember(const priv_set_t *a, const char *p)
1020 {
1021 int priv = priv_getbyname(p);
1022
1023 if (priv < 0)
1024 return (B_FALSE);
1025
1026 return ((boolean_t)PRIV_ISMEMBER(a, priv));
1027 }