mirror of
https://github.com/tmate-io/tmate.git
synced 2026-01-23 02:24:06 +00:00
Merge with latest tmux
This commit is contained in:
Nicolas Viennot
commit
9b2778c439
222 changed files with 22308 additions and 13427 deletions
421
server.c
421
server.c
|
|
@ -1,4 +1,4 @@
|
|||
/* $Id$ */
|
||||
/* $OpenBSD$ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net>
|
||||
|
|
@ -30,7 +30,6 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <syslog.h>
|
||||
#include <termios.h>
|
||||
#include <time.h>
|
||||
#include <unistd.h>
|
||||
|
|
@ -42,30 +41,62 @@
|
|||
* Main server functions.
|
||||
*/
|
||||
|
||||
/* Client list. */
|
||||
struct clients clients;
|
||||
struct clients dead_clients;
|
||||
struct clients clients;
|
||||
|
||||
int server_fd;
|
||||
int server_shutdown;
|
||||
struct event server_ev_accept;
|
||||
struct event server_ev_second;
|
||||
struct tmuxproc *server_proc;
|
||||
int server_fd;
|
||||
int server_exit;
|
||||
struct event server_ev_accept;
|
||||
|
||||
struct paste_stack global_buffers;
|
||||
struct cmd_find_state marked_pane;
|
||||
|
||||
int server_create_socket(void);
|
||||
void server_loop(void);
|
||||
int server_should_shutdown(void);
|
||||
void server_send_shutdown(void);
|
||||
void server_clean_dead(void);
|
||||
void server_accept_callback(int, short, void *);
|
||||
void server_signal_callback(int, short, void *);
|
||||
void server_child_signal(void);
|
||||
void server_child_exited(pid_t, int);
|
||||
void server_child_stopped(pid_t, int);
|
||||
void server_second_callback(int, short, void *);
|
||||
void server_lock_server(void);
|
||||
void server_lock_sessions(void);
|
||||
int server_create_socket(void);
|
||||
int server_loop(void);
|
||||
int server_should_exit(void);
|
||||
void server_send_exit(void);
|
||||
void server_accept(int, short, void *);
|
||||
void server_signal(int);
|
||||
void server_child_signal(void);
|
||||
void server_child_exited(pid_t, int);
|
||||
void server_child_stopped(pid_t, int);
|
||||
|
||||
/* Set marked pane. */
|
||||
void
|
||||
server_set_marked(struct session *s, struct winlink *wl, struct window_pane *wp)
|
||||
{
|
||||
cmd_find_clear_state(&marked_pane, NULL, 0);
|
||||
marked_pane.s = s;
|
||||
marked_pane.wl = wl;
|
||||
marked_pane.w = wl->window;
|
||||
marked_pane.wp = wp;
|
||||
}
|
||||
|
||||
/* Clear marked pane. */
|
||||
void
|
||||
server_clear_marked(void)
|
||||
{
|
||||
cmd_find_clear_state(&marked_pane, NULL, 0);
|
||||
}
|
||||
|
||||
/* Is this the marked pane? */
|
||||
int
|
||||
server_is_marked(struct session *s, struct winlink *wl, struct window_pane *wp)
|
||||
{
|
||||
if (s == NULL || wl == NULL || wp == NULL)
|
||||
return (0);
|
||||
if (marked_pane.s != s || marked_pane.wl != wl)
|
||||
return (0);
|
||||
if (marked_pane.wp != wp)
|
||||
return (0);
|
||||
return (server_check_marked());
|
||||
}
|
||||
|
||||
/* Check if the marked pane is still valid. */
|
||||
int
|
||||
server_check_marked(void)
|
||||
{
|
||||
return (cmd_find_valid_state(&marked_pane));
|
||||
}
|
||||
|
||||
/* Create server socket. */
|
||||
int
|
||||
|
|
@ -81,220 +112,135 @@ server_create_socket(void)
|
|||
size = strlcpy(sa.sun_path, socket_path, sizeof sa.sun_path);
|
||||
if (size >= sizeof sa.sun_path) {
|
||||
errno = ENAMETOOLONG;
|
||||
fatal("socket failed");
|
||||
return (-1);
|
||||
}
|
||||
unlink(sa.sun_path);
|
||||
|
||||
if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
|
||||
fatal("socket failed");
|
||||
return (-1);
|
||||
|
||||
mask = umask(S_IXUSR|S_IXGRP|S_IRWXO);
|
||||
if (bind(fd, (struct sockaddr *) &sa, SUN_LEN(&sa)) == -1)
|
||||
fatal("bind failed");
|
||||
if (bind(fd, (struct sockaddr *) &sa, sizeof(sa)) == -1)
|
||||
return (-1);
|
||||
umask(mask);
|
||||
|
||||
if (listen(fd, 16) == -1)
|
||||
fatal("listen failed");
|
||||
return (-1);
|
||||
setblocking(fd, 0);
|
||||
|
||||
server_update_socket();
|
||||
|
||||
return (fd);
|
||||
}
|
||||
|
||||
/* Fork new server. */
|
||||
int
|
||||
server_start(int lockfd, char *lockfile)
|
||||
server_start(struct event_base *base, int lockfd, char *lockfile)
|
||||
{
|
||||
int pair[2];
|
||||
struct timeval tv;
|
||||
char *cause;
|
||||
int pair[2];
|
||||
|
||||
/* The first client is special and gets a socketpair; create it. */
|
||||
if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, pair) != 0)
|
||||
fatal("socketpair failed");
|
||||
|
||||
switch (fork()) {
|
||||
case -1:
|
||||
fatal("fork failed");
|
||||
case 0:
|
||||
break;
|
||||
default:
|
||||
server_proc = proc_start("server", base, 1, server_signal);
|
||||
if (server_proc == NULL) {
|
||||
close(pair[1]);
|
||||
return (pair[0]);
|
||||
}
|
||||
close(pair[0]);
|
||||
|
||||
/*
|
||||
* Must daemonise before loading configuration as the PID changes so
|
||||
* $TMUX would be wrong for sessions created in the config file.
|
||||
*/
|
||||
if (daemon(1, 0) != 0)
|
||||
fatal("daemon failed");
|
||||
if (log_get_level() > 3)
|
||||
tty_create_log();
|
||||
|
||||
/* event_init() was called in our parent, need to reinit. */
|
||||
if (event_reinit(ev_base) != 0)
|
||||
fatal("event_reinit failed");
|
||||
clear_signals(0);
|
||||
|
||||
logfile("server");
|
||||
log_debug("server started, pid %ld", (long) getpid());
|
||||
|
||||
ARRAY_INIT(&windows);
|
||||
RB_INIT(&all_window_panes);
|
||||
ARRAY_INIT(&clients);
|
||||
ARRAY_INIT(&dead_clients);
|
||||
RB_INIT(&sessions);
|
||||
RB_INIT(&dead_sessions);
|
||||
TAILQ_INIT(&session_groups);
|
||||
ARRAY_INIT(&global_buffers);
|
||||
mode_key_init_trees();
|
||||
key_bindings_init();
|
||||
utf8_build();
|
||||
|
||||
start_time = time(NULL);
|
||||
log_debug("socket path %s", socket_path);
|
||||
#ifdef HAVE_SETPROCTITLE
|
||||
setproctitle("server (%s)", socket_path);
|
||||
#ifdef __OpenBSD__
|
||||
if (pledge("stdio rpath wpath cpath fattr unix getpw recvfd proc exec "
|
||||
"tty ps", NULL) != 0)
|
||||
fatal("pledge failed");
|
||||
#endif
|
||||
|
||||
RB_INIT(&windows);
|
||||
RB_INIT(&all_window_panes);
|
||||
TAILQ_INIT(&clients);
|
||||
RB_INIT(&sessions);
|
||||
TAILQ_INIT(&session_groups);
|
||||
mode_key_init_trees();
|
||||
key_bindings_init();
|
||||
|
||||
gettimeofday(&start_time, NULL);
|
||||
|
||||
server_fd = server_create_socket();
|
||||
if (server_fd == -1)
|
||||
fatal("couldn't create socket");
|
||||
server_update_socket();
|
||||
server_client_create(pair[1]);
|
||||
|
||||
unlink(lockfile);
|
||||
free(lockfile);
|
||||
close(lockfd);
|
||||
|
||||
cfg_cmd_q = cmdq_new(NULL);
|
||||
cfg_cmd_q->emptyfn = cfg_default_done;
|
||||
cfg_finished = 0;
|
||||
cfg_references = 1;
|
||||
ARRAY_INIT(&cfg_causes);
|
||||
|
||||
if (access(SYSTEM_CFG, R_OK) == 0) {
|
||||
if (load_cfg(SYSTEM_CFG, cfg_cmd_q, &cause) == -1) {
|
||||
xasprintf(&cause, "%s: %s", SYSTEM_CFG, cause);
|
||||
ARRAY_ADD(&cfg_causes, cause);
|
||||
}
|
||||
} else if (errno != ENOENT) {
|
||||
xasprintf(&cause, "%s: %s", SYSTEM_CFG, strerror(errno));
|
||||
ARRAY_ADD(&cfg_causes, cause);
|
||||
}
|
||||
if (cfg_file != NULL) {
|
||||
if (load_cfg(cfg_file, cfg_cmd_q, &cause) == -1) {
|
||||
xasprintf(&cause, "%s: %s", cfg_file, cause);
|
||||
ARRAY_ADD(&cfg_causes, cause);
|
||||
}
|
||||
}
|
||||
if (tmate_cfg_file != NULL) {
|
||||
if (load_cfg(tmate_cfg_file, cfg_cmd_q, &cause) == -1) {
|
||||
xasprintf(&cause, "%s: %s", tmate_cfg_file, cause);
|
||||
ARRAY_ADD(&cfg_causes, cause);
|
||||
}
|
||||
if (lockfd >= 0) {
|
||||
unlink(lockfile);
|
||||
free(lockfile);
|
||||
close(lockfd);
|
||||
}
|
||||
|
||||
tmate_session_init();
|
||||
cmdq_continue(cfg_cmd_q);
|
||||
#ifdef TMATE
|
||||
tmate_session_init(base);
|
||||
#endif
|
||||
|
||||
start_cfg();
|
||||
|
||||
status_prompt_load_history();
|
||||
|
||||
server_add_accept(0);
|
||||
|
||||
memset(&tv, 0, sizeof tv);
|
||||
tv.tv_sec = 1;
|
||||
evtimer_set(&server_ev_second, server_second_callback, NULL);
|
||||
evtimer_add(&server_ev_second, &tv);
|
||||
|
||||
set_signals(server_signal_callback);
|
||||
|
||||
/* tmate_session_start() is called in cfg_default_done */
|
||||
server_loop();
|
||||
proc_loop(server_proc, server_loop);
|
||||
status_prompt_save_history();
|
||||
exit(0);
|
||||
}
|
||||
|
||||
/* Main server loop. */
|
||||
void
|
||||
/* Server loop callback. */
|
||||
int
|
||||
server_loop(void)
|
||||
{
|
||||
while (!server_should_shutdown()) {
|
||||
event_loop(EVLOOP_ONCE);
|
||||
struct client *c;
|
||||
|
||||
server_window_loop();
|
||||
server_client_loop();
|
||||
server_client_loop();
|
||||
|
||||
key_bindings_clean();
|
||||
server_clean_dead();
|
||||
}
|
||||
}
|
||||
|
||||
/* Check if the server should be shutting down (no more clients or sessions). */
|
||||
int
|
||||
server_should_shutdown(void)
|
||||
{
|
||||
u_int i;
|
||||
|
||||
if (!options_get_number(&global_options, "exit-unattached")) {
|
||||
if (!options_get_number(global_options, "exit-unattached")) {
|
||||
if (!RB_EMPTY(&sessions))
|
||||
return (0);
|
||||
}
|
||||
for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
|
||||
if (ARRAY_ITEM(&clients, i) != NULL)
|
||||
|
||||
TAILQ_FOREACH(c, &clients, entry) {
|
||||
if (c->session != NULL)
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* No attached clients therefore want to exit - flush any waiting
|
||||
* clients but don't actually exit until they've gone.
|
||||
*/
|
||||
cmd_wait_for_flush();
|
||||
if (!TAILQ_EMPTY(&clients))
|
||||
return (0);
|
||||
|
||||
return (1);
|
||||
}
|
||||
|
||||
/* Shutdown the server by killing all clients and windows. */
|
||||
/* Exit the server by killing all clients and windows. */
|
||||
void
|
||||
server_send_shutdown(void)
|
||||
server_send_exit(void)
|
||||
{
|
||||
struct client *c;
|
||||
struct session *s, *next_s;
|
||||
u_int i;
|
||||
struct client *c, *c1;
|
||||
struct session *s, *s1;
|
||||
|
||||
for (i = 0; i < ARRAY_LENGTH(&clients); i++) {
|
||||
c = ARRAY_ITEM(&clients, i);
|
||||
if (c != NULL) {
|
||||
if (c->flags & (CLIENT_BAD|CLIENT_SUSPENDED))
|
||||
server_client_lost(c);
|
||||
else
|
||||
server_write_client(c, MSG_SHUTDOWN, NULL, 0);
|
||||
c->session = NULL;
|
||||
}
|
||||
cmd_wait_for_flush();
|
||||
|
||||
TAILQ_FOREACH_SAFE(c, &clients, entry, c1) {
|
||||
if (c->flags & CLIENT_SUSPENDED)
|
||||
server_client_lost(c);
|
||||
else
|
||||
proc_send(c->peer, MSG_SHUTDOWN, -1, NULL, 0);
|
||||
c->session = NULL;
|
||||
}
|
||||
|
||||
s = RB_MIN(sessions, &sessions);
|
||||
while (s != NULL) {
|
||||
next_s = RB_NEXT(sessions, &sessions, s);
|
||||
RB_FOREACH_SAFE(s, sessions, &sessions, s1)
|
||||
session_destroy(s);
|
||||
s = next_s;
|
||||
}
|
||||
}
|
||||
|
||||
/* Free dead, unreferenced clients and sessions. */
|
||||
void
|
||||
server_clean_dead(void)
|
||||
{
|
||||
struct session *s, *next_s;
|
||||
struct client *c;
|
||||
u_int i;
|
||||
|
||||
s = RB_MIN(sessions, &dead_sessions);
|
||||
while (s != NULL) {
|
||||
next_s = RB_NEXT(sessions, &dead_sessions, s);
|
||||
if (s->references == 0) {
|
||||
RB_REMOVE(sessions, &dead_sessions, s);
|
||||
free(s->name);
|
||||
free(s);
|
||||
}
|
||||
s = next_s;
|
||||
}
|
||||
|
||||
for (i = 0; i < ARRAY_LENGTH(&dead_clients); i++) {
|
||||
c = ARRAY_ITEM(&dead_clients, i);
|
||||
if (c == NULL || c->references != 0)
|
||||
continue;
|
||||
ARRAY_SET(&dead_clients, i, NULL);
|
||||
free(c);
|
||||
}
|
||||
}
|
||||
|
||||
/* Update socket execute permissions based on whether sessions are attached. */
|
||||
|
|
@ -335,7 +281,7 @@ server_update_socket(void)
|
|||
|
||||
/* Callback for server socket. */
|
||||
void
|
||||
server_accept_callback(int fd, short events, unused void *data)
|
||||
server_accept(int fd, short events, __unused void *data)
|
||||
{
|
||||
struct sockaddr_storage sa;
|
||||
socklen_t slen = sizeof sa;
|
||||
|
|
@ -356,7 +302,7 @@ server_accept_callback(int fd, short events, unused void *data)
|
|||
}
|
||||
fatal("accept failed");
|
||||
}
|
||||
if (server_shutdown) {
|
||||
if (server_exit) {
|
||||
close(newfd);
|
||||
return;
|
||||
}
|
||||
|
|
@ -376,32 +322,38 @@ server_add_accept(int timeout)
|
|||
event_del(&server_ev_accept);
|
||||
|
||||
if (timeout == 0) {
|
||||
event_set(&server_ev_accept,
|
||||
server_fd, EV_READ, server_accept_callback, NULL);
|
||||
event_set(&server_ev_accept, server_fd, EV_READ, server_accept,
|
||||
NULL);
|
||||
event_add(&server_ev_accept, NULL);
|
||||
} else {
|
||||
event_set(&server_ev_accept,
|
||||
server_fd, EV_TIMEOUT, server_accept_callback, NULL);
|
||||
event_set(&server_ev_accept, server_fd, EV_TIMEOUT,
|
||||
server_accept, NULL);
|
||||
event_add(&server_ev_accept, &tv);
|
||||
}
|
||||
}
|
||||
|
||||
/* Signal handler. */
|
||||
void
|
||||
server_signal_callback(int sig, unused short events, unused void *data)
|
||||
server_signal(int sig)
|
||||
{
|
||||
int fd;
|
||||
|
||||
switch (sig) {
|
||||
case SIGTERM:
|
||||
server_shutdown = 1;
|
||||
server_send_shutdown();
|
||||
server_exit = 1;
|
||||
server_send_exit();
|
||||
break;
|
||||
case SIGCHLD:
|
||||
server_child_signal();
|
||||
break;
|
||||
case SIGUSR1:
|
||||
event_del(&server_ev_accept);
|
||||
close(server_fd);
|
||||
server_fd = server_create_socket();
|
||||
fd = server_create_socket();
|
||||
if (fd != -1) {
|
||||
close(server_fd);
|
||||
server_fd = fd;
|
||||
server_update_socket();
|
||||
}
|
||||
server_add_accept(0);
|
||||
break;
|
||||
}
|
||||
|
|
@ -434,17 +386,15 @@ server_child_signal(void)
|
|||
void
|
||||
server_child_exited(pid_t pid, int status)
|
||||
{
|
||||
struct window *w;
|
||||
struct window *w, *w1;
|
||||
struct window_pane *wp;
|
||||
struct job *job;
|
||||
u_int i;
|
||||
|
||||
for (i = 0; i < ARRAY_LENGTH(&windows); i++) {
|
||||
if ((w = ARRAY_ITEM(&windows, i)) == NULL)
|
||||
continue;
|
||||
RB_FOREACH_SAFE(w, windows, &windows, w1) {
|
||||
TAILQ_FOREACH(wp, &w->panes, entry) {
|
||||
if (wp->pid == pid) {
|
||||
server_destroy_pane(wp);
|
||||
wp->status = status;
|
||||
server_destroy_pane(wp, 1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
|
@ -464,14 +414,11 @@ server_child_stopped(pid_t pid, int status)
|
|||
{
|
||||
struct window *w;
|
||||
struct window_pane *wp;
|
||||
u_int i;
|
||||
|
||||
if (WSTOPSIG(status) == SIGTTIN || WSTOPSIG(status) == SIGTTOU)
|
||||
return;
|
||||
|
||||
for (i = 0; i < ARRAY_LENGTH(&windows); i++) {
|
||||
if ((w = ARRAY_ITEM(&windows, i)) == NULL)
|
||||
continue;
|
||||
RB_FOREACH(w, windows, &windows) {
|
||||
TAILQ_FOREACH(wp, &w->panes, entry) {
|
||||
if (wp->pid == pid) {
|
||||
if (killpg(pid, SIGCONT) != 0)
|
||||
|
|
@ -480,77 +427,3 @@ server_child_stopped(pid_t pid, int status)
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* Handle once-per-second timer events. */
|
||||
void
|
||||
server_second_callback(unused int fd, unused short events, unused void *arg)
|
||||
{
|
||||
struct window *w;
|
||||
struct window_pane *wp;
|
||||
struct timeval tv;
|
||||
u_int i;
|
||||
|
||||
if (options_get_number(&global_s_options, "lock-server"))
|
||||
server_lock_server();
|
||||
else
|
||||
server_lock_sessions();
|
||||
|
||||
for (i = 0; i < ARRAY_LENGTH(&windows); i++) {
|
||||
w = ARRAY_ITEM(&windows, i);
|
||||
if (w == NULL)
|
||||
continue;
|
||||
|
||||
TAILQ_FOREACH(wp, &w->panes, entry) {
|
||||
if (wp->mode != NULL && wp->mode->timer != NULL)
|
||||
wp->mode->timer(wp);
|
||||
}
|
||||
}
|
||||
|
||||
server_client_status_timer();
|
||||
|
||||
evtimer_del(&server_ev_second);
|
||||
memset(&tv, 0, sizeof tv);
|
||||
tv.tv_sec = 1;
|
||||
evtimer_add(&server_ev_second, &tv);
|
||||
}
|
||||
|
||||
/* Lock the server if ALL sessions have hit the time limit. */
|
||||
void
|
||||
server_lock_server(void)
|
||||
{
|
||||
struct session *s;
|
||||
int timeout;
|
||||
time_t t;
|
||||
|
||||
t = time(NULL);
|
||||
RB_FOREACH(s, sessions, &sessions) {
|
||||
if (s->flags & SESSION_UNATTACHED)
|
||||
continue;
|
||||
timeout = options_get_number(&s->options, "lock-after-time");
|
||||
if (timeout <= 0 || t <= s->activity_time.tv_sec + timeout)
|
||||
return; /* not timed out */
|
||||
}
|
||||
|
||||
server_lock();
|
||||
recalculate_sizes();
|
||||
}
|
||||
|
||||
/* Lock any sessions which have timed out. */
|
||||
void
|
||||
server_lock_sessions(void)
|
||||
{
|
||||
struct session *s;
|
||||
int timeout;
|
||||
time_t t;
|
||||
|
||||
t = time(NULL);
|
||||
RB_FOREACH(s, sessions, &sessions) {
|
||||
if (s->flags & SESSION_UNATTACHED)
|
||||
continue;
|
||||
timeout = options_get_number(&s->options, "lock-after-time");
|
||||
if (timeout > 0 && t > s->activity_time.tv_sec + timeout) {
|
||||
server_lock_session(s);
|
||||
recalculate_sizes();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue