![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to kern_prot.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Net/2] / Net2 / kern|
Return to kern_prot.c CVS log | Up to [Net/2] / Net2 / kern |
1.1 ! root 1: /* ! 2: * Copyright (c) 1982, 1986, 1989, 1990, 1991 Regents of the University ! 3: * of California. All rights reserved. ! 4: * ! 5: * Redistribution and use in source and binary forms, with or without ! 6: * modification, are permitted provided that the following conditions ! 7: * are met: ! 8: * 1. Redistributions of source code must retain the above copyright ! 9: * notice, this list of conditions and the following disclaimer. ! 10: * 2. Redistributions in binary form must reproduce the above copyright ! 11: * notice, this list of conditions and the following disclaimer in the ! 12: * documentation and/or other materials provided with the distribution. ! 13: * 3. All advertising materials mentioning features or use of this software ! 14: * must display the following acknowledgement: ! 15: * This product includes software developed by the University of ! 16: * California, Berkeley and its contributors. ! 17: * 4. Neither the name of the University nor the names of its contributors ! 18: * may be used to endorse or promote products derived from this software ! 19: * without specific prior written permission. ! 20: * ! 21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 31: * SUCH DAMAGE. ! 32: * ! 33: * @(#)kern_prot.c 7.21 (Berkeley) 5/3/91 ! 34: */ ! 35: ! 36: /* ! 37: * System calls related to processes and protection ! 38: */ ! 39: ! 40: #include "param.h" ! 41: #include "acct.h" ! 42: #include "systm.h" ! 43: #include "ucred.h" ! 44: #include "proc.h" ! 45: #include "timeb.h" ! 46: #include "times.h" ! 47: #include "malloc.h" ! 48: ! 49: /* ARGSUSED */ ! 50: getpid(p, uap, retval) ! 51: struct proc *p; ! 52: void *uap; ! 53: int *retval; ! 54: { ! 55: ! 56: *retval = p->p_pid; ! 57: #ifdef COMPAT_43 ! 58: retval[1] = p->p_pptr->p_pid; ! 59: #endif ! 60: return (0); ! 61: } ! 62: ! 63: /* ARGSUSED */ ! 64: getppid(p, uap, retval) ! 65: struct proc *p; ! 66: void *uap; ! 67: int *retval; ! 68: { ! 69: ! 70: *retval = p->p_pptr->p_pid; ! 71: return (0); ! 72: } ! 73: ! 74: /* Get process group ID; note that POSIX getpgrp takes no parameter */ ! 75: getpgrp(p, uap, retval) ! 76: struct proc *p; ! 77: void *uap; ! 78: int *retval; ! 79: { ! 80: ! 81: *retval = p->p_pgrp->pg_id; ! 82: return (0); ! 83: } ! 84: ! 85: /* ARGSUSED */ ! 86: getuid(p, uap, retval) ! 87: struct proc *p; ! 88: void *uap; ! 89: int *retval; ! 90: { ! 91: ! 92: *retval = p->p_cred->p_ruid; ! 93: #ifdef COMPAT_43 ! 94: retval[1] = p->p_ucred->cr_uid; ! 95: #endif ! 96: return (0); ! 97: } ! 98: ! 99: /* ARGSUSED */ ! 100: geteuid(p, uap, retval) ! 101: struct proc *p; ! 102: void *uap; ! 103: int *retval; ! 104: { ! 105: ! 106: *retval = p->p_ucred->cr_uid; ! 107: return (0); ! 108: } ! 109: ! 110: /* ARGSUSED */ ! 111: getgid(p, uap, retval) ! 112: struct proc *p; ! 113: void *uap; ! 114: int *retval; ! 115: { ! 116: ! 117: *retval = p->p_cred->p_rgid; ! 118: #ifdef COMPAT_43 ! 119: retval[1] = p->p_ucred->cr_groups[0]; ! 120: #endif ! 121: return (0); ! 122: } ! 123: ! 124: /* ! 125: * Get effective group ID. The "egid" is groups[0], and could be obtained ! 126: * via getgroups. This syscall exists because it is somewhat painful to do ! 127: * correctly in a library function. ! 128: */ ! 129: /* ARGSUSED */ ! 130: getegid(p, uap, retval) ! 131: struct proc *p; ! 132: void *uap; ! 133: int *retval; ! 134: { ! 135: ! 136: *retval = p->p_ucred->cr_groups[0]; ! 137: return (0); ! 138: } ! 139: ! 140: getgroups(p, uap, retval) ! 141: struct proc *p; ! 142: register struct arg { ! 143: u_int gidsetsize; ! 144: int *gidset; /* XXX not yet POSIX */ ! 145: } *uap; ! 146: int *retval; ! 147: { ! 148: register struct pcred *pc = p->p_cred; ! 149: register gid_t *gp; ! 150: register int *lp; ! 151: register u_int ngrp; ! 152: int groups[NGROUPS]; ! 153: int error; ! 154: ! 155: if ((ngrp = uap->gidsetsize) == 0) { ! 156: *retval = pc->pc_ucred->cr_ngroups; ! 157: return (0); ! 158: } ! 159: if (ngrp < pc->pc_ucred->cr_ngroups) ! 160: return (EINVAL); ! 161: ngrp = pc->pc_ucred->cr_ngroups; ! 162: for (gp = pc->pc_ucred->cr_groups, lp = groups; lp < &groups[ngrp]; ) ! 163: *lp++ = *gp++; ! 164: if (error = copyout((caddr_t)groups, (caddr_t)uap->gidset, ! 165: ngrp * sizeof (groups[0]))) ! 166: return (error); ! 167: *retval = ngrp; ! 168: return (0); ! 169: } ! 170: ! 171: /* ARGSUSED */ ! 172: setsid(p, uap, retval) ! 173: register struct proc *p; ! 174: void *uap; ! 175: int *retval; ! 176: { ! 177: ! 178: if (p->p_pgid == p->p_pid || pgfind(p->p_pid)) { ! 179: return (EPERM); ! 180: } else { ! 181: enterpgrp(p, p->p_pid, 1); ! 182: *retval = p->p_pid; ! 183: return (0); ! 184: } ! 185: } ! 186: ! 187: /* ! 188: * set process group (setpgid/old setpgrp) ! 189: * ! 190: * caller does setpgid(targpid, targpgid) ! 191: * ! 192: * pid must be caller or child of caller (ESRCH) ! 193: * if a child ! 194: * pid must be in same session (EPERM) ! 195: * pid can't have done an exec (EACCES) ! 196: * if pgid != pid ! 197: * there must exist some pid in same session having pgid (EPERM) ! 198: * pid must not be session leader (EPERM) ! 199: */ ! 200: /* ARGSUSED */ ! 201: setpgid(curp, uap, retval) ! 202: struct proc *curp; ! 203: register struct args { ! 204: int pid; /* target process id */ ! 205: int pgid; /* target pgrp id */ ! 206: } *uap; ! 207: int *retval; ! 208: { ! 209: register struct proc *targp; /* target process */ ! 210: register struct pgrp *pgrp; /* target pgrp */ ! 211: ! 212: if (uap->pid != 0 && uap->pid != curp->p_pid) { ! 213: if ((targp = pfind(uap->pid)) == 0 || !inferior(targp)) ! 214: return (ESRCH); ! 215: if (targp->p_session != curp->p_session) ! 216: return (EPERM); ! 217: if (targp->p_flag&SEXEC) ! 218: return (EACCES); ! 219: } else ! 220: targp = curp; ! 221: if (SESS_LEADER(targp)) ! 222: return (EPERM); ! 223: if (uap->pgid == 0) ! 224: uap->pgid = targp->p_pid; ! 225: else if (uap->pgid != targp->p_pid) ! 226: if ((pgrp = pgfind(uap->pgid)) == 0 || ! 227: pgrp->pg_session != curp->p_session) ! 228: return (EPERM); ! 229: enterpgrp(targp, uap->pgid, 0); ! 230: return (0); ! 231: } ! 232: ! 233: /* ARGSUSED */ ! 234: setuid(p, uap, retval) ! 235: struct proc *p; ! 236: struct args { ! 237: int uid; ! 238: } *uap; ! 239: int *retval; ! 240: { ! 241: register struct pcred *pc = p->p_cred; ! 242: register uid_t uid; ! 243: int error; ! 244: ! 245: uid = uap->uid; ! 246: if (uid != pc->p_ruid && ! 247: (error = suser(pc->pc_ucred, &p->p_acflag))) ! 248: return (error); ! 249: /* ! 250: * Everything's okay, do it. Copy credentials so other references do ! 251: * not see our changes. ! 252: */ ! 253: pc->pc_ucred = crcopy(pc->pc_ucred); ! 254: pc->pc_ucred->cr_uid = uid; ! 255: pc->p_ruid = uid; ! 256: pc->p_svuid = uid; ! 257: return (0); ! 258: } ! 259: ! 260: /* ARGSUSED */ ! 261: seteuid(p, uap, retval) ! 262: struct proc *p; ! 263: struct args { ! 264: int euid; ! 265: } *uap; ! 266: int *retval; ! 267: { ! 268: register struct pcred *pc = p->p_cred; ! 269: register uid_t euid; ! 270: int error; ! 271: ! 272: euid = uap->euid; ! 273: if (euid != pc->p_ruid && euid != pc->p_svuid && ! 274: (error = suser(pc->pc_ucred, &p->p_acflag))) ! 275: return (error); ! 276: /* ! 277: * Everything's okay, do it. Copy credentials so other references do ! 278: * not see our changes. ! 279: */ ! 280: pc->pc_ucred = crcopy(pc->pc_ucred); ! 281: pc->pc_ucred->cr_uid = euid; ! 282: return (0); ! 283: } ! 284: ! 285: /* ARGSUSED */ ! 286: setgid(p, uap, retval) ! 287: struct proc *p; ! 288: struct args { ! 289: int gid; ! 290: } *uap; ! 291: int *retval; ! 292: { ! 293: register struct pcred *pc = p->p_cred; ! 294: register gid_t gid; ! 295: int error; ! 296: ! 297: gid = uap->gid; ! 298: if (gid != pc->p_rgid && (error = suser(pc->pc_ucred, &p->p_acflag))) ! 299: return (error); ! 300: pc->pc_ucred = crcopy(pc->pc_ucred); ! 301: pc->pc_ucred->cr_groups[0] = gid; ! 302: pc->p_rgid = gid; ! 303: pc->p_svgid = gid; /* ??? */ ! 304: return (0); ! 305: } ! 306: ! 307: /* ARGSUSED */ ! 308: setegid(p, uap, retval) ! 309: struct proc *p; ! 310: struct args { ! 311: int egid; ! 312: } *uap; ! 313: int *retval; ! 314: { ! 315: register struct pcred *pc = p->p_cred; ! 316: register gid_t egid; ! 317: int error; ! 318: ! 319: egid = uap->egid; ! 320: if (egid != pc->p_rgid && egid != pc->p_svgid && ! 321: (error = suser(pc->pc_ucred, &p->p_acflag))) ! 322: return (error); ! 323: pc->pc_ucred = crcopy(pc->pc_ucred); ! 324: pc->pc_ucred->cr_groups[0] = egid; ! 325: return (0); ! 326: } ! 327: ! 328: #ifdef COMPAT_43 ! 329: /* ARGSUSED */ ! 330: osetreuid(p, uap, retval) ! 331: register struct proc *p; ! 332: struct args { ! 333: int ruid; ! 334: int euid; ! 335: } *uap; ! 336: int *retval; ! 337: { ! 338: register struct pcred *pc = p->p_cred; ! 339: register uid_t ruid, euid; ! 340: int error; ! 341: ! 342: if (uap->ruid == -1) ! 343: ruid = pc->p_ruid; ! 344: else ! 345: ruid = uap->ruid; ! 346: /* ! 347: * Allow setting real uid to previous effective, for swapping real and ! 348: * effective. This should be: ! 349: * ! 350: * if (ruid != pc->p_ruid && ! 351: * (error = suser(pc->pc_ucred, &p->p_acflag))) ! 352: */ ! 353: if (ruid != pc->p_ruid && ruid != pc->pc_ucred->cr_uid /* XXX */ && ! 354: (error = suser(pc->pc_ucred, &p->p_acflag))) ! 355: return (error); ! 356: if (uap->euid == -1) ! 357: euid = pc->pc_ucred->cr_uid; ! 358: else ! 359: euid = uap->euid; ! 360: if (euid != pc->pc_ucred->cr_uid && euid != pc->p_ruid && ! 361: euid != pc->p_svuid && (error = suser(pc->pc_ucred, &p->p_acflag))) ! 362: return (error); ! 363: /* ! 364: * Everything's okay, do it. Copy credentials so other references do ! 365: * not see our changes. ! 366: */ ! 367: pc->pc_ucred = crcopy(pc->pc_ucred); ! 368: pc->pc_ucred->cr_uid = euid; ! 369: pc->p_ruid = ruid; ! 370: return (0); ! 371: } ! 372: ! 373: /* ARGSUSED */ ! 374: osetregid(p, uap, retval) ! 375: register struct proc *p; ! 376: struct args { ! 377: int rgid; ! 378: int egid; ! 379: } *uap; ! 380: int *retval; ! 381: { ! 382: register struct pcred *pc = p->p_cred; ! 383: register gid_t rgid, egid; ! 384: int error; ! 385: ! 386: if (uap->rgid == -1) ! 387: rgid = pc->p_rgid; ! 388: else ! 389: rgid = uap->rgid; ! 390: /* ! 391: * Allow setting real gid to previous effective, for swapping real and ! 392: * effective. This didn't really work correctly in 4.[23], but is ! 393: * preserved so old stuff doesn't fail. This should be: ! 394: * ! 395: * if (rgid != pc->p_rgid && ! 396: * (error = suser(pc->pc_ucred, &p->p_acflag))) ! 397: */ ! 398: if (rgid != pc->p_rgid && rgid != pc->pc_ucred->cr_groups[0] /* XXX */ && ! 399: (error = suser(pc->pc_ucred, &p->p_acflag))) ! 400: return (error); ! 401: if (uap->egid == -1) ! 402: egid = pc->pc_ucred->cr_groups[0]; ! 403: else ! 404: egid = uap->egid; ! 405: if (egid != pc->pc_ucred->cr_groups[0] && egid != pc->p_rgid && ! 406: egid != pc->p_svgid && (error = suser(pc->pc_ucred, &p->p_acflag))) ! 407: return (error); ! 408: pc->pc_ucred = crcopy(pc->pc_ucred); ! 409: pc->pc_ucred->cr_groups[0] = egid; ! 410: pc->p_rgid = rgid; ! 411: return (0); ! 412: } ! 413: #endif ! 414: ! 415: /* ARGSUSED */ ! 416: setgroups(p, uap, retval) ! 417: struct proc *p; ! 418: struct args { ! 419: u_int gidsetsize; ! 420: int *gidset; ! 421: } *uap; ! 422: int *retval; ! 423: { ! 424: register struct pcred *pc = p->p_cred; ! 425: register gid_t *gp; ! 426: register u_int ngrp; ! 427: register int *lp; ! 428: int error, groups[NGROUPS]; ! 429: ! 430: if (error = suser(pc->pc_ucred, &p->p_acflag)) ! 431: return (error); ! 432: if ((ngrp = uap->gidsetsize) > NGROUPS) ! 433: return (EINVAL); ! 434: if (error = copyin((caddr_t)uap->gidset, (caddr_t)groups, ! 435: ngrp * sizeof (groups[0]))) ! 436: return (error); ! 437: pc->pc_ucred = crcopy(pc->pc_ucred); ! 438: pc->pc_ucred->cr_ngroups = ngrp; ! 439: /* convert from int's to gid_t's */ ! 440: for (gp = pc->pc_ucred->cr_groups, lp = groups; ngrp--; ) ! 441: *gp++ = *lp++; ! 442: return (0); ! 443: } ! 444: ! 445: /* ! 446: * Check if gid is a member of the group set. ! 447: */ ! 448: groupmember(gid, cred) ! 449: gid_t gid; ! 450: register struct ucred *cred; ! 451: { ! 452: register gid_t *gp; ! 453: gid_t *egp; ! 454: ! 455: egp = &(cred->cr_groups[cred->cr_ngroups]); ! 456: for (gp = cred->cr_groups; gp < egp; gp++) ! 457: if (*gp == gid) ! 458: return (1); ! 459: return (0); ! 460: } ! 461: ! 462: /* ! 463: * Test whether the specified credentials imply "super-user" ! 464: * privilege; if so, and we have accounting info, set the flag ! 465: * indicating use of super-powers. ! 466: * Returns 0 or error. ! 467: */ ! 468: suser(cred, acflag) ! 469: struct ucred *cred; ! 470: short *acflag; ! 471: { ! 472: if (cred->cr_uid == 0) { ! 473: if (acflag) ! 474: *acflag |= ASU; ! 475: return (0); ! 476: } ! 477: return (EPERM); ! 478: } ! 479: ! 480: /* ! 481: * Allocate a zeroed cred structure. ! 482: */ ! 483: struct ucred * ! 484: crget() ! 485: { ! 486: register struct ucred *cr; ! 487: ! 488: MALLOC(cr, struct ucred *, sizeof(*cr), M_CRED, M_WAITOK); ! 489: bzero((caddr_t)cr, sizeof(*cr)); ! 490: cr->cr_ref = 1; ! 491: return (cr); ! 492: } ! 493: ! 494: /* ! 495: * Free a cred structure. ! 496: * Throws away space when ref count gets to 0. ! 497: */ ! 498: crfree(cr) ! 499: struct ucred *cr; ! 500: { ! 501: int s = splimp(); /* ??? */ ! 502: ! 503: if (--cr->cr_ref != 0) { ! 504: (void) splx(s); ! 505: return; ! 506: } ! 507: FREE((caddr_t)cr, M_CRED); ! 508: (void) splx(s); ! 509: } ! 510: ! 511: /* ! 512: * Copy cred structure to a new one and free the old one. ! 513: */ ! 514: struct ucred * ! 515: crcopy(cr) ! 516: struct ucred *cr; ! 517: { ! 518: struct ucred *newcr; ! 519: ! 520: if (cr->cr_ref == 1) ! 521: return (cr); ! 522: newcr = crget(); ! 523: *newcr = *cr; ! 524: crfree(cr); ! 525: newcr->cr_ref = 1; ! 526: return (newcr); ! 527: } ! 528: ! 529: /* ! 530: * Dup cred struct to a new held one. ! 531: */ ! 532: struct ucred * ! 533: crdup(cr) ! 534: struct ucred *cr; ! 535: { ! 536: struct ucred *newcr; ! 537: ! 538: newcr = crget(); ! 539: *newcr = *cr; ! 540: newcr->cr_ref = 1; ! 541: return (newcr); ! 542: } ! 543: ! 544: /* ! 545: * Get login name, if available. ! 546: */ ! 547: /* ARGSUSED */ ! 548: getlogin(p, uap, retval) ! 549: struct proc *p; ! 550: struct args { ! 551: char *namebuf; ! 552: u_int namelen; ! 553: } *uap; ! 554: int *retval; ! 555: { ! 556: ! 557: if (uap->namelen > sizeof (p->p_pgrp->pg_session->s_login)) ! 558: uap->namelen = sizeof (p->p_pgrp->pg_session->s_login); ! 559: return (copyout((caddr_t) p->p_pgrp->pg_session->s_login, ! 560: (caddr_t) uap->namebuf, uap->namelen)); ! 561: } ! 562: ! 563: /* ! 564: * Set login name. ! 565: */ ! 566: /* ARGSUSED */ ! 567: setlogin(p, uap, retval) ! 568: struct proc *p; ! 569: struct args { ! 570: char *namebuf; ! 571: } *uap; ! 572: int *retval; ! 573: { ! 574: int error; ! 575: ! 576: if (error = suser(p->p_ucred, &p->p_acflag)) ! 577: return (error); ! 578: error = copyinstr((caddr_t) uap->namebuf, ! 579: (caddr_t) p->p_pgrp->pg_session->s_login, ! 580: sizeof (p->p_pgrp->pg_session->s_login) - 1, (u_int *)0); ! 581: if (error == ENAMETOOLONG) ! 582: error = EINVAL; ! 583: return (error); ! 584: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.