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