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