Annotation of sys/kern/kern_prot.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: kern_prot.c,v 1.30 2007/04/03 08:05:43 art Exp $ */
2: /* $NetBSD: kern_prot.c,v 1.33 1996/02/09 18:59:42 christos Exp $ */
3:
4: /*
5: * Copyright (c) 1982, 1986, 1989, 1990, 1991, 1993
6: * The Regents of the University of California. All rights reserved.
7: * (c) UNIX System Laboratories, Inc.
8: * All or some portions of this file are derived from material licensed
9: * to the University of California by American Telephone and Telegraph
10: * Co. or Unix System Laboratories, Inc. and are reproduced herein with
11: * the permission of UNIX System Laboratories, Inc.
12: *
13: * Redistribution and use in source and binary forms, with or without
14: * modification, are permitted provided that the following conditions
15: * are met:
16: * 1. Redistributions of source code must retain the above copyright
17: * notice, this list of conditions and the following disclaimer.
18: * 2. Redistributions in binary form must reproduce the above copyright
19: * notice, this list of conditions and the following disclaimer in the
20: * documentation and/or other materials provided with the distribution.
21: * 3. Neither the name of the University nor the names of its contributors
22: * may be used to endorse or promote products derived from this software
23: * without specific prior written permission.
24: *
25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35: * SUCH DAMAGE.
36: *
37: * @(#)kern_prot.c 8.6 (Berkeley) 1/21/94
38: */
39:
40: /*
41: * System calls related to processes and protection
42: */
43:
44: #include <sys/param.h>
45: #include <sys/acct.h>
46: #include <sys/systm.h>
47: #include <sys/ucred.h>
48: #include <sys/proc.h>
49: #include <sys/timeb.h>
50: #include <sys/times.h>
51: #include <sys/malloc.h>
52: #include <sys/filedesc.h>
53: #include <sys/pool.h>
54:
55: #include <sys/mount.h>
56: #include <sys/syscallargs.h>
57:
58: /* ARGSUSED */
59: int
60: sys_getpid(struct proc *p, void *v, register_t *retval)
61: {
62:
63: *retval = p->p_p->ps_mainproc->p_pid;
64: #if defined(COMPAT_43) || defined(COMPAT_SUNOS) || defined(COMPAT_IBCS2) || \
65: defined(COMPAT_FREEBSD) || defined(COMPAT_BSDOS)
66: retval[1] = p->p_p->ps_mainproc->p_pptr->p_pid;
67: #endif
68: return (0);
69: }
70:
71: #ifdef RTHREADS
72: /* ARGSUSED */
73: int
74: sys_getthrid(p, v, retval)
75: struct proc *p;
76: void *v;
77: register_t *retval;
78: {
79:
80: *retval = p->p_pid;
81: return (0);
82: }
83: #endif
84:
85: /* ARGSUSED */
86: int
87: sys_getppid(struct proc *p, void *v, register_t *retval)
88: {
89:
90: *retval = p->p_p->ps_mainproc->p_pptr->p_pid;
91: return (0);
92: }
93:
94: /* Get process group ID; note that POSIX getpgrp takes no parameter */
95: int
96: sys_getpgrp(struct proc *p, void *v, register_t *retval)
97: {
98:
99: *retval = p->p_pgrp->pg_id;
100: return (0);
101: }
102:
103: /*
104: * SysVR.4 compatible getpgid()
105: */
106: pid_t
107: sys_getpgid(struct proc *curp, void *v, register_t *retval)
108: {
109: struct sys_getpgid_args /* {
110: syscallarg(pid_t) pid;
111: } */ *uap = v;
112: struct proc *targp = curp;
113:
114: if (SCARG(uap, pid) == 0 || SCARG(uap, pid) == curp->p_pid)
115: goto found;
116: if ((targp = pfind(SCARG(uap, pid))) == NULL)
117: return (ESRCH);
118: if (targp->p_session != curp->p_session)
119: return (EPERM);
120: found:
121: *retval = targp->p_pgid;
122: return (0);
123: }
124:
125: pid_t
126: sys_getsid(struct proc *curp, void *v, register_t *retval)
127: {
128: struct sys_getsid_args /* {
129: syscallarg(pid_t) pid;
130: } */ *uap = v;
131: struct proc *targp = curp;
132:
133: if (SCARG(uap, pid) == 0 || SCARG(uap, pid) == curp->p_pid)
134: goto found;
135: if ((targp = pfind(SCARG(uap, pid))) == NULL)
136: return (ESRCH);
137: if (targp->p_session != curp->p_session)
138: return (EPERM);
139: found:
140: /* Skip exiting processes */
141: if (targp->p_pgrp->pg_session->s_leader == NULL)
142: return (ESRCH);
143: *retval = targp->p_pgrp->pg_session->s_leader->p_pid;
144: return (0);
145: }
146:
147: /* ARGSUSED */
148: int
149: sys_getuid(struct proc *p, void *v, register_t *retval)
150: {
151:
152: *retval = p->p_cred->p_ruid;
153: #if defined(COMPAT_43) || defined(COMPAT_SUNOS) || defined(COMPAT_IBCS2) || \
154: defined(COMPAT_FREEBSD) || defined(COMPAT_BSDOS)
155: retval[1] = p->p_ucred->cr_uid;
156: #endif
157: return (0);
158: }
159:
160: /* ARGSUSED */
161: int
162: sys_geteuid(struct proc *p, void *v, register_t *retval)
163: {
164:
165: *retval = p->p_ucred->cr_uid;
166: return (0);
167: }
168:
169: /* ARGSUSED */
170: int
171: sys_issetugid(struct proc *p, void *v, register_t *retval)
172: {
173: if (p->p_flag & P_SUGIDEXEC)
174: *retval = 1;
175: else
176: *retval = 0;
177: return (0);
178: }
179:
180: /* ARGSUSED */
181: int
182: sys_getgid(struct proc *p, void *v, register_t *retval)
183: {
184:
185: *retval = p->p_cred->p_rgid;
186: #if defined(COMPAT_43) || defined(COMPAT_SUNOS) || defined(COMPAT_FREEBSD) || defined(COMPAT_BSDOS)
187: retval[1] = p->p_ucred->cr_gid;
188: #endif
189: return (0);
190: }
191:
192: /*
193: * Get effective group ID. The "egid" is groups[0], and could be obtained
194: * via getgroups. This syscall exists because it is somewhat painful to do
195: * correctly in a library function.
196: */
197: /* ARGSUSED */
198: int
199: sys_getegid(struct proc *p, void *v, register_t *retval)
200: {
201:
202: *retval = p->p_ucred->cr_gid;
203: return (0);
204: }
205:
206: int
207: sys_getgroups(struct proc *p, void *v, register_t *retval)
208: {
209: struct sys_getgroups_args /* {
210: syscallarg(int) gidsetsize;
211: syscallarg(gid_t *) gidset;
212: } */ *uap = v;
213: struct pcred *pc = p->p_cred;
214: u_int ngrp;
215: int error;
216:
217: if ((ngrp = SCARG(uap, gidsetsize)) == 0) {
218: *retval = pc->pc_ucred->cr_ngroups;
219: return (0);
220: }
221: if (ngrp < pc->pc_ucred->cr_ngroups)
222: return (EINVAL);
223: ngrp = pc->pc_ucred->cr_ngroups;
224: error = copyout((caddr_t)pc->pc_ucred->cr_groups,
225: (caddr_t)SCARG(uap, gidset), ngrp * sizeof(gid_t));
226: if (error)
227: return (error);
228: *retval = ngrp;
229: return (0);
230: }
231:
232: /* ARGSUSED */
233: int
234: sys_setsid(struct proc *p, void *v, register_t *retval)
235: {
236:
237: if (p->p_pgid == p->p_pid || pgfind(p->p_pid)) {
238: return (EPERM);
239: } else {
240: (void)enterpgrp(p, p->p_pid, 1);
241: *retval = p->p_pid;
242: return (0);
243: }
244: }
245:
246: /*
247: * set process group (setpgid/old setpgrp)
248: *
249: * caller does setpgid(targpid, targpgid)
250: *
251: * pid must be caller or child of caller (ESRCH)
252: * if a child
253: * pid must be in same session (EPERM)
254: * pid can't have done an exec (EACCES)
255: * if pgid != pid
256: * there must exist some pid in same session having pgid (EPERM)
257: * pid must not be session leader (EPERM)
258: */
259: /* ARGSUSED */
260: int
261: sys_setpgid(struct proc *curp, void *v, register_t *retval)
262: {
263: struct sys_setpgid_args /* {
264: syscallarg(pid_t) pid;
265: syscallarg(int) pgid;
266: } */ *uap = v;
267: struct proc *targp; /* target process */
268: struct pgrp *pgrp; /* target pgrp */
269: pid_t pid;
270: int pgid;
271:
272: pid = SCARG(uap, pid);
273: pgid = SCARG(uap, pgid);
274:
275: if (pgid < 0)
276: return (EINVAL);
277:
278: if (pid != 0 && pid != curp->p_pid) {
279: if ((targp = pfind(pid)) == 0 || !inferior(targp))
280: return (ESRCH);
281: if (targp->p_session != curp->p_session)
282: return (EPERM);
283: if (targp->p_flag & P_EXEC)
284: return (EACCES);
285: } else
286: targp = curp;
287: if (SESS_LEADER(targp))
288: return (EPERM);
289: if (pgid == 0)
290: pgid = targp->p_pid;
291: else if (pgid != targp->p_pid)
292: if ((pgrp = pgfind(pgid)) == 0 ||
293: pgrp->pg_session != curp->p_session)
294: return (EPERM);
295: return (enterpgrp(targp, pgid, 0));
296: }
297:
298: /* ARGSUSED */
299: int
300: sys_getresuid(struct proc *p, void *v, register_t *retval)
301: {
302: struct sys_getresuid_args /* {
303: syscallarg(uid_t *) ruid;
304: syscallarg(uid_t *) euid;
305: syscallarg(uid_t *) suid;
306: } */ *uap = v;
307: struct pcred *pc = p->p_cred;
308: uid_t *ruid, *euid, *suid;
309: int error1 = 0, error2 = 0, error3 = 0;
310:
311: ruid = SCARG(uap, ruid);
312: euid = SCARG(uap, euid);
313: suid = SCARG(uap, suid);
314:
315: if (ruid != NULL)
316: error1 = copyout(&pc->p_ruid, ruid, sizeof(*ruid));
317: if (euid != NULL)
318: error2 = copyout(&pc->pc_ucred->cr_uid, euid, sizeof(*euid));
319: if (suid != NULL)
320: error3 = copyout(&pc->p_svuid, suid, sizeof(*suid));
321:
322: return (error1 ? error1 : error2 ? error2 : error3);
323: }
324:
325: /* ARGSUSED */
326: int
327: sys_setresuid(struct proc *p, void *v, register_t *retval)
328: {
329: struct sys_setresuid_args /* {
330: syscallarg(uid_t) ruid;
331: syscallarg(uid_t) euid;
332: syscallarg(uid_t) suid;
333: } */ *uap = v;
334: struct pcred *pc = p->p_cred;
335: uid_t ruid, euid, suid;
336: int error;
337:
338: ruid = SCARG(uap, ruid);
339: euid = SCARG(uap, euid);
340: suid = SCARG(uap, suid);
341:
342: if ((ruid == -1 || ruid == pc->p_ruid) &&
343: (euid == -1 || euid == pc->pc_ucred->cr_uid) &&
344: (suid == -1 || suid == pc->p_svuid))
345: return (0); /* no change */
346:
347: /*
348: * Any of the real, effective, and saved uids may be changed
349: * to the current value of one of the three (root is not limited).
350: */
351: if (ruid != (uid_t)-1 &&
352: ruid != pc->p_ruid &&
353: ruid != pc->pc_ucred->cr_uid &&
354: ruid != pc->p_svuid &&
355: (error = suser(p, 0)))
356: return (error);
357:
358: if (euid != (uid_t)-1 &&
359: euid != pc->p_ruid &&
360: euid != pc->pc_ucred->cr_uid &&
361: euid != pc->p_svuid &&
362: (error = suser(p, 0)))
363: return (error);
364:
365: if (suid != (uid_t)-1 &&
366: suid != pc->p_ruid &&
367: suid != pc->pc_ucred->cr_uid &&
368: suid != pc->p_svuid &&
369: (error = suser(p, 0)))
370: return (error);
371:
372: /*
373: * Note that unlike the other set*uid() calls, each
374: * uid type is set independently of the others.
375: */
376: if (ruid != (uid_t)-1 && ruid != pc->p_ruid) {
377: /*
378: * Transfer proc count to new user.
379: */
380: (void)chgproccnt(pc->p_ruid, -1);
381: (void)chgproccnt(ruid, 1);
382: pc->p_ruid = ruid;
383: }
384: if (euid != (uid_t)-1 && euid != pc->pc_ucred->cr_uid) {
385: /*
386: * Copy credentials so other references do not see our changes.
387: */
388: pc->pc_ucred = crcopy(pc->pc_ucred);
389: pc->pc_ucred->cr_uid = euid;
390: }
391: if (suid != (uid_t)-1 && suid != pc->p_svuid)
392: pc->p_svuid = suid;
393:
394: atomic_setbits_int(&p->p_flag, P_SUGID);
395: return (0);
396: }
397:
398: /* ARGSUSED */
399: int
400: sys_getresgid(struct proc *p, void *v, register_t *retval)
401: {
402: struct sys_getresgid_args /* {
403: syscallarg(gid_t *) rgid;
404: syscallarg(gid_t *) egid;
405: syscallarg(gid_t *) sgid;
406: } */ *uap = v;
407: struct pcred *pc = p->p_cred;
408: gid_t *rgid, *egid, *sgid;
409: int error1 = 0, error2 = 0, error3 = 0;
410:
411: rgid = SCARG(uap, rgid);
412: egid = SCARG(uap, egid);
413: sgid = SCARG(uap, sgid);
414:
415: if (rgid != NULL)
416: error1 = copyout(&pc->p_rgid, rgid, sizeof(*rgid));
417: if (egid != NULL)
418: error2 = copyout(&pc->pc_ucred->cr_gid, egid, sizeof(*egid));
419: if (sgid != NULL)
420: error3 = copyout(&pc->p_svgid, sgid, sizeof(*sgid));
421:
422: return (error1 ? error1 : error2 ? error2 : error3);
423: }
424:
425: /* ARGSUSED */
426: int
427: sys_setresgid(struct proc *p, void *v, register_t *retval)
428: {
429: struct sys_setresgid_args /* {
430: syscallarg(gid_t) rgid;
431: syscallarg(gid_t) egid;
432: syscallarg(gid_t) sgid;
433: } */ *uap = v;
434: struct pcred *pc = p->p_cred;
435: gid_t rgid, egid, sgid;
436: int error;
437:
438: rgid = SCARG(uap, rgid);
439: egid = SCARG(uap, egid);
440: sgid = SCARG(uap, sgid);
441:
442: if ((rgid == -1 || rgid == pc->p_rgid) &&
443: (egid == -1 || egid == pc->pc_ucred->cr_gid) &&
444: (sgid == -1 || sgid == pc->p_svgid))
445: return (0); /* no change */
446:
447: /*
448: * Any of the real, effective, and saved gids may be changed
449: * to the current value of one of the three (root is not limited).
450: */
451: if (rgid != (gid_t)-1 &&
452: rgid != pc->p_rgid &&
453: rgid != pc->pc_ucred->cr_gid &&
454: rgid != pc->p_svgid &&
455: (error = suser(p, 0)))
456: return (error);
457:
458: if (egid != (gid_t)-1 &&
459: egid != pc->p_rgid &&
460: egid != pc->pc_ucred->cr_gid &&
461: egid != pc->p_svgid &&
462: (error = suser(p, 0)))
463: return (error);
464:
465: if (sgid != (gid_t)-1 &&
466: sgid != pc->p_rgid &&
467: sgid != pc->pc_ucred->cr_gid &&
468: sgid != pc->p_svgid &&
469: (error = suser(p, 0)))
470: return (error);
471:
472: /*
473: * Note that unlike the other set*gid() calls, each
474: * gid type is set independently of the others.
475: */
476: if (rgid != (gid_t)-1)
477: pc->p_rgid = rgid;
478: if (egid != (gid_t)-1) {
479: /*
480: * Copy credentials so other references do not see our changes.
481: */
482: pc->pc_ucred = crcopy(pc->pc_ucred);
483: pc->pc_ucred->cr_gid = egid;
484: }
485: if (sgid != (gid_t)-1)
486: pc->p_svgid = sgid;
487:
488: atomic_setbits_int(&p->p_flag, P_SUGID);
489: return (0);
490: }
491:
492: /* ARGSUSED */
493: int
494: sys_setregid(struct proc *p, void *v, register_t *retval)
495: {
496: struct sys_setregid_args /* {
497: syscallarg(gid_t) rgid;
498: syscallarg(gid_t) egid;
499: } */ *uap = v;
500: struct pcred *pc = p->p_cred;
501: struct sys_setresgid_args sresgidargs;
502: gid_t rgid, egid;
503:
504: rgid = SCARG(&sresgidargs, rgid) = SCARG(uap, rgid);
505: egid = SCARG(&sresgidargs, egid) = SCARG(uap, egid);
506:
507: /*
508: * The saved gid presents a bit of a dilemma, as it did not
509: * exist when setregid(2) was conceived. We only set the saved
510: * gid when the real gid is specified and either its value would
511: * change, or where the saved and effective gids are different.
512: */
513: if (rgid != (gid_t)-1 && (rgid != pc->p_rgid ||
514: pc->p_svgid != (egid != (gid_t)-1 ? egid : pc->pc_ucred->cr_gid)))
515: SCARG(&sresgidargs, sgid) = rgid;
516: else
517: SCARG(&sresgidargs, sgid) = (gid_t)-1;
518:
519: return (sys_setresgid(p, &sresgidargs, retval));
520: }
521:
522: /* ARGSUSED */
523: int
524: sys_setreuid(struct proc *p, void *v, register_t *retval)
525: {
526: struct sys_setreuid_args /* {
527: syscallarg(uid_t) ruid;
528: syscallarg(uid_t) euid;
529: } */ *uap = v;
530: struct pcred *pc = p->p_cred;
531: struct sys_setresuid_args sresuidargs;
532: uid_t ruid, euid;
533:
534: ruid = SCARG(&sresuidargs, ruid) = SCARG(uap, ruid);
535: euid = SCARG(&sresuidargs, euid) = SCARG(uap, euid);
536:
537: /*
538: * The saved uid presents a bit of a dilemma, as it did not
539: * exist when setreuid(2) was conceived. We only set the saved
540: * uid when the real uid is specified and either its value would
541: * change, or where the saved and effective uids are different.
542: */
543: if (ruid != (uid_t)-1 && (ruid != pc->p_ruid ||
544: pc->p_svuid != (euid != (uid_t)-1 ? euid : pc->pc_ucred->cr_uid)))
545: SCARG(&sresuidargs, suid) = ruid;
546: else
547: SCARG(&sresuidargs, suid) = (uid_t)-1;
548:
549: return (sys_setresuid(p, &sresuidargs, retval));
550: }
551:
552: /* ARGSUSED */
553: int
554: sys_setuid(struct proc *p, void *v, register_t *retval)
555: {
556: struct sys_setuid_args /* {
557: syscallarg(uid_t) uid;
558: } */ *uap = v;
559: struct pcred *pc = p->p_cred;
560: uid_t uid;
561: int error;
562:
563: uid = SCARG(uap, uid);
564:
565: if (pc->pc_ucred->cr_uid == uid &&
566: pc->p_ruid == uid &&
567: pc->p_svuid == uid)
568: return (0);
569:
570: if (uid != pc->p_ruid &&
571: uid != pc->p_svuid &&
572: uid != pc->pc_ucred->cr_uid &&
573: (error = suser(p, 0)))
574: return (error);
575:
576: /*
577: * Everything's okay, do it.
578: */
579: if (uid == pc->pc_ucred->cr_uid ||
580: suser(p, 0) == 0) {
581: /*
582: * Transfer proc count to new user.
583: */
584: if (uid != pc->p_ruid) {
585: (void)chgproccnt(pc->p_ruid, -1);
586: (void)chgproccnt(uid, 1);
587: }
588: pc->p_ruid = uid;
589: pc->p_svuid = uid;
590: }
591:
592: /*
593: * Copy credentials so other references do not see our changes.
594: */
595: pc->pc_ucred = crcopy(pc->pc_ucred);
596: pc->pc_ucred->cr_uid = uid;
597: atomic_setbits_int(&p->p_flag, P_SUGID);
598: return (0);
599: }
600:
601: /* ARGSUSED */
602: int
603: sys_seteuid(struct proc *p, void *v, register_t *retval)
604: {
605: struct sys_seteuid_args /* {
606: syscallarg(uid_t) euid;
607: } */ *uap = v;
608: struct pcred *pc = p->p_cred;
609: uid_t euid;
610: int error;
611:
612: euid = SCARG(uap, euid);
613:
614: if (pc->pc_ucred->cr_uid == euid)
615: return (0);
616:
617: if (euid != pc->p_ruid && euid != pc->p_svuid &&
618: (error = suser(p, 0)))
619: return (error);
620:
621: /*
622: * Copy credentials so other references do not see our changes.
623: */
624: pc->pc_ucred = crcopy(pc->pc_ucred);
625: pc->pc_ucred->cr_uid = euid;
626: atomic_setbits_int(&p->p_flag, P_SUGID);
627: return (0);
628: }
629:
630: /* ARGSUSED */
631: int
632: sys_setgid(struct proc *p, void *v, register_t *retval)
633: {
634: struct sys_setgid_args /* {
635: syscallarg(gid_t) gid;
636: } */ *uap = v;
637: struct pcred *pc = p->p_cred;
638: gid_t gid;
639: int error;
640:
641: gid = SCARG(uap, gid);
642:
643: if (pc->pc_ucred->cr_gid == gid &&
644: pc->p_rgid == gid &&
645: pc->p_svgid == gid)
646: return (0);
647:
648: if (gid != pc->p_rgid &&
649: gid != pc->p_svgid &&
650: gid != pc->pc_ucred->cr_gid &&
651: (error = suser(p, 0)))
652: return (error);
653:
654: if (gid == pc->pc_ucred->cr_gid ||
655: suser(p, 0) == 0) {
656: pc->p_rgid = gid;
657: pc->p_svgid = gid;
658: }
659:
660: /*
661: * Copy credentials so other references do not see our changes.
662: */
663: pc->pc_ucred = crcopy(pc->pc_ucred);
664: pc->pc_ucred->cr_gid = gid;
665: atomic_setbits_int(&p->p_flag, P_SUGID);
666: return (0);
667: }
668:
669: /* ARGSUSED */
670: int
671: sys_setegid(struct proc *p, void *v, register_t *retval)
672: {
673: struct sys_setegid_args /* {
674: syscallarg(gid_t) egid;
675: } */ *uap = v;
676: struct pcred *pc = p->p_cred;
677: gid_t egid;
678: int error;
679:
680: egid = SCARG(uap, egid);
681:
682: if (pc->pc_ucred->cr_gid == egid)
683: return (0);
684:
685: if (egid != pc->p_rgid && egid != pc->p_svgid &&
686: (error = suser(p, 0)))
687: return (error);
688:
689: /*
690: * Copy credentials so other references do not see our changes.
691: */
692: pc->pc_ucred = crcopy(pc->pc_ucred);
693: pc->pc_ucred->cr_gid = egid;
694: atomic_setbits_int(&p->p_flag, P_SUGID);
695: return (0);
696: }
697:
698: /* ARGSUSED */
699: int
700: sys_setgroups(struct proc *p, void *v, register_t *retval)
701: {
702: struct sys_setgroups_args /* {
703: syscallarg(int) gidsetsize;
704: syscallarg(const gid_t *) gidset;
705: } */ *uap = v;
706: struct pcred *pc = p->p_cred;
707: u_int ngrp;
708: int error;
709:
710: if ((error = suser(p, 0)) != 0)
711: return (error);
712: ngrp = SCARG(uap, gidsetsize);
713: if (ngrp > NGROUPS)
714: return (EINVAL);
715: pc->pc_ucred = crcopy(pc->pc_ucred);
716: error = copyin((caddr_t)SCARG(uap, gidset),
717: (caddr_t)pc->pc_ucred->cr_groups, ngrp * sizeof(gid_t));
718: if (error)
719: return (error);
720: pc->pc_ucred->cr_ngroups = ngrp;
721: atomic_setbits_int(&p->p_flag, P_SUGID);
722: return (0);
723: }
724:
725: /*
726: * Check if gid is a member of the group set.
727: */
728: int
729: groupmember(gid_t gid, struct ucred *cred)
730: {
731: gid_t *gp;
732: gid_t *egp;
733:
734: egp = &(cred->cr_groups[cred->cr_ngroups]);
735: for (gp = cred->cr_groups; gp < egp; gp++)
736: if (*gp == gid)
737: return (1);
738: return (0);
739: }
740:
741: /*
742: * Test whether this process has special user powers.
743: * Returns 0 or error.
744: */
745: int
746: suser(struct proc *p, u_int flags)
747: {
748: struct ucred *cred = p->p_ucred;
749:
750: if (cred->cr_uid == 0) {
751: if (!(flags & SUSER_NOACCT))
752: p->p_acflag |= ASU;
753: return (0);
754: }
755: return (EPERM);
756: }
757:
758: /*
759: * replacement for old suser, for callers who don't have a process
760: */
761: int
762: suser_ucred(struct ucred *cred)
763: {
764: if (cred->cr_uid == 0)
765: return (0);
766: return (EPERM);
767: }
768:
769: /*
770: * Allocate a zeroed cred structure.
771: */
772: struct ucred *
773: crget(void)
774: {
775: struct ucred *cr;
776:
777: cr = pool_get(&ucred_pool, PR_WAITOK);
778: bzero((caddr_t)cr, sizeof(*cr));
779: cr->cr_ref = 1;
780: return (cr);
781: }
782:
783: /*
784: * Free a cred structure.
785: * Throws away space when ref count gets to 0.
786: */
787: void
788: crfree(struct ucred *cr)
789: {
790:
791: if (--cr->cr_ref == 0)
792: pool_put(&ucred_pool, cr);
793: }
794:
795: /*
796: * Copy cred structure to a new one and free the old one.
797: */
798: struct ucred *
799: crcopy(struct ucred *cr)
800: {
801: struct ucred *newcr;
802:
803: if (cr->cr_ref == 1)
804: return (cr);
805: newcr = crget();
806: *newcr = *cr;
807: crfree(cr);
808: newcr->cr_ref = 1;
809: return (newcr);
810: }
811:
812: /*
813: * Dup cred struct to a new held one.
814: */
815: struct ucred *
816: crdup(struct ucred *cr)
817: {
818: struct ucred *newcr;
819:
820: newcr = crget();
821: *newcr = *cr;
822: newcr->cr_ref = 1;
823: return (newcr);
824: }
825:
826: /*
827: * Get login name, if available.
828: */
829: /* ARGSUSED */
830: int
831: sys_getlogin(struct proc *p, void *v, register_t *retval)
832: {
833: struct sys_getlogin_args /* {
834: syscallarg(char *) namebuf;
835: syscallarg(u_int) namelen;
836: } */ *uap = v;
837:
838: if (SCARG(uap, namelen) > sizeof (p->p_pgrp->pg_session->s_login))
839: SCARG(uap, namelen) = sizeof (p->p_pgrp->pg_session->s_login);
840: return (copyout((caddr_t) p->p_pgrp->pg_session->s_login,
841: (caddr_t) SCARG(uap, namebuf), SCARG(uap, namelen)));
842: }
843:
844: /*
845: * Set login name.
846: */
847: /* ARGSUSED */
848: int
849: sys_setlogin(struct proc *p, void *v, register_t *retval)
850: {
851: struct sys_setlogin_args /* {
852: syscallarg(const char *) namebuf;
853: } */ *uap = v;
854: int error;
855:
856: if ((error = suser(p, 0)) != 0)
857: return (error);
858: error = copyinstr((caddr_t) SCARG(uap, namebuf),
859: (caddr_t) p->p_pgrp->pg_session->s_login,
860: sizeof (p->p_pgrp->pg_session->s_login), (size_t *)0);
861: if (error == ENAMETOOLONG)
862: error = EINVAL;
863: return (error);
864: }
865:
866: /*
867: * Check if a process is allowed to raise its privileges.
868: */
869: int
870: proc_cansugid(struct proc *p)
871: {
872: /* ptrace(2)d processes shouldn't. */
873: if ((p->p_flag & P_TRACED) != 0)
874: return (0);
875:
876: /* proceses with shared filedescriptors shouldn't. */
877: if (p->p_fd->fd_refcnt > 1)
878: return (0);
879:
880: /* Allow. */
881: return (1);
882: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to kern_prot.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / kern