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