server.c

   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/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
  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
  81 server_clear_marked(void)
  82 {
  83         cmd_find_clear_state(&marked_pane, 0);
  84 }
  85
  86 /* Is this the marked pane? */
  87 int
  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
 101 server_check_marked(void)
 102 {
 103         return (cmd_find_valid_state(&marked_pane));
 104 }
 105
 106 /* Create server socket. */
 107 static int
 108 server_create_socket(int 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
 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
 173 server_start(struct tmuxproc *client, int 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_build_combined();
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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 }