#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <string.h>
#include <stddef.h>
#include <sys/sysmacros.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <sys/syscall.h>
#include <sys/user.h>
#include <sys/ioctl.h>
#include <sys/ptrace.h>
#include <sys/mount.h>
#include <linux/limits.h>
#include <linux/filter.h>
#include <linux/seccomp.h>

#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*(x)))

static int seccomp(unsigned int op, unsigned int flags, void *args)
{
 errno = 0;
 return syscall(__NR_seccomp, op, flags, args);
}

static int send_fd(int sock, int fd)
{
 struct msghdr msg = {};
 struct cmsghdr *cmsg;
 int *fd_ptr;
 char buf[CMSG_SPACE(sizeof(int))] = {0}, c = 'c';
 struct iovec io = {
  .iov_base = &c,
  .iov_len = 1,
 };

 msg.msg_iov = &io;
 msg.msg_iovlen = 1;
 msg.msg_control = buf;
 msg.msg_controllen = sizeof(buf);
 cmsg = CMSG_FIRSTHDR(&msg);
 cmsg->cmsg_level = SOL_SOCKET;
 cmsg->cmsg_type = SCM_RIGHTS;
 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
 fd_ptr = (int *)CMSG_DATA(cmsg);
 *fd_ptr = fd;
 msg.msg_controllen = cmsg->cmsg_len;

 if (sendmsg(sock, &msg, 0) < 0) {
  perror("sendmsg");
  return -1;
 }

 return 0;
}

static int recv_fd(int sock)
{
 struct msghdr msg = {};
 struct cmsghdr *cmsg;
 int *fd_ptr;
 char buf[CMSG_SPACE(sizeof(int))] = {0}, c = 'c';
 struct iovec io = {
  .iov_base = &c,
  .iov_len = 1,
 };

 msg.msg_iov = &io;
 msg.msg_iovlen = 1;
 msg.msg_control = buf;
 msg.msg_controllen = sizeof(buf);

 if (recvmsg(sock, &msg, 0) < 0) {
  perror("recvmsg");
  return -1;
 }

 cmsg = CMSG_FIRSTHDR(&msg);
 fd_ptr = (int *)CMSG_DATA(cmsg);

 return *fd_ptr;
}

static int user_trap_syscall(int nr, unsigned int flags)
{
 struct sock_filter filter[] = {
  BPF_STMT(BPF_LD+BPF_W+BPF_ABS,
   offsetof(struct seccomp_data, nr)),
  BPF_JUMP(BPF_JMP+BPF_JEQ+BPF_K, nr, 0, 1),
  BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_USER_NOTIF),
  BPF_STMT(BPF_RET+BPF_K, SECCOMP_RET_ALLOW),
 };

 struct sock_fprog prog = {
  .len = (unsigned short)ARRAY_SIZE(filter),
  .filter = filter,
 };

 return seccomp(SECCOMP_SET_MODE_FILTER, flags, &prog);
}

static int handle_req(struct seccomp_notif *req,
        struct seccomp_notif_resp *resp, int listener)
{
 char path[PATH_MAX], source[PATH_MAX], target[PATH_MAX];
 int ret = -1, mem;

 resp->id = req->id;
 resp->error = -EPERM;
 resp->val = 0;

 if (req->data.nr != __NR_mount) {
  fprintf(stderr, "huh? trapped something besides mount? %d\n", req->data.nr);
  return -1;
 }

 /* Only allow bind mounts. */
 if (!(req->data.args[3] & MS_BIND))
  return 0;

 /*
  * Ok, let's read the task's memory to see where they wanted their
  * mount to go.
 */
 snprintf(path, sizeof(path), "/proc/%d/mem", req->pid);
 mem = open(path, O_RDONLY);
 if (mem < 0) {
  perror("open mem");
  return -1;
 }

 /*
  * Now we avoid a TOCTOU: we referred to a pid by its pid, but since
  * the pid that made the syscall may have died, we need to confirm that
  * the pid is still valid after we open its /proc/pid/mem file. We can
  * ask the listener fd this as follows.
  *
  * Note that this check should occur *after* any task-specific
  * resources are opened, to make sure that the task has not died and
  * we're not wrongly reading someone else's state in order to make
  * decisions.
 */
 if (ioctl(listener, SECCOMP_IOCTL_NOTIF_ID_VALID, &req->id) < 0) {
  fprintf(stderr, "task died before we could map its memory\n");
  goto out;
 }

 /*
  * Phew, we've got the right /proc/pid/mem. Now we can read it. Note
  * that to avoid another TOCTOU, we should read all of the pointer args
  * before we decide to allow the syscall.
 */
 if (lseek(mem, req->data.args[0], SEEK_SET) < 0) {
  perror("seek");
  goto out;
 }

 ret = read(mem, source, sizeof(source));
 if (ret < 0) {
  perror("read");
  goto out;
 }

 if (lseek(mem, req->data.args[1], SEEK_SET) < 0) {
  perror("seek");
  goto out;
 }

 ret = read(mem, target, sizeof(target));
 if (ret < 0) {
  perror("read");
  goto out;
 }

 /*
  * Our policy is to only allow bind mounts inside /tmp. This isn't very
  * interesting, because we could do unprivlieged bind mounts with user
  * namespaces already, but you get the idea.
 */
 if (!strncmp(source, "/tmp/", 5) && !strncmp(target, "/tmp/", 5)) {
  if (mount(source, target, NULL, req->data.args[3], NULL) < 0) {
   ret = -1;
   perror("actual mount");
   goto out;
  }
  resp->error = 0;
 }

 /* Even if we didn't allow it because of policy, generating the
  * response was be a success, because we want to tell the worker EPERM.
 */
 ret = 0;

out:
 close(mem);
 return ret;
}

int main(void)
{
 int sk_pair[2], ret = 1, status, listener;
 pid_t worker = 0 , tracer = 0;

 if (socketpair(PF_LOCAL, SOCK_SEQPACKET, 0, sk_pair) < 0) {
  perror("socketpair");
  return 1;
 }

 worker = fork();
 if (worker < 0) {
  perror("fork");
  goto close_pair;
 }

 if (worker == 0) {
  listener = user_trap_syscall(__NR_mount,
          SECCOMP_FILTER_FLAG_NEW_LISTENER);
  if (listener < 0) {
   perror("seccomp");
   exit(1);
  }

  /*
   * Drop privileges. We definitely can't mount as uid 1000.
 */
  if (setuid(1000) < 0) {
   perror("setuid");
   exit(1);
  }

  /*
   * Send the listener to the parent; also serves as
   * synchronization.
 */
  if (send_fd(sk_pair[1], listener) < 0)
   exit(1);
  close(listener);

  if (mkdir("/tmp/foo", 0755) < 0) {
   perror("mkdir");
   exit(1);
  }

  /*
   * Try a bad mount just for grins.
 */
  if (mount("/dev/sda", "/tmp/foo", NULL, 0, NULL) != -1) {
   fprintf(stderr, "huh? mounted /dev/sda?\n");
   exit(1);
  }

  if (errno != EPERM) {
   perror("bad error from mount");
   exit(1);
  }

  /*
   * Ok, we expect this one to succeed.
 */
  if (mount("/tmp/foo", "/tmp/foo", NULL, MS_BIND, NULL) < 0) {
   perror("mount");
   exit(1);
  }

  exit(0);
 }

 /*
  * Get the listener from the child.
 */
 listener = recv_fd(sk_pair[0]);
 if (listener < 0)
  goto out_kill;

 /*
  * Fork a task to handle the requests. This isn't strictly necessary,
  * but it makes the particular writing of this sample easier, since we
  * can just wait ofr the tracee to exit and kill the tracer.
 */
 tracer = fork();
 if (tracer < 0) {
  perror("fork");
  goto out_kill;
 }

 if (tracer == 0) {
  struct seccomp_notif *req;
  struct seccomp_notif_resp *resp;
  struct seccomp_notif_sizes sizes;

  if (seccomp(SECCOMP_GET_NOTIF_SIZES, 0, &sizes) < 0) {
   perror("seccomp(GET_NOTIF_SIZES)");
   goto out_close;
  }

  req = malloc(sizes.seccomp_notif);
  if (!req)
   goto out_close;

  resp = malloc(sizes.seccomp_notif_resp);
  if (!resp)
   goto out_req;
  memset(resp, 0, sizes.seccomp_notif_resp);

  while (1) {
   memset(req, 0, sizes.seccomp_notif);
   if (ioctl(listener, SECCOMP_IOCTL_NOTIF_RECV, req)) {
    perror("ioctl recv");
    goto out_resp;
   }

   if (handle_req(req, resp, listener) < 0)
    goto out_resp;

   /*
    * ENOENT here means that the task may have gotten a
    * signal and restarted the syscall. It's up to the
    * handler to decide what to do in this case, but for
    * the sample code, we just ignore it. Probably
    * something better should happen, like undoing the
    * mount, or keeping track of the args to make sure we
    * don't do it again.
 */
   if (ioctl(listener, SECCOMP_IOCTL_NOTIF_SEND, resp) < 0 &&
       errno != ENOENT) {
    perror("ioctl send");
    goto out_resp;
   }
  }
out_resp:
  free(resp);
out_req:
  free(req);
out_close:
  close(listener);
  exit(1);
 }

 close(listener);

 if (waitpid(worker, &status, 0) != worker) {
  perror("waitpid");
  goto out_kill;
 }

 if (umount2("/tmp/foo", MNT_DETACH) < 0 && errno != EINVAL) {
  perror("umount2");
  goto out_kill;
 }

 if (remove("/tmp/foo") < 0 && errno != ENOENT) {
  perror("remove");
  exit(1);
 }

 if (!WIFEXITED(status) || WEXITSTATUS(status)) {
  fprintf(stderr, "worker exited nonzero\n");
  goto out_kill;
 }

 ret = 0;

out_kill:
 if (tracer > 0)
  kill(tracer, SIGKILL);
 if (worker > 0)
  kill(worker, SIGKILL);

close_pair:
 close(sk_pair[0]);
 close(sk_pair[1]);
 return ret;
}