root/dev/systrace.c

DEFINITIONS

1. systrace_lock
2. systrace_unlock
3. systracef_read
4. systracef_write
5. systracef_ioctl
6. systracef_poll
7. systracef_kqfilter
8. systracef_stat
9. systracef_close
10. systraceattach
11. systraceopen
12. systraceclose
13. systraceread
14. systracewrite
15. systraceioctl
16. systracepoll
17. systrace_wakeup
18. systrace_find
19. systrace_exit
20. systrace_fork
21. systrace_redirect
22. systrace_seteuid
23. systrace_setegid
24. systrace_answer
25. systrace_setscriptname
26. systrace_inject
27. systrace_prepinject
28. systrace_policy
29. systrace_processready
30. systrace_getcwd
31. systrace_io
32. systrace_attach
33. systrace_execve0
34. systrace_execve1
35. systrace_preprepl
36. systrace_replace
37. systrace_fname
38. systrace_replacefree
39. systrace_scriptname
40. systrace_namei
41. systrace_findpid
42. systrace_detach
43. systrace_closepolicy
44. systrace_insert_process
45. systrace_newpolicy
46. systrace_msg_ask
47. systrace_msg_result
48. systrace_msg_emul
49. systrace_msg_ugid
50. systrace_make_msg
51. systrace_msg_child
52. systrace_msg_policyfree

    1 /*      $OpenBSD: systrace.c,v 1.44 2007/03/15 10:22:30 art Exp $       */
    2 /*
    3  * Copyright 2002 Niels Provos <provos@citi.umich.edu>
    4  * All rights reserved.
    5  *
    6  * Redistribution and use in source and binary forms, with or without
    7  * modification, are permitted provided that the following conditions
    8  * are met:
    9  * 1. Redistributions of source code must retain the above copyright
   10  *    notice, this list of conditions and the following disclaimer.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  * 3. All advertising materials mentioning features or use of this software
   15  *    must display the following acknowledgement:
   16  *      This product includes software developed by Niels Provos.
   17  * 4. The name of the author may not be used to endorse or promote products
   18  *    derived from this software without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   21  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   22  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   23  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   24  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   25  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   29  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   30  */
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/tree.h>
   34 #include <sys/malloc.h>
   35 #include <sys/syscall.h>
   36 #include <sys/vnode.h>
   37 #include <sys/errno.h>
   38 #include <sys/conf.h>
   39 #include <sys/device.h>
   40 #include <sys/proc.h>
   41 #include <sys/file.h>
   42 #include <sys/filedesc.h>
   43 #include <sys/filio.h>
   44 #include <sys/signalvar.h>
   45 #include <sys/rwlock.h>
   46 #include <sys/pool.h>
   47 #include <sys/mount.h>
   48 #include <sys/namei.h>
   49 #include <sys/poll.h>
   50 #include <sys/ptrace.h>
   52 #include <compat/common/compat_util.h>
   54 #include <dev/systrace.h>
   56 void    systraceattach(int);
   58 int     systraceopen(dev_t, int, int, struct proc *);
   59 int     systraceclose(dev_t, int, int, struct proc *);
   60 int     systraceread(dev_t, struct uio *, int);
   61 int     systracewrite(dev_t, struct uio *, int);
   62 int     systraceioctl(dev_t, u_long, caddr_t, int, struct proc *);
   63 int     systracepoll(dev_t, int, struct proc *);
uid_t   systrace_seteuid(struct proc *,  uid_t);
gid_t   systrace_setegid(struct proc *,  gid_t);
   67 int     systracef_read(struct file *, off_t *, struct uio *, struct ucred *);
   68 int     systracef_write(struct file *, off_t *, struct uio *, struct ucred *);
   69 int     systracef_ioctl(struct file *, u_long, caddr_t, struct proc *p);
   70 int     systracef_poll(struct file *, int, struct proc *);
   71 int     systracef_kqfilter(struct file *, struct knote *);
   72 int     systracef_stat(struct file *, struct stat *, struct proc *);
   73 int     systracef_close(struct file *, struct proc *);
   75 struct str_policy {
TAILQ_ENTRY(str_policy) next;
   78         int nr;
   80         struct emul *emul;      /* Is only valid for this emulation */
   82         int refcount;
   84         int nsysent;
u_char *sysent;
   86 };
   88 struct str_inject {
caddr_t kaddr;
caddr_t uaddr;
size_t  len;
   92 };
   94 #define STR_PROC_ONQUEUE        0x01
   95 #define STR_PROC_WAITANSWER     0x02
   96 #define STR_PROC_SYSCALLRES     0x04
   97 #define STR_PROC_REPORT         0x08    /* Report emulation */
   98 #define STR_PROC_NEEDSEQNR      0x10    /* Answer must quote seqnr */
   99 #define STR_PROC_SETEUID        0x20    /* Elevate privileges */
  100 #define STR_PROC_SETEGID        0x40
  102 struct str_process {
TAILQ_ENTRY(str_process) next;
TAILQ_ENTRY(str_process) msg_next;
  106         struct proc *proc;
pid_t pid;
  109         struct fsystrace *parent;
  110         struct str_policy *policy;
  112         struct systrace_replace *replace;
  113         char *fname[SYSTR_MAXFNAME];
size_t nfname;
  116         int flags;
  117         short answer;
  118         short error;
u_int16_t seqnr;        /* expected reply sequence number */
uid_t seteuid;
uid_t saveuid;
gid_t setegid;
gid_t savegid;
  126         int isscript;
  127         char scriptname[MAXPATHLEN];
  129         struct str_message msg;
caddr_t sg;
  132         struct str_inject injects[SYSTR_MAXINJECTS];
  133         int  injectind;
  134 };
  136 struct rwlock systrace_lck;
  138 static __inline void
systrace_lock(void)
  140 {
rw_enter_write(&systrace_lck);
  142 }
  144 static __inline void
systrace_unlock(void)
  146 {
rw_exit_write(&systrace_lck);
  148 }
  150 /* Needs to be called with fst locked */
  152 int     systrace_attach(struct fsystrace *, pid_t);
  153 int     systrace_detach(struct str_process *);
  154 int     systrace_answer(struct str_process *, struct systrace_answer *);
  155 int     systrace_setscriptname(struct str_process *,
  156             struct systrace_scriptname *);
  157 int     systrace_prepinject(struct str_process *, struct systrace_inject *);
  158 int     systrace_inject(struct str_process *, int);
  159 int     systrace_io(struct str_process *, struct systrace_io *);
  160 int     systrace_policy(struct fsystrace *, struct systrace_policy *);
  161 int     systrace_preprepl(struct str_process *, struct systrace_replace *);
  162 int     systrace_replace(struct str_process *, size_t, register_t []);
  163 int     systrace_getcwd(struct fsystrace *, struct str_process *);
  164 int     systrace_fname(struct str_process *, caddr_t, size_t);
  165 void    systrace_replacefree(struct str_process *);
  167 int     systrace_processready(struct str_process *);
  168 struct proc *systrace_find(struct str_process *);
  169 struct str_process *systrace_findpid(struct fsystrace *fst, pid_t pid);
  170 void    systrace_wakeup(struct fsystrace *);
  171 void    systrace_closepolicy(struct fsystrace *, struct str_policy *);
  172 int     systrace_insert_process(struct fsystrace *, struct proc *);
  173 struct str_policy *systrace_newpolicy(struct fsystrace *, int);
  174 int     systrace_msg_child(struct fsystrace *, struct str_process *, pid_t);
  175 int     systrace_msg_policyfree(struct fsystrace *, struct str_policy *);
  176 int     systrace_msg_ask(struct fsystrace *, struct str_process *,
  177             int, size_t, register_t []);
  178 int     systrace_msg_result(struct fsystrace *, struct str_process *,
  179             int, int, size_t, register_t [], register_t []);
  180 int     systrace_msg_emul(struct fsystrace *, struct str_process *);
  181 int     systrace_msg_ugid(struct fsystrace *, struct str_process *);
  182 int     systrace_make_msg(struct str_process *, int);
  184 static struct fileops systracefops = {
systracef_read,
systracef_write,
systracef_ioctl,
systracef_poll,
systracef_kqfilter,
systracef_stat,
systracef_close
  192 };
  194 struct pool systr_proc_pl;
  195 struct pool systr_policy_pl;
  197 int systrace_debug = 0;
  199 #define DPRINTF(y)      if (systrace_debug) printf y;
  201 /* ARGSUSED */
  202 int
systracef_read(fp, poff, uio, cred)
  204         struct file *fp;
off_t *poff;
  206         struct uio *uio;
  207         struct ucred *cred;
  208 {
  209         struct fsystrace *fst = (struct fsystrace *)fp->f_data;
  210         struct str_process *process;
  211         int error = 0;
  213         if (uio->uio_resid != sizeof(struct str_message))
  214                 return (EINVAL);
again:
systrace_lock();
rw_enter_write(&fst->lock);
systrace_unlock();
  220         if ((process = TAILQ_FIRST(&fst->messages)) != NULL) {
error = uiomove((caddr_t)&process->msg,
  222                     sizeof(struct str_message), uio);
  223                 if (!error) {
TAILQ_REMOVE(&fst->messages, process, msg_next);
CLR(process->flags, STR_PROC_ONQUEUE);
  227                         if (SYSTR_MSG_NOPROCESS(process))
pool_put(&systr_proc_pl, process);
  230                 }
  231         } else if (TAILQ_FIRST(&fst->processes) == NULL) {
  232                 /* EOF situation */
  233                 ;
  234         } else {
  235                 if (fp->f_flag & FNONBLOCK)
error = EAGAIN;
  237                 else {
rw_exit_write(&fst->lock);
error = tsleep(fst, PWAIT|PCATCH, "systrrd", 0);
  240                         if (error)
  241                                 goto out;
  242                         goto again;
  243                 }
  245         }
rw_exit_write(&fst->lock);
out:
  249         return (error);
  250 }
  252 /* ARGSUSED */
  253 int
systracef_write(fp, poff, uio, cred)
  255         struct file *fp;
off_t *poff;
  257         struct uio *uio;
  258         struct ucred *cred;
  259 {
  260         return (EIO);
  261 }
  263 #define POLICY_VALID(x) ((x) == SYSTR_POLICY_PERMIT || \
  264                          (x) == SYSTR_POLICY_ASK || \
  265                          (x) == SYSTR_POLICY_NEVER)
  267 /* ARGSUSED */
  268 int
systracef_ioctl(fp, cmd, data, p)
  270         struct file *fp;
u_long cmd;
caddr_t data;
  273         struct proc *p;
  274 {
  275         int ret = 0;
  276         struct fsystrace *fst = (struct fsystrace *)fp->f_data;
  277         struct filedesc *fdp;
  278         struct str_process *strp;
pid_t pid = 0;
  281         switch (cmd) {
  282         case FIONBIO:
  283         case FIOASYNC:
  284                 return (0);
  286         case STRIOCDETACH:
  287         case STRIOCREPORT:
pid = *(pid_t *)data;
  289                 if (!pid)
ret = EINVAL;
  291                 break;
  292         case STRIOCANSWER:
pid = ((struct systrace_answer *)data)->stra_pid;
  294                 if (!pid)
ret = EINVAL;
  296                 break;
  297         case STRIOCIO:
pid = ((struct systrace_io *)data)->strio_pid;
  299                 if (!pid)
ret = EINVAL;
  301                 break;
  302         case STRIOCSCRIPTNAME:
pid = ((struct systrace_scriptname *)data)->sn_pid;
  304                 if (!pid)
ret = EINVAL;
  306                 break;
  307         case STRIOCINJECT:
pid = ((struct systrace_inject *)data)->stri_pid;
  309                 if (!pid)
ret = EINVAL;
  311                 break;
  312         case STRIOCGETCWD:
pid = *(pid_t *)data;
  314                 if (!pid)
ret = EINVAL;
  316                 break;
  317         case STRIOCATTACH:
  318         case STRIOCRESCWD:
  319         case STRIOCPOLICY:
  320                 break;
  321         case STRIOCREPLACE:
pid = ((struct systrace_replace *)data)->strr_pid;
  323                 if (!pid)
ret = EINVAL;
  325                 break;
  326         default:
ret = EINVAL;
  328                 break;
  329         }
  331         if (ret)
  332                 return (ret);
systrace_lock();
rw_enter_write(&fst->lock);
systrace_unlock();
  337         if (pid) {
strp = systrace_findpid(fst, pid);
  339                 if (strp == NULL) {
ret = ESRCH;
  341                         goto unlock;
  342                 }
  343         }
  345         switch (cmd) {
  346         case STRIOCATTACH:
pid = *(pid_t *)data;
  348                 if (!pid)
ret = EINVAL;
  350                 else
ret = systrace_attach(fst, pid);
DPRINTF(("%s: attach to %u: %d\n", __func__, pid, ret));
  353                 break;
  354         case STRIOCDETACH:
ret = systrace_detach(strp);
  356                 break;
  357         case STRIOCREPORT:
SET(strp->flags, STR_PROC_REPORT);
  359                 break;
  360         case STRIOCANSWER:
ret = systrace_answer(strp, (struct systrace_answer *)data);
  362                 break;
  363         case STRIOCIO:
ret = systrace_io(strp, (struct systrace_io *)data);
  365                 break;
  366         case STRIOCSCRIPTNAME:
ret = systrace_setscriptname(strp,
  368                     (struct systrace_scriptname *)data);
  369                 break;
  370         case STRIOCINJECT:
ret = systrace_prepinject(strp, (struct systrace_inject *)data);
  372                 break;
  373         case STRIOCPOLICY:
ret = systrace_policy(fst, (struct systrace_policy *)data);
  375                 break;
  376         case STRIOCREPLACE:
ret = systrace_preprepl(strp, (struct systrace_replace *)data);
  378                 break;
  379         case STRIOCRESCWD:
  380                 if (!fst->fd_pid) {
ret = EINVAL;
  382                         break;
  383                 }
fdp = p->p_fd;
  386                 /* Release cwd from other process */
  387                 if (fdp->fd_cdir)
vrele(fdp->fd_cdir);
  389                 if (fdp->fd_rdir)
vrele(fdp->fd_rdir);
  391                 /* This restores the cwd we had before */
fdp->fd_cdir = fst->fd_cdir;
fdp->fd_rdir = fst->fd_rdir;
  394                 /* Note that we are normal again */
fst->fd_pid = 0;
fst->fd_cdir = fst->fd_rdir = NULL;
  397                 break;
  398         case STRIOCGETCWD:
ret = systrace_getcwd(fst, strp);
  400                 break;
  401         default:
ret = EINVAL;
  403                 break;
  404         }
unlock:
rw_exit_write(&fst->lock);
  408         return (ret);
  409 }
  411 /* ARGSUSED */
  412 int
systracef_poll(fp, events, p)
  414         struct file *fp;
  415         int events;
  416         struct proc *p;
  417 {
  418         struct fsystrace *fst = (struct fsystrace *)fp->f_data;
  419         int revents = 0;
  421         if ((events & (POLLIN | POLLRDNORM)) == 0)
  422                 return (0);
systrace_lock();
rw_enter_write(&fst->lock);
systrace_unlock();
  427         if (!TAILQ_EMPTY(&fst->messages))
revents = events & (POLLIN | POLLRDNORM);
  429         else
selrecord(p, &fst->si);
rw_exit_write(&fst->lock);
  433         return (revents);
  434 }
  436 /* ARGSUSED */
  437 int
systracef_kqfilter(fp, kn)
  439         struct file *fp;
  440         struct knote *kn;
  441 {
  442         return (1);
  443 }
  445 /* ARGSUSED */
  446 int
systracef_stat(fp, sb, p)
  448         struct file *fp;
  449         struct stat *sb;
  450         struct proc *p;
  451 {
  452         return (EOPNOTSUPP);
  453 }
  455 /* ARGSUSED */
  456 int
systracef_close(fp, p)
  458         struct file *fp;
  459         struct proc *p;
  460 {
  461         struct fsystrace *fst = (struct fsystrace *)fp->f_data;
  462         struct str_process *strp;
  463         struct str_policy *strpol;
systrace_lock();
rw_enter_write(&fst->lock);
systrace_unlock();
  469         /* Untrace all processes */
  470         for (strp = TAILQ_FIRST(&fst->processes); strp;
strp = TAILQ_FIRST(&fst->processes)) {
  472                 struct proc *q = strp->proc;
systrace_detach(strp);
psignal(q, SIGKILL);
  476         }
  478         /* Clean up fork and exit messages */
  479         for (strp = TAILQ_FIRST(&fst->messages); strp;
strp = TAILQ_FIRST(&fst->messages)) {
TAILQ_REMOVE(&fst->messages, strp, msg_next);
pool_put(&systr_proc_pl, strp);
  483         }
  485         /* Clean up all policies */
  486         for (strpol = TAILQ_FIRST(&fst->policies); strpol;
strpol = TAILQ_FIRST(&fst->policies))
systrace_closepolicy(fst, strpol);
  490         /* Release vnodes */
  491         if (fst->fd_cdir)
vrele(fst->fd_cdir);
  493         if (fst->fd_rdir)
vrele(fst->fd_rdir);
rw_exit_write(&fst->lock);
FREE(fp->f_data, M_XDATA);
fp->f_data = NULL;
  500         return (0);
  501 }
  503 void
systraceattach(int n)
  505 {
pool_init(&systr_proc_pl, sizeof(struct str_process), 0, 0, 0,
  507             "strprocpl", NULL);
pool_init(&systr_policy_pl, sizeof(struct str_policy), 0, 0, 0,
  509             "strpolpl", NULL);
rw_init(&systrace_lck, "systrace");
  511 }
  513 int
systraceopen(dev, flag, mode, p)
dev_t   dev;
  516         int     flag;
  517         int     mode;
  518         struct proc *p;
  519 {
  520         return (0);
  521 }
  523 int
systraceclose(dev, flag, mode, p)
dev_t   dev;
  526         int     flag;
  527         int     mode;
  528         struct proc *p;
  529 {
  530         return (0);
  531 }
  533 int
systraceread(dev, uio, ioflag)
dev_t   dev;
  536         struct uio *uio;
  537         int     ioflag;
  538 {
  539         return (EIO);
  540 }
  542 int
systracewrite(dev, uio, ioflag)
dev_t   dev;
  545         struct uio *uio;
  546         int     ioflag;
  547 {
  548         return (EIO);
  549 }
  551 int
systraceioctl(dev, cmd, data, flag, p)
dev_t   dev;
u_long  cmd;
caddr_t data;
  556         int     flag;
  557         struct proc *p;
  558 {
  559         struct file *f;
  560         struct fsystrace *fst = NULL;
  561         int fd, error;
  563         switch (cmd) {
  564         case STRIOCCLONE:
MALLOC(fst, struct fsystrace *, sizeof(struct fsystrace),
M_XDATA, M_WAITOK);
memset(fst, 0, sizeof(struct fsystrace));
rw_init(&fst->lock, "systrace");
TAILQ_INIT(&fst->processes);
TAILQ_INIT(&fst->messages);
TAILQ_INIT(&fst->policies);
  574                 if (suser(p, 0) == 0)
fst->issuser = 1;
fst->p_ruid = p->p_cred->p_ruid;
fst->p_rgid = p->p_cred->p_rgid;
error = falloc(p, &f, &fd);
  580                 if (error) {
FREE(fst, M_XDATA);
  582                         return (error);
  583                 }
f->f_flag = FREAD | FWRITE;
f->f_type = DTYPE_SYSTRACE;
f->f_ops = &systracefops;
f->f_data = (caddr_t) fst;
  588                 *(int *)data = fd;
FILE_SET_MATURE(f);
  590                 break;
  591         default:
error = EINVAL;
  593                 break;
  594         }
  595         return (error);
  596 }
  598 int
systracepoll(dev, events, p)
dev_t   dev;
  601         int     events;
  602         struct proc *p;
  603 {
  604         return (seltrue(dev, events, p));
  605 }
  607 void
systrace_wakeup(struct fsystrace *fst)
  609 {
wakeup((caddr_t)fst);
selwakeup(&fst->si);
  612 }
  614 struct proc *
systrace_find(struct str_process *strp)
  616 {
  617         struct proc *proc;
  619         if ((proc = pfind(strp->pid)) == NULL)
  620                 return (NULL);
  622         if (proc != strp->proc)
  623                 return (NULL);
  625         if (!ISSET(proc->p_flag, P_SYSTRACE))
  626                 return (NULL);
  628         return (proc);
  629 }
  631 void
systrace_exit(struct proc *proc)
  633 {
  634         struct str_process *strp;
  635         struct fsystrace *fst;
systrace_lock();
strp = proc->p_systrace;
  639         if (strp != NULL) {
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
  644                 /* Insert Exit message */
systrace_msg_child(fst, strp, -1);
systrace_detach(strp);
rw_exit_write(&fst->lock);
  649         } else
systrace_unlock();
atomic_clearbits_int(&proc->p_flag, P_SYSTRACE);
  652 }
  654 void
systrace_fork(struct proc *oldproc, struct proc *p)
  656 {
  657         struct str_process *oldstrp, *strp;
  658         struct fsystrace *fst;
systrace_lock();
oldstrp = oldproc->p_systrace;
  662         if (oldstrp == NULL) {
systrace_unlock();
  664                 return;
  665         }
fst = oldstrp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
  671         if (systrace_insert_process(fst, p))
  672                 goto out;
  673         if ((strp = systrace_findpid(fst, p->p_pid)) == NULL)
panic("systrace_fork");
  676         /* Reference policy */
  677         if ((strp->policy = oldstrp->policy) != NULL)
strp->policy->refcount++;
  680         /* Insert fork message */
systrace_msg_child(fst, oldstrp, p->p_pid);
out:
rw_exit_write(&fst->lock);
  684 }
  686 #define REACQUIRE_LOCK  do { \
systrace_lock(); \
strp = p->p_systrace; \
  689         if (strp == NULL) { \
systrace_unlock(); \
  691                 return (error); \
  692         } \
fst = strp->parent; \
rw_enter_write(&fst->lock); \
systrace_unlock(); \
  696 } while (0)
  698 int
systrace_redirect(int code, struct proc *p, void *v, register_t *retval)
  700 {
  701         struct sysent *callp;
  702         struct str_process *strp;
  703         struct str_policy *strpolicy;
  704         struct fsystrace *fst = NULL;
  705         struct emul *oldemul;
  706         struct pcred *pc;
uid_t olduid;
gid_t oldgid;
  709         int policy, error = 0, report = 0, maycontrol = 0, issuser = 0;
systrace_lock();
strp = p->p_systrace;
  713         if (strp == NULL) {
systrace_unlock();
  715                 return (EINVAL);
  716         }
  718         if (code < 0 || code >= p->p_emul->e_nsysent) {
systrace_unlock();
  720                 return (EINVAL);
  721         }
KASSERT(strp->proc == p);
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
  730         /*
  731          * We can not monitor a SUID process unless we are root,
  732          * but we wait until it executes something unprivileged.
  733          * A non-root user may only monitor if the real uid and
  734          * real gid match the monitored process.  Changing the
  735          * uid or gid causes P_SUGID to be set.
  736          */
  737         if (fst->issuser) {
maycontrol = 1;
issuser = 1;
  740         } else if (!ISSET(p->p_flag, P_SUGID) &&
  741             !ISSET(p->p_flag, P_SUGIDEXEC)) {
maycontrol = fst->p_ruid == p->p_cred->p_ruid &&
fst->p_rgid == p->p_cred->p_rgid;
  744         }
  746         if (!maycontrol) {
policy = SYSTR_POLICY_PERMIT;
  748         } else {
  749                 /* Find out current policy */
  750                 if ((strpolicy = strp->policy) == NULL)
policy = SYSTR_POLICY_ASK;
  752                 else {
  753                         if (code >= strpolicy->nsysent)
policy = SYSTR_POLICY_NEVER;
  755                         else
policy = strpolicy->sysent[code];
  757                 }
  758         }
callp = p->p_emul->e_sysent + code;
  762         /* Fast-path */
  763         if (policy != SYSTR_POLICY_ASK) {
  764                 if (policy != SYSTR_POLICY_PERMIT) {
  765                         if (policy > 0)
error = policy;
  767                         else
error = EPERM;
  769                 }
systrace_replacefree(strp);
rw_exit_write(&fst->lock);
  772                 if (policy == SYSTR_POLICY_PERMIT)
error = (*callp->sy_call)(p, v, retval);
  774                 return (error);
  775         }
  777         /*
  778          * Reset our stackgap allocation.  Note that when resetting
  779          * the stackgap allocation, we expect to get the same address
  780          * base; i.e. that stackgap_init() is idempotent.
  781          */
systrace_inject(strp, 0 /* Just reset internal state */);
strp->sg = stackgap_init(p->p_emul);
  785         /* Puts the current process to sleep, return unlocked */
error = systrace_msg_ask(fst, strp, code, callp->sy_argsize, v);
  787         /* lock has been released in systrace_msg_ask() */
  789         if (error)
  790                 return (error);
  792         /* We might have detached by now for some reason */
systrace_lock();
  794         if ((strp = p->p_systrace) == NULL) {
systrace_unlock();
  796                 return (error);
  797         }
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
  803         if (strp->answer == SYSTR_POLICY_NEVER) {
error = strp->error;
systrace_replacefree(strp);
  806                 goto out_unlock;
  807         }
  809         if (ISSET(strp->flags, STR_PROC_SYSCALLRES)) {
CLR(strp->flags, STR_PROC_SYSCALLRES);
report = 1;
  812         }
error = systrace_inject(strp, 1/* Perform copies */);
  815         /* Replace the arguments if necessary */
  816         if (!error && strp->replace != NULL)
error = systrace_replace(strp, callp->sy_argsize, v);
  818         if (error)
  819                 goto out_unlock;
oldemul = p->p_emul;
pc = p->p_cred;
olduid = pc->p_ruid;
oldgid = pc->p_rgid;
  826         /* Elevate privileges as desired */
  827         if (issuser) {
  828                 if (ISSET(strp->flags, STR_PROC_SETEUID))
strp->saveuid = systrace_seteuid(p, strp->seteuid);
  830                 if (ISSET(strp->flags, STR_PROC_SETEGID))
strp->savegid = systrace_setegid(p, strp->setegid);
  832         } else
CLR(strp->flags, STR_PROC_SETEUID|STR_PROC_SETEGID);
rw_exit_write(&fst->lock);
error = (*callp->sy_call)(p, v, retval);
  839         /* Return to old privileges */
systrace_lock();
  841         if ((strp = p->p_systrace) == NULL) {
systrace_unlock();
  843                 return (error);
  844         }
  846         if (issuser) {
  847                 if (ISSET(strp->flags, STR_PROC_SETEUID)) {
  848                         if (pc->pc_ucred->cr_uid == strp->seteuid)
systrace_seteuid(p, strp->saveuid);
CLR(strp->flags, STR_PROC_SETEUID);
  851                 }
  852                 if (ISSET(strp->flags, STR_PROC_SETEGID)) {
  853                         if (pc->pc_ucred->cr_gid == strp->setegid)
systrace_setegid(p, strp->savegid);
CLR(strp->flags, STR_PROC_SETEGID);
  856                 }
  857         }
systrace_replacefree(strp);
  861         if (ISSET(p->p_flag, P_SUGID) || ISSET(p->p_flag, P_SUGIDEXEC)) {
  862                 if ((fst = strp->parent) == NULL || !fst->issuser) {
systrace_unlock();
  864                         return (error);
  865                 }
  866         }
  868         /* Report change in emulation */
  870         /* See if we should force a report */
  871         if (ISSET(strp->flags, STR_PROC_REPORT)) {
CLR(strp->flags, STR_PROC_REPORT);
oldemul = NULL;
  874         }
  876         /* Acquire lock */
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
  881         if (p->p_emul != oldemul) {
  882                 /* Old policy is without meaning now */
  883                 if (strp->policy) {
systrace_closepolicy(fst, strp->policy);
strp->policy = NULL;
  886                 }
systrace_msg_emul(fst, strp);
REACQUIRE_LOCK;
  890         }
  892         /* Report if effective uid or gid changed */
  893         if (olduid != p->p_cred->p_ruid ||
oldgid != p->p_cred->p_rgid) {
systrace_msg_ugid(fst, strp);
REACQUIRE_LOCK;
  898         }
  900         /* Report result from system call */
  901         if (report) {
systrace_msg_result(fst, strp, error, code,
callp->sy_argsize, v, retval);
  905                 /* not locked */
  906                 goto out;
  907         }
out_unlock:
rw_exit_write(&fst->lock);
out:
  912         return (error);
  913 }
uid_t
systrace_seteuid(struct proc *p,  uid_t euid)
  917 {
  918         struct pcred *pc = p->p_cred;
uid_t oeuid = pc->pc_ucred->cr_uid;
  921         if (pc->pc_ucred->cr_uid == euid)
  922                 return (oeuid);
  924         /*
  925          * Copy credentials so other references do not see our changes.
  926          */
pc->pc_ucred = crcopy(pc->pc_ucred);
pc->pc_ucred->cr_uid = euid;
atomic_setbits_int(&p->p_flag, P_SUGID);
  931         return (oeuid);
  932 }
gid_t
systrace_setegid(struct proc *p,  gid_t egid)
  936 {
  937         struct pcred *pc = p->p_cred;
gid_t oegid = pc->pc_ucred->cr_gid;
  940         if (pc->pc_ucred->cr_gid == egid)
  941                 return (oegid);
  943         /*
  944          * Copy credentials so other references do not see our changes.
  945          */
pc->pc_ucred = crcopy(pc->pc_ucred);
pc->pc_ucred->cr_gid = egid;
atomic_setbits_int(&p->p_flag, P_SUGID);
  950         return (oegid);
  951 }
  953 /* Called with fst locked */
  955 int
systrace_answer(struct str_process *strp, struct systrace_answer *ans)
  957 {
  958         int error = 0;
DPRINTF(("%s: %u: policy %d\n", __func__,
ans->stra_pid, ans->stra_policy));
  963         if (!POLICY_VALID(ans->stra_policy)) {
error = EINVAL;
  965                 goto out;
  966         }
  968         /* Check if answer is in sync with us */
  969         if (ans->stra_seqnr != strp->seqnr) {
error = ESRCH;
  971                 goto out;
  972         }
  974         if ((error = systrace_processready(strp)) != 0)
  975                 goto out;
strp->answer = ans->stra_policy;
strp->error = ans->stra_error;
  979         if (!strp->error)
strp->error = EPERM;
  981         if (ISSET(ans->stra_flags, SYSTR_FLAGS_RESULT))
SET(strp->flags, STR_PROC_SYSCALLRES);
  984         /* See if we should elevate privileges for this system call */
  985         if (ISSET(ans->stra_flags, SYSTR_FLAGS_SETEUID)) {
SET(strp->flags, STR_PROC_SETEUID);
strp->seteuid = ans->stra_seteuid;
  988         }
  989         if (ISSET(ans->stra_flags, SYSTR_FLAGS_SETEGID)) {
SET(strp->flags, STR_PROC_SETEGID);
strp->setegid = ans->stra_setegid;
  992         }
  994         /* Clearing the flag indicates to the process that it woke up */
CLR(strp->flags, STR_PROC_WAITANSWER);
wakeup(strp);
out:
  999         return (error);
 1000 }
 1002 int
systrace_setscriptname(struct str_process *strp, struct systrace_scriptname *ans)
 1004 {
strlcpy(strp->scriptname,
ans->sn_scriptname, sizeof(strp->scriptname));
 1008         return (0);
 1009 }
 1011 int
systrace_inject(struct str_process *strp, int docopy)
 1013 {
 1014         int ind, ret = 0;
 1016         for (ind = 0; ind < strp->injectind; ind++) {
 1017                 struct str_inject *inject = &strp->injects[ind];
 1018                 if (!ret && docopy &&
copyout(inject->kaddr, inject->uaddr, inject->len))
ret = EINVAL;
free(inject->kaddr, M_XDATA);
 1022         }
strp->injectind = 0;
 1025         return (ret);
 1026 }
 1028 int
systrace_prepinject(struct str_process *strp, struct systrace_inject *inj)
 1030 {
caddr_t udata, kaddr = NULL;
 1032         int ret = 0;
 1033         struct str_inject *inject;
 1035         if (strp->injectind >= SYSTR_MAXINJECTS)
 1036                 return (ENOBUFS);
udata = stackgap_alloc(&strp->sg, inj->stri_len);
 1039         if (udata == NULL)
 1040                 return (ENOMEM);
 1042         /*
 1043          * We have infact forced a maximum length on stri_len because
 1044          * of the stackgap.
 1045          */
kaddr = malloc(inj->stri_len, M_XDATA, M_WAITOK);
ret = copyin(inj->stri_addr, kaddr, inj->stri_len);
 1049         if (ret) {
free(kaddr, M_XDATA);
 1051                 return (ret);
 1052         }
inject = &strp->injects[strp->injectind++];
inject->kaddr = kaddr;
inject->uaddr = inj->stri_addr = udata;
inject->len = inj->stri_len;
 1059         return (0);
 1060 }
 1062 int
systrace_policy(struct fsystrace *fst, struct systrace_policy *pol)
 1064 {
 1065         struct str_policy *strpol;
 1066         struct str_process *strp;
 1068         switch(pol->strp_op) {
 1069         case SYSTR_POLICY_NEW:
DPRINTF(("%s: new, ents %d\n", __func__,
pol->strp_maxents));
 1072                 if (pol->strp_maxents <= 0 || pol->strp_maxents > 1024)
 1073                         return (EINVAL);
strpol = systrace_newpolicy(fst, pol->strp_maxents);
 1075                 if (strpol == NULL)
 1076                         return (ENOBUFS);
pol->strp_num = strpol->nr;
 1078                 break;
 1079         case SYSTR_POLICY_ASSIGN:
DPRINTF(("%s: %d -> pid %d\n", __func__,
pol->strp_num, pol->strp_pid));
 1083                 /* Find right policy by number */
TAILQ_FOREACH(strpol, &fst->policies, next)
 1085                     if (strpol->nr == pol->strp_num)
 1086                             break;
 1087                 if (strpol == NULL)
 1088                         return (EINVAL);
strp = systrace_findpid(fst, pol->strp_pid);
 1091                 if (strp == NULL)
 1092                         return (EINVAL);
 1094                 /* Check that emulation matches */
 1095                 if (strpol->emul && strpol->emul != strp->proc->p_emul)
 1096                         return (EINVAL);
 1098                 if (strp->policy)
systrace_closepolicy(fst, strp->policy);
strp->policy = strpol;
 1102                 /* LRU for policy use */
TAILQ_REMOVE(&fst->policies, strpol, next);
TAILQ_INSERT_TAIL(&fst->policies, strpol, next);
strpol->refcount++;
 1107                 /* Record emulation for this policy */
 1108                 if (strpol->emul == NULL)
strpol->emul = strp->proc->p_emul;
 1111                 break;
 1112         case SYSTR_POLICY_MODIFY:
DPRINTF(("%s: %d: code %d -> policy %d\n", __func__,
pol->strp_num, pol->strp_code, pol->strp_policy));
 1115                 if (!POLICY_VALID(pol->strp_policy))
 1116                         return (EINVAL);
TAILQ_FOREACH(strpol, &fst->policies, next)
 1118                     if (strpol->nr == pol->strp_num)
 1119                             break;
 1120                 if (strpol == NULL)
 1121                         return (EINVAL);
 1122                 if (pol->strp_code < 0 || pol->strp_code >= strpol->nsysent)
 1123                         return (EINVAL);
strpol->sysent[pol->strp_code] = pol->strp_policy;
 1125                 break;
 1126         default:
 1127                 return (EINVAL);
 1128         }
 1130         return (0);
 1131 }
 1133 int
systrace_processready(struct str_process *strp)
 1135 {
 1136         if (ISSET(strp->flags, STR_PROC_ONQUEUE))
 1137                 return (EBUSY);
 1139         if (!ISSET(strp->flags, STR_PROC_WAITANSWER))
 1140                 return (EBUSY);
 1142         if (strp->proc->p_stat != SSLEEP)
 1143                 return (EBUSY);
 1145         return (0);
 1146 }
 1148 int
systrace_getcwd(struct fsystrace *fst, struct str_process *strp)
 1150 {
 1151         struct filedesc *myfdp, *fdp;
 1152         int error;
DPRINTF(("%s: %d\n", __func__, strp->pid));
error = systrace_processready(strp);
 1157         if (error)
 1158                 return (error);
myfdp = curproc->p_fd;
fdp = strp->proc->p_fd;
 1162         if (myfdp == NULL || fdp == NULL)
 1163                 return (EINVAL);
 1165         /* Store our current values */
fst->fd_pid = strp->pid;
fst->fd_cdir = myfdp->fd_cdir;
fst->fd_rdir = myfdp->fd_rdir;
 1170         if ((myfdp->fd_cdir = fdp->fd_cdir) != NULL)
VREF(myfdp->fd_cdir);
 1172         if ((myfdp->fd_rdir = fdp->fd_rdir) != NULL)
VREF(myfdp->fd_rdir);
 1175         return (0);
 1176 }
 1178 int
systrace_io(struct str_process *strp, struct systrace_io *io)
 1180 {
 1181         struct proc *p = curproc, *t = strp->proc;
 1182         struct uio uio;
 1183         struct iovec iov;
 1184         int error = 0;
DPRINTF(("%s: %u: %p(%lu)\n", __func__,
io->strio_pid, io->strio_offs, (u_long)io->strio_len));
 1189         switch (io->strio_op) {
 1190         case SYSTR_READ:
uio.uio_rw = UIO_READ;
 1192                 break;
 1193         case SYSTR_WRITE:
uio.uio_rw = UIO_WRITE;
 1195                 break;
 1196         default:
 1197                 return (EINVAL);
 1198         }
error = systrace_processready(strp);
 1201         if (error)
 1202                 goto out;
iov.iov_base = io->strio_addr;
iov.iov_len = io->strio_len;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_offset = (off_t)(u_long)io->strio_offs;
uio.uio_resid = io->strio_len;
uio.uio_segflg = UIO_USERSPACE;
uio.uio_procp = p;
error = process_domem(p, t, &uio, PT_WRITE_I);
io->strio_len -= uio.uio_resid;
out:
 1217         return (error);
 1218 }
 1220 int
systrace_attach(struct fsystrace *fst, pid_t pid)
 1222 {
 1223         int error = 0;
 1224         struct proc *proc, *p = curproc;
 1226         if ((proc = pfind(pid)) == NULL) {
error = ESRCH;
 1228                 goto out;
 1229         }
 1231         if (ISSET(proc->p_flag, P_INEXEC)) {
error = EAGAIN;
 1233                 goto out;
 1234         }
 1236         /*
 1237          * You can't attach to a process if:
 1238          *      (1) it's the process that's doing the attaching,
 1239          */
 1240         if (proc->p_pid == p->p_pid) {
error = EINVAL;
 1242                 goto out;
 1243         }
 1245         /*
 1246          *      (2) it's a system process
 1247          */
 1248         if (ISSET(proc->p_flag, P_SYSTEM)) {
error = EPERM;
 1250                 goto out;
 1251         }
 1253         /*
 1254          *      (3) it's being traced already
 1255          */
 1256         if (ISSET(proc->p_flag, P_SYSTRACE)) {
error = EBUSY;
 1258                 goto out;
 1259         }
 1261         /*
 1262          *      (4) it's not owned by you, or the last exec
 1263          *          gave us setuid/setgid privs (unless
 1264          *          you're root), or...
 1265          *
 1266          *      [Note: once P_SUGID or P_SUGIDEXEC gets set in execve(),
 1267          *      it stays set until the process does another execve(). Hence
 1268          *      this prevents a setuid process which revokes its
 1269          *      special privileges using setuid() from being
 1270          *      traced. This is good security.]
 1271          */
 1272         if ((proc->p_cred->p_ruid != p->p_cred->p_ruid ||
ISSET(proc->p_flag, P_SUGID) ||
ISSET(proc->p_flag, P_SUGIDEXEC)) &&
 1275             (error = suser(p, 0)) != 0)
 1276                 goto out;
 1278         /*
 1279          *      (5) ...it's init, which controls the security level
 1280          *          of the entire system, and the system was not
 1281          *          compiled with permanently insecure mode turned
 1282          *          on.
 1283          */
 1284         if ((proc->p_pid == 1) && (securelevel > -1)) {
error = EPERM;
 1286                 goto out;
 1287         }
error = systrace_insert_process(fst, proc);
out:
 1292         return (error);
 1293 }
 1295 void
systrace_execve0(struct proc *p)
 1297 {  
 1298         struct str_process *strp;
systrace_lock();
strp = p->p_systrace;
strp->isscript = 0;
systrace_unlock();
 1304 }
 1306 void
systrace_execve1(char *path, struct proc *p)
 1308 {
 1309         struct str_process *strp;
 1310         struct fsystrace *fst;
 1311         struct str_msg_execve *msg_execve;
 1313         do { 
systrace_lock();
strp = p->p_systrace;
 1316                 if (strp == NULL) {
systrace_unlock();
 1318                         return;
 1319                 }
msg_execve = &strp->msg.msg_data.msg_execve;
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
 1326                 /*
 1327                  * susers will get the execve call anyway.  Also, if
 1328                  * we're not allowed to control the process, escape.
 1329                  */
 1331                 if (fst->issuser ||
fst->p_ruid != p->p_cred->p_ruid ||
fst->p_rgid != p->p_cred->p_rgid) {
rw_exit_write(&fst->lock);
 1335                         return;
 1336                 }
strlcpy(msg_execve->path, path, MAXPATHLEN);
 1338         } while (systrace_make_msg(strp, SYSTR_MSG_EXECVE) != 0);
 1339 }
 1341 /* Prepare to replace arguments */
 1343 int
systrace_preprepl(struct str_process *strp, struct systrace_replace *repl)
 1345 {
size_t len;
 1347         int i, ret = 0;
ret = systrace_processready(strp);
 1350         if (ret)
 1351                 return (ret);
 1353         if (strp->replace != NULL) {
free(strp->replace, M_XDATA);
strp->replace = NULL;
 1356         }
 1358         if (repl->strr_nrepl < 0 || repl->strr_nrepl > SYSTR_MAXARGS)
 1359                 return (EINVAL);
 1361         for (i = 0, len = 0; i < repl->strr_nrepl; i++) {
 1362                 if (repl->strr_argind[i] < 0 ||
repl->strr_argind[i] >= SYSTR_MAXARGS)
 1364                         return (EINVAL);
 1365                 if (repl->strr_offlen[i] == 0)
 1366                         continue;
len += repl->strr_offlen[i];
 1368                 if (repl->strr_offlen[i] > SYSTR_MAXREPLEN ||
repl->strr_off[i] > SYSTR_MAXREPLEN ||
len > SYSTR_MAXREPLEN)
 1371                         return (EINVAL);
 1372                 if (repl->strr_offlen[i] + repl->strr_off[i] > len)
 1373                         return (EINVAL);
 1374         }
 1376         /* Make sure that the length adds up */
 1377         if (repl->strr_len != len)
 1378                 return (EINVAL);
 1380         /* Check against a maximum length */
 1381         if (repl->strr_len > SYSTR_MAXREPLEN)
 1382                 return (EINVAL);
strp->replace = (struct systrace_replace *)
malloc(sizeof(struct systrace_replace) + len, M_XDATA, M_WAITOK);
memcpy(strp->replace, repl, sizeof(struct systrace_replace));
ret = copyin(repl->strr_base, strp->replace + 1, len);
 1389         if (ret) {
free(strp->replace, M_XDATA);
strp->replace = NULL;
 1392                 return (ret);
 1393         }
 1395         /* Adjust the offset */
repl = strp->replace;
repl->strr_base = (caddr_t)(repl + 1);
 1399         return (0);
 1400 }
 1402 /*
 1403  * Replace the arguments with arguments from the monitoring process.
 1404  */
 1406 int
systrace_replace(struct str_process *strp, size_t argsize, register_t args[])
 1408 {
 1409         struct systrace_replace *repl = strp->replace;
caddr_t kdata, kbase;
caddr_t udata, ubase;
 1412         int i, maxarg, ind, ret = 0;
maxarg = argsize/sizeof(register_t);
ubase = stackgap_alloc(&strp->sg, repl->strr_len);
 1416         if (ubase == NULL) {
ret = EINVAL;
 1418                 goto out;
 1419         }
kbase = repl->strr_base;
 1422         for (i = 0; i < maxarg && i < repl->strr_nrepl; i++) {
ind = repl->strr_argind[i];
 1424                 if (ind < 0 || ind >= maxarg) {
ret = EINVAL;
 1426                         goto out;
 1427                 }
 1428                 if (repl->strr_offlen[i] == 0) {
args[ind] = repl->strr_off[i];
 1430                         continue;
 1431                 }
kdata = kbase + repl->strr_off[i];
 1433                 if (repl->strr_flags[i] & SYSTR_NOLINKS) {
ret = systrace_fname(strp, kdata, repl->strr_offlen[i]);
 1435                         if (ret != 0)
 1436                                 goto out;
 1437                 }
udata = ubase + repl->strr_off[i];
 1439                 if (copyout(kdata, udata, repl->strr_offlen[i])) {
ret = EINVAL;
 1441                         goto out;
 1442                 }
 1444                 /* Replace the argument with the new address */
args[ind] = (register_t)udata;
 1446         }
out:
 1449         return (ret);
 1450 }
 1452 int
systrace_fname(struct str_process *strp, caddr_t kdata, size_t len)
 1454 {
 1455         if (strp->nfname >= SYSTR_MAXFNAME || len < 1)
 1456                 return EINVAL;
strp->fname[strp->nfname] = kdata;
strp->fname[strp->nfname][len - 1] = '\0';
strp->nfname++;
 1462         return 0;
 1463 }
 1465 void
systrace_replacefree(struct str_process *strp)
 1467 {
 1468         if (strp->replace != NULL) {
free(strp->replace, M_XDATA);
strp->replace = NULL;
 1471         }
 1472         while (strp->nfname > 0) {
strp->nfname--;
strp->fname[strp->nfname] = NULL;
 1475         }
 1476 }
 1477 int
systrace_scriptname(struct proc *p, char *dst)
 1479 {
 1480         struct str_process *strp;
 1481         struct fsystrace *fst;
 1482         int error = 0;
systrace_lock();  
strp = p->p_systrace;
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
 1491         if (!fst->issuser && (ISSET(p->p_flag, P_SUGID) ||
ISSET(p->p_flag, P_SUGIDEXEC) ||
fst->p_ruid != p->p_cred->p_ruid ||
fst->p_rgid != p->p_cred->p_rgid)) {
error = EPERM;
 1496                 goto out;
 1497         }
 1499         if (strp != NULL) {
 1500                 if (strp->scriptname[0] == '\0') {
error = ENOENT;
 1502                         goto out;
 1503                 }
strlcpy(dst, strp->scriptname, MAXPATHLEN);
strp->isscript = 1;
 1507         }
out:
strp->scriptname[0] = '\0';
rw_exit_write(&fst->lock);
 1513         return (error);
 1514 }
 1516 void
systrace_namei(struct nameidata *ndp)
 1518 {
 1519         struct str_process *strp;
 1520         struct fsystrace *fst;
 1521         struct componentname *cnp = &ndp->ni_cnd;
size_t i;
 1523         int hamper = 0;
systrace_lock();
strp = cnp->cn_proc->p_systrace;
 1527         if (strp != NULL) {
fst = strp->parent;
rw_enter_write(&fst->lock);
systrace_unlock();
 1532                 for (i = 0; i < strp->nfname; i++)
 1533                         if (strcmp(cnp->cn_pnbuf, strp->fname[i]) == 0) {
hamper = 1;
 1535                                 break;
 1536                         }
 1538                 if (!hamper && strp->isscript &&
strcmp(cnp->cn_pnbuf, strp->scriptname) == 0)
hamper = 1;
rw_exit_write(&fst->lock);
 1543         } else
systrace_unlock();
 1546         if (hamper) {
 1547                 /* ELOOP if namei() tries to readlink */
ndp->ni_loopcnt = MAXSYMLINKS;
cnp->cn_flags &= ~FOLLOW;
cnp->cn_flags |= NOFOLLOW;
 1551         }
 1552 }
 1554 struct str_process *
systrace_findpid(struct fsystrace *fst, pid_t pid)
 1556 {
 1557         struct str_process *strp;
 1558         struct proc *proc = NULL;
TAILQ_FOREACH(strp, &fst->processes, next)
 1561             if (strp->pid == pid)
 1562                     break;
 1564         if (strp == NULL)
 1565                 return (NULL);
proc = systrace_find(strp);
 1569         return (proc ? strp : NULL);
 1570 }
 1572 int
systrace_detach(struct str_process *strp)
 1574 {
 1575         struct proc *proc;
 1576         struct fsystrace *fst = NULL;
 1577         int error = 0;
DPRINTF(("%s: Trying to detach from %d\n", __func__, strp->pid));
 1581         if ((proc = systrace_find(strp)) != NULL) {
atomic_clearbits_int(&proc->p_flag, P_SYSTRACE);
proc->p_systrace = NULL;
 1584         } else
error = ESRCH;
 1587         if (ISSET(strp->flags, STR_PROC_WAITANSWER)) {
CLR(strp->flags, STR_PROC_WAITANSWER);
wakeup(strp);
 1590         }
fst = strp->parent;
systrace_wakeup(fst);
 1595         if (ISSET(strp->flags, STR_PROC_ONQUEUE))
TAILQ_REMOVE(&fst->messages, strp, msg_next);
TAILQ_REMOVE(&fst->processes, strp, next);
fst->nprocesses--;
 1601         if (strp->policy)
systrace_closepolicy(fst, strp->policy);
systrace_replacefree(strp);
pool_put(&systr_proc_pl, strp);
 1606         return (error);
 1607 }
 1609 void
systrace_closepolicy(struct fsystrace *fst, struct str_policy *policy)
 1611 {
 1612         if (--policy->refcount)
 1613                 return;
fst->npolicies--;
 1617         if (policy->nsysent)
free(policy->sysent, M_XDATA);
TAILQ_REMOVE(&fst->policies, policy, next);
pool_put(&systr_policy_pl, policy);
 1623 }
 1626 int
systrace_insert_process(struct fsystrace *fst, struct proc *proc)
 1628 {
 1629         struct str_process *strp;
strp = pool_get(&systr_proc_pl, PR_NOWAIT);
 1632         if (strp == NULL)
 1633                 return (ENOBUFS);
memset((caddr_t)strp, 0, sizeof(struct str_process));
strp->pid = proc->p_pid;
strp->proc = proc;
strp->parent = fst;
TAILQ_INSERT_TAIL(&fst->processes, strp, next);
fst->nprocesses++;
proc->p_systrace = strp;
atomic_setbits_int(&proc->p_flag, P_SYSTRACE);
 1646         return (0);
 1647 }
 1649 struct str_policy *
systrace_newpolicy(struct fsystrace *fst, int maxents)
 1651 {
 1652         struct str_policy *pol;
 1653         int i;
 1655         if (fst->npolicies > SYSTR_MAX_POLICIES && !fst->issuser) {
 1656                 struct str_policy *tmp;
 1658                 /* Try to find a policy for freeing */
TAILQ_FOREACH(tmp, &fst->policies, next) {
 1660                         if (tmp->refcount == 1)
 1661                                 break;
 1662                 }
 1664                 if (tmp == NULL)
 1665                         return (NULL);
 1667                 /* Notify userland about freed policy */
systrace_msg_policyfree(fst, tmp);
 1669                 /* Free this policy */
systrace_closepolicy(fst, tmp);
 1671         }
pol = pool_get(&systr_policy_pl, PR_NOWAIT);
 1674         if (pol == NULL)
 1675                 return (NULL);
DPRINTF(("%s: allocating %d -> %lu\n", __func__,
maxents, (u_long)maxents * sizeof(int)));
memset((caddr_t)pol, 0, sizeof(struct str_policy));
pol->sysent = (u_char *)malloc(maxents * sizeof(u_char),
M_XDATA, M_WAITOK);
pol->nsysent = maxents;
 1685         for (i = 0; i < maxents; i++)
pol->sysent[i] = SYSTR_POLICY_ASK;
fst->npolicies++;
pol->nr = fst->npolicynr++;
pol->refcount = 1;
TAILQ_INSERT_TAIL(&fst->policies, pol, next);
 1694         return (pol);
 1695 }
 1697 int
systrace_msg_ask(struct fsystrace *fst, struct str_process *strp,
 1699     int code, size_t argsize, register_t args[])
 1700 {
 1701         struct str_msg_ask *msg_ask = &strp->msg.msg_data.msg_ask;
 1702         int i;
msg_ask->code = code;
msg_ask->argsize = argsize;
 1706         for (i = 0; i < (argsize/sizeof(register_t)) && i < SYSTR_MAXARGS; i++)
msg_ask->args[i] = args[i];
 1709         return (systrace_make_msg(strp, SYSTR_MSG_ASK));
 1710 }
 1712 int
systrace_msg_result(struct fsystrace *fst, struct str_process *strp,
 1714     int error, int code, size_t argsize, register_t args[], register_t rval[])
 1715 {
 1716         struct str_msg_ask *msg_ask = &strp->msg.msg_data.msg_ask;
 1717         int i;
msg_ask->code = code;
msg_ask->argsize = argsize;
msg_ask->result = error;
 1722         for (i = 0; i < (argsize/sizeof(register_t)) && i < SYSTR_MAXARGS; i++)
msg_ask->args[i] = args[i];
msg_ask->rval[0] = rval[0];
msg_ask->rval[1] = rval[1];
 1728         return (systrace_make_msg(strp, SYSTR_MSG_RES));
 1729 }
 1731 int
systrace_msg_emul(struct fsystrace *fst, struct str_process *strp)
 1733 {
 1734         struct str_msg_emul *msg_emul = &strp->msg.msg_data.msg_emul;
 1735         struct proc *p = strp->proc;
memcpy(msg_emul->emul, p->p_emul->e_name, SYSTR_EMULEN);
 1739         return (systrace_make_msg(strp, SYSTR_MSG_EMUL));
 1740 }
 1742 int
systrace_msg_ugid(struct fsystrace *fst, struct str_process *strp)
 1744 {
 1745         struct str_msg_ugid *msg_ugid = &strp->msg.msg_data.msg_ugid;
 1746         struct proc *p = strp->proc;
msg_ugid->uid = p->p_cred->p_ruid;
msg_ugid->gid = p->p_cred->p_rgid;
 1751         return (systrace_make_msg(strp, SYSTR_MSG_UGID));
 1752 }
 1754 int
systrace_make_msg(struct str_process *strp, int type)
 1756 {
 1757         struct str_message *msg = &strp->msg;
 1758         struct fsystrace *fst = strp->parent;
 1759         int st, pri;
pri = PWAIT|PCATCH;
 1762         if (type == SYSTR_MSG_EXECVE)
pri &= ~PCATCH;
msg->msg_seqnr = ++strp->seqnr;
msg->msg_type = type;
msg->msg_pid = strp->pid;
 1768         if (strp->policy)
msg->msg_policy = strp->policy->nr;
 1770         else
msg->msg_policy = -1;
SET(strp->flags, STR_PROC_WAITANSWER);
 1774         if (ISSET(strp->flags, STR_PROC_ONQUEUE))
 1775                 goto out;
TAILQ_INSERT_TAIL(&fst->messages, strp, msg_next);
SET(strp->flags, STR_PROC_ONQUEUE);
out:
systrace_wakeup(fst);
 1783         /* Release the lock - XXX */
rw_exit_write(&fst->lock);
 1786         while (1) {
st = tsleep(strp, pri, "systrmsg", 0);
 1788                 if (st != 0)
 1789                         return (ERESTART);
 1790                 /* If we detach, then everything is permitted */
 1791                 if ((strp = curproc->p_systrace) == NULL)
 1792                         return (0);
 1793                 if (!ISSET(strp->flags, STR_PROC_WAITANSWER))
 1794                         break;
 1795         }
 1797         return (0);
 1798 }
 1800 int
systrace_msg_child(struct fsystrace *fst, struct str_process *strp, pid_t npid)
 1802 {
 1803         struct str_process *nstrp;
 1804         struct str_message *msg;
 1805         struct str_msg_child *msg_child;
nstrp = pool_get(&systr_proc_pl, PR_WAITOK);
memset(nstrp, 0, sizeof(struct str_process));
DPRINTF(("%s: %p: pid %d -> pid %d\n", __func__,
nstrp, strp->pid, npid));
msg = &nstrp->msg;
msg_child = &msg->msg_data.msg_child;
msg->msg_type = SYSTR_MSG_CHILD;
msg->msg_pid = strp->pid;
 1818         if (strp->policy)
msg->msg_policy = strp->policy->nr;
 1820         else
msg->msg_policy = -1;
msg_child->new_pid = npid;
TAILQ_INSERT_TAIL(&fst->messages, nstrp, msg_next);
systrace_wakeup(fst);
 1828         return (0);
 1829 }
 1831 int
systrace_msg_policyfree(struct fsystrace *fst, struct str_policy *strpol)
 1833 {
 1834         struct str_process *nstrp;
 1835         struct str_message *msg;
nstrp = pool_get(&systr_proc_pl, PR_WAITOK);
memset(nstrp, 0, sizeof(struct str_process));
DPRINTF(("%s: free %d\n", __func__, strpol->nr));
msg = &nstrp->msg;
msg->msg_type = SYSTR_MSG_POLICYFREE;
msg->msg_policy = strpol->nr;
TAILQ_INSERT_TAIL(&fst->messages, nstrp, msg_next);
systrace_wakeup(fst);
 1851         return (0);
 1852 }