/* $OpenBSD: client.c,v 1.166 2026/07/10 15:45:11 nicm Exp $ */

/*

 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER

 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING

 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/uio.h>

#include <sys/un.h>

#include <sys/wait.h>

#include <sys/file.h>

#include <errno.h>

#include <fcntl.h>

#include <signal.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "tmux.h"

static struct tmuxproc  *client_proc;

static struct tmuxpeer  *client_peer;

static uint64_t    client_flags;

static int     client_suspended;

static enum {

  CLIENT_EXIT_NONE,

  CLIENT_EXIT_DETACHED,

  CLIENT_EXIT_DETACHED_HUP,

  CLIENT_EXIT_LOST_TTY,

  CLIENT_EXIT_TERMINATED,

  CLIENT_EXIT_LOST_SERVER,

  CLIENT_EXIT_EXITED,

  CLIENT_EXIT_SERVER_EXITED,

  CLIENT_EXIT_MESSAGE_PROVIDED

} client_exitreason = CLIENT_EXIT_NONE;

static int     client_exitflag;

static int     client_exitval;

static enum msgtype  client_exittype;

static const char *client_exitsession;

static char   *client_exitmessage;

static const char *client_execshell;

static const char *client_execcmd;

static int     client_attached;

static struct client_files client_files = RB_INITIALIZER(&client_files);

static __dead void   client_exec(const char *,const char *);

static int     client_get_lock(char *);

static int     client_connect(struct event_base *, const char *,

           uint64_t);

static void    client_send_identify(const char *, const char *,

           char **, u_int, const char *, int);

static void    client_signal(int);

static void    client_dispatch(struct imsg *, void *);

static void    client_dispatch_attached(struct imsg *);

static void    client_dispatch_wait(struct imsg *);

static const char *client_exit_message(void);

/*

 * Get server create lock. If already held then server start is happening in

 * another client, so block until the lock is released and return -2 to

 * retry. Return -1 on failure to continue and start the server anyway.

 */

static int

client_get_lock(char *lockfile)

{

  int lockfd;

  log_debug("lock file is %s", lockfile);

  if ((lockfd = open(lockfile, O_WRONLY|O_CREAT, 0600)) == -1) {

    log_debug("open failed: %s", strerror(errno));

    return (-1);

  }

  if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {

    log_debug("flock failed: %s", strerror(errno));

    if (errno != EAGAIN)

      return (lockfd);

    while (flock(lockfd, LOCK_EX) == -1 && errno == EINTR)

      /* nothing */;

    close(lockfd);

    return (-2);

  }

  log_debug("flock succeeded");

  return (lockfd);

}

/* Connect client to server. */

static int

client_connect(struct event_base *base, const char *path, uint64_t flags)

{

  struct sockaddr_un  sa;

  size_t      size;

  int     fd, lockfd = -1, locked = 0;

  char           *lockfile = NULL;

  memset(&sa, 0, sizeof sa);

  sa.sun_family = AF_UNIX;

  size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);

  if (size >= sizeof sa.sun_path) {

    errno = ENAMETOOLONG;

    return (-1);

  }

  log_debug("socket is %s", path);

retry:

  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)

    return (-1);

  log_debug("trying connect");

  if (connect(fd, (struct sockaddr *)&sa, sizeof sa) == -1) {

    log_debug("connect failed: %s", strerror(errno));

    if (errno != ECONNREFUSED && errno != ENOENT)

      goto failed;

    if (flags & CLIENT_NOSTARTSERVER)

      goto failed;

    if (~flags & CLIENT_STARTSERVER)

      goto failed;

    close(fd);

    if (!locked) {

      xasprintf(&lockfile, "%s.lock", path);

      if ((lockfd = client_get_lock(lockfile)) < 0) {

        log_debug("didn't get lock (%d)", lockfd);

        free(lockfile);

        lockfile = NULL;

        if (lockfd == -2)

          goto retry;

      }

      log_debug("got lock (%d)", lockfd);

      /*

       * Always retry at least once, even if we got the lock,

       * because another client could have taken the lock,

       * started the server and released the lock between our

       * connect() and flock().

       */

      locked = 1;

      goto retry;

    }

    if (lockfd >= 0 && unlink(path) != 0 && errno != ENOENT) {

      free(lockfile);

      close(lockfd);

      return (-1);

    }

    fd = server_start(client_proc, flags, base, lockfd, lockfile);

  }

  if (locked && lockfd >= 0) {

    free(lockfile);

    close(lockfd);

  }

  setblocking(fd, 0);

  return (fd);

failed:

  if (locked) {

    free(lockfile);

    close(lockfd);

  }

  close(fd);

  return (-1);

}

/* Get exit string from reason number. */

const char *

client_exit_message(void)

{

  static char msg[256];

  switch (client_exitreason) {

  case CLIENT_EXIT_NONE:

    break;

  case CLIENT_EXIT_DETACHED:

    if (client_exitsession != NULL) {

      xsnprintf(msg, sizeof msg, "detached "

          "(from session %s)", client_exitsession);

      return (msg);

    }

    return ("detached");

  case CLIENT_EXIT_DETACHED_HUP:

    if (client_exitsession != NULL) {

      xsnprintf(msg, sizeof msg, "detached and SIGHUP "

          "(from session %s)", client_exitsession);

      return (msg);

    }

    return ("detached and SIGHUP");

  case CLIENT_EXIT_LOST_TTY:

    return ("lost tty");

  case CLIENT_EXIT_TERMINATED:

    return ("terminated");

  case CLIENT_EXIT_LOST_SERVER:

    return ("server exited unexpectedly");

  case CLIENT_EXIT_EXITED:

    return ("exited");

  case CLIENT_EXIT_SERVER_EXITED:

    return ("server exited");

  case CLIENT_EXIT_MESSAGE_PROVIDED:

    return (client_exitmessage);

  }

  return ("unknown reason");

}

/* Exit if all streams flushed. */

static void

client_exit(void)

{

  if (!file_write_left(&client_files))

    proc_exit(client_proc);

}

/* Client main loop. */

int

client_main(struct event_base *base, int argc, char **argv, uint64_t flags,

    int feat)

{

  struct cmd_parse_result *pr;

  struct msg_command  *data;

  int      fd, i;

  const char    *ttynam, *termname, *cwd;

  pid_t      ppid;

  enum msgtype     msg;

  struct termios     tio, saved_tio;

  size_t       size;

  char      **caps = NULL, *cause;

  u_int      ncaps = 0;

  struct args_value *values;

  /* Set up the initial command. */

  if (shell_command != NULL) {

    msg = MSG_SHELL;

    flags |= CLIENT_STARTSERVER;

  } else if (argc == 0) {

    msg = MSG_COMMAND;

    flags |= CLIENT_STARTSERVER;

  } else {

    msg = MSG_COMMAND;

    /*

     * It's annoying parsing the command string twice (in client

     * and later in server) but it is necessary to get the start

     * server flag.

     */

    values = args_from_vector(argc, argv);

    pr = cmd_parse_from_arguments(values, argc, NULL);

    if (pr->status == CMD_PARSE_SUCCESS) {

      if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))

        flags |= CLIENT_STARTSERVER;

      cmd_list_free(pr->cmdlist);

    } else

      free(pr->error);

    args_free_values(values, argc);

    free(values);

  }

  /* Create client process structure (starts logging). */

  client_proc = proc_start("client");

  proc_set_signals(client_proc, client_signal);

  /* Save the flags. */

  client_flags = flags;

  log_debug("flags are %#llx", (unsigned long long)client_flags);

  /* Initialize the client socket and start the server. */

#ifdef HAVE_SYSTEMD

  if (systemd_activated()) {

    /* socket-based activation, do not even try to be a client. */

    fd = server_start(client_proc, flags, base, 0, NULL);

  } else

#endif

  fd = client_connect(base, socket_path, client_flags);

  if (fd == -1) {

    if (errno == ECONNREFUSED) {

      fprintf(stderr, "no server running on %s\n",

          socket_path);

    } else {

      fprintf(stderr, "error connecting to %s (%s)\n",

          socket_path, strerror(errno));

    }

    return (1);

  }

  client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);

  /* Save these before pledge(). */

  if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)

    cwd = "/";

  if ((ttynam = ttyname(STDIN_FILENO)) == NULL)

    ttynam = "";

  if ((termname = getenv("TERM")) == NULL)

    termname = "";

  /*

   * Drop privileges for client. "proc exec" is needed for -c and for

   * locking (which uses system(3)).

   *

   * "tty" is needed to restore termios(4) and also for some reason -CC

   * does not work properly without it (input is not recognised).

   *

   * "sendfd" is dropped later in client_dispatch_wait().

   */

  if (pledge(

      "stdio rpath wpath cpath unix sendfd proc exec tty",

      NULL) != 0)

    fatal("pledge failed");

  /* Load terminfo entry if any. */

  if (isatty(STDIN_FILENO) &&

      *termname != '\0' &&

      tty_term_read_list(termname, STDIN_FILENO, &caps, &ncaps,

      &cause) != 0) {

    fprintf(stderr, "%s\n", cause);

    free(cause);

    return (1);

  }

  /* Free stuff that is not used in the client. */

  if (ptm_fd != -1)

    close(ptm_fd);

  options_free(global_options);

  options_free(global_s_options);

  options_free(global_w_options);

  environ_free(global_environ);

  /* Set up control mode. */

  if (client_flags & CLIENT_CONTROLCONTROL) {

    if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {

      fprintf(stderr, "tcgetattr failed: %s\n",

          strerror(errno));

      return (1);

    }

    cfmakeraw(&tio);

    tio.c_iflag = ICRNL|IXANY;

    tio.c_oflag = OPOST|ONLCR;

#ifdef NOKERNINFO

    tio.c_lflag = NOKERNINFO;

#endif

    tio.c_cflag = CREAD|CS8|HUPCL;

    tio.c_cc[VMIN] = 1;

    tio.c_cc[VTIME] = 0;

    cfsetispeed(&tio, cfgetispeed(&saved_tio));

    cfsetospeed(&tio, cfgetospeed(&saved_tio));

    tcsetattr(STDIN_FILENO, TCSANOW, &tio);

  }

  /* Send identify messages. */

  client_send_identify(ttynam, termname, caps, ncaps, cwd, feat);

  tty_term_free_list(caps, ncaps);

  proc_flush_peer(client_peer);

  /* Send first command. */

  if (msg == MSG_COMMAND) {

    /* How big is the command? */

    size = 0;

    for (i = 0; i < argc; i++)

      size += strlen(argv[i]) + 1;

    if (size > MAX_IMSGSIZE - (sizeof *data)) {

      fprintf(stderr, "command too long\n");

      return (1);

    }

    data = xmalloc((sizeof *data) + size);

    /* Prepare command for server. */

    data->argc = argc;

    if (cmd_pack_argv(argc, argv, (char *)(data + 1), size) != 0) {

      fprintf(stderr, "command too long\n");

      free(data);

      return (1);

    }

    size += sizeof *data;

    /* Send the command. */

    if (proc_send(client_peer, msg, -1, data, size) != 0) {

      fprintf(stderr, "failed to send command\n");

      free(data);

      return (1);

    }

    free(data);

  } else if (msg == MSG_SHELL)

    proc_send(client_peer, msg, -1, NULL, 0);

  /* Start main loop. */

  proc_loop(client_proc, NULL);

  /* Run command if user requested exec, instead of exiting. */

  if (client_exittype == MSG_EXEC) {

    if (client_flags & CLIENT_CONTROLCONTROL)

      tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);

    client_exec(client_execshell, client_execcmd);

  }

  /* Print the exit message, if any, and exit. */

  if (client_attached) {

    if (client_exitreason != CLIENT_EXIT_NONE)

      printf("[%s]\n", client_exit_message());

    ppid = getppid();

    if (client_exittype == MSG_DETACHKILL && ppid > 1)

      kill(ppid, SIGHUP);

  } else if (client_flags & CLIENT_CONTROL) {

    if (client_exitreason != CLIENT_EXIT_NONE)

      printf("%%exit %s\n", client_exit_message());

    else

      printf("%%exit\n");

    fflush(stdout);

    if (client_flags & CLIENT_CONTROL_WAITEXIT)

      control_wait_exit(STDIN_FILENO);

    if (client_flags & CLIENT_CONTROLCONTROL) {

      printf("\033\\");

      fflush(stdout);

      tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);

    }

  } else if (client_exitreason != CLIENT_EXIT_NONE)

    fprintf(stderr, "%s\n", client_exit_message());

  /* Restore the streams to blocking. */

  setblocking(STDIN_FILENO, 1);

  setblocking(STDOUT_FILENO, 1);

  setblocking(STDERR_FILENO, 1);

  return (client_exitval);

}

/* Send identify messages to server. */

static void

client_send_identify(const char *ttynam, const char *termname, char **caps,

    u_int ncaps, const char *cwd, int feat)

{

  char  **ss;

  size_t    sslen;

  int   fd;

  uint64_t  flags = client_flags;

  pid_t   pid;

  u_int   i;

  proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &flags, sizeof flags);

  proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,

      sizeof client_flags);

  proc_send(client_peer, MSG_IDENTIFY_TERM, -1, termname,

      strlen(termname) + 1);

  proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);

  proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,

      strlen(ttynam) + 1);

  proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);

  for (i = 0; i < ncaps; i++) {

    proc_send(client_peer, MSG_IDENTIFY_TERMINFO, -1,

        caps[i], strlen(caps[i]) + 1);

  }

  if ((fd = dup(STDIN_FILENO)) == -1)

    fatal("dup failed");

  proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);

  if ((fd = dup(STDOUT_FILENO)) == -1)

    fatal("dup failed");

  proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);

  pid = getpid();

  proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);

  for (ss = environ; *ss != NULL; ss++) {

    sslen = strlen(*ss) + 1;

    if (sslen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)

      continue;

    proc_send(client_peer, MSG_IDENTIFY_ENVIRON, -1, *ss, sslen);

  }

  proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);

}

/* Run command in shell; used for -c. */

static __dead void

client_exec(const char *shell, const char *shellcmd)

{

  char  *argv0;

  log_debug("shell %s, command %s", shell, shellcmd);

  argv0 = shell_argv0(shell, !!(client_flags & CLIENT_LOGIN));

  setenv("SHELL", shell, 1);

  proc_clear_signals(client_proc, 1);

  setblocking(STDIN_FILENO, 1);

  setblocking(STDOUT_FILENO, 1);

  setblocking(STDERR_FILENO, 1);

  closefrom(STDERR_FILENO + 1);

  execl(shell, argv0, "-c", shellcmd, (char *) NULL);

  fatal("execl failed");

}

/* Callback to handle signals in the client. */

static void

client_signal(int sig)

{

  struct sigaction sigact;

  int    status;

  pid_t    pid;

  log_debug("%s: %s", __func__, strsignal(sig));

  if (sig == SIGCHLD) {

    for (;;) {

      pid = waitpid(WAIT_ANY, &status, WNOHANG);

      if (pid == 0)

        break;

      if (pid == -1) {

        if (errno == ECHILD)

          break;

        log_debug("waitpid failed: %s",

            strerror(errno));

      }

    }

  } else if (!client_attached) {

    if (sig == SIGTERM || sig == SIGHUP)

      proc_exit(client_proc);

  } else {

    switch (sig) {

    case SIGHUP:

      client_exitreason = CLIENT_EXIT_LOST_TTY;

      client_exitval = 1;

      proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

      break;

    case SIGTERM:

      if (!client_suspended)

        client_exitreason = CLIENT_EXIT_TERMINATED;

      client_exitval = 1;

      proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

      break;

    case SIGWINCH:

      proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);

      break;

    case SIGCONT:

      memset(&sigact, 0, sizeof sigact);

      sigemptyset(&sigact.sa_mask);

      sigact.sa_flags = SA_RESTART;

      sigact.sa_handler = SIG_IGN;

      if (sigaction(SIGTSTP, &sigact, NULL) != 0)

        fatal("sigaction failed");

      proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);

      client_suspended = 0;

      break;

    }

  }

}

/* Callback for file write error or close. */

static void

client_file_check_cb(__unused struct client *c, __unused const char *path,

    __unused int error, __unused int closed, __unused struct evbuffer *buffer,

    __unused void *data)

{

  if (client_exitflag)

    client_exit();

}

/* Callback for client read events. */

static void

client_dispatch(struct imsg *imsg, __unused void *arg)

{

  if (imsg == NULL) {

    if (!client_exitflag) {

      client_exitreason = CLIENT_EXIT_LOST_SERVER;

      client_exitval = 1;

    }

    proc_exit(client_proc);

    return;

  }

  if (client_attached)

    client_dispatch_attached(imsg);

  else

    client_dispatch_wait(imsg);

}

/* Process an exit message. */

static void

client_dispatch_exit_message(char *data, size_t datalen)

{

  int retval;

  if (datalen < sizeof retval && datalen != 0)

    fatalx("bad MSG_EXIT size");

  if (datalen >= sizeof retval) {

    memcpy(&retval, data, sizeof retval);

    client_exitval = retval;

  }

  if (datalen > sizeof retval) {

    datalen -= sizeof retval;

    data += sizeof retval;

    client_exitmessage = xmalloc(datalen);

    memcpy(client_exitmessage, data, datalen);

    client_exitmessage[datalen - 1] = '\0';

    client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;

  }

}

/* Dispatch imsgs when in wait state (before MSG_READY). */

static void

client_dispatch_wait(struct imsg *imsg)

{

  char    *data;

  ssize_t    datalen;

  static int   pledge_applied;

  /*

   * "sendfd" is no longer required once all of the identify messages

   * have been sent. We know the server won't send us anything until that

   * point (because we don't ask it to), so we can drop "sendfd" once we

   * get the first message from the server.

   */

  if (!pledge_applied) {

    if (pledge(

        "stdio rpath wpath cpath unix proc exec tty",

        NULL) != 0)

      fatal("pledge failed");

    pledge_applied = 1;

  }

  data = imsg->data;

  datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

  switch (imsg->hdr.type) {

  case MSG_EXIT:

  case MSG_SHUTDOWN:

    client_dispatch_exit_message(data, datalen);

    client_exitflag = 1;

    client_exit();

    break;

  case MSG_READY:

    if (datalen != 0)

      fatalx("bad MSG_READY size");

    client_attached = 1;

    proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);

    break;

  case MSG_VERSION:

    if (datalen != 0)

      fatalx("bad MSG_VERSION size");

    fprintf(stderr, "protocol version mismatch "

        "(client %d, server %u)\n", PROTOCOL_VERSION,

        imsg->hdr.peerid & 0xff);

    client_exitval = 1;

    proc_exit(client_proc);

    break;

  case MSG_FLAGS:

    if (datalen != sizeof client_flags)

      fatalx("bad MSG_FLAGS string");

    memcpy(&client_flags, data, sizeof client_flags);

    log_debug("new flags are %#llx",

        (unsigned long long)client_flags);

    break;

  case MSG_SHELL:

    if (datalen == 0 || data[datalen - 1] != '\0')

      fatalx("bad MSG_SHELL string");

    client_exec(data, shell_command);

    /* NOTREACHED */

  case MSG_DETACH:

  case MSG_DETACHKILL:

    proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

    break;

  case MSG_EXITED:

    proc_exit(client_proc);

    break;

  case MSG_READ_OPEN:

    file_read_open(&client_files, client_peer, imsg, 1,

        !(client_flags & CLIENT_CONTROL), client_file_check_cb,

        NULL);

    break;

  case MSG_READ_CANCEL:

    file_read_cancel(&client_files, imsg);

    break;

  case MSG_WRITE_OPEN:

    file_write_open(&client_files, client_peer, imsg, 1,

        !(client_flags & CLIENT_CONTROL), client_file_check_cb,

        NULL);

    break;

  case MSG_WRITE:

    file_write_data(&client_files, imsg);

    break;

  case MSG_WRITE_CLOSE:

    file_write_close(&client_files, imsg);

    break;

  case MSG_OLDSTDERR:

  case MSG_OLDSTDIN:

  case MSG_OLDSTDOUT:

    fprintf(stderr, "server version is too old for client\n");

    proc_exit(client_proc);

    break;

  }

}

/* Dispatch imsgs in attached state (after MSG_READY). */

static void

client_dispatch_attached(struct imsg *imsg)

{

  struct sigaction   sigact;

  char      *data;

  ssize_t      datalen;

  data = imsg->data;

  datalen = imsg->hdr.len - IMSG_HEADER_SIZE;

  switch (imsg->hdr.type) {

  case MSG_FLAGS:

    if (datalen != sizeof client_flags)

      fatalx("bad MSG_FLAGS string");

    memcpy(&client_flags, data, sizeof client_flags);

    log_debug("new flags are %#llx",

        (unsigned long long)client_flags);

    break;

  case MSG_DETACH:

  case MSG_DETACHKILL:

    if (datalen == 0 || data[datalen - 1] != '\0')

      fatalx("bad MSG_DETACH string");

    client_exitsession = xstrdup(data);

    client_exittype = imsg->hdr.type;

    if (imsg->hdr.type == MSG_DETACHKILL)

      client_exitreason = CLIENT_EXIT_DETACHED_HUP;

    else

      client_exitreason = CLIENT_EXIT_DETACHED;

    proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

    break;

  case MSG_EXEC:

    if (datalen == 0 || data[datalen - 1] != '\0' ||

        strlen(data) + 1 == (size_t)datalen)

      fatalx("bad MSG_EXEC string");

    client_execcmd = xstrdup(data);

    client_execshell = xstrdup(data + strlen(data) + 1);

    client_exittype = imsg->hdr.type;

    proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

    break;

  case MSG_EXIT:

    client_dispatch_exit_message(data, datalen);

    if (client_exitreason == CLIENT_EXIT_NONE)

      client_exitreason = CLIENT_EXIT_EXITED;

    proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

    break;

  case MSG_EXITED:

    if (datalen != 0)

      fatalx("bad MSG_EXITED size");

    proc_exit(client_proc);

    break;

  case MSG_SHUTDOWN:

    if (datalen != 0)

      fatalx("bad MSG_SHUTDOWN size");

    proc_send(client_peer, MSG_EXITING, -1, NULL, 0);

    client_exitreason = CLIENT_EXIT_SERVER_EXITED;

    client_exitval = 1;

    break;

  case MSG_SUSPEND:

    if (datalen != 0)

      fatalx("bad MSG_SUSPEND size");

    memset(&sigact, 0, sizeof sigact);

    sigemptyset(&sigact.sa_mask);

    sigact.sa_flags = SA_RESTART;

    sigact.sa_handler = SIG_DFL;

    if (sigaction(SIGTSTP, &sigact, NULL) != 0)

      fatal("sigaction failed");

    client_suspended = 1;

    kill(getpid(), SIGTSTP);

    break;

  case MSG_LOCK:

    if (datalen == 0 || data[datalen - 1] != '\0')

      fatalx("bad MSG_LOCK string");

    system(data);

    proc_send(client_peer, MSG_UNLOCK, -1, NULL, 0);

    break;

  }

}