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