client.c

   1 /* $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
   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/file.h>
  21 #include <sys/socket.h>
  22 #include <sys/stat.h>
  23 #include <sys/un.h>
  24 #include <sys/wait.h>
  25
  26 #include <errno.h>
  27 #include <event.h>
  28 #include <fcntl.h>
  29 #include <pwd.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <unistd.h>
  33
  34 #include "tmux.h"
  35
  36 struct imsgbuf  client_ibuf;
  37 struct event    client_event;
  38 struct event    client_stdin;
  39 enum {
  40         CLIENT_EXIT_NONE,
  41         CLIENT_EXIT_DETACHED,
  42         CLIENT_EXIT_DETACHED_HUP,
  43         CLIENT_EXIT_LOST_TTY,
  44         CLIENT_EXIT_TERMINATED,
  45         CLIENT_EXIT_LOST_SERVER,
  46         CLIENT_EXIT_EXITED,
  47         CLIENT_EXIT_SERVER_EXITED,
  48 } client_exitreason = CLIENT_EXIT_NONE;
  49 int             client_exitval;
  50 enum msgtype    client_exittype;
  51 const char     *client_exitsession;
  52 int             client_attached;
  53
  54 int             client_get_lock(char *);
  55 int             client_connect(char *, int);
  56 void            client_send_identify(int);
  57 int             client_write_one(enum msgtype, int, const void *, size_t);
  58 int             client_write_server(enum msgtype, const void *, size_t);
  59 void            client_update_event(void);
  60 void            client_signal(int, short, void *);
  61 void            client_stdin_callback(int, short, void *);
  62 void            client_write(int, const char *, size_t);
  63 void            client_callback(int, short, void *);
  64 int             client_dispatch_attached(void);
  65 int             client_dispatch_wait(void *);
  66 const char     *client_exit_message(void);
  67
  68 /*
  69  * Get server create lock. If already held then server start is happening in
  70  * another client, so block until the lock is released and return -1 to
  71  * retry. Ignore other errors - just continue and start the server without the
  72  * lock.
  73  */
  74 int
  75 client_get_lock(char *lockfile)
  76 {
  77         int lockfd;
  78
  79         if ((lockfd = open(lockfile, O_WRONLY|O_CREAT, 0600)) == -1)
  80                 fatal("open failed");
  81
  82         if (lockf(lockfd, F_TLOCK, 0) == -1 && errno == EAGAIN) {
  83                 while (lockf(lockfd, F_LOCK, 0) == -1 && errno == EINTR)
  84                         /* nothing */;
  85                 close(lockfd);
  86                 return (-1);
  87         }
  88
  89         return (lockfd);
  90 }
  91
  92 /* Connect client to server. */
  93 int
  94 client_connect(char *path, int start_server)
  95 {
  96         struct sockaddr_un      sa;
  97         size_t                  size;
  98         int                     fd, lockfd;
  99         char                   *lockfile;
 100
 101         memset(&sa, 0, sizeof sa);
 102         sa.sun_family = AF_UNIX;
 103         size = strlcpy(sa.sun_path, path, sizeof sa.sun_path);
 104         if (size >= sizeof sa.sun_path) {
 105                 errno = ENAMETOOLONG;
 106                 return (-1);
 107         }
 108
 109 retry:
 110         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
 111                 fatal("socket failed");
 112
 113         if (connect(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == -1) {
 114                 if (errno != ECONNREFUSED && errno != ENOENT)
 115                         goto failed;
 116                 if (!start_server)
 117                         goto failed;
 118                 close(fd);
 119
 120                 xasprintf(&lockfile, "%s.lock", path);
 121                 if ((lockfd = client_get_lock(lockfile)) == -1)
 122                         goto retry;
 123                 if (unlink(path) != 0 && errno != ENOENT)
 124                         return (-1);
 125                 fd = server_start(lockfd, lockfile);
 126                 free(lockfile);
 127                 close(lockfd);
 128         }
 129
 130         setblocking(fd, 0);
 131         return (fd);
 132
 133 failed:
 134         close(fd);
 135         return (-1);
 136 }
 137
 138 /* Get exit string from reason number. */
 139 const char *
 140 client_exit_message(void)
 141 {
 142         static char msg[256];
 143
 144         switch (client_exitreason) {
 145         case CLIENT_EXIT_NONE:
 146                 break;
 147         case CLIENT_EXIT_DETACHED:
 148                 if (client_exitsession != NULL) {
 149                         xsnprintf(msg, sizeof msg, "detached "
 150                             "(from session %s)", client_exitsession);
 151                         return (msg);
 152                 }
 153                 return ("detached");
 154         case CLIENT_EXIT_DETACHED_HUP:
 155                 if (client_exitsession != NULL) {
 156                         xsnprintf(msg, sizeof msg, "detached and SIGHUP "
 157                             "(from session %s)", client_exitsession);
 158                         return (msg);
 159                 }
 160                 return ("detached and SIGHUP");
 161         case CLIENT_EXIT_LOST_TTY:
 162                 return ("lost tty");
 163         case CLIENT_EXIT_TERMINATED:
 164                 return ("terminated");
 165         case CLIENT_EXIT_LOST_SERVER:
 166                 return ("lost server");
 167         case CLIENT_EXIT_EXITED:
 168                 return ("exited");
 169         case CLIENT_EXIT_SERVER_EXITED:
 170                 return ("server exited");
 171         }
 172         return ("unknown reason");
 173 }
 174
 175 /* Client main loop. */
 176 int
 177 client_main(int argc, char **argv, int flags)
 178 {
 179         struct cmd              *cmd;
 180         struct cmd_list         *cmdlist;
 181         struct msg_command_data *data;
 182         int                      cmdflags, fd, i;
 183         pid_t                    ppid;
 184         enum msgtype             msg;
 185         char                    *cause;
 186         struct termios           tio, saved_tio;
 187         size_t                   size;
 188
 189         /* Set up the initial command. */
 190         cmdflags = 0;
 191         if (shell_cmd != NULL) {
 192                 msg = MSG_SHELL;
 193                 cmdflags = CMD_STARTSERVER;
 194         } else if (argc == 0) {
 195                 msg = MSG_COMMAND;
 196                 cmdflags = CMD_STARTSERVER|CMD_CANTNEST;
 197         } else {
 198                 msg = MSG_COMMAND;
 199
 200                 /*
 201                  * It sucks parsing the command string twice (in client and
 202                  * later in server) but it is necessary to get the start server
 203                  * flag.
 204                  */
 205                 cmdlist = cmd_list_parse(argc, argv, NULL, 0, &cause);
 206                 if (cmdlist == NULL) {
 207                         fprintf(stderr, "%s\n", cause);
 208                         return (1);
 209                 }
 210                 cmdflags &= ~CMD_STARTSERVER;
 211                 TAILQ_FOREACH(cmd, &cmdlist->list, qentry) {
 212                         if (cmd->entry->flags & CMD_STARTSERVER)
 213                                 cmdflags |= CMD_STARTSERVER;
 214                         if (cmd->entry->flags & CMD_CANTNEST)
 215                                 cmdflags |= CMD_CANTNEST;
 216                 }
 217                 cmd_list_free(cmdlist);
 218         }
 219
 220         /*
 221          * Check if this could be a nested session, if the command can't nest:
 222          * if the socket path matches $TMUX, this is probably the same server.
 223          */
 224         if (shell_cmd == NULL && environ_path != NULL &&
 225             (cmdflags & CMD_CANTNEST) &&
 226             strcmp(socket_path, environ_path) == 0) {
 227                 fprintf(stderr, "sessions should be nested with care, "
 228                     "unset $TMUX to force\n");
 229                 return (1);
 230         }
 231
 232         /* Initialise the client socket and start the server. */
 233         fd = client_connect(socket_path, cmdflags & CMD_STARTSERVER);
 234         if (fd == -1) {
 235                 fprintf(stderr, "failed to connect to server\n");
 236                 return (1);
 237         }
 238
 239         /* Set process title, log and signals now this is the client. */
 240         setproctitle("client (%s)", socket_path);
 241         logfile("client");
 242
 243         /* Create imsg. */
 244         imsg_init(&client_ibuf, fd);
 245         event_set(&client_event, fd, EV_READ, client_callback, shell_cmd);
 246
 247         /* Create stdin handler. */
 248         setblocking(STDIN_FILENO, 0);
 249         event_set(&client_stdin, STDIN_FILENO, EV_READ|EV_PERSIST,
 250             client_stdin_callback, NULL);
 251         if (flags & CLIENT_CONTROLCONTROL) {
 252                 if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
 253                         fprintf(stderr, "tcgetattr failed: %s\n",
 254                             strerror(errno));
 255                         return (1);
 256                 }
 257                 cfmakeraw(&tio);
 258                 tio.c_iflag = ICRNL|IXANY;
 259                 tio.c_oflag = OPOST|ONLCR;
 260                 tio.c_lflag = NOKERNINFO;
 261                 tio.c_cflag = CREAD|CS8|HUPCL;
 262                 tio.c_cc[VMIN] = 1;
 263                 tio.c_cc[VTIME] = 0;
 264                 cfsetispeed(&tio, cfgetispeed(&saved_tio));
 265                 cfsetospeed(&tio, cfgetospeed(&saved_tio));
 266                 tcsetattr(STDIN_FILENO, TCSANOW, &tio);
 267         }
 268
 269         /* Establish signal handlers. */
 270         set_signals(client_signal);
 271
 272         /* Send identify messages. */
 273         client_send_identify(flags);
 274
 275         /* Send first command. */
 276         if (msg == MSG_COMMAND) {
 277                 /* How big is the command? */
 278                 size = 0;
 279                 for (i = 0; i < argc; i++)
 280                         size += strlen(argv[i]) + 1;
 281                 data = xmalloc((sizeof *data) + size);
 282
 283                 /* Prepare command for server. */
 284                 data->argc = argc;
 285                 if (cmd_pack_argv(argc, argv, (char*)(data + 1), size) != 0) {
 286                         fprintf(stderr, "command too long\n");
 287                         free(data);
 288                         return (1);
 289                 }
 290                 size += sizeof *data;
 291
 292                 /* Send the command. */
 293                 if (client_write_server(msg, data, size) != 0) {
 294                         fprintf(stderr, "failed to send command\n");
 295                         free(data);
 296                         return (1);
 297                 }
 298                 free(data);
 299         } else if (msg == MSG_SHELL)
 300                 client_write_server(msg, NULL, 0);
 301
 302         /* Set the event and dispatch. */
 303         client_update_event();
 304         event_dispatch();
 305
 306         /* Print the exit message, if any, and exit. */
 307         if (client_attached) {
 308                 if (client_exitreason != CLIENT_EXIT_NONE && !login_shell)
 309                         printf("[%s]\n", client_exit_message());
 310
 311                 ppid = getppid();
 312                 if (client_exittype == MSG_DETACHKILL && ppid > 1)
 313                         kill(ppid, SIGHUP);
 314         } else if (flags & CLIENT_CONTROLCONTROL) {
 315                 if (client_exitreason != CLIENT_EXIT_NONE)
 316                         printf("%%exit %s\n", client_exit_message());
 317                 else
 318                         printf("%%exit\n");
 319                 printf("\033\\");
 320                 tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 321         }
 322         setblocking(STDIN_FILENO, 1);
 323         return (client_exitval);
 324 }
 325
 326 /* Send identify messages to server. */
 327 void
 328 client_send_identify(int flags)
 329 {
 330         const char      *s;
 331         char            **ss;
 332         int              fd;
 333
 334         client_write_one(MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
 335
 336         if ((s = getenv("TERM")) == NULL)
 337                 s = "";
 338         client_write_one(MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
 339
 340         if ((s = ttyname(STDIN_FILENO)) == NULL)
 341                 s = "";
 342         client_write_one(MSG_IDENTIFY_TTYNAME, -1, s, strlen(s) + 1);
 343
 344         if ((fd = open(".", O_RDONLY)) == -1)
 345                 fd = open("/", O_RDONLY);
 346         client_write_one(MSG_IDENTIFY_CWD, fd, NULL, 0);
 347
 348         if ((fd = dup(STDIN_FILENO)) == -1)
 349                 fatal("dup failed");
 350         client_write_one(MSG_IDENTIFY_STDIN, fd, NULL, 0);
 351
 352         for (ss = environ; *ss != NULL; ss++)
 353                 client_write_one(MSG_IDENTIFY_ENVIRON, -1, *ss, strlen(*ss) + 1);
 354
 355         client_write_one(MSG_IDENTIFY_DONE, -1, NULL, 0);
 356
 357         client_update_event();
 358 }
 359
 360 /* Helper to send one message. */
 361 int
 362 client_write_one(enum msgtype type, int fd, const void *buf, size_t len)
 363 {
 364         int     retval;
 365
 366         retval = imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, fd,
 367             (void*)buf, len);
 368         if (retval != 1)
 369                 return (-1);
 370         return (0);
 371 }
 372
 373 /* Write a message to the server without a file descriptor. */
 374 int
 375 client_write_server(enum msgtype type, const void *buf, size_t len)
 376 {
 377         int     retval;
 378
 379         retval = client_write_one(type, -1, buf, len);
 380         if (retval == 0)
 381                 client_update_event();
 382         return (retval);
 383 }
 384
 385 /* Update client event based on whether it needs to read or read and write. */
 386 void
 387 client_update_event(void)
 388 {
 389         short   events;
 390
 391         event_del(&client_event);
 392         events = EV_READ;
 393         if (client_ibuf.w.queued > 0)
 394                 events |= EV_WRITE;
 395         event_set(
 396             &client_event, client_ibuf.fd, events, client_callback, shell_cmd);
 397         event_add(&client_event, NULL);
 398 }
 399
 400 /* Callback to handle signals in the client. */
 401 void
 402 client_signal(int sig, unused short events, unused void *data)
 403 {
 404         struct sigaction sigact;
 405         int              status;
 406
 407         if (!client_attached) {
 408                 switch (sig) {
 409                 case SIGCHLD:
 410                         waitpid(WAIT_ANY, &status, WNOHANG);
 411                         break;
 412                 case SIGTERM:
 413                         event_loopexit(NULL);
 414                         break;
 415                 }
 416         } else {
 417                 switch (sig) {
 418                 case SIGHUP:
 419                         client_exitreason = CLIENT_EXIT_LOST_TTY;
 420                         client_exitval = 1;
 421                         client_write_server(MSG_EXITING, NULL, 0);
 422                         break;
 423                 case SIGTERM:
 424                         client_exitreason = CLIENT_EXIT_TERMINATED;
 425                         client_exitval = 1;
 426                         client_write_server(MSG_EXITING, NULL, 0);
 427                         break;
 428                 case SIGWINCH:
 429                         client_write_server(MSG_RESIZE, NULL, 0);
 430                         break;
 431                 case SIGCONT:
 432                         memset(&sigact, 0, sizeof sigact);
 433                         sigemptyset(&sigact.sa_mask);
 434                         sigact.sa_flags = SA_RESTART;
 435                         sigact.sa_handler = SIG_IGN;
 436                         if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 437                                 fatal("sigaction failed");
 438                         client_write_server(MSG_WAKEUP, NULL, 0);
 439                         break;
 440                 }
 441         }
 442
 443         client_update_event();
 444 }
 445
 446 /* Callback for client imsg read events. */
 447 void
 448 client_callback(unused int fd, short events, void *data)
 449 {
 450         ssize_t n;
 451         int     retval;
 452
 453         if (events & EV_READ) {
 454                 if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
 455                         goto lost_server;
 456                 if (client_attached)
 457                         retval = client_dispatch_attached();
 458                 else
 459                         retval = client_dispatch_wait(data);
 460                 if (retval != 0) {
 461                         event_loopexit(NULL);
 462                         return;
 463                 }
 464         }
 465
 466         if (events & EV_WRITE) {
 467                 if (msgbuf_write(&client_ibuf.w) < 0 && errno != EAGAIN)
 468                         goto lost_server;
 469         }
 470
 471         client_update_event();
 472         return;
 473
 474 lost_server:
 475         client_exitreason = CLIENT_EXIT_LOST_SERVER;
 476         client_exitval = 1;
 477         event_loopexit(NULL);
 478 }
 479
 480 /* Callback for client stdin read events. */
 481 void
 482 client_stdin_callback(unused int fd, unused short events, unused void *data1)
 483 {
 484         struct msg_stdin_data   data;
 485
 486         data.size = read(STDIN_FILENO, data.data, sizeof data.data);
 487         if (data.size < 0 && (errno == EINTR || errno == EAGAIN))
 488                 return;
 489
 490         client_write_server(MSG_STDIN, &data, sizeof data);
 491         if (data.size <= 0)
 492                 event_del(&client_stdin);
 493         client_update_event();
 494 }
 495
 496 /* Force write to file descriptor. */
 497 void
 498 client_write(int fd, const char *data, size_t size)
 499 {
 500         ssize_t used;
 501
 502         while (size != 0) {
 503                 used = write(fd, data, size);
 504                 if (used == -1) {
 505                         if (errno == EINTR || errno == EAGAIN)
 506                                 continue;
 507                         break;
 508                 }
 509                 data += used;
 510                 size -= used;
 511         }
 512 }
 513
 514 /* Dispatch imsgs when in wait state (before MSG_READY). */
 515 int
 516 client_dispatch_wait(void *data0)
 517 {
 518         struct imsg              imsg;
 519         char                    *data;
 520         ssize_t                  n, datalen;
 521         struct msg_stdout_data   stdoutdata;
 522         struct msg_stderr_data   stderrdata;
 523         int                      retval;
 524
 525         for (;;) {
 526                 if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
 527                         fatalx("imsg_get failed");
 528                 if (n == 0)
 529                         return (0);
 530
 531                 data = imsg.data;
 532                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 533
 534                 log_debug("got %d from server", imsg.hdr.type);
 535                 switch (imsg.hdr.type) {
 536                 case MSG_EXIT:
 537                 case MSG_SHUTDOWN:
 538                         if (datalen != sizeof retval && datalen != 0)
 539                                 fatalx("bad MSG_EXIT size");
 540                         if (datalen == sizeof retval) {
 541                                 memcpy(&retval, data, sizeof retval);
 542                                 client_exitval = retval;
 543                         }
 544                         imsg_free(&imsg);
 545                         return (-1);
 546                 case MSG_READY:
 547                         if (datalen != 0)
 548                                 fatalx("bad MSG_READY size");
 549
 550                         event_del(&client_stdin);
 551                         client_attached = 1;
 552                         client_write_server(MSG_RESIZE, NULL, 0);
 553                         break;
 554                 case MSG_STDIN:
 555                         if (datalen != 0)
 556                                 fatalx("bad MSG_STDIN size");
 557
 558                         event_add(&client_stdin, NULL);
 559                         break;
 560                 case MSG_STDOUT:
 561                         if (datalen != sizeof stdoutdata)
 562                                 fatalx("bad MSG_STDOUT size");
 563                         memcpy(&stdoutdata, data, sizeof stdoutdata);
 564
 565                         client_write(STDOUT_FILENO, stdoutdata.data,
 566                             stdoutdata.size);
 567                         break;
 568                 case MSG_STDERR:
 569                         if (datalen != sizeof stderrdata)
 570                                 fatalx("bad MSG_STDERR size");
 571                         memcpy(&stderrdata, data, sizeof stderrdata);
 572
 573                         client_write(STDERR_FILENO, stderrdata.data,
 574                             stderrdata.size);
 575                         break;
 576                 case MSG_VERSION:
 577                         if (datalen != 0)
 578                                 fatalx("bad MSG_VERSION size");
 579
 580                         fprintf(stderr, "protocol version mismatch "
 581                             "(client %u, server %u)\n", PROTOCOL_VERSION,
 582                             imsg.hdr.peerid);
 583                         client_exitval = 1;
 584
 585                         imsg_free(&imsg);
 586                         return (-1);
 587                 case MSG_SHELL:
 588                         if (datalen == 0 || data[datalen - 1] != '\0')
 589                                 fatalx("bad MSG_SHELL string");
 590
 591                         clear_signals(0);
 592                         shell_exec(data, data0);
 593                         /* NOTREACHED */
 594                 case MSG_DETACH:
 595                 case MSG_DETACHKILL:
 596                         client_write_server(MSG_EXITING, NULL, 0);
 597                         break;
 598                 case MSG_EXITED:
 599                         imsg_free(&imsg);
 600                         return (-1);
 601                 }
 602
 603                 imsg_free(&imsg);
 604         }
 605 }
 606
 607 /* Dispatch imsgs in attached state (after MSG_READY). */
 608 int
 609 client_dispatch_attached(void)
 610 {
 611         struct imsg              imsg;
 612         struct sigaction         sigact;
 613         char                    *data;
 614         ssize_t                  n, datalen;
 615
 616         for (;;) {
 617                 if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
 618                         fatalx("imsg_get failed");
 619                 if (n == 0)
 620                         return (0);
 621
 622                 data = imsg.data;
 623                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 624
 625                 log_debug("got %d from server", imsg.hdr.type);
 626                 switch (imsg.hdr.type) {
 627                 case MSG_DETACH:
 628                 case MSG_DETACHKILL:
 629                         if (datalen == 0 || data[datalen - 1] != '\0')
 630                                 fatalx("bad MSG_DETACH string");
 631
 632                         client_exitsession = xstrdup(data);
 633                         client_exittype = imsg.hdr.type;
 634                         if (imsg.hdr.type == MSG_DETACHKILL)
 635                                 client_exitreason = CLIENT_EXIT_DETACHED_HUP;
 636                         else
 637                                 client_exitreason = CLIENT_EXIT_DETACHED;
 638                         client_write_server(MSG_EXITING, NULL, 0);
 639                         break;
 640                 case MSG_EXIT:
 641                         if (datalen != 0 && datalen != sizeof (int))
 642                                 fatalx("bad MSG_EXIT size");
 643
 644                         client_write_server(MSG_EXITING, NULL, 0);
 645                         client_exitreason = CLIENT_EXIT_EXITED;
 646                         break;
 647                 case MSG_EXITED:
 648                         if (datalen != 0)
 649                                 fatalx("bad MSG_EXITED size");
 650
 651                         imsg_free(&imsg);
 652                         return (-1);
 653                 case MSG_SHUTDOWN:
 654                         if (datalen != 0)
 655                                 fatalx("bad MSG_SHUTDOWN size");
 656
 657                         client_write_server(MSG_EXITING, NULL, 0);
 658                         client_exitreason = CLIENT_EXIT_SERVER_EXITED;
 659                         client_exitval = 1;
 660                         break;
 661                 case MSG_SUSPEND:
 662                         if (datalen != 0)
 663                                 fatalx("bad MSG_SUSPEND size");
 664
 665                         memset(&sigact, 0, sizeof sigact);
 666                         sigemptyset(&sigact.sa_mask);
 667                         sigact.sa_flags = SA_RESTART;
 668                         sigact.sa_handler = SIG_DFL;
 669                         if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 670                                 fatal("sigaction failed");
 671                         kill(getpid(), SIGTSTP);
 672                         break;
 673                 case MSG_LOCK:
 674                         if (datalen == 0 || data[datalen - 1] != '\0')
 675                                 fatalx("bad MSG_LOCK string");
 676
 677                         system(data);
 678                         client_write_server(MSG_UNLOCK, NULL, 0);
 679                         break;
 680                 }
 681
 682                 imsg_free(&imsg);
 683         }
 684 }