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: %s\n",
 236                     strerror(errno));
 237                 return (1);
 238         }
 239
 240         /* Set process title, log and signals now this is the client. */
 241         setproctitle("client (%s)", socket_path);
 242         logfile("client");
 243
 244         /* Create imsg. */
 245         imsg_init(&client_ibuf, fd);
 246         event_set(&client_event, fd, EV_READ, client_callback, shell_cmd);
 247
 248         /* Create stdin handler. */
 249         setblocking(STDIN_FILENO, 0);
 250         event_set(&client_stdin, STDIN_FILENO, EV_READ|EV_PERSIST,
 251             client_stdin_callback, NULL);
 252         if (flags & CLIENT_CONTROLCONTROL) {
 253                 if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
 254                         fprintf(stderr, "tcgetattr failed: %s\n",
 255                             strerror(errno));
 256                         return (1);
 257                 }
 258                 cfmakeraw(&tio);
 259                 tio.c_iflag = ICRNL|IXANY;
 260                 tio.c_oflag = OPOST|ONLCR;
 261                 tio.c_lflag = NOKERNINFO;
 262                 tio.c_cflag = CREAD|CS8|HUPCL;
 263                 tio.c_cc[VMIN] = 1;
 264                 tio.c_cc[VTIME] = 0;
 265                 cfsetispeed(&tio, cfgetispeed(&saved_tio));
 266                 cfsetospeed(&tio, cfgetospeed(&saved_tio));
 267                 tcsetattr(STDIN_FILENO, TCSANOW, &tio);
 268         }
 269
 270         /* Establish signal handlers. */
 271         set_signals(client_signal);
 272
 273         /* Send identify messages. */
 274         client_send_identify(flags);
 275
 276         /* Send first command. */
 277         if (msg == MSG_COMMAND) {
 278                 /* How big is the command? */
 279                 size = 0;
 280                 for (i = 0; i < argc; i++)
 281                         size += strlen(argv[i]) + 1;
 282                 data = xmalloc((sizeof *data) + size);
 283
 284                 /* Prepare command for server. */
 285                 data->argc = argc;
 286                 if (cmd_pack_argv(argc, argv, (char*)(data + 1), size) != 0) {
 287                         fprintf(stderr, "command too long\n");
 288                         free(data);
 289                         return (1);
 290                 }
 291                 size += sizeof *data;
 292
 293                 /* Send the command. */
 294                 if (client_write_server(msg, data, size) != 0) {
 295                         fprintf(stderr, "failed to send command\n");
 296                         free(data);
 297                         return (1);
 298                 }
 299                 free(data);
 300         } else if (msg == MSG_SHELL)
 301                 client_write_server(msg, NULL, 0);
 302
 303         /* Set the event and dispatch. */
 304         client_update_event();
 305         event_dispatch();
 306
 307         /* Print the exit message, if any, and exit. */
 308         if (client_attached) {
 309                 if (client_exitreason != CLIENT_EXIT_NONE && !login_shell)
 310                         printf("[%s]\n", client_exit_message());
 311
 312                 ppid = getppid();
 313                 if (client_exittype == MSG_DETACHKILL && ppid > 1)
 314                         kill(ppid, SIGHUP);
 315         } else if (flags & CLIENT_CONTROLCONTROL) {
 316                 if (client_exitreason != CLIENT_EXIT_NONE)
 317                         printf("%%exit %s\n", client_exit_message());
 318                 else
 319                         printf("%%exit\n");
 320                 printf("\033\\");
 321                 tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
 322         }
 323         setblocking(STDIN_FILENO, 1);
 324         return (client_exitval);
 325 }
 326
 327 /* Send identify messages to server. */
 328 void
 329 client_send_identify(int flags)
 330 {
 331         const char      *s;
 332         char            **ss;
 333         int              fd;
 334
 335         client_write_one(MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
 336
 337         if ((s = getenv("TERM")) == NULL)
 338                 s = "";
 339         client_write_one(MSG_IDENTIFY_TERM, -1, s, strlen(s) + 1);
 340
 341         if ((s = ttyname(STDIN_FILENO)) == NULL)
 342                 s = "";
 343         client_write_one(MSG_IDENTIFY_TTYNAME, -1, s, strlen(s) + 1);
 344
 345         if ((fd = open(".", O_RDONLY)) == -1)
 346                 fd = open("/", O_RDONLY);
 347         client_write_one(MSG_IDENTIFY_CWD, fd, NULL, 0);
 348
 349         if ((fd = dup(STDIN_FILENO)) == -1)
 350                 fatal("dup failed");
 351         client_write_one(MSG_IDENTIFY_STDIN, fd, NULL, 0);
 352
 353         for (ss = environ; *ss != NULL; ss++)
 354                 client_write_one(MSG_IDENTIFY_ENVIRON, -1, *ss, strlen(*ss) + 1);
 355
 356         client_write_one(MSG_IDENTIFY_DONE, -1, NULL, 0);
 357
 358         client_update_event();
 359 }
 360
 361 /* Helper to send one message. */
 362 int
 363 client_write_one(enum msgtype type, int fd, const void *buf, size_t len)
 364 {
 365         int     retval;
 366
 367         retval = imsg_compose(&client_ibuf, type, PROTOCOL_VERSION, -1, fd,
 368             (void*)buf, len);
 369         if (retval != 1)
 370                 return (-1);
 371         return (0);
 372 }
 373
 374 /* Write a message to the server without a file descriptor. */
 375 int
 376 client_write_server(enum msgtype type, const void *buf, size_t len)
 377 {
 378         int     retval;
 379
 380         retval = client_write_one(type, -1, buf, len);
 381         if (retval == 0)
 382                 client_update_event();
 383         return (retval);
 384 }
 385
 386 /* Update client event based on whether it needs to read or read and write. */
 387 void
 388 client_update_event(void)
 389 {
 390         short   events;
 391
 392         event_del(&client_event);
 393         events = EV_READ;
 394         if (client_ibuf.w.queued > 0)
 395                 events |= EV_WRITE;
 396         event_set(
 397             &client_event, client_ibuf.fd, events, client_callback, shell_cmd);
 398         event_add(&client_event, NULL);
 399 }
 400
 401 /* Callback to handle signals in the client. */
 402 void
 403 client_signal(int sig, unused short events, unused void *data)
 404 {
 405         struct sigaction sigact;
 406         int              status;
 407
 408         if (!client_attached) {
 409                 switch (sig) {
 410                 case SIGCHLD:
 411                         waitpid(WAIT_ANY, &status, WNOHANG);
 412                         break;
 413                 case SIGTERM:
 414                         event_loopexit(NULL);
 415                         break;
 416                 }
 417         } else {
 418                 switch (sig) {
 419                 case SIGHUP:
 420                         client_exitreason = CLIENT_EXIT_LOST_TTY;
 421                         client_exitval = 1;
 422                         client_write_server(MSG_EXITING, NULL, 0);
 423                         break;
 424                 case SIGTERM:
 425                         client_exitreason = CLIENT_EXIT_TERMINATED;
 426                         client_exitval = 1;
 427                         client_write_server(MSG_EXITING, NULL, 0);
 428                         break;
 429                 case SIGWINCH:
 430                         client_write_server(MSG_RESIZE, NULL, 0);
 431                         break;
 432                 case SIGCONT:
 433                         memset(&sigact, 0, sizeof sigact);
 434                         sigemptyset(&sigact.sa_mask);
 435                         sigact.sa_flags = SA_RESTART;
 436                         sigact.sa_handler = SIG_IGN;
 437                         if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 438                                 fatal("sigaction failed");
 439                         client_write_server(MSG_WAKEUP, NULL, 0);
 440                         break;
 441                 }
 442         }
 443
 444         client_update_event();
 445 }
 446
 447 /* Callback for client imsg read events. */
 448 void
 449 client_callback(unused int fd, short events, void *data)
 450 {
 451         ssize_t n;
 452         int     retval;
 453
 454         if (events & EV_READ) {
 455                 if ((n = imsg_read(&client_ibuf)) == -1 || n == 0)
 456                         goto lost_server;
 457                 if (client_attached)
 458                         retval = client_dispatch_attached();
 459                 else
 460                         retval = client_dispatch_wait(data);
 461                 if (retval != 0) {
 462                         event_loopexit(NULL);
 463                         return;
 464                 }
 465         }
 466
 467         if (events & EV_WRITE) {
 468                 if (msgbuf_write(&client_ibuf.w) < 0 && errno != EAGAIN)
 469                         goto lost_server;
 470         }
 471
 472         client_update_event();
 473         return;
 474
 475 lost_server:
 476         client_exitreason = CLIENT_EXIT_LOST_SERVER;
 477         client_exitval = 1;
 478         event_loopexit(NULL);
 479 }
 480
 481 /* Callback for client stdin read events. */
 482 void
 483 client_stdin_callback(unused int fd, unused short events, unused void *data1)
 484 {
 485         struct msg_stdin_data   data;
 486
 487         data.size = read(STDIN_FILENO, data.data, sizeof data.data);
 488         if (data.size < 0 && (errno == EINTR || errno == EAGAIN))
 489                 return;
 490
 491         client_write_server(MSG_STDIN, &data, sizeof data);
 492         if (data.size <= 0)
 493                 event_del(&client_stdin);
 494         client_update_event();
 495 }
 496
 497 /* Force write to file descriptor. */
 498 void
 499 client_write(int fd, const char *data, size_t size)
 500 {
 501         ssize_t used;
 502
 503         while (size != 0) {
 504                 used = write(fd, data, size);
 505                 if (used == -1) {
 506                         if (errno == EINTR || errno == EAGAIN)
 507                                 continue;
 508                         break;
 509                 }
 510                 data += used;
 511                 size -= used;
 512         }
 513 }
 514
 515 /* Dispatch imsgs when in wait state (before MSG_READY). */
 516 int
 517 client_dispatch_wait(void *data0)
 518 {
 519         struct imsg              imsg;
 520         char                    *data;
 521         ssize_t                  n, datalen;
 522         struct msg_stdout_data   stdoutdata;
 523         struct msg_stderr_data   stderrdata;
 524         int                      retval;
 525
 526         for (;;) {
 527                 if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
 528                         fatalx("imsg_get failed");
 529                 if (n == 0)
 530                         return (0);
 531
 532                 data = imsg.data;
 533                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 534
 535                 log_debug("got %d from server", imsg.hdr.type);
 536                 switch (imsg.hdr.type) {
 537                 case MSG_EXIT:
 538                 case MSG_SHUTDOWN:
 539                         if (datalen != sizeof retval && datalen != 0)
 540                                 fatalx("bad MSG_EXIT size");
 541                         if (datalen == sizeof retval) {
 542                                 memcpy(&retval, data, sizeof retval);
 543                                 client_exitval = retval;
 544                         }
 545                         imsg_free(&imsg);
 546                         return (-1);
 547                 case MSG_READY:
 548                         if (datalen != 0)
 549                                 fatalx("bad MSG_READY size");
 550
 551                         event_del(&client_stdin);
 552                         client_attached = 1;
 553                         client_write_server(MSG_RESIZE, NULL, 0);
 554                         break;
 555                 case MSG_STDIN:
 556                         if (datalen != 0)
 557                                 fatalx("bad MSG_STDIN size");
 558
 559                         event_add(&client_stdin, NULL);
 560                         break;
 561                 case MSG_STDOUT:
 562                         if (datalen != sizeof stdoutdata)
 563                                 fatalx("bad MSG_STDOUT size");
 564                         memcpy(&stdoutdata, data, sizeof stdoutdata);
 565
 566                         client_write(STDOUT_FILENO, stdoutdata.data,
 567                             stdoutdata.size);
 568                         break;
 569                 case MSG_STDERR:
 570                         if (datalen != sizeof stderrdata)
 571                                 fatalx("bad MSG_STDERR size");
 572                         memcpy(&stderrdata, data, sizeof stderrdata);
 573
 574                         client_write(STDERR_FILENO, stderrdata.data,
 575                             stderrdata.size);
 576                         break;
 577                 case MSG_VERSION:
 578                         if (datalen != 0)
 579                                 fatalx("bad MSG_VERSION size");
 580
 581                         fprintf(stderr, "protocol version mismatch "
 582                             "(client %u, server %u)\n", PROTOCOL_VERSION,
 583                             imsg.hdr.peerid);
 584                         client_exitval = 1;
 585
 586                         imsg_free(&imsg);
 587                         return (-1);
 588                 case MSG_SHELL:
 589                         if (datalen == 0 || data[datalen - 1] != '\0')
 590                                 fatalx("bad MSG_SHELL string");
 591
 592                         clear_signals(0);
 593                         shell_exec(data, data0);
 594                         /* NOTREACHED */
 595                 case MSG_DETACH:
 596                 case MSG_DETACHKILL:
 597                         client_write_server(MSG_EXITING, NULL, 0);
 598                         break;
 599                 case MSG_EXITED:
 600                         imsg_free(&imsg);
 601                         return (-1);
 602                 }
 603
 604                 imsg_free(&imsg);
 605         }
 606 }
 607
 608 /* Dispatch imsgs in attached state (after MSG_READY). */
 609 int
 610 client_dispatch_attached(void)
 611 {
 612         struct imsg              imsg;
 613         struct sigaction         sigact;
 614         char                    *data;
 615         ssize_t                  n, datalen;
 616
 617         for (;;) {
 618                 if ((n = imsg_get(&client_ibuf, &imsg)) == -1)
 619                         fatalx("imsg_get failed");
 620                 if (n == 0)
 621                         return (0);
 622
 623                 data = imsg.data;
 624                 datalen = imsg.hdr.len - IMSG_HEADER_SIZE;
 625
 626                 log_debug("got %d from server", imsg.hdr.type);
 627                 switch (imsg.hdr.type) {
 628                 case MSG_DETACH:
 629                 case MSG_DETACHKILL:
 630                         if (datalen == 0 || data[datalen - 1] != '\0')
 631                                 fatalx("bad MSG_DETACH string");
 632
 633                         client_exitsession = xstrdup(data);
 634                         client_exittype = imsg.hdr.type;
 635                         if (imsg.hdr.type == MSG_DETACHKILL)
 636                                 client_exitreason = CLIENT_EXIT_DETACHED_HUP;
 637                         else
 638                                 client_exitreason = CLIENT_EXIT_DETACHED;
 639                         client_write_server(MSG_EXITING, NULL, 0);
 640                         break;
 641                 case MSG_EXIT:
 642                         if (datalen != 0 && datalen != sizeof (int))
 643                                 fatalx("bad MSG_EXIT size");
 644
 645                         client_write_server(MSG_EXITING, NULL, 0);
 646                         client_exitreason = CLIENT_EXIT_EXITED;
 647                         break;
 648                 case MSG_EXITED:
 649                         if (datalen != 0)
 650                                 fatalx("bad MSG_EXITED size");
 651
 652                         imsg_free(&imsg);
 653                         return (-1);
 654                 case MSG_SHUTDOWN:
 655                         if (datalen != 0)
 656                                 fatalx("bad MSG_SHUTDOWN size");
 657
 658                         client_write_server(MSG_EXITING, NULL, 0);
 659                         client_exitreason = CLIENT_EXIT_SERVER_EXITED;
 660                         client_exitval = 1;
 661                         break;
 662                 case MSG_SUSPEND:
 663                         if (datalen != 0)
 664                                 fatalx("bad MSG_SUSPEND size");
 665
 666                         memset(&sigact, 0, sizeof sigact);
 667                         sigemptyset(&sigact.sa_mask);
 668                         sigact.sa_flags = SA_RESTART;
 669                         sigact.sa_handler = SIG_DFL;
 670                         if (sigaction(SIGTSTP, &sigact, NULL) != 0)
 671                                 fatal("sigaction failed");
 672                         kill(getpid(), SIGTSTP);
 673                         break;
 674                 case MSG_LOCK:
 675                         if (datalen == 0 || data[datalen - 1] != '\0')
 676                                 fatalx("bad MSG_LOCK string");
 677
 678                         system(data);
 679                         client_write_server(MSG_UNLOCK, NULL, 0);
 680                         break;
 681                 }
 682
 683                 imsg_free(&imsg);
 684         }
 685 }