client.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
   5  *
   6  * Permission to use, copy, modify, and distribute this software for any
   7  * purpose with or without fee is hereby granted, provided that the above
   8  * copyright notice and this permission notice appear in all copies.
   9  *
  10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
  15  * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
  16  * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17  */
  18
  19 #include <sys/types.h>
  20 #include <sys/socket.h>
  21 #include <sys/uio.h>
  22 #include <sys/un.h>
  23 #include <sys/wait.h>
  24
  25 #include <errno.h>
  26 #include <event.h>
  27 #include <fcntl.h>
  28 #include <imsg.h>
  29 #include <signal.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33
  34 #include "tmux.h"
  35
  36 static struct tmuxproc  *client_proc;
  37 static struct tmuxpeer  *client_peer;
  38 static uint64_t          client_flags;
  39 static int               client_suspended;
  40 static enum {
  41         CLIENT_EXIT_NONE,
  42         CLIENT_EXIT_DETACHED,
  43         CLIENT_EXIT_DETACHED_HUP,
  44         CLIENT_EXIT_LOST_TTY,
  45         CLIENT_EXIT_TERMINATED,
  46         CLIENT_EXIT_LOST_SERVER,
  47         CLIENT_EXIT_EXITED,
  48         CLIENT_EXIT_SERVER_EXITED,
  49         CLIENT_EXIT_MESSAGE_PROVIDED
  50 } client_exitreason = CLIENT_EXIT_NONE;
  51 static int               client_exitflag;
  52 static int               client_exitval;
  53 static enum msgtype      client_exittype;
  54 static const char       *client_exitsession;
  55 static char             *client_exitmessage;
  56 static const char       *client_execshell;
  57 static const char       *client_execcmd;
  58 static int               client_attached;
  59 static struct client_files client_files = RB_INITIALIZER(&client_files);
  60
  61 static __dead void       client_exec(const char *,const char *);
  62 static int               client_get_lock(char *);
  63 static int               client_connect(struct event_base *, const char *,
  64                              uint64_t);
  65 static void              client_send_identify(const char *, const char *,
  66                              char **, u_int, const char *, int);
  67 static void              client_signal(int);
  68 static void              client_dispatch(struct imsg *, void *);
  69 static void              client_dispatch_attached(struct imsg *);
  70 static void              client_dispatch_wait(struct imsg *);
  71 static const char       *client_exit_message(void);
  72
  73 /*
  74  * Get server create lock. If already held then server start is happening in
  75  * another client, so block until the lock is released and return -2 to
  76  * retry. Return -1 on failure to continue and start the server anyway.
  77  */
  78 static int
  79 client_get_lock(char *lockfile)
  80 {
  81         int lockfd;
  82
  83         log_debug("lock file is %s", lockfile);
  84
  85         if ((lockfd = open(lockfile, O_WRONLY|O_CREAT, 0600)) == -1) {
  86                 log_debug("open failed: %s", strerror(errno));
  87                 return (-1);
  88         }
  89
  90         if (flock(lockfd, LOCK_EX|LOCK_NB) == -1) {
  91                 log_debug("flock failed: %s", strerror(errno));
  92                 if (errno != EAGAIN)
  93                         return (lockfd);
  94                 while (flock(lockfd, LOCK_EX) == -1 && errno == EINTR)
  95                         /* nothing */;
  96                 close(lockfd);
  97                 return (-2);
  98         }
  99         log_debug("flock succeeded");
 100
 101         return (lockfd);
 102 }
 103
 104 /* Connect client to server. */
 105 static int
 106 client_connect(struct event_base *base, const char *path, uint64_t flags)
 107 {
 108         struct sockaddr_un      sa;
 109         size_t                  size;
 110         int                     fd, lockfd = -1, locked = 0;
 111         char                   *lockfile = NULL;
 112
 113         memset(&sa, 0, sizeof sa);
 114         sa.sun_family = AF_UNIX;
 115         size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);
 116         if (size >= sizeof sa.sun_path) {
 117                 errno = ENAMETOOLONG;
 118                 return (-1);
 119         }
 120         log_debug("socket is %s", path);
 121
 122 retry:
 123         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 124                 return (-1);
 125
 126         log_debug("trying connect");
 127         if (connect(fd, (struct sockaddr *)&sa, sizeof sa) == -1) {
 128                 log_debug("connect failed: %s", strerror(errno));
 129                 if (errno != ECONNREFUSED && errno != ENOENT)
 130                         goto failed;
 131                 if (flags & CLIENT_NOSTARTSERVER)
 132                         goto failed;
 133                 if (~flags & CLIENT_STARTSERVER)
 134                         goto failed;
 135                 close(fd);
 136
 137                 if (!locked) {
 138                         xasprintf(&lockfile, "%s.lock", path);
 139                         if ((lockfd = client_get_lock(lockfile)) < 0) {
 140                                 log_debug("didn't get lock (%d)", lockfd);
 141
 142                                 free(lockfile);
 143                                 lockfile = NULL;
 144
 145                                 if (lockfd == -2)
 146                                         goto retry;
 147                         }
 148                         log_debug("got lock (%d)", lockfd);
 149
 150                         /*
 151                          * Always retry at least once, even if we got the lock,
 152                          * because another client could have taken the lock,
 153                          * started the server and released the lock between our
 154                          * connect() and flock().
 155                          */
 156                         locked = 1;
 157                         goto retry;
 158                 }
 159
 160                 if (lockfd >= 0 && unlink(path) != 0 && errno != ENOENT) {
 161                         free(lockfile);
 162                         close(lockfd);
 163                         return (-1);
 164                 }
 165                 fd = server_start(client_proc, flags, base, lockfd, lockfile);
 166         }
 167
 168         if (locked && lockfd >= 0) {
 169                 free(lockfile);
 170                 close(lockfd);
 171         }
 172         setblocking(fd, 0);
 173         return (fd);
 174
 175 failed:
 176         if (locked) {
 177                 free(lockfile);
 178                 close(lockfd);
 179         }
 180         close(fd);
 181         return (-1);
 182 }
 183
 184 /* Get exit string from reason number. */
 185 const char *
 186 client_exit_message(void)
 187 {
 188         static char msg[256];
 189
 190         switch (client_exitreason) {
 191         case CLIENT_EXIT_NONE:
 192                 break;
 193         case CLIENT_EXIT_DETACHED:
 194                 if (client_exitsession != NULL) {
 195                         xsnprintf(msg, sizeof msg, "detached "
 196                             "(from session %s)", client_exitsession);
 197                         return (msg);
 198                 }
 199                 return ("detached");
 200         case CLIENT_EXIT_DETACHED_HUP:
 201                 if (client_exitsession != NULL) {
 202                         xsnprintf(msg, sizeof msg, "detached and SIGHUP "
 203                             "(from session %s)", client_exitsession);
 204                         return (msg);
 205                 }
 206                 return ("detached and SIGHUP");
 207         case CLIENT_EXIT_LOST_TTY:
 208                 return ("lost tty");
 209         case CLIENT_EXIT_TERMINATED:
 210                 return ("terminated");
 211         case CLIENT_EXIT_LOST_SERVER:
 212                 return ("server exited unexpectedly");
 213         case CLIENT_EXIT_EXITED:
 214                 return ("exited");
 215         case CLIENT_EXIT_SERVER_EXITED:
 216                 return ("server exited");
 217         case CLIENT_EXIT_MESSAGE_PROVIDED:
 218                 return (client_exitmessage);
 219         }
 220         return ("unknown reason");
 221 }
 222
 223 /* Exit if all streams flushed. */
 224 static void
 225 client_exit(void)
 226 {
 227         if (!file_write_left(&client_files))
 228                 proc_exit(client_proc);
 229 }
 230
 231 /* Client main loop. */
 232 int
 233 client_main(struct event_base *base, int argc, char **argv, uint64_t flags,
 234     int feat)
 235 {
 236         struct cmd_parse_result *pr;
 237         struct msg_command      *data;
 238         int                      fd, i;
 239         const char              *ttynam, *termname, *cwd;
 240         pid_t                    ppid;
 241         enum msgtype             msg;
 242         struct termios           tio, saved_tio;
 243         size_t                   size, linesize = 0;
 244         ssize_t                  linelen;
 245         char                    *line = NULL, **caps = NULL, *cause;
 246         u_int                    ncaps = 0;
 247         struct args_value       *values;
 248
 249         /* Ignore SIGCHLD now or daemon() in the server will leave a zombie. */
 250         signal(SIGCHLD, SIG_IGN);
 251
 252         /* Set up the initial command. */
 253         if (shell_command != NULL) {
 254                 msg = MSG_SHELL;
 255                 flags |= CLIENT_STARTSERVER;
 256         } else if (argc == 0) {
 257                 msg = MSG_COMMAND;
 258                 flags |= CLIENT_STARTSERVER;
 259         } else {
 260                 msg = MSG_COMMAND;
 261
 262                 /*
 263                  * It's annoying parsing the command string twice (in client
 264                  * and later in server) but it is necessary to get the start
 265                  * server flag.
 266                  */
 267                 values = args_from_vector(argc, argv);
 268                 pr = cmd_parse_from_arguments(values, argc, NULL);
 269                 if (pr->status == CMD_PARSE_SUCCESS) {
 270                         if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
 271                                 flags |= CLIENT_STARTSERVER;
 272                         cmd_list_free(pr->cmdlist);
 273                 } else
 274                         free(pr->error);
 275                 args_free_values(values, argc);
 276                 free(values);
 277         }
 278
 279         /* Create client process structure (starts logging). */
 280         client_proc = proc_start("client");
 281         proc_set_signals(client_proc, client_signal);
 282
 283         /* Save the flags. */
 284         client_flags = flags;
 285         log_debug("flags are %#llx", (unsigned long long)client_flags);
 286
 287         /* Initialize the client socket and start the server. */
 288         fd = client_connect(base, socket_path, client_flags);
 289         if (fd == -1) {
 290                 if (errno == ECONNREFUSED) {
 291                         fprintf(stderr, "no server running on %s\n",
 292                             socket_path);
 293                 } else {
 294                         fprintf(stderr, "error connecting to %s (%s)\n",
 295                             socket_path, strerror(errno));
 296                 }
 297                 return (1);
 298         }
 299         client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);
 300
 301         /* Save these before pledge(). */
 302         if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
 303                 cwd = "/";
 304         if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
 305                 ttynam = "";
 306         if ((termname = getenv("TERM")) == NULL)
 307                 termname = "";
 308
 309         /*
 310          * Drop privileges for client. "proc exec" is needed for -c and for
 311          * locking (which uses system(3)).
 312          *
 313          * "tty" is needed to restore termios(4) and also for some reason -CC
 314          * does not work properly without it (input is not recognised).
 315          *
 316          * "sendfd" is dropped later in client_dispatch_wait().
 317          */
 318         if (pledge(
 319             "stdio rpath wpath cpath unix sendfd proc exec tty",
 320             NULL) != 0)
 321                 fatal("pledge failed");
 322
 323         /* Load terminfo entry if any. */
 324         if (isatty(STDIN_FILENO) &&
 325             *termname != '\0' &&
 326             tty_term_read_list(termname, STDIN_FILENO, &caps, &ncaps,
 327             &cause) != 0) {
 328                 fprintf(stderr, "%s\n", cause);
 329                 free(cause);
 330                 return (1);
 331         }
 332
 333         /* Free stuff that is not used in the client. */
 334         if (ptm_fd != -1)
 335                 close(ptm_fd);
 336         options_free(global_options);
 337         options_free(global_s_options);
 338         options_free(global_w_options);
 339         environ_free(global_environ);
 340
 341         /* Set up control mode. */
 342         if (client_flags & CLIENT_CONTROLCONTROL) {
 343                 if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
 344                         fprintf(stderr, "tcgetattr failed: %s\n",
 345                             strerror(errno));
 346                         return (1);
 347                 }
 348                 cfmakeraw(&tio);
 349                 tio.c_iflag = ICRNL|IXANY;
 350                 tio.c_oflag = OPOST|ONLCR;
 351                 tio.c_lflag = NOKERNINFO;
 352                 tio.c_cflag = CREAD|CS8|HUPCL;
 353                 tio.c_cc[VMIN] = 1;
 354                 tio.c_cc[VTIME] = 0;
 355                 cfsetispeed(&tio, cfgetispeed(&saved_tio));
 356                 cfsetospeed(&tio, cfgetospeed(&saved_tio));
 357                 tcsetattr(STDIN_FILENO, TCSANOW, &tio);
 358         }
 359
 360         /* Send identify messages. */
 361         client_send_identify(ttynam, termname, caps, ncaps, cwd, feat);
 362         tty_term_free_list(caps, ncaps);
 363
 364         /* Send first command. */
 365         if (msg == MSG_COMMAND) {
 366                 /* How big is the command? */
 367                 size = 0;
 368                 for (i = 0; i < argc; i++)
 369                         size += strlen(argv[i]) + 1;
 370                 if (size > MAX_IMSGSIZE - (sizeof *data)) {
 371                         fprintf(stderr, "command too long\n");
 372                         return (1);
 373                 }
 374                 data = xmalloc((sizeof *data) + size);
 375
 376                 /* Prepare command for server. */
 377                 data->argc = argc;
 378                 if (cmd_pack_argv(argc, argv, (char *)(data + 1), size) != 0) {
 379                         fprintf(stderr, "command too long\n");
 380                         free(data);
 381                         return (1);
 382                 }
 383                 size += sizeof *data;
 384
 385                 /* Send the command. */
 386                 if (proc_send(client_peer, msg, -1, data, size) != 0) {
 387                         fprintf(stderr, "failed to send command\n");
 388                         free(data);
 389                         return (1);
 390                 }
 391                 free(data);
 392         } else if (msg == MSG_SHELL)
 393                 proc_send(client_peer, msg, -1, NULL, 0);
 394
 395         /* Start main loop. */
 396         proc_loop(client_proc, NULL);
 397
 398         /* Run command if user requested exec, instead of exiting. */
 399         if (client_exittype == MSG_EXEC) {
 400                 if (client_flags & CLIENT_CONTROLCONTROL)
 401                         tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 402                 client_exec(client_execshell, client_execcmd);
 403         }
 404
 405         /* Restore streams to blocking. */
 406         setblocking(STDIN_FILENO, 1);
 407         setblocking(STDOUT_FILENO, 1);
 408         setblocking(STDERR_FILENO, 1);
 409
 410         /* Print the exit message, if any, and exit. */
 411         if (client_attached) {
 412                 if (client_exitreason != CLIENT_EXIT_NONE)
 413                         printf("[%s]\n", client_exit_message());
 414
 415                 ppid = getppid();
 416                 if (client_exittype == MSG_DETACHKILL && ppid > 1)
 417                         kill(ppid, SIGHUP);
 418         } else if (client_flags & CLIENT_CONTROL) {
 419                 if (client_exitreason != CLIENT_EXIT_NONE)
 420                         printf("%%exit %s\n", client_exit_message());
 421                 else
 422                         printf("%%exit\n");
 423                 fflush(stdout);
 424                 if (client_flags & CLIENT_CONTROL_WAITEXIT) {
 425                         setvbuf(stdin, NULL, _IOLBF, 0);
 426                         for (;;) {
 427                                 linelen = getline(&line, &linesize, stdin);
 428                                 if (linelen <= 1)
 429                                         break;
 430                         }
 431                         free(line);
 432                 }
 433                 if (client_flags & CLIENT_CONTROLCONTROL) {
 434                         printf("\033\\");
 435                         fflush(stdout);
 436                         tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 437                 }
 438         } else if (client_exitreason != CLIENT_EXIT_NONE)
 439                 fprintf(stderr, "%s\n", client_exit_message());
 440         return (client_exitval);
 441 }
 442
 443 /* Send identify messages to server. */
 444 static void
 445 client_send_identify(const char *ttynam, const char *termname, char **caps,
 446     u_int ncaps, const char *cwd, int feat)
 447 {
 448         char    **ss;
 449         size_t    sslen;
 450         int       fd, flags = client_flags;
 451         pid_t     pid;
 452         u_int     i;
 453
 454         proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
 455         proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
 456             sizeof client_flags);
 457
 458         proc_send(client_peer, MSG_IDENTIFY_TERM, -1, termname,
 459             strlen(termname) + 1);
 460         proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);
 461
 462         proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
 463             strlen(ttynam) + 1);
 464         proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);
 465
 466         for (i = 0; i < ncaps; i++) {
 467                 proc_send(client_peer, MSG_IDENTIFY_TERMINFO, -1,
 468                     caps[i], strlen(caps[i]) + 1);
 469         }
 470
 471         if ((fd = dup(STDIN_FILENO)) == -1)
 472                 fatal("dup failed");
 473         proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
 474         if ((fd = dup(STDOUT_FILENO)) == -1)
 475                 fatal("dup failed");
 476         proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);
 477
 478         pid = getpid();
 479         proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);
 480
 481         for (ss = environ; *ss != NULL; ss++) {
 482                 sslen = strlen(*ss) + 1;
 483                 if (sslen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
 484                         continue;
 485                 proc_send(client_peer, MSG_IDENTIFY_ENVIRON, -1, *ss, sslen);
 486         }
 487
 488         proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
 489 }
 490
 491 /* Run command in shell; used for -c. */
 492 static __dead void
 493 client_exec(const char *shell, const char *shellcmd)
 494 {
 495         const char      *name, *ptr;
 496         char            *argv0;
 497
 498         log_debug("shell %s, command %s", shell, shellcmd);
 499
 500         ptr = strrchr(shell, '/');
 501         if (ptr != NULL && *(ptr + 1) != '\0')
 502                 name = ptr + 1;
 503         else
 504                 name = shell;
 505         if (client_flags & CLIENT_LOGIN)
 506                 xasprintf(&argv0, "-%s", name);
 507         else
 508                 xasprintf(&argv0, "%s", name);
 509         setenv("SHELL", shell, 1);
 510
 511         proc_clear_signals(client_proc, 1);
 512
 513         setblocking(STDIN_FILENO, 1);
 514         setblocking(STDOUT_FILENO, 1);
 515         setblocking(STDERR_FILENO, 1);
 516         closefrom(STDERR_FILENO + 1);
 517
 518         execl(shell, argv0, "-c", shellcmd, (char *) NULL);
 519         fatal("execl failed");
 520 }
 521
 522 /* Callback to handle signals in the client. */
 523 static void
 524 client_signal(int sig)
 525 {
 526         struct sigaction sigact;
 527         int              status;
 528
 529         log_debug("%s: %s", __func__, strsignal(sig));
 530         if (sig == SIGCHLD)
 531                 waitpid(WAIT_ANY, &status, WNOHANG);
 532         else if (!client_attached) {
 533                 if (sig == SIGTERM)
 534                         proc_exit(client_proc);
 535         } else {
 536                 switch (sig) {
 537                 case SIGHUP:
 538                         client_exitreason = CLIENT_EXIT_LOST_TTY;
 539                         client_exitval = 1;
 540                         proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 541                         break;
 542                 case SIGTERM:
 543                         if (!client_suspended)
 544                                 client_exitreason = CLIENT_EXIT_TERMINATED;
 545                         client_exitval = 1;
 546                         proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 547                         break;
 548                 case SIGWINCH:
 549                         proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
 550                         break;
 551                 case SIGCONT:
 552                         memset(&sigact, 0, sizeof sigact);
 553                         sigemptyset(&sigact.sa_mask);
 554                         sigact.sa_flags = SA_RESTART;
 555                         sigact.sa_handler = SIG_IGN;
 556                         if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 557                                 fatal("sigaction failed");
 558                         proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
 559                         client_suspended = 0;
 560                         break;
 561                 }
 562         }
 563 }
 564
 565 /* Callback for file write error or close. */
 566 static void
 567 client_file_check_cb(__unused struct client *c, __unused const char *path,
 568     __unused int error, __unused int closed, __unused struct evbuffer *buffer,
 569     __unused void *data)
 570 {
 571         if (client_exitflag)
 572                 client_exit();
 573 }
 574
 575 /* Callback for client read events. */
 576 static void
 577 client_dispatch(struct imsg *imsg, __unused void *arg)
 578 {
 579         if (imsg == NULL) {
 580                 if (!client_exitflag) {
 581                         client_exitreason = CLIENT_EXIT_LOST_SERVER;
 582                         client_exitval = 1;
 583                 }
 584                 proc_exit(client_proc);
 585                 return;
 586         }
 587
 588         if (client_attached)
 589                 client_dispatch_attached(imsg);
 590         else
 591                 client_dispatch_wait(imsg);
 592 }
 593
 594 /* Process an exit message. */
 595 static void
 596 client_dispatch_exit_message(char *data, size_t datalen)
 597 {
 598         int     retval;
 599
 600         if (datalen < sizeof retval && datalen != 0)
 601                 fatalx("bad MSG_EXIT size");
 602
 603         if (datalen >= sizeof retval) {
 604                 memcpy(&retval, data, sizeof retval);
 605                 client_exitval = retval;
 606         }
 607
 608         if (datalen > sizeof retval) {
 609                 datalen -= sizeof retval;
 610                 data += sizeof retval;
 611
 612                 client_exitmessage = xmalloc(datalen);
 613                 memcpy(client_exitmessage, data, datalen);
 614                 client_exitmessage[datalen - 1] = '\0';
 615
 616                 client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
 617         }
 618 }
 619
 620 /* Dispatch imsgs when in wait state (before MSG_READY). */
 621 static void
 622 client_dispatch_wait(struct imsg *imsg)
 623 {
 624         char            *data;
 625         ssize_t          datalen;
 626         static int       pledge_applied;
 627
 628         /*
 629          * "sendfd" is no longer required once all of the identify messages
 630          * have been sent. We know the server won't send us anything until that
 631          * point (because we don't ask it to), so we can drop "sendfd" once we
 632          * get the first message from the server.
 633          */
 634         if (!pledge_applied) {
 635                 if (pledge(
 636                     "stdio rpath wpath cpath unix proc exec tty",
 637                     NULL) != 0)
 638                         fatal("pledge failed");
 639                 pledge_applied = 1;
 640         }
 641
 642         data = imsg->data;
 643         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 644
 645         switch (imsg->hdr.type) {
 646         case MSG_EXIT:
 647         case MSG_SHUTDOWN:
 648                 client_dispatch_exit_message(data, datalen);
 649                 client_exitflag = 1;
 650                 client_exit();
 651                 break;
 652         case MSG_READY:
 653                 if (datalen != 0)
 654                         fatalx("bad MSG_READY size");
 655
 656                 client_attached = 1;
 657                 proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
 658                 break;
 659         case MSG_VERSION:
 660                 if (datalen != 0)
 661                         fatalx("bad MSG_VERSION size");
 662
 663                 fprintf(stderr, "protocol version mismatch "
 664                     "(client %d, server %u)\n", PROTOCOL_VERSION,
 665                     imsg->hdr.peerid & 0xff);
 666                 client_exitval = 1;
 667                 proc_exit(client_proc);
 668                 break;
 669         case MSG_FLAGS:
 670                 if (datalen != sizeof client_flags)
 671                         fatalx("bad MSG_FLAGS string");
 672
 673                 memcpy(&client_flags, data, sizeof client_flags);
 674                 log_debug("new flags are %#llx",
 675                     (unsigned long long)client_flags);
 676                 break;
 677         case MSG_SHELL:
 678                 if (datalen == 0 || data[datalen - 1] != '\0')
 679                         fatalx("bad MSG_SHELL string");
 680
 681                 client_exec(data, shell_command);
 682                 /* NOTREACHED */
 683         case MSG_DETACH:
 684         case MSG_DETACHKILL:
 685                 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 686                 break;
 687         case MSG_EXITED:
 688                 proc_exit(client_proc);
 689                 break;
 690         case MSG_READ_OPEN:
 691                 file_read_open(&client_files, client_peer, imsg, 1,
 692                     !(client_flags & CLIENT_CONTROL), client_file_check_cb,
 693                     NULL);
 694                 break;
 695         case MSG_WRITE_OPEN:
 696                 file_write_open(&client_files, client_peer, imsg, 1,
 697                     !(client_flags & CLIENT_CONTROL), client_file_check_cb,
 698                     NULL);
 699                 break;
 700         case MSG_WRITE:
 701                 file_write_data(&client_files, imsg);
 702                 break;
 703         case MSG_WRITE_CLOSE:
 704                 file_write_close(&client_files, imsg);
 705                 break;
 706         case MSG_OLDSTDERR:
 707         case MSG_OLDSTDIN:
 708         case MSG_OLDSTDOUT:
 709                 fprintf(stderr, "server version is too old for client\n");
 710                 proc_exit(client_proc);
 711                 break;
 712         }
 713 }
 714
 715 /* Dispatch imsgs in attached state (after MSG_READY). */
 716 static void
 717 client_dispatch_attached(struct imsg *imsg)
 718 {
 719         struct sigaction         sigact;
 720         char                    *data;
 721         ssize_t                  datalen;
 722
 723         data = imsg->data;
 724         datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
 725
 726         switch (imsg->hdr.type) {
 727         case MSG_FLAGS:
 728                 if (datalen != sizeof client_flags)
 729                         fatalx("bad MSG_FLAGS string");
 730
 731                 memcpy(&client_flags, data, sizeof client_flags);
 732                 log_debug("new flags are %#llx",
 733                     (unsigned long long)client_flags);
 734                 break;
 735         case MSG_DETACH:
 736         case MSG_DETACHKILL:
 737                 if (datalen == 0 || data[datalen - 1] != '\0')
 738                         fatalx("bad MSG_DETACH string");
 739
 740                 client_exitsession = xstrdup(data);
 741                 client_exittype = imsg->hdr.type;
 742                 if (imsg->hdr.type == MSG_DETACHKILL)
 743                         client_exitreason = CLIENT_EXIT_DETACHED_HUP;
 744                 else
 745                         client_exitreason = CLIENT_EXIT_DETACHED;
 746                 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 747                 break;
 748         case MSG_EXEC:
 749                 if (datalen == 0 || data[datalen - 1] != '\0' ||
 750                     strlen(data) + 1 == (size_t)datalen)
 751                         fatalx("bad MSG_EXEC string");
 752                 client_execcmd = xstrdup(data);
 753                 client_execshell = xstrdup(data + strlen(data) + 1);
 754
 755                 client_exittype = imsg->hdr.type;
 756                 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 757                 break;
 758         case MSG_EXIT:
 759                 client_dispatch_exit_message(data, datalen);
 760                 if (client_exitreason == CLIENT_EXIT_NONE)
 761                         client_exitreason = CLIENT_EXIT_EXITED;
 762                 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 763                 break;
 764         case MSG_EXITED:
 765                 if (datalen != 0)
 766                         fatalx("bad MSG_EXITED size");
 767
 768                 proc_exit(client_proc);
 769                 break;
 770         case MSG_SHUTDOWN:
 771                 if (datalen != 0)
 772                         fatalx("bad MSG_SHUTDOWN size");
 773
 774                 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
 775                 client_exitreason = CLIENT_EXIT_SERVER_EXITED;
 776                 client_exitval = 1;
 777                 break;
 778         case MSG_SUSPEND:
 779                 if (datalen != 0)
 780                         fatalx("bad MSG_SUSPEND size");
 781
 782                 memset(&sigact, 0, sizeof sigact);
 783                 sigemptyset(&sigact.sa_mask);
 784                 sigact.sa_flags = SA_RESTART;
 785                 sigact.sa_handler = SIG_DFL;
 786                 if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 787                         fatal("sigaction failed");
 788                 client_suspended = 1;
 789                 kill(getpid(), SIGTSTP);
 790                 break;
 791         case MSG_LOCK:
 792                 if (datalen == 0 || data[datalen - 1] != '\0')
 793                         fatalx("bad MSG_LOCK string");
 794
 795                 system(data);
 796                 proc_send(client_peer, MSG_UNLOCK, -1, NULL, 0);
 797                 break;
 798         }
 799 }