src/lxc/terminal.c

   1 /*
   2  * lxc: linux Container library
   3  *
   4  * (C) Copyright IBM Corp. 2007, 2008
   5  *
   6  * Authors:
   7  * Daniel Lezcano <daniel.lezcano at free.fr>
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22  */
  23
  24 #define _GNU_SOURCE
  25 #include <errno.h>
  26 #include <fcntl.h>
  27 #include <lxc/lxccontainer.h>
  28 #include <pthread.h>
  29 #include <signal.h>
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <sys/epoll.h>
  33 #include <sys/types.h>
  34 #include <termios.h>
  35 #include <unistd.h>
  36
  37 #include "af_unix.h"
  38 #include "caps.h"
  39 #include "commands.h"
  40 #include "conf.h"
  41 #include "config.h"
  42 #include "log.h"
  43 #include "lxclock.h"
  44 #include "mainloop.h"
  45 #include "start.h"
  46 #include "terminal.h"
  47 #include "utils.h"
  48
  49 #if HAVE_PTY_H
  50 #include <pty.h>
  51 #else
  52 #include <../include/openpty.h>
  53 #endif
  54
  55 #define LXC_TERMINAL_BUFFER_SIZE 1024
  56
  57 lxc_log_define(terminal, lxc);
  58
  59 static struct lxc_list lxc_ttys;
  60
  61 typedef void (*sighandler_t)(int);
  62
  63 __attribute__((constructor)) void lxc_terminal_init_global(void)
  64 {
  65         lxc_list_init(&lxc_ttys);
  66 }
  67
  68 void lxc_terminal_winsz(int srcfd, int dstfd)
  69 {
  70         int ret;
  71         struct winsize wsz;
  72
  73         if (!isatty(srcfd))
  74                 return;
  75
  76         ret = ioctl(srcfd, TIOCGWINSZ, &wsz);
  77         if (ret < 0) {
  78                 WARN("Failed to get window size");
  79                 return;
  80         }
  81
  82         ret = ioctl(dstfd, TIOCSWINSZ, &wsz);
  83         if (ret < 0)
  84                 WARN("Failed to set window size");
  85         else
  86                 DEBUG("Set window size to %d columns and %d rows", wsz.ws_col,
  87                       wsz.ws_row);
  88
  89         return;
  90 }
  91
  92 static void lxc_terminal_winch(struct lxc_terminal_state *ts)
  93 {
  94         lxc_terminal_winsz(ts->stdinfd, ts->masterfd);
  95
  96         if (ts->winch_proxy)
  97                 lxc_cmd_terminal_winch(ts->winch_proxy, ts->winch_proxy_lxcpath);
  98 }
  99
 100 void lxc_terminal_sigwinch(int sig)
 101 {
 102         struct lxc_list *it;
 103         struct lxc_terminal_state *ts;
 104
 105         lxc_list_for_each(it, &lxc_ttys) {
 106                 ts = it->elem;
 107                 lxc_terminal_winch(ts);
 108         }
 109 }
 110
 111 int lxc_terminal_signalfd_cb(int fd, uint32_t events, void *cbdata,
 112                              struct lxc_epoll_descr *descr)
 113 {
 114         ssize_t ret;
 115         struct signalfd_siginfo siginfo;
 116         struct lxc_terminal_state *ts = cbdata;
 117
 118         ret = read(fd, &siginfo, sizeof(siginfo));
 119         if (ret < 0 || (size_t)ret < sizeof(siginfo)) {
 120                 ERROR("Failed to read signal info");
 121                 return LXC_MAINLOOP_ERROR;
 122         }
 123
 124         if (siginfo.ssi_signo == SIGTERM) {
 125                 DEBUG("Received SIGTERM. Detaching from the terminal");
 126                 return LXC_MAINLOOP_CLOSE;
 127         }
 128
 129         if (siginfo.ssi_signo == SIGWINCH)
 130                 lxc_terminal_winch(ts);
 131
 132         return LXC_MAINLOOP_CONTINUE;
 133 }
 134
 135 struct lxc_terminal_state *lxc_terminal_signal_init(int srcfd, int dstfd)
 136 {
 137         int ret;
 138         bool istty = false;
 139         sigset_t mask;
 140         struct lxc_terminal_state *ts;
 141
 142         ts = malloc(sizeof(*ts));
 143         if (!ts)
 144                 return NULL;
 145
 146         memset(ts, 0, sizeof(*ts));
 147         ts->stdinfd = srcfd;
 148         ts->masterfd = dstfd;
 149         ts->sigfd = -1;
 150
 151         ret = sigemptyset(&mask);
 152         if (ret < 0) {
 153                 SYSERROR("Failed to initialize an empty signal set");
 154                 goto on_error;
 155         }
 156
 157         istty = (isatty(srcfd) == 1);
 158         if (!istty) {
 159                 INFO("fd %d does not refer to a tty device", srcfd);
 160         } else {
 161                 /* Add tty to list to be scanned at SIGWINCH time. */
 162                 lxc_list_add_elem(&ts->node, ts);
 163                 lxc_list_add_tail(&lxc_ttys, &ts->node);
 164                 ret = sigaddset(&mask, SIGWINCH);
 165                 if (ret < 0)
 166                         NOTICE("%s - Failed to add SIGWINCH to signal set",
 167                                strerror(errno));
 168         }
 169
 170         /* Exit the mainloop cleanly on SIGTERM. */
 171         ret = sigaddset(&mask, SIGTERM);
 172         if (ret < 0) {
 173                 SYSERROR("Failed to add SIGWINCH to signal set");
 174                 goto on_error;
 175         }
 176
 177         ret = pthread_sigmask(SIG_BLOCK, &mask, &ts->oldmask);
 178         if (ret < 0) {
 179                 WARN("Failed to block signals");
 180                 goto on_error;
 181         }
 182
 183         ts->sigfd = signalfd(-1, &mask, SFD_CLOEXEC);
 184         if (ts->sigfd < 0) {
 185                 WARN("Failed to create signal fd");
 186                 (void)pthread_sigmask(SIG_SETMASK, &ts->oldmask, NULL);
 187                 goto on_error;
 188         }
 189
 190         DEBUG("Created signal fd %d", ts->sigfd);
 191         return ts;
 192
 193 on_error:
 194         ERROR("Failed to create signal fd");
 195         if (ts->sigfd >= 0) {
 196                 close(ts->sigfd);
 197                 ts->sigfd = -1;
 198         }
 199
 200         if (istty)
 201                 lxc_list_del(&ts->node);
 202
 203         return ts;
 204 }
 205
 206 void lxc_terminal_signal_fini(struct lxc_terminal_state *ts)
 207 {
 208         if (ts->sigfd >= 0) {
 209                 close(ts->sigfd);
 210
 211                 if (pthread_sigmask(SIG_SETMASK, &ts->oldmask, NULL) < 0)
 212                         SYSWARN("Failed to restore signal mask");
 213         }
 214
 215         if (isatty(ts->stdinfd))
 216                 lxc_list_del(&ts->node);
 217
 218         free(ts);
 219 }
 220
 221 static int lxc_terminal_truncate_log_file(struct lxc_terminal *terminal)
 222 {
 223         /* be very certain things are kosher */
 224         if (!terminal->log_path || terminal->log_fd < 0)
 225                 return -EBADF;
 226
 227         return lxc_unpriv(ftruncate(terminal->log_fd, 0));
 228 }
 229
 230 static int lxc_terminal_rotate_log_file(struct lxc_terminal *terminal)
 231 {
 232         int ret;
 233         size_t len;
 234         char *tmp;
 235
 236         if (!terminal->log_path || terminal->log_rotate == 0)
 237                 return -EOPNOTSUPP;
 238
 239         /* be very certain things are kosher */
 240         if (terminal->log_fd < 0)
 241                 return -EBADF;
 242
 243         len = strlen(terminal->log_path) + sizeof(".1");
 244         tmp = alloca(len);
 245
 246         ret = snprintf(tmp, len, "%s.1", terminal->log_path);
 247         if (ret < 0 || (size_t)ret >= len)
 248                 return -EFBIG;
 249
 250         close(terminal->log_fd);
 251         terminal->log_fd = -1;
 252         ret = lxc_unpriv(rename(terminal->log_path, tmp));
 253         if (ret < 0)
 254                 return ret;
 255
 256         return lxc_terminal_create_log_file(terminal);
 257 }
 258
 259 static int lxc_terminal_write_log_file(struct lxc_terminal *terminal, char *buf,
 260                                        int bytes_read)
 261 {
 262         int ret;
 263         struct stat st;
 264         int64_t space_left = -1;
 265
 266         if (terminal->log_fd < 0)
 267                 return 0;
 268
 269         /* A log size <= 0 means that there's no limit on the size of the log
 270          * file at which point we simply ignore whether the log is supposed to
 271          * be rotated or not.
 272          */
 273         if (terminal->log_size <= 0)
 274                 return lxc_write_nointr(terminal->log_fd, buf, bytes_read);
 275
 276         /* Get current size of the log file. */
 277         ret = fstat(terminal->log_fd, &st);
 278         if (ret < 0) {
 279                 SYSERROR("Failed to stat the terminal log file descriptor");
 280                 return -1;
 281         }
 282
 283         /* handle non-regular files */
 284         if ((st.st_mode & S_IFMT) != S_IFREG) {
 285                 /* This isn't a regular file. so rotating the file seems a
 286                  * dangerous thing to do, size limits are also very
 287                  * questionable. Let's not risk anything and tell the user that
 288                  * he's requesting us to do weird stuff.
 289                  */
 290                 if (terminal->log_rotate > 0 || terminal->log_size > 0)
 291                         return -EINVAL;
 292
 293                 /* I mean, sure log wherever you want to. */
 294                 return lxc_write_nointr(terminal->log_fd, buf, bytes_read);
 295         }
 296
 297         space_left = terminal->log_size - st.st_size;
 298
 299         /* User doesn't want to rotate the log file and there's no more space
 300          * left so simply truncate it.
 301          */
 302         if (space_left <= 0 && terminal->log_rotate <= 0) {
 303                 ret = lxc_terminal_truncate_log_file(terminal);
 304                 if (ret < 0)
 305                         return ret;
 306
 307                 if (bytes_read <= terminal->log_size)
 308                         return lxc_write_nointr(terminal->log_fd, buf, bytes_read);
 309
 310                 /* Write as much as we can into the buffer and loose the rest. */
 311                 return lxc_write_nointr(terminal->log_fd, buf, terminal->log_size);
 312         }
 313
 314         /* There's enough space left. */
 315         if (bytes_read <= space_left)
 316                 return lxc_write_nointr(terminal->log_fd, buf, bytes_read);
 317
 318         /* There's not enough space left but at least write as much as we can
 319          * into the old log file.
 320          */
 321         ret = lxc_write_nointr(terminal->log_fd, buf, space_left);
 322         if (ret < 0)
 323                 return -1;
 324
 325         /* Calculate how many bytes we still need to write. */
 326         bytes_read -= space_left;
 327
 328         /* There'd be more to write but we aren't instructed to rotate the log
 329          * file so simply return. There's no error on our side here.
 330          */
 331         if (terminal->log_rotate > 0)
 332                 ret = lxc_terminal_rotate_log_file(terminal);
 333         else
 334                 ret = lxc_terminal_truncate_log_file(terminal);
 335         if (ret < 0)
 336                 return ret;
 337
 338         if (terminal->log_size < bytes_read) {
 339                 /* Well, this is unfortunate because it means that there is more
 340                  * to write than the user has granted us space. There are
 341                  * multiple ways to handle this but let's use the simplest one:
 342                  * write as much as we can, tell the user that there was more
 343                  * stuff to write and move on.
 344                  * Note that this scenario shouldn't actually happen with the
 345                  * standard pty-based terminal that LXC allocates since it will
 346                  * be switched into raw mode. In raw mode only 1 byte at a time
 347                  * should be read and written.
 348                  */
 349                 WARN("Size of terminal log file is smaller than the bytes to write");
 350                 ret = lxc_write_nointr(terminal->log_fd, buf, terminal->log_size);
 351                 if (ret < 0)
 352                         return -1;
 353                 bytes_read -= ret;
 354                 return bytes_read;
 355         }
 356
 357         /* Yay, we made it. */
 358         ret = lxc_write_nointr(terminal->log_fd, buf, bytes_read);
 359         if (ret < 0)
 360                 return -1;
 361         bytes_read -= ret;
 362         return bytes_read;
 363 }
 364
 365 int lxc_terminal_io_cb(int fd, uint32_t events, void *data,
 366                        struct lxc_epoll_descr *descr)
 367 {
 368         struct lxc_terminal *terminal = data;
 369         char buf[LXC_TERMINAL_BUFFER_SIZE];
 370         int r, w, w_log, w_rbuf;
 371
 372         w = r = lxc_read_nointr(fd, buf, sizeof(buf));
 373         if (r <= 0) {
 374                 INFO("Terminal client on fd %d has exited", fd);
 375                 lxc_mainloop_del_handler(descr, fd);
 376
 377                 if (fd == terminal->master) {
 378                         terminal->master = -EBADF;
 379                 } else if (fd == terminal->peer) {
 380                         if (terminal->tty_state) {
 381                                 lxc_terminal_signal_fini(terminal->tty_state);
 382                                 terminal->tty_state = NULL;
 383                         }
 384                         terminal->peer = -EBADF;
 385                 } else {
 386                         ERROR("Handler received unexpected file descriptor");
 387                 }
 388                 close(fd);
 389
 390                 return LXC_MAINLOOP_CLOSE;
 391         }
 392
 393         if (fd == terminal->peer)
 394                 w = lxc_write_nointr(terminal->master, buf, r);
 395
 396         w_rbuf = w_log = 0;
 397         if (fd == terminal->master) {
 398                 /* write to peer first */
 399                 if (terminal->peer >= 0)
 400                         w = lxc_write_nointr(terminal->peer, buf, r);
 401
 402                 /* write to terminal ringbuffer */
 403                 if (terminal->buffer_size > 0)
 404                         w_rbuf = lxc_ringbuf_write(&terminal->ringbuf, buf, r);
 405
 406                 /* write to terminal log */
 407                 if (terminal->log_fd >= 0)
 408                         w_log = lxc_terminal_write_log_file(terminal, buf, r);
 409         }
 410
 411         if (w != r)
 412                 WARN("Short write on terminal r:%d != w:%d", r, w);
 413
 414         if (w_rbuf < 0)
 415                 TRACE("%s - Failed to write %d bytes to terminal ringbuffer",
 416                       strerror(-w_rbuf), r);
 417
 418         if (w_log < 0)
 419                 TRACE("Failed to write %d bytes to terminal log", r);
 420
 421         return LXC_MAINLOOP_CONTINUE;
 422 }
 423
 424 static int lxc_terminal_mainloop_add_peer(struct lxc_terminal *terminal)
 425 {
 426         int ret;
 427
 428         if (terminal->peer >= 0) {
 429                 ret = lxc_mainloop_add_handler(terminal->descr, terminal->peer,
 430                                                lxc_terminal_io_cb, terminal);
 431                 if (ret < 0) {
 432                         WARN("Failed to add terminal peer handler to mainloop");
 433                         return -1;
 434                 }
 435         }
 436
 437         if (!terminal->tty_state || terminal->tty_state->sigfd < 0)
 438                 return 0;
 439
 440         ret = lxc_mainloop_add_handler(terminal->descr, terminal->tty_state->sigfd,
 441                                        lxc_terminal_signalfd_cb, terminal->tty_state);
 442         if (ret < 0) {
 443                 WARN("Failed to add signal handler to mainloop");
 444                 return -1;
 445         }
 446
 447         return 0;
 448 }
 449
 450 int lxc_terminal_mainloop_add(struct lxc_epoll_descr *descr,
 451                               struct lxc_terminal *terminal)
 452 {
 453         int ret;
 454
 455         if (terminal->master < 0) {
 456                 INFO("Terminal is not initialized");
 457                 return 0;
 458         }
 459
 460         ret = lxc_mainloop_add_handler(descr, terminal->master,
 461                                        lxc_terminal_io_cb, terminal);
 462         if (ret < 0) {
 463                 ERROR("Failed to add handler for terminal master fd %d to "
 464                       "mainloop", terminal->master);
 465                 return -1;
 466         }
 467
 468         /* We cache the descr so that we can add an fd to it when someone
 469          * does attach to it in lxc_terminal_allocate().
 470          */
 471         terminal->descr = descr;
 472
 473         return lxc_terminal_mainloop_add_peer(terminal);
 474 }
 475
 476 int lxc_setup_tios(int fd, struct termios *oldtios)
 477 {
 478         int ret;
 479         struct termios newtios;
 480
 481         if (!isatty(fd)) {
 482                 ERROR("File descriptor %d does not refert to a terminal", fd);
 483                 return -1;
 484         }
 485
 486         /* Get current termios. */
 487         ret = tcgetattr(fd, oldtios);
 488         if (ret < 0) {
 489                 SYSERROR("Failed to get current terminal settings");
 490                 return -1;
 491         }
 492
 493         /* ensure we don't end up in an endless loop:
 494          * The kernel might fire SIGTTOU while an
 495          * ioctl() in tcsetattr() is executed. When the ioctl()
 496          * is resumed and retries, the signal handler interrupts it again.
 497          */
 498         signal (SIGTTIN, SIG_IGN);
 499         signal (SIGTTOU, SIG_IGN);
 500
 501         newtios = *oldtios;
 502
 503         /* We use the same settings that ssh does. */
 504         newtios.c_iflag |= IGNPAR;
 505         newtios.c_iflag &= ~(ISTRIP | INLCR | IGNCR | ICRNL | IXON | IXANY | IXOFF);
 506 #ifdef IUCLC
 507         newtios.c_iflag &= ~IUCLC;
 508 #endif
 509         newtios.c_lflag &= ~(TOSTOP | ISIG | ICANON | ECHO | ECHOE | ECHOK | ECHONL);
 510 #ifdef IEXTEN
 511         newtios.c_lflag &= ~IEXTEN;
 512 #endif
 513         newtios.c_oflag |= OPOST;
 514         newtios.c_cc[VMIN] = 1;
 515         newtios.c_cc[VTIME] = 0;
 516
 517         /* Set new attributes. */
 518         ret = tcsetattr(fd, TCSAFLUSH, &newtios);
 519         if (ret < 0) {
 520                 ERROR("Failed to set new terminal settings");
 521                 return -1;
 522         }
 523
 524         return 0;
 525 }
 526
 527 static void lxc_terminal_peer_proxy_free(struct lxc_terminal *terminal)
 528 {
 529         if (terminal->tty_state) {
 530                 lxc_terminal_signal_fini(terminal->tty_state);
 531                 terminal->tty_state = NULL;
 532         }
 533
 534         close(terminal->proxy.master);
 535         terminal->proxy.master = -1;
 536
 537         close(terminal->proxy.slave);
 538         terminal->proxy.slave = -1;
 539
 540         terminal->proxy.busy = -1;
 541
 542         terminal->proxy.name[0] = '\0';
 543
 544         terminal->peer = -1;
 545 }
 546
 547 static int lxc_terminal_peer_proxy_alloc(struct lxc_terminal *terminal,
 548                                          int sockfd)
 549 {
 550         int ret;
 551         struct termios oldtermio;
 552         struct lxc_terminal_state *ts;
 553
 554         if (terminal->master < 0) {
 555                 ERROR("Terminal not set up");
 556                 return -1;
 557         }
 558
 559         if (terminal->proxy.busy != -1 || terminal->peer != -1) {
 560                 NOTICE("Terminal already in use");
 561                 return -1;
 562         }
 563
 564         if (terminal->tty_state) {
 565                 ERROR("Terminal has already been initialized");
 566                 return -1;
 567         }
 568
 569         /* This is the proxy terminal that will be given to the client, and
 570          * that the real terminal master will send to / recv from.
 571          */
 572         ret = openpty(&terminal->proxy.master, &terminal->proxy.slave,
 573                       terminal->proxy.name, NULL, NULL);
 574         if (ret < 0) {
 575                 SYSERROR("Failed to open proxy terminal");
 576                 return -1;
 577         }
 578
 579         ret = lxc_setup_tios(terminal->proxy.slave, &oldtermio);
 580         if (ret < 0)
 581                 goto on_error;
 582
 583         ts = lxc_terminal_signal_init(terminal->proxy.master, terminal->master);
 584         if (!ts)
 585                 goto on_error;
 586
 587         terminal->tty_state = ts;
 588         terminal->peer = terminal->proxy.slave;
 589         terminal->proxy.busy = sockfd;
 590         ret = lxc_terminal_mainloop_add_peer(terminal);
 591         if (ret < 0)
 592                 goto on_error;
 593
 594         NOTICE("Opened proxy terminal with master fd %d and slave fd %d",
 595                terminal->proxy.master, terminal->proxy.slave);
 596         return 0;
 597
 598 on_error:
 599         lxc_terminal_peer_proxy_free(terminal);
 600         return -1;
 601 }
 602
 603 int lxc_terminal_allocate(struct lxc_conf *conf, int sockfd, int *ttyreq)
 604 {
 605         int ttynum;
 606         int masterfd = -1;
 607         struct lxc_tty_info *ttys = &conf->ttys;
 608         struct lxc_terminal *terminal = &conf->console;
 609
 610         if (*ttyreq == 0) {
 611                 int ret;
 612
 613                 ret = lxc_terminal_peer_proxy_alloc(terminal, sockfd);
 614                 if (ret < 0)
 615                         goto out;
 616
 617                 masterfd = terminal->proxy.master;
 618                 goto out;
 619         }
 620
 621         if (*ttyreq > 0) {
 622                 if (*ttyreq > ttys->max)
 623                         goto out;
 624
 625                 if (ttys->tty[*ttyreq - 1].busy)
 626                         goto out;
 627
 628                 /* The requested tty is available. */
 629                 ttynum = *ttyreq;
 630                 goto out_tty;
 631         }
 632
 633         /* Search for next available tty, fixup index tty1 => [0]. */
 634         for (ttynum = 1; ttynum <= ttys->max && ttys->tty[ttynum - 1].busy; ttynum++) {
 635                 ;
 636         }
 637
 638         /* We didn't find any available slot for tty. */
 639         if (ttynum > ttys->max)
 640                 goto out;
 641
 642         *ttyreq = ttynum;
 643
 644 out_tty:
 645         ttys->tty[ttynum - 1].busy = sockfd;
 646         masterfd = ttys->tty[ttynum - 1].master;
 647
 648 out:
 649         return masterfd;
 650 }
 651
 652 void lxc_terminal_free(struct lxc_conf *conf, int fd)
 653 {
 654         int i;
 655         struct lxc_tty_info *ttys = &conf->ttys;
 656         struct lxc_terminal *terminal = &conf->console;
 657
 658         for (i = 0; i < ttys->max; i++)
 659                 if (ttys->tty[i].busy == fd)
 660                         ttys->tty[i].busy = 0;
 661
 662         if (terminal->proxy.busy != fd)
 663                 return;
 664
 665         lxc_mainloop_del_handler(terminal->descr, terminal->proxy.slave);
 666         lxc_terminal_peer_proxy_free(terminal);
 667 }
 668
 669 static int lxc_terminal_peer_default(struct lxc_terminal *terminal)
 670 {
 671         struct lxc_terminal_state *ts;
 672         const char *path;
 673         int ret = 0;
 674
 675         if (terminal->path)
 676                 path = terminal->path;
 677         else
 678                 path = "/dev/tty";
 679
 680         terminal->peer = lxc_unpriv(open(path, O_RDWR | O_CLOEXEC));
 681         if (terminal->peer < 0) {
 682                 if (!terminal->path) {
 683                         errno = ENODEV;
 684                         DEBUG("%s - The process does not have a controlling "
 685                               "terminal", strerror(errno));
 686                         goto on_succes;
 687                 }
 688
 689                 ERROR("%s - Failed to open proxy terminal \"%s\"",
 690                       strerror(errno), path);
 691                 return -ENOTTY;
 692         }
 693         DEBUG("Using terminal \"%s\" as proxy", path);
 694
 695         if (!isatty(terminal->peer)) {
 696                 ERROR("File descriptor for \"%s\" does not refer to a terminal", path);
 697                 goto on_error_free_tios;
 698         }
 699
 700         ts = lxc_terminal_signal_init(terminal->peer, terminal->master);
 701         terminal->tty_state = ts;
 702         if (!ts) {
 703                 WARN("Failed to install signal handler");
 704                 goto on_error_free_tios;
 705         }
 706
 707         lxc_terminal_winsz(terminal->peer, terminal->master);
 708
 709         terminal->tios = malloc(sizeof(*terminal->tios));
 710         if (!terminal->tios)
 711                 goto on_error_free_tios;
 712
 713         ret = lxc_setup_tios(terminal->peer, terminal->tios);
 714         if (ret < 0)
 715                 goto on_error_close_peer;
 716         else
 717                 goto on_succes;
 718
 719 on_error_free_tios:
 720         free(terminal->tios);
 721         terminal->tios = NULL;
 722
 723 on_error_close_peer:
 724         close(terminal->peer);
 725         terminal->peer = -1;
 726         ret = -ENOTTY;
 727
 728 on_succes:
 729         return ret;
 730 }
 731
 732 int lxc_terminal_write_ringbuffer(struct lxc_terminal *terminal)
 733 {
 734         char *r_addr;
 735         ssize_t ret;
 736         uint64_t used;
 737         struct lxc_ringbuf *buf = &terminal->ringbuf;
 738
 739         /* There's not log file where we can dump the ringbuffer to. */
 740         if (terminal->log_fd < 0)
 741                 return 0;
 742
 743         used = lxc_ringbuf_used(buf);
 744         if (used == 0)
 745                 return 0;
 746
 747         ret = lxc_terminal_truncate_log_file(terminal);
 748         if (ret < 0)
 749                 return ret;
 750
 751         /* Write as much as we can without exceeding the limit. */
 752         if (terminal->log_size < used)
 753                 used = terminal->log_size;
 754
 755         r_addr = lxc_ringbuf_get_read_addr(buf);
 756         ret = lxc_write_nointr(terminal->log_fd, r_addr, used);
 757         if (ret < 0)
 758                 return -EIO;
 759
 760         return 0;
 761 }
 762
 763 void lxc_terminal_delete(struct lxc_terminal *terminal)
 764 {
 765         int ret;
 766
 767         ret = lxc_terminal_write_ringbuffer(terminal);
 768         if (ret < 0)
 769                 WARN("Failed to write terminal log to disk");
 770
 771         if (terminal->tios && terminal->peer >= 0) {
 772                 ret = tcsetattr(terminal->peer, TCSAFLUSH, terminal->tios);
 773                 if (ret < 0)
 774                         SYSWARN("Failed to set old terminal settings");
 775         }
 776         free(terminal->tios);
 777         terminal->tios = NULL;
 778
 779         if (terminal->peer >= 0)
 780                 close(terminal->peer);
 781         terminal->peer = -1;
 782
 783         if (terminal->master >= 0)
 784                 close(terminal->master);
 785         terminal->master = -1;
 786
 787         if (terminal->slave >= 0)
 788                 close(terminal->slave);
 789         terminal->slave = -1;
 790
 791         if (terminal->log_fd >= 0)
 792                 close(terminal->log_fd);
 793         terminal->log_fd = -1;
 794 }
 795
 796 /**
 797  * Note that this function needs to run before the mainloop starts. Since we
 798  * register a handler for the terminal's masterfd when we create the mainloop
 799  * the terminal handler needs to see an allocated ringbuffer.
 800  */
 801 static int lxc_terminal_create_ringbuf(struct lxc_terminal *terminal)
 802 {
 803         int ret;
 804         struct lxc_ringbuf *buf = &terminal->ringbuf;
 805         uint64_t size = terminal->buffer_size;
 806
 807         /* no ringbuffer previously allocated and no ringbuffer requested */
 808         if (!buf->addr && size <= 0)
 809                 return 0;
 810
 811         /* ringbuffer allocated but no new ringbuffer requested */
 812         if (buf->addr && size <= 0) {
 813                 lxc_ringbuf_release(buf);
 814                 buf->addr = NULL;
 815                 buf->r_off = 0;
 816                 buf->w_off = 0;
 817                 buf->size = 0;
 818                 TRACE("Deallocated terminal ringbuffer");
 819                 return 0;
 820         }
 821
 822         if (size <= 0)
 823                 return 0;
 824
 825         /* check wether the requested size for the ringbuffer has changed */
 826         if (buf->addr && buf->size != size) {
 827                 TRACE("Terminal ringbuffer size changed from %" PRIu64
 828                       " to %" PRIu64 " bytes. Deallocating terminal ringbuffer",
 829                       buf->size, size);
 830                 lxc_ringbuf_release(buf);
 831         }
 832
 833         ret = lxc_ringbuf_create(buf, size);
 834         if (ret < 0) {
 835                 ERROR("Failed to setup %" PRIu64 " byte terminal ringbuffer", size);
 836                 return -1;
 837         }
 838
 839         TRACE("Allocated %" PRIu64 " byte terminal ringbuffer", size);
 840         return 0;
 841 }
 842
 843 /**
 844  * This is the terminal log file. Please note that the terminal log file is
 845  * (implementation wise not content wise) independent of the terminal ringbuffer.
 846  */
 847 int lxc_terminal_create_log_file(struct lxc_terminal *terminal)
 848 {
 849         if (!terminal->log_path)
 850                 return 0;
 851
 852         terminal->log_fd = lxc_unpriv(open(terminal->log_path, O_CLOEXEC | O_RDWR | O_CREAT | O_APPEND, 0600));
 853         if (terminal->log_fd < 0) {
 854                 SYSERROR("Failed to open terminal log file \"%s\"", terminal->log_path);
 855                 return -1;
 856         }
 857
 858         DEBUG("Using \"%s\" as terminal log file", terminal->log_path);
 859         return 0;
 860 }
 861
 862 int lxc_terminal_create(struct lxc_terminal *terminal)
 863 {
 864         int ret;
 865
 866         ret = openpty(&terminal->master, &terminal->slave, terminal->name, NULL, NULL);
 867         if (ret < 0) {
 868                 SYSERROR("Failed to open terminal");
 869                 return -1;
 870         }
 871
 872         ret = fcntl(terminal->master, F_SETFD, FD_CLOEXEC);
 873         if (ret < 0) {
 874                 SYSERROR("Failed to set FD_CLOEXEC flag on terminal master");
 875                 goto err;
 876         }
 877
 878         ret = fcntl(terminal->slave, F_SETFD, FD_CLOEXEC);
 879         if (ret < 0) {
 880                 SYSERROR("Failed to set FD_CLOEXEC flag on terminal slave");
 881                 goto err;
 882         }
 883
 884         ret = lxc_terminal_peer_default(terminal);
 885         if (ret < 0) {
 886                 ERROR("Failed to allocate proxy terminal");
 887                 goto err;
 888         }
 889
 890         return 0;
 891
 892 err:
 893         lxc_terminal_delete(terminal);
 894         return -ENODEV;
 895 }
 896
 897 int lxc_terminal_setup(struct lxc_conf *conf)
 898 {
 899         int ret;
 900         struct lxc_terminal *terminal = &conf->console;
 901
 902         if (terminal->path && strcmp(terminal->path, "none") == 0) {
 903                 INFO("No terminal requested");
 904                 return 0;
 905         }
 906
 907         ret = lxc_terminal_create(terminal);
 908         if (ret < 0)
 909                 return -1;
 910
 911         ret = lxc_terminal_create_log_file(terminal);
 912         if (ret < 0)
 913                 goto err;
 914
 915         ret = lxc_terminal_create_ringbuf(terminal);
 916         if (ret < 0)
 917                 goto err;
 918
 919         return 0;
 920
 921 err:
 922         lxc_terminal_delete(terminal);
 923         return -ENODEV;
 924 }
 925
 926 static bool __terminal_dup2(int duplicate, int original)
 927 {
 928         int ret;
 929
 930         if (!isatty(original))
 931                 return true;
 932
 933         ret = dup2(duplicate, original);
 934         if (ret < 0) {
 935                 SYSERROR("Failed to dup2(%d, %d)", duplicate, original);
 936                 return false;
 937         }
 938
 939         return true;
 940 }
 941
 942 int lxc_terminal_set_stdfds(int fd)
 943 {
 944         int i;
 945
 946         if (fd < 0)
 947                 return 0;
 948
 949         for (i = 0; i < 3; i++)
 950                 if (!__terminal_dup2(fd, (int[]){STDIN_FILENO, STDOUT_FILENO,
 951                                                  STDERR_FILENO}[i]))
 952                         return -1;
 953
 954         return 0;
 955 }
 956
 957 int lxc_terminal_stdin_cb(int fd, uint32_t events, void *cbdata,
 958                           struct lxc_epoll_descr *descr)
 959 {
 960         int ret;
 961         char c;
 962         struct lxc_terminal_state *ts = cbdata;
 963
 964         if (fd != ts->stdinfd)
 965                 return LXC_MAINLOOP_CLOSE;
 966
 967         ret = lxc_read_nointr(ts->stdinfd, &c, 1);
 968         if (ret <= 0)
 969                 return LXC_MAINLOOP_CLOSE;
 970
 971         if (ts->escape >= 1) {
 972                 /* we want to exit the terminal with Ctrl+a q */
 973                 if (c == ts->escape && !ts->saw_escape) {
 974                         ts->saw_escape = 1;
 975                         return LXC_MAINLOOP_CONTINUE;
 976                 }
 977
 978                 if (c == 'q' && ts->saw_escape)
 979                         return LXC_MAINLOOP_CLOSE;
 980
 981                 ts->saw_escape = 0;
 982         }
 983
 984         ret = lxc_write_nointr(ts->masterfd, &c, 1);
 985         if (ret <= 0)
 986                 return LXC_MAINLOOP_CLOSE;
 987
 988         return LXC_MAINLOOP_CONTINUE;
 989 }
 990
 991 int lxc_terminal_master_cb(int fd, uint32_t events, void *cbdata,
 992                            struct lxc_epoll_descr *descr)
 993 {
 994         int r, w;
 995         char buf[LXC_TERMINAL_BUFFER_SIZE];
 996         struct lxc_terminal_state *ts = cbdata;
 997
 998         if (fd != ts->masterfd)
 999                 return LXC_MAINLOOP_CLOSE;
1000
1001         r = lxc_read_nointr(fd, buf, sizeof(buf));
1002         if (r <= 0)
1003                 return LXC_MAINLOOP_CLOSE;
1004
1005         w = lxc_write_nointr(ts->stdoutfd, buf, r);
1006         if (w <= 0 || w != r)
1007                 return LXC_MAINLOOP_CLOSE;
1008
1009         return LXC_MAINLOOP_CONTINUE;
1010 }
1011
1012 int lxc_terminal_getfd(struct lxc_container *c, int *ttynum, int *masterfd)
1013 {
1014         return lxc_cmd_console(c->name, ttynum, masterfd, c->config_path);
1015 }
1016
1017 int lxc_console(struct lxc_container *c, int ttynum,
1018                 int stdinfd, int stdoutfd, int stderrfd,
1019                 int escape)
1020 {
1021         int masterfd, ret, ttyfd;
1022         struct lxc_epoll_descr descr;
1023         struct termios oldtios;
1024         struct lxc_terminal_state *ts;
1025         int istty = 0;
1026
1027         ttyfd = lxc_cmd_console(c->name, &ttynum, &masterfd, c->config_path);
1028         if (ttyfd < 0)
1029                 return -1;
1030
1031         ret = setsid();
1032         if (ret < 0)
1033                 TRACE("Process is already group leader");
1034
1035         ts = lxc_terminal_signal_init(stdinfd, masterfd);
1036         if (!ts) {
1037                 ret = -1;
1038                 goto close_fds;
1039         }
1040         ts->escape = escape;
1041         ts->winch_proxy = c->name;
1042         ts->winch_proxy_lxcpath = c->config_path;
1043         ts->stdoutfd = stdoutfd;
1044
1045         istty = isatty(stdinfd);
1046         if (istty) {
1047                 lxc_terminal_winsz(stdinfd, masterfd);
1048                 lxc_cmd_terminal_winch(ts->winch_proxy, ts->winch_proxy_lxcpath);
1049         } else {
1050                 INFO("File descriptor %d does not refer to a terminal", stdinfd);
1051         }
1052
1053         ret = lxc_mainloop_open(&descr);
1054         if (ret) {
1055                 ERROR("Failed to create mainloop");
1056                 goto sigwinch_fini;
1057         }
1058
1059         if (ts->sigfd != -1) {
1060                 ret = lxc_mainloop_add_handler(&descr, ts->sigfd,
1061                                                lxc_terminal_signalfd_cb, ts);
1062                 if (ret < 0) {
1063                         ERROR("Failed to add signal handler to mainloop");
1064                         goto close_mainloop;
1065                 }
1066         }
1067
1068         ret = lxc_mainloop_add_handler(&descr, ts->stdinfd,
1069                                        lxc_terminal_stdin_cb, ts);
1070         if (ret < 0) {
1071                 ERROR("Failed to add stdin handler");
1072                 goto close_mainloop;
1073         }
1074
1075         ret = lxc_mainloop_add_handler(&descr, ts->masterfd,
1076                                        lxc_terminal_master_cb, ts);
1077         if (ret < 0) {
1078                 ERROR("Failed to add master handler");
1079                 goto close_mainloop;
1080         }
1081
1082         if (ts->escape >= 1) {
1083                 fprintf(stderr,
1084                         "\n"
1085                         "Connected to tty %1$d\n"
1086                         "Type <Ctrl+%2$c q> to exit the console, "
1087                         "<Ctrl+%2$c Ctrl+%2$c> to enter Ctrl+%2$c itself\n",
1088                         ttynum, 'a' + escape - 1);
1089         }
1090
1091         if (istty) {
1092                 ret = lxc_setup_tios(stdinfd, &oldtios);
1093                 if (ret < 0)
1094                         goto close_mainloop;
1095         }
1096
1097         ret = lxc_mainloop(&descr, -1);
1098         if (ret < 0) {
1099                 ERROR("The mainloop returned an error");
1100                 goto restore_tios;
1101         }
1102
1103         ret = 0;
1104
1105 restore_tios:
1106         if (istty) {
1107                 istty = tcsetattr(stdinfd, TCSAFLUSH, &oldtios);
1108                 if (istty < 0)
1109                         SYSWARN("Failed to restore terminal properties");
1110         }
1111
1112 close_mainloop:
1113         lxc_mainloop_close(&descr);
1114
1115 sigwinch_fini:
1116         lxc_terminal_signal_fini(ts);
1117
1118 close_fds:
1119         close(masterfd);
1120         close(ttyfd);
1121
1122         return ret;
1123 }
1124
1125 int lxc_make_controlling_terminal(int fd)
1126 {
1127         int ret;
1128
1129         setsid();
1130
1131         ret = ioctl(fd, TIOCSCTTY, (char *)NULL);
1132         if (ret < 0)
1133                 return -1;
1134
1135         return 0;
1136 }
1137
1138 int lxc_terminal_prepare_login(int fd)
1139 {
1140         int ret;
1141
1142         ret = lxc_make_controlling_terminal(fd);
1143         if (ret < 0)
1144                 return -1;
1145
1146         ret = lxc_terminal_set_stdfds(fd);
1147         if (ret < 0)
1148                 return -1;
1149
1150         if (fd > STDERR_FILENO)
1151                 close(fd);
1152
1153         return 0;
1154 }
1155
1156 void lxc_terminal_info_init(struct lxc_terminal_info *terminal)
1157 {
1158         terminal->name[0] = '\0';
1159         terminal->master = -EBADF;
1160         terminal->slave = -EBADF;
1161         terminal->busy = -1;
1162 }
1163
1164 void lxc_terminal_init(struct lxc_terminal *terminal)
1165 {
1166         memset(terminal, 0, sizeof(*terminal));
1167         terminal->slave = -EBADF;
1168         terminal->master = -EBADF;
1169         terminal->peer = -EBADF;
1170         terminal->log_fd = -EBADF;
1171         lxc_terminal_info_init(&terminal->proxy);
1172 }
1173
1174 void lxc_terminal_conf_free(struct lxc_terminal *terminal)
1175 {
1176         free(terminal->log_path);
1177         free(terminal->path);
1178         if (terminal->buffer_size > 0 && terminal->ringbuf.addr)
1179                 lxc_ringbuf_release(&terminal->ringbuf);
1180 }
1181
1182 int lxc_terminal_map_ids(struct lxc_conf *c, struct lxc_terminal *terminal)
1183 {
1184         int ret;
1185
1186         if (lxc_list_empty(&c->id_map))
1187                 return 0;
1188
1189         if (strcmp(terminal->name, "") == 0)
1190                 return 0;
1191
1192         ret = chown_mapped_root(terminal->name, c);
1193         if (ret < 0) {
1194                 ERROR("Failed to chown terminal \"%s\"", terminal->name);
1195                 return -1;
1196         }
1197
1198         TRACE("Chowned terminal \"%s\"", terminal->name);
1199
1200         return 0;
1201 }