1 /* $OpenBSD: client.c,v 1.162 2024/05/15 09:59:12 nicm Exp $ */
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
client_get_lock(char * lockfile)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
client_connect(struct event_base * base,const char * path,uint64_t flags)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 *
client_exit_message(void)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
client_exit(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
client_main(struct event_base * base,int argc,char ** argv,uint64_t flags,int feat)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 /* Set up the initial command. */
250 if (shell_command != NULL) {
251 msg = MSG_SHELL;
252 flags |= CLIENT_STARTSERVER;
253 } else if (argc == 0) {
254 msg = MSG_COMMAND;
255 flags |= CLIENT_STARTSERVER;
256 } else {
257 msg = MSG_COMMAND;
258
259 /*
260 * It's annoying parsing the command string twice (in client
261 * and later in server) but it is necessary to get the start
262 * server flag.
263 */
264 values = args_from_vector(argc, argv);
265 pr = cmd_parse_from_arguments(values, argc, NULL);
266 if (pr->status == CMD_PARSE_SUCCESS) {
267 if (cmd_list_any_have(pr->cmdlist, CMD_STARTSERVER))
268 flags |= CLIENT_STARTSERVER;
269 cmd_list_free(pr->cmdlist);
270 } else
271 free(pr->error);
272 args_free_values(values, argc);
273 free(values);
274 }
275
276 /* Create client process structure (starts logging). */
277 client_proc = proc_start("client");
278 proc_set_signals(client_proc, client_signal);
279
280 /* Save the flags. */
281 client_flags = flags;
282 log_debug("flags are %#llx", (unsigned long long)client_flags);
283
284 /* Initialize the client socket and start the server. */
285 fd = client_connect(base, socket_path, client_flags);
286 if (fd == -1) {
287 if (errno == ECONNREFUSED) {
288 fprintf(stderr, "no server running on %s\n",
289 socket_path);
290 } else {
291 fprintf(stderr, "error connecting to %s (%s)\n",
292 socket_path, strerror(errno));
293 }
294 return (1);
295 }
296 client_peer = proc_add_peer(client_proc, fd, client_dispatch, NULL);
297
298 /* Save these before pledge(). */
299 if ((cwd = find_cwd()) == NULL && (cwd = find_home()) == NULL)
300 cwd = "/";
301 if ((ttynam = ttyname(STDIN_FILENO)) == NULL)
302 ttynam = "";
303 if ((termname = getenv("TERM")) == NULL)
304 termname = "";
305
306 /*
307 * Drop privileges for client. "proc exec" is needed for -c and for
308 * locking (which uses system(3)).
309 *
310 * "tty" is needed to restore termios(4) and also for some reason -CC
311 * does not work properly without it (input is not recognised).
312 *
313 * "sendfd" is dropped later in client_dispatch_wait().
314 */
315 if (pledge(
316 "stdio rpath wpath cpath unix sendfd proc exec tty",
317 NULL) != 0)
318 fatal("pledge failed");
319
320 /* Load terminfo entry if any. */
321 if (isatty(STDIN_FILENO) &&
322 *termname != '\0' &&
323 tty_term_read_list(termname, STDIN_FILENO, &caps, &ncaps,
324 &cause) != 0) {
325 fprintf(stderr, "%s\n", cause);
326 free(cause);
327 return (1);
328 }
329
330 /* Free stuff that is not used in the client. */
331 if (ptm_fd != -1)
332 close(ptm_fd);
333 options_free(global_options);
334 options_free(global_s_options);
335 options_free(global_w_options);
336 environ_free(global_environ);
337
338 /* Set up control mode. */
339 if (client_flags & CLIENT_CONTROLCONTROL) {
340 if (tcgetattr(STDIN_FILENO, &saved_tio) != 0) {
341 fprintf(stderr, "tcgetattr failed: %s\n",
342 strerror(errno));
343 return (1);
344 }
345 cfmakeraw(&tio);
346 tio.c_iflag = ICRNL|IXANY;
347 tio.c_oflag = OPOST|ONLCR;
348 tio.c_lflag = NOKERNINFO;
349 tio.c_cflag = CREAD|CS8|HUPCL;
350 tio.c_cc[VMIN] = 1;
351 tio.c_cc[VTIME] = 0;
352 cfsetispeed(&tio, cfgetispeed(&saved_tio));
353 cfsetospeed(&tio, cfgetospeed(&saved_tio));
354 tcsetattr(STDIN_FILENO, TCSANOW, &tio);
355 }
356
357 /* Send identify messages. */
358 client_send_identify(ttynam, termname, caps, ncaps, cwd, feat);
359 tty_term_free_list(caps, ncaps);
360 proc_flush_peer(client_peer);
361
362 /* Send first command. */
363 if (msg == MSG_COMMAND) {
364 /* How big is the command? */
365 size = 0;
366 for (i = 0; i < argc; i++)
367 size += strlen(argv[i]) + 1;
368 if (size > MAX_IMSGSIZE - (sizeof *data)) {
369 fprintf(stderr, "command too long\n");
370 return (1);
371 }
372 data = xmalloc((sizeof *data) + size);
373
374 /* Prepare command for server. */
375 data->argc = argc;
376 if (cmd_pack_argv(argc, argv, (char *)(data + 1), size) != 0) {
377 fprintf(stderr, "command too long\n");
378 free(data);
379 return (1);
380 }
381 size += sizeof *data;
382
383 /* Send the command. */
384 if (proc_send(client_peer, msg, -1, data, size) != 0) {
385 fprintf(stderr, "failed to send command\n");
386 free(data);
387 return (1);
388 }
389 free(data);
390 } else if (msg == MSG_SHELL)
391 proc_send(client_peer, msg, -1, NULL, 0);
392
393 /* Start main loop. */
394 proc_loop(client_proc, NULL);
395
396 /* Run command if user requested exec, instead of exiting. */
397 if (client_exittype == MSG_EXEC) {
398 if (client_flags & CLIENT_CONTROLCONTROL)
399 tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
400 client_exec(client_execshell, client_execcmd);
401 }
402
403 /* Restore streams to blocking. */
404 setblocking(STDIN_FILENO, 1);
405 setblocking(STDOUT_FILENO, 1);
406 setblocking(STDERR_FILENO, 1);
407
408 /* Print the exit message, if any, and exit. */
409 if (client_attached) {
410 if (client_exitreason != CLIENT_EXIT_NONE)
411 printf("[%s]\n", client_exit_message());
412
413 ppid = getppid();
414 if (client_exittype == MSG_DETACHKILL && ppid > 1)
415 kill(ppid, SIGHUP);
416 } else if (client_flags & CLIENT_CONTROL) {
417 if (client_exitreason != CLIENT_EXIT_NONE)
418 printf("%%exit %s\n", client_exit_message());
419 else
420 printf("%%exit\n");
421 fflush(stdout);
422 if (client_flags & CLIENT_CONTROL_WAITEXIT) {
423 setvbuf(stdin, NULL, _IOLBF, 0);
424 for (;;) {
425 linelen = getline(&line, &linesize, stdin);
426 if (linelen <= 1)
427 break;
428 }
429 free(line);
430 }
431 if (client_flags & CLIENT_CONTROLCONTROL) {
432 printf("\033\\");
433 fflush(stdout);
434 tcsetattr(STDOUT_FILENO, TCSAFLUSH, &saved_tio);
435 }
436 } else if (client_exitreason != CLIENT_EXIT_NONE)
437 fprintf(stderr, "%s\n", client_exit_message());
438 return (client_exitval);
439 }
440
441 /* Send identify messages to server. */
442 static void
client_send_identify(const char * ttynam,const char * termname,char ** caps,u_int ncaps,const char * cwd,int feat)443 client_send_identify(const char *ttynam, const char *termname, char **caps,
444 u_int ncaps, const char *cwd, int feat)
445 {
446 char **ss;
447 size_t sslen;
448 int fd, flags = client_flags;
449 pid_t pid;
450 u_int i;
451
452 proc_send(client_peer, MSG_IDENTIFY_FLAGS, -1, &flags, sizeof flags);
453 proc_send(client_peer, MSG_IDENTIFY_LONGFLAGS, -1, &client_flags,
454 sizeof client_flags);
455
456 proc_send(client_peer, MSG_IDENTIFY_TERM, -1, termname,
457 strlen(termname) + 1);
458 proc_send(client_peer, MSG_IDENTIFY_FEATURES, -1, &feat, sizeof feat);
459
460 proc_send(client_peer, MSG_IDENTIFY_TTYNAME, -1, ttynam,
461 strlen(ttynam) + 1);
462 proc_send(client_peer, MSG_IDENTIFY_CWD, -1, cwd, strlen(cwd) + 1);
463
464 for (i = 0; i < ncaps; i++) {
465 proc_send(client_peer, MSG_IDENTIFY_TERMINFO, -1,
466 caps[i], strlen(caps[i]) + 1);
467 }
468
469 if ((fd = dup(STDIN_FILENO)) == -1)
470 fatal("dup failed");
471 proc_send(client_peer, MSG_IDENTIFY_STDIN, fd, NULL, 0);
472 if ((fd = dup(STDOUT_FILENO)) == -1)
473 fatal("dup failed");
474 proc_send(client_peer, MSG_IDENTIFY_STDOUT, fd, NULL, 0);
475
476 pid = getpid();
477 proc_send(client_peer, MSG_IDENTIFY_CLIENTPID, -1, &pid, sizeof pid);
478
479 for (ss = environ; *ss != NULL; ss++) {
480 sslen = strlen(*ss) + 1;
481 if (sslen > MAX_IMSGSIZE - IMSG_HEADER_SIZE)
482 continue;
483 proc_send(client_peer, MSG_IDENTIFY_ENVIRON, -1, *ss, sslen);
484 }
485
486 proc_send(client_peer, MSG_IDENTIFY_DONE, -1, NULL, 0);
487 }
488
489 /* Run command in shell; used for -c. */
490 static __dead void
client_exec(const char * shell,const char * shellcmd)491 client_exec(const char *shell, const char *shellcmd)
492 {
493 char *argv0;
494
495 log_debug("shell %s, command %s", shell, shellcmd);
496 argv0 = shell_argv0(shell, !!(client_flags & CLIENT_LOGIN));
497 setenv("SHELL", shell, 1);
498
499 proc_clear_signals(client_proc, 1);
500
501 setblocking(STDIN_FILENO, 1);
502 setblocking(STDOUT_FILENO, 1);
503 setblocking(STDERR_FILENO, 1);
504 closefrom(STDERR_FILENO + 1);
505
506 execl(shell, argv0, "-c", shellcmd, (char *) NULL);
507 fatal("execl failed");
508 }
509
510 /* Callback to handle signals in the client. */
511 static void
client_signal(int sig)512 client_signal(int sig)
513 {
514 struct sigaction sigact;
515 int status;
516 pid_t pid;
517
518 log_debug("%s: %s", __func__, strsignal(sig));
519 if (sig == SIGCHLD) {
520 for (;;) {
521 pid = waitpid(WAIT_ANY, &status, WNOHANG);
522 if (pid == 0)
523 break;
524 if (pid == -1) {
525 if (errno == ECHILD)
526 break;
527 log_debug("waitpid failed: %s",
528 strerror(errno));
529 }
530 }
531 } else if (!client_attached) {
532 if (sig == SIGTERM || sig == SIGHUP)
533 proc_exit(client_proc);
534 } else {
535 switch (sig) {
536 case SIGHUP:
537 client_exitreason = CLIENT_EXIT_LOST_TTY;
538 client_exitval = 1;
539 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
540 break;
541 case SIGTERM:
542 if (!client_suspended)
543 client_exitreason = CLIENT_EXIT_TERMINATED;
544 client_exitval = 1;
545 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
546 break;
547 case SIGWINCH:
548 proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
549 break;
550 case SIGCONT:
551 memset(&sigact, 0, sizeof sigact);
552 sigemptyset(&sigact.sa_mask);
553 sigact.sa_flags = SA_RESTART;
554 sigact.sa_handler = SIG_IGN;
555 if (sigaction(SIGTSTP, &sigact, NULL) != 0)
556 fatal("sigaction failed");
557 proc_send(client_peer, MSG_WAKEUP, -1, NULL, 0);
558 client_suspended = 0;
559 break;
560 }
561 }
562 }
563
564 /* Callback for file write error or close. */
565 static void
client_file_check_cb(__unused struct client * c,__unused const char * path,__unused int error,__unused int closed,__unused struct evbuffer * buffer,__unused void * data)566 client_file_check_cb(__unused struct client *c, __unused const char *path,
567 __unused int error, __unused int closed, __unused struct evbuffer *buffer,
568 __unused void *data)
569 {
570 if (client_exitflag)
571 client_exit();
572 }
573
574 /* Callback for client read events. */
575 static void
client_dispatch(struct imsg * imsg,__unused void * arg)576 client_dispatch(struct imsg *imsg, __unused void *arg)
577 {
578 if (imsg == NULL) {
579 if (!client_exitflag) {
580 client_exitreason = CLIENT_EXIT_LOST_SERVER;
581 client_exitval = 1;
582 }
583 proc_exit(client_proc);
584 return;
585 }
586
587 if (client_attached)
588 client_dispatch_attached(imsg);
589 else
590 client_dispatch_wait(imsg);
591 }
592
593 /* Process an exit message. */
594 static void
client_dispatch_exit_message(char * data,size_t datalen)595 client_dispatch_exit_message(char *data, size_t datalen)
596 {
597 int retval;
598
599 if (datalen < sizeof retval && datalen != 0)
600 fatalx("bad MSG_EXIT size");
601
602 if (datalen >= sizeof retval) {
603 memcpy(&retval, data, sizeof retval);
604 client_exitval = retval;
605 }
606
607 if (datalen > sizeof retval) {
608 datalen -= sizeof retval;
609 data += sizeof retval;
610
611 client_exitmessage = xmalloc(datalen);
612 memcpy(client_exitmessage, data, datalen);
613 client_exitmessage[datalen - 1] = '\0';
614
615 client_exitreason = CLIENT_EXIT_MESSAGE_PROVIDED;
616 }
617 }
618
619 /* Dispatch imsgs when in wait state (before MSG_READY). */
620 static void
client_dispatch_wait(struct imsg * imsg)621 client_dispatch_wait(struct imsg *imsg)
622 {
623 char *data;
624 ssize_t datalen;
625 static int pledge_applied;
626
627 /*
628 * "sendfd" is no longer required once all of the identify messages
629 * have been sent. We know the server won't send us anything until that
630 * point (because we don't ask it to), so we can drop "sendfd" once we
631 * get the first message from the server.
632 */
633 if (!pledge_applied) {
634 if (pledge(
635 "stdio rpath wpath cpath unix proc exec tty",
636 NULL) != 0)
637 fatal("pledge failed");
638 pledge_applied = 1;
639 }
640
641 data = imsg->data;
642 datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
643
644 switch (imsg->hdr.type) {
645 case MSG_EXIT:
646 case MSG_SHUTDOWN:
647 client_dispatch_exit_message(data, datalen);
648 client_exitflag = 1;
649 client_exit();
650 break;
651 case MSG_READY:
652 if (datalen != 0)
653 fatalx("bad MSG_READY size");
654
655 client_attached = 1;
656 proc_send(client_peer, MSG_RESIZE, -1, NULL, 0);
657 break;
658 case MSG_VERSION:
659 if (datalen != 0)
660 fatalx("bad MSG_VERSION size");
661
662 fprintf(stderr, "protocol version mismatch "
663 "(client %d, server %u)\n", PROTOCOL_VERSION,
664 imsg->hdr.peerid & 0xff);
665 client_exitval = 1;
666 proc_exit(client_proc);
667 break;
668 case MSG_FLAGS:
669 if (datalen != sizeof client_flags)
670 fatalx("bad MSG_FLAGS string");
671
672 memcpy(&client_flags, data, sizeof client_flags);
673 log_debug("new flags are %#llx",
674 (unsigned long long)client_flags);
675 break;
676 case MSG_SHELL:
677 if (datalen == 0 || data[datalen - 1] != '\0')
678 fatalx("bad MSG_SHELL string");
679
680 client_exec(data, shell_command);
681 /* NOTREACHED */
682 case MSG_DETACH:
683 case MSG_DETACHKILL:
684 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
685 break;
686 case MSG_EXITED:
687 proc_exit(client_proc);
688 break;
689 case MSG_READ_OPEN:
690 file_read_open(&client_files, client_peer, imsg, 1,
691 !(client_flags & CLIENT_CONTROL), client_file_check_cb,
692 NULL);
693 break;
694 case MSG_READ_CANCEL:
695 file_read_cancel(&client_files, imsg);
696 break;
697 case MSG_WRITE_OPEN:
698 file_write_open(&client_files, client_peer, imsg, 1,
699 !(client_flags & CLIENT_CONTROL), client_file_check_cb,
700 NULL);
701 break;
702 case MSG_WRITE:
703 file_write_data(&client_files, imsg);
704 break;
705 case MSG_WRITE_CLOSE:
706 file_write_close(&client_files, imsg);
707 break;
708 case MSG_OLDSTDERR:
709 case MSG_OLDSTDIN:
710 case MSG_OLDSTDOUT:
711 fprintf(stderr, "server version is too old for client\n");
712 proc_exit(client_proc);
713 break;
714 }
715 }
716
717 /* Dispatch imsgs in attached state (after MSG_READY). */
718 static void
client_dispatch_attached(struct imsg * imsg)719 client_dispatch_attached(struct imsg *imsg)
720 {
721 struct sigaction sigact;
722 char *data;
723 ssize_t datalen;
724
725 data = imsg->data;
726 datalen = imsg->hdr.len - IMSG_HEADER_SIZE;
727
728 switch (imsg->hdr.type) {
729 case MSG_FLAGS:
730 if (datalen != sizeof client_flags)
731 fatalx("bad MSG_FLAGS string");
732
733 memcpy(&client_flags, data, sizeof client_flags);
734 log_debug("new flags are %#llx",
735 (unsigned long long)client_flags);
736 break;
737 case MSG_DETACH:
738 case MSG_DETACHKILL:
739 if (datalen == 0 || data[datalen - 1] != '\0')
740 fatalx("bad MSG_DETACH string");
741
742 client_exitsession = xstrdup(data);
743 client_exittype = imsg->hdr.type;
744 if (imsg->hdr.type == MSG_DETACHKILL)
745 client_exitreason = CLIENT_EXIT_DETACHED_HUP;
746 else
747 client_exitreason = CLIENT_EXIT_DETACHED;
748 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
749 break;
750 case MSG_EXEC:
751 if (datalen == 0 || data[datalen - 1] != '\0' ||
752 strlen(data) + 1 == (size_t)datalen)
753 fatalx("bad MSG_EXEC string");
754 client_execcmd = xstrdup(data);
755 client_execshell = xstrdup(data + strlen(data) + 1);
756
757 client_exittype = imsg->hdr.type;
758 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
759 break;
760 case MSG_EXIT:
761 client_dispatch_exit_message(data, datalen);
762 if (client_exitreason == CLIENT_EXIT_NONE)
763 client_exitreason = CLIENT_EXIT_EXITED;
764 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
765 break;
766 case MSG_EXITED:
767 if (datalen != 0)
768 fatalx("bad MSG_EXITED size");
769
770 proc_exit(client_proc);
771 break;
772 case MSG_SHUTDOWN:
773 if (datalen != 0)
774 fatalx("bad MSG_SHUTDOWN size");
775
776 proc_send(client_peer, MSG_EXITING, -1, NULL, 0);
777 client_exitreason = CLIENT_EXIT_SERVER_EXITED;
778 client_exitval = 1;
779 break;
780 case MSG_SUSPEND:
781 if (datalen != 0)
782 fatalx("bad MSG_SUSPEND size");
783
784 memset(&sigact, 0, sizeof sigact);
785 sigemptyset(&sigact.sa_mask);
786 sigact.sa_flags = SA_RESTART;
787 sigact.sa_handler = SIG_DFL;
788 if (sigaction(SIGTSTP, &sigact, NULL) != 0)
789 fatal("sigaction failed");
790 client_suspended = 1;
791 kill(getpid(), SIGTSTP);
792 break;
793 case MSG_LOCK:
794 if (datalen == 0 || data[datalen - 1] != '\0')
795 fatalx("bad MSG_LOCK string");
796
797 system(data);
798 proc_send(client_peer, MSG_UNLOCK, -1, NULL, 0);
799 break;
800 }
801 }
802