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