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