1 /* $OpenBSD: server.c,v 1.208 2025/01/01 15:17:36 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/ioctl.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 <paths.h>
30 #include <signal.h>
31 #include <stdio.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <termios.h>
35 #include <time.h>
36 #include <unistd.h>
37
38 #include "tmux.h"
39
40 /*
41 * Main server functions.
42 */
43
44 struct clients clients;
45
46 struct tmuxproc *server_proc;
47 static int server_fd = -1;
48 static uint64_t server_client_flags;
49 static int server_exit;
50 static struct event server_ev_accept;
51 static struct event server_ev_tidy;
52
53 struct cmd_find_state marked_pane;
54
55 static u_int message_next;
56 struct message_list message_log;
57
58 time_t current_time;
59
60 static int server_loop(void);
61 static void server_send_exit(void);
62 static void server_accept(int, short, void *);
63 static void server_signal(int);
64 static void server_child_signal(void);
65 static void server_child_exited(pid_t, int);
66 static void server_child_stopped(pid_t, int);
67
68 /* Set marked pane. */
69 void
server_set_marked(struct session * s,struct winlink * wl,struct window_pane * wp)70 server_set_marked(struct session *s, struct winlink *wl, struct window_pane *wp)
71 {
72 cmd_find_clear_state(&marked_pane, 0);
73 marked_pane.s = s;
74 marked_pane.wl = wl;
75 marked_pane.w = wl->window;
76 marked_pane.wp = wp;
77 }
78
79 /* Clear marked pane. */
80 void
server_clear_marked(void)81 server_clear_marked(void)
82 {
83 cmd_find_clear_state(&marked_pane, 0);
84 }
85
86 /* Is this the marked pane? */
87 int
server_is_marked(struct session * s,struct winlink * wl,struct window_pane * wp)88 server_is_marked(struct session *s, struct winlink *wl, struct window_pane *wp)
89 {
90 if (s == NULL || wl == NULL || wp == NULL)
91 return (0);
92 if (marked_pane.s != s || marked_pane.wl != wl)
93 return (0);
94 if (marked_pane.wp != wp)
95 return (0);
96 return (server_check_marked());
97 }
98
99 /* Check if the marked pane is still valid. */
100 int
server_check_marked(void)101 server_check_marked(void)
102 {
103 return (cmd_find_valid_state(&marked_pane));
104 }
105
106 /* Create server socket. */
107 int
server_create_socket(uint64_t flags,char ** cause)108 server_create_socket(uint64_t flags, char **cause)
109 {
110 struct sockaddr_un sa;
111 size_t size;
112 mode_t mask;
113 int fd, saved_errno;
114
115 memset(&sa, 0, sizeof sa);
116 sa.sun_family = AF_UNIX;
117 size = strlcpy(sa.sun_path, socket_path, sizeof sa.sun_path);
118 if (size >= sizeof sa.sun_path) {
119 errno = ENAMETOOLONG;
120 goto fail;
121 }
122 unlink(sa.sun_path);
123
124 if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
125 goto fail;
126
127 if (flags & CLIENT_DEFAULTSOCKET)
128 mask = umask(S_IXUSR|S_IXGRP|S_IRWXO);
129 else
130 mask = umask(S_IXUSR|S_IRWXG|S_IRWXO);
131 if (bind(fd, (struct sockaddr *)&sa, sizeof sa) == -1) {
132 saved_errno = errno;
133 close(fd);
134 errno = saved_errno;
135 goto fail;
136 }
137 umask(mask);
138
139 if (listen(fd, 128) == -1) {
140 saved_errno = errno;
141 close(fd);
142 errno = saved_errno;
143 goto fail;
144 }
145 setblocking(fd, 0);
146
147 return (fd);
148
149 fail:
150 if (cause != NULL) {
151 xasprintf(cause, "error creating %s (%s)", socket_path,
152 strerror(errno));
153 }
154 return (-1);
155 }
156
157 /* Tidy up every hour. */
158 static void
server_tidy_event(__unused int fd,__unused short events,__unused void * data)159 server_tidy_event(__unused int fd, __unused short events, __unused void *data)
160 {
161 struct timeval tv = { .tv_sec = 3600 };
162 uint64_t t = get_timer();
163
164 format_tidy_jobs();
165
166 log_debug("%s: took %llu milliseconds", __func__,
167 (unsigned long long)(get_timer() - t));
168 evtimer_add(&server_ev_tidy, &tv);
169 }
170
171 /* Fork new server. */
172 int
server_start(struct tmuxproc * client,uint64_t flags,struct event_base * base,int lockfd,char * lockfile)173 server_start(struct tmuxproc *client, uint64_t flags, struct event_base *base,
174 int lockfd, char *lockfile)
175 {
176 int fd;
177 sigset_t set, oldset;
178 struct client *c = NULL;
179 char *cause = NULL;
180 struct timeval tv = { .tv_sec = 3600 };
181
182 sigfillset(&set);
183 sigprocmask(SIG_BLOCK, &set, &oldset);
184
185 if (~flags & CLIENT_NOFORK) {
186 if (proc_fork_and_daemon(&fd) != 0) {
187 sigprocmask(SIG_SETMASK, &oldset, NULL);
188 return (fd);
189 }
190 }
191 proc_clear_signals(client, 0);
192 server_client_flags = flags;
193
194 if (event_reinit(base) != 0)
195 fatalx("event_reinit failed");
196 server_proc = proc_start("server");
197
198 proc_set_signals(server_proc, server_signal);
199 sigprocmask(SIG_SETMASK, &oldset, NULL);
200
201 if (log_get_level() > 1)
202 tty_create_log();
203 if (pledge("stdio rpath wpath cpath fattr unix getpw recvfd proc exec "
204 "tty ps", NULL) != 0)
205 fatal("pledge failed");
206
207 input_key_build();
208 utf8_update_width_cache();
209 RB_INIT(&windows);
210 RB_INIT(&all_window_panes);
211 TAILQ_INIT(&clients);
212 RB_INIT(&sessions);
213 key_bindings_init();
214 TAILQ_INIT(&message_log);
215 gettimeofday(&start_time, NULL);
216
217 server_fd = server_create_socket(flags, &cause);
218 if (server_fd != -1)
219 server_update_socket();
220 if (~flags & CLIENT_NOFORK)
221 c = server_client_create(fd);
222 else
223 options_set_number(global_options, "exit-empty", 0);
224
225 if (lockfd >= 0) {
226 unlink(lockfile);
227 free(lockfile);
228 close(lockfd);
229 }
230
231 if (cause != NULL) {
232 if (c != NULL) {
233 c->exit_message = cause;
234 c->flags |= CLIENT_EXIT;
235 } else {
236 fprintf(stderr, "%s\n", cause);
237 exit(1);
238 }
239 }
240
241 evtimer_set(&server_ev_tidy, server_tidy_event, NULL);
242 evtimer_add(&server_ev_tidy, &tv);
243
244 server_acl_init();
245
246 server_add_accept(0);
247 proc_loop(server_proc, server_loop);
248
249 job_kill_all();
250 status_prompt_save_history();
251
252 exit(0);
253 }
254
255 /* Server loop callback. */
256 static int
server_loop(void)257 server_loop(void)
258 {
259 struct client *c;
260 u_int items;
261
262 current_time = time(NULL);
263
264 do {
265 items = cmdq_next(NULL);
266 TAILQ_FOREACH(c, &clients, entry) {
267 if (c->flags & CLIENT_IDENTIFIED)
268 items += cmdq_next(c);
269 }
270 } while (items != 0);
271
272 server_client_loop();
273
274 if (!options_get_number(global_options, "exit-empty") && !server_exit)
275 return (0);
276
277 if (!options_get_number(global_options, "exit-unattached")) {
278 if (!RB_EMPTY(&sessions))
279 return (0);
280 }
281
282 TAILQ_FOREACH(c, &clients, entry) {
283 if (c->session != NULL)
284 return (0);
285 }
286
287 /*
288 * No attached clients therefore want to exit - flush any waiting
289 * clients but don't actually exit until they've gone.
290 */
291 cmd_wait_for_flush();
292 if (!TAILQ_EMPTY(&clients))
293 return (0);
294
295 if (job_still_running())
296 return (0);
297
298 return (1);
299 }
300
301 /* Exit the server by killing all clients and windows. */
302 static void
server_send_exit(void)303 server_send_exit(void)
304 {
305 struct client *c, *c1;
306 struct session *s, *s1;
307
308 cmd_wait_for_flush();
309
310 TAILQ_FOREACH_SAFE(c, &clients, entry, c1) {
311 if (c->flags & CLIENT_SUSPENDED)
312 server_client_lost(c);
313 else {
314 c->flags |= CLIENT_EXIT;
315 c->exit_type = CLIENT_EXIT_SHUTDOWN;
316 }
317 c->session = NULL;
318 }
319
320 RB_FOREACH_SAFE(s, sessions, &sessions, s1)
321 session_destroy(s, 1, __func__);
322 }
323
324 /* Update socket execute permissions based on whether sessions are attached. */
325 void
server_update_socket(void)326 server_update_socket(void)
327 {
328 struct session *s;
329 static int last = -1;
330 int n, mode;
331 struct stat sb;
332
333 n = 0;
334 RB_FOREACH(s, sessions, &sessions) {
335 if (s->attached != 0) {
336 n++;
337 break;
338 }
339 }
340
341 if (n != last) {
342 last = n;
343
344 if (stat(socket_path, &sb) != 0)
345 return;
346 mode = sb.st_mode & ACCESSPERMS;
347 if (n != 0) {
348 if (mode & S_IRUSR)
349 mode |= S_IXUSR;
350 if (mode & S_IRGRP)
351 mode |= S_IXGRP;
352 if (mode & S_IROTH)
353 mode |= S_IXOTH;
354 } else
355 mode &= ~(S_IXUSR|S_IXGRP|S_IXOTH);
356 chmod(socket_path, mode);
357 }
358 }
359
360 /* Callback for server socket. */
361 static void
server_accept(int fd,short events,__unused void * data)362 server_accept(int fd, short events, __unused void *data)
363 {
364 struct sockaddr_storage sa;
365 socklen_t slen = sizeof sa;
366 int newfd;
367 struct client *c;
368
369 server_add_accept(0);
370 if (!(events & EV_READ))
371 return;
372
373 newfd = accept(fd, (struct sockaddr *) &sa, &slen);
374 if (newfd == -1) {
375 if (errno == EAGAIN || errno == EINTR || errno == ECONNABORTED)
376 return;
377 if (errno == ENFILE || errno == EMFILE) {
378 /* Delete and don't try again for 1 second. */
379 server_add_accept(1);
380 return;
381 }
382 fatal("accept failed");
383 }
384
385 if (server_exit) {
386 close(newfd);
387 return;
388 }
389 c = server_client_create(newfd);
390 if (!server_acl_join(c)) {
391 c->exit_message = xstrdup("access not allowed");
392 c->flags |= CLIENT_EXIT;
393 }
394 }
395
396 /*
397 * Add accept event. If timeout is nonzero, add as a timeout instead of a read
398 * event - used to backoff when running out of file descriptors.
399 */
400 void
server_add_accept(int timeout)401 server_add_accept(int timeout)
402 {
403 struct timeval tv = { timeout, 0 };
404
405 if (server_fd == -1)
406 return;
407
408 if (event_initialized(&server_ev_accept))
409 event_del(&server_ev_accept);
410
411 if (timeout == 0) {
412 event_set(&server_ev_accept, server_fd, EV_READ, server_accept,
413 NULL);
414 event_add(&server_ev_accept, NULL);
415 } else {
416 event_set(&server_ev_accept, server_fd, EV_TIMEOUT,
417 server_accept, NULL);
418 event_add(&server_ev_accept, &tv);
419 }
420 }
421
422 /* Signal handler. */
423 static void
server_signal(int sig)424 server_signal(int sig)
425 {
426 int fd;
427
428 log_debug("%s: %s", __func__, strsignal(sig));
429 switch (sig) {
430 case SIGINT:
431 case SIGTERM:
432 server_exit = 1;
433 server_send_exit();
434 break;
435 case SIGCHLD:
436 server_child_signal();
437 break;
438 case SIGUSR1:
439 event_del(&server_ev_accept);
440 fd = server_create_socket(server_client_flags, NULL);
441 if (fd != -1) {
442 close(server_fd);
443 server_fd = fd;
444 server_update_socket();
445 }
446 server_add_accept(0);
447 break;
448 case SIGUSR2:
449 proc_toggle_log(server_proc);
450 break;
451 }
452 }
453
454 /* Handle SIGCHLD. */
455 static void
server_child_signal(void)456 server_child_signal(void)
457 {
458 int status;
459 pid_t pid;
460
461 for (;;) {
462 switch (pid = waitpid(WAIT_ANY, &status, WNOHANG|WUNTRACED)) {
463 case -1:
464 if (errno == ECHILD)
465 return;
466 fatal("waitpid failed");
467 case 0:
468 return;
469 }
470 if (WIFSTOPPED(status))
471 server_child_stopped(pid, status);
472 else if (WIFEXITED(status) || WIFSIGNALED(status))
473 server_child_exited(pid, status);
474 }
475 }
476
477 /* Handle exited children. */
478 static void
server_child_exited(pid_t pid,int status)479 server_child_exited(pid_t pid, int status)
480 {
481 struct window *w, *w1;
482 struct window_pane *wp;
483
484 RB_FOREACH_SAFE(w, windows, &windows, w1) {
485 TAILQ_FOREACH(wp, &w->panes, entry) {
486 if (wp->pid == pid) {
487 wp->status = status;
488 wp->flags |= PANE_STATUSREADY;
489
490 log_debug("%%%u exited", wp->id);
491 wp->flags |= PANE_EXITED;
492
493 if (window_pane_destroy_ready(wp))
494 server_destroy_pane(wp, 1);
495 break;
496 }
497 }
498 }
499 job_check_died(pid, status);
500 }
501
502 /* Handle stopped children. */
503 static void
server_child_stopped(pid_t pid,int status)504 server_child_stopped(pid_t pid, int status)
505 {
506 struct window *w;
507 struct window_pane *wp;
508
509 if (WSTOPSIG(status) == SIGTTIN || WSTOPSIG(status) == SIGTTOU)
510 return;
511
512 RB_FOREACH(w, windows, &windows) {
513 TAILQ_FOREACH(wp, &w->panes, entry) {
514 if (wp->pid == pid) {
515 if (killpg(pid, SIGCONT) != 0)
516 kill(pid, SIGCONT);
517 }
518 }
519 }
520 job_check_died(pid, status);
521 }
522
523 /* Add to message log. */
524 void
server_add_message(const char * fmt,...)525 server_add_message(const char *fmt, ...)
526 {
527 struct message_entry *msg, *msg1;
528 char *s;
529 va_list ap;
530 u_int limit;
531
532 va_start(ap, fmt);
533 xvasprintf(&s, fmt, ap);
534 va_end(ap);
535
536 log_debug("message: %s", s);
537
538 msg = xcalloc(1, sizeof *msg);
539 gettimeofday(&msg->msg_time, NULL);
540 msg->msg_num = message_next++;
541 msg->msg = s;
542 TAILQ_INSERT_TAIL(&message_log, msg, entry);
543
544 limit = options_get_number(global_options, "message-limit");
545 TAILQ_FOREACH_SAFE(msg, &message_log, entry, msg1) {
546 if (msg->msg_num + limit >= message_next)
547 break;
548 free(msg->msg);
549 TAILQ_REMOVE(&message_log, msg, entry);
550 free(msg);
551 }
552 }
553