1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  * Copyright 2012 Joyent, Inc.  All rights reserved.
  26  */
  27 
  28 /*
  29  * Console support for zones requires a significant infrastructure.  The
  30  * core pieces are contained in this file, but other portions of note
  31  * are in the zlogin(1M) command, the zcons(7D) driver, and in the
  32  * devfsadm(1M) misc_link generator.
  33  *
  34  * Care is taken to make the console behave in an "intuitive" fashion for
  35  * administrators.  Essentially, we try as much as possible to mimic the
  36  * experience of using a system via a tip line and system controller.
  37  *
  38  * The zone console architecture looks like this:
  39  *
  40  *                                      Global Zone | Non-Global Zone
  41  *                        .--------------.          |
  42  *        .-----------.   | zoneadmd -z  |          | .--------. .---------.
  43  *        | zlogin -C |   |     myzone   |          | | ttymon | | syslogd |
  44  *        `-----------'   `--------------'          | `--------' `---------'
  45  *                  |       |       | |             |      |       |
  46  *  User            |       |       | |             |      V       V
  47  * - - - - - - - - -|- - - -|- - - -|-|- - - - - - -|- - /dev/zconsole - - -
  48  *  Kernel          V       V       | |                        |
  49  *               [AF_UNIX Socket]   | `--------. .-------------'
  50  *                                  |          | |
  51  *                                  |          V V
  52  *                                  |     +-----------+
  53  *                                  |     |  ldterm,  |
  54  *                                  |     |   etc.    |
  55  *                                  |     +-----------+
  56  *                                  |     +-[Anchor]--+
  57  *                                  |     |   ptem    |
  58  *                                  V     +-----------+
  59  *                           +---master---+---slave---+
  60  *                           |                        |
  61  *                           |      zcons driver      |
  62  *                           |    zonename="myzone"   |
  63  *                           +------------------------+
  64  *
  65  * There are basically two major tasks which the console subsystem in
  66  * zoneadmd accomplishes:
  67  *
  68  * - Setup and teardown of zcons driver instances.  One zcons instance
  69  *   is maintained per zone; we take advantage of the libdevice APIs
  70  *   to online new instances of zcons as needed.  Care is taken to
  71  *   prune and manage these appropriately; see init_console_dev() and
  72  *   destroy_console_dev().  The end result is the creation of the
  73  *   zcons(7D) instance and an open file descriptor to the master side.
  74  *   zcons instances are associated with zones via their zonename device
  75  *   property.  This the console instance to persist across reboots,
  76  *   and while the zone is halted.
  77  *
  78  * - Acting as a server for 'zlogin -C' instances.  When zlogin -C is
  79  *   run, zlogin connects to zoneadmd via unix domain socket.  zoneadmd
  80  *   functions as a two-way proxy for console I/O, relaying user input
  81  *   to the master side of the console, and relaying output from the
  82  *   zone to the user.
  83  */
  84 
  85 #include <sys/types.h>
  86 #include <sys/socket.h>
  87 #include <sys/stat.h>
  88 #include <sys/termios.h>
  89 #include <sys/zcons.h>
  90 #include <sys/mkdev.h>
  91 
  92 #include <assert.h>
  93 #include <ctype.h>
  94 #include <errno.h>
  95 #include <fcntl.h>
  96 #include <stdarg.h>
  97 #include <stdio.h>
  98 #include <stdlib.h>
  99 #include <strings.h>
 100 #include <stropts.h>
 101 #include <thread.h>
 102 #include <ucred.h>
 103 #include <unistd.h>
 104 #include <zone.h>
 105 
 106 #include <libdevinfo.h>
 107 #include <libdevice.h>
 108 #include <libzonecfg.h>
 109 
 110 #include <syslog.h>
 111 #include <sys/modctl.h>
 112 
 113 #include "zoneadmd.h"
 114 
 115 #define ZCONSNEX_DEVTREEPATH    "/pseudo/zconsnex@1"
 116 #define ZCONSNEX_FILEPATH       "/devices/pseudo/zconsnex@1"
 117 
 118 #define CONSOLE_SOCKPATH        ZONES_TMPDIR "/%s.console_sock"
 119 
 120 static int      serverfd = -1;  /* console server unix domain socket fd */
 121 char boot_args[BOOTARGS_MAX];
 122 char bad_boot_arg[BOOTARGS_MAX];
 123 
 124 /*
 125  * The eventstream is a simple one-directional flow of messages from the
 126  * door server to the console subsystem, implemented with a pipe.
 127  * It is used to wake up the console poller when it needs to take action,
 128  * message the user, die off, etc.
 129  */
 130 static int eventstream[2];
 131 
 132 
 133 
 134 int
 135 eventstream_init()
 136 {
 137         if (pipe(eventstream) == -1)
 138                 return (-1);
 139         return (0);
 140 }
 141 
 142 void
 143 eventstream_write(zone_evt_t evt)
 144 {
 145         (void) write(eventstream[0], &evt, sizeof (evt));
 146 }
 147 
 148 static zone_evt_t
 149 eventstream_read(void)
 150 {
 151         zone_evt_t evt = Z_EVT_NULL;
 152 
 153         (void) read(eventstream[1], &evt, sizeof (evt));
 154         return (evt);
 155 }
 156 
 157 /*
 158  * count_console_devs() and its helper count_cb() do a walk of the
 159  * subtree of the device tree where zone console nodes are represented.
 160  * The goal is to count zone console instances already setup for a zone
 161  * with the given name.  More than 1 is anomolous, and our caller will
 162  * have to deal with that if we find that's the case.
 163  *
 164  * Note: this algorithm is a linear search of nodes in the zconsnex subtree
 165  * of the device tree, and could be a scalability problem, but I don't see
 166  * how to avoid it.
 167  */
 168 
 169 /*
 170  * cb_data is shared by count_cb and destroy_cb for simplicity.
 171  */
 172 struct cb_data {
 173         zlog_t *zlogp;
 174         int found;
 175         int killed;
 176 };
 177 
 178 static int
 179 count_cb(di_node_t node, void *arg)
 180 {
 181         struct cb_data *cb = (struct cb_data *)arg;
 182         char *prop_data;
 183 
 184         if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zonename",
 185             &prop_data) != -1) {
 186                 assert(prop_data != NULL);
 187                 if (strcmp(prop_data, zone_name) == 0) {
 188                         cb->found++;
 189                         return (DI_WALK_CONTINUE);
 190                 }
 191         }
 192         return (DI_WALK_CONTINUE);
 193 }
 194 
 195 static int
 196 count_console_devs(zlog_t *zlogp)
 197 {
 198         di_node_t root;
 199         struct cb_data cb;
 200 
 201         bzero(&cb, sizeof (cb));
 202         cb.zlogp = zlogp;
 203 
 204         if ((root = di_init(ZCONSNEX_DEVTREEPATH, DINFOCPYALL)) ==
 205             DI_NODE_NIL) {
 206                 zerror(zlogp, B_TRUE, "%s failed", "di_init");
 207                 return (-1);
 208         }
 209 
 210         (void) di_walk_node(root, DI_WALK_CLDFIRST, (void *)&cb, count_cb);
 211         di_fini(root);
 212         return (cb.found);
 213 }
 214 
 215 /*
 216  * destroy_console_devs() and its helper destroy_cb() tears down any console
 217  * instances associated with this zone.  If things went very wrong, we
 218  * might have more than one console instance hanging around.  This routine
 219  * hunts down and tries to remove all of them.  Of course, if the console
 220  * is open, the instance will not detach, which is a potential issue.
 221  */
 222 static int
 223 destroy_cb(di_node_t node, void *arg)
 224 {
 225         struct cb_data *cb = (struct cb_data *)arg;
 226         char *prop_data;
 227         char *tmp;
 228         char devpath[MAXPATHLEN];
 229         devctl_hdl_t hdl;
 230 
 231         if (di_prop_lookup_strings(DDI_DEV_T_ANY, node, "zonename",
 232             &prop_data) == -1)
 233                 return (DI_WALK_CONTINUE);
 234 
 235         assert(prop_data != NULL);
 236         if (strcmp(prop_data, zone_name) != 0) {
 237                 /* this is the console for a different zone */
 238                 return (DI_WALK_CONTINUE);
 239         }
 240 
 241         cb->found++;
 242         tmp = di_devfs_path(node);
 243         (void) snprintf(devpath, sizeof (devpath), "/devices/%s", tmp);
 244         di_devfs_path_free(tmp);
 245 
 246         if ((hdl = devctl_device_acquire(devpath, 0)) == NULL) {
 247                 zerror(cb->zlogp, B_TRUE, "WARNING: console %s found, "
 248                     "but it could not be controlled.", devpath);
 249                 return (DI_WALK_CONTINUE);
 250         }
 251         if (devctl_device_remove(hdl) == 0) {
 252                 cb->killed++;
 253         } else {
 254                 zerror(cb->zlogp, B_TRUE, "WARNING: console %s found, "
 255                     "but it could not be removed.", devpath);
 256         }
 257         devctl_release(hdl);
 258         return (DI_WALK_CONTINUE);
 259 }
 260 
 261 static int
 262 destroy_console_devs(zlog_t *zlogp)
 263 {
 264         char conspath[MAXPATHLEN];
 265         di_node_t root;
 266         struct cb_data cb;
 267         int masterfd;
 268         int slavefd;
 269 
 270         /*
 271          * Signal the master side to release its handle on the slave side by
 272          * issuing a ZC_RELEASESLAVE ioctl.
 273          */
 274         (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
 275             zone_name, ZCONS_MASTER_NAME);
 276         if ((masterfd = open(conspath, O_RDWR | O_NOCTTY)) != -1) {
 277                 (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
 278                     zone_name, ZCONS_SLAVE_NAME);
 279                 if ((slavefd = open(conspath, O_RDWR | O_NOCTTY)) != -1) {
 280                         if (ioctl(masterfd, ZC_RELEASESLAVE,
 281                             (caddr_t)(intptr_t)slavefd) != 0)
 282                                 zerror(zlogp, B_TRUE, "WARNING: error while "
 283                                     "releasing slave handle of zone console for"
 284                                     " %s", zone_name);
 285                         (void) close(slavefd);
 286                 } else {
 287                         zerror(zlogp, B_TRUE, "WARNING: could not open slave "
 288                             "side of zone console for %s to release slave "
 289                             "handle", zone_name);
 290                 }
 291                 (void) close(masterfd);
 292         } else {
 293                 zerror(zlogp, B_TRUE, "WARNING: could not open master side of "
 294                     "zone console for %s to release slave handle", zone_name);
 295         }
 296 
 297         bzero(&cb, sizeof (cb));
 298         cb.zlogp = zlogp;
 299 
 300         if ((root = di_init(ZCONSNEX_DEVTREEPATH, DINFOCPYALL)) ==
 301             DI_NODE_NIL) {
 302                 zerror(zlogp, B_TRUE, "%s failed", "di_init");
 303                 return (-1);
 304         }
 305 
 306         (void) di_walk_node(root, DI_WALK_CLDFIRST, (void *)&cb, destroy_cb);
 307         if (cb.found > 1) {
 308                 zerror(zlogp, B_FALSE, "WARNING: multiple zone console "
 309                     "instances detected for zone '%s'; %d of %d "
 310                     "successfully removed.",
 311                     zone_name, cb.killed, cb.found);
 312         }
 313 
 314         di_fini(root);
 315         return (0);
 316 }
 317 
 318 /*
 319  * init_console_dev() drives the device-tree configuration of the zone
 320  * console device.  The general strategy is to use the libdevice (devctl)
 321  * interfaces to instantiate a new zone console node.  We do a lot of
 322  * sanity checking, and are careful to reuse a console if one exists.
 323  *
 324  * Once the device is in the device tree, we kick devfsadm via di_init_devs()
 325  * to ensure that the appropriate symlinks (to the master and slave console
 326  * devices) are placed in /dev in the global zone.
 327  */
 328 static int
 329 init_console_dev(zlog_t *zlogp)
 330 {
 331         char conspath[MAXPATHLEN];
 332         devctl_hdl_t bus_hdl = NULL;
 333         devctl_hdl_t dev_hdl = NULL;
 334         devctl_ddef_t ddef_hdl = NULL;
 335         di_devlink_handle_t dl = NULL;
 336         int rv = -1;
 337         int ndevs;
 338         int masterfd;
 339         int slavefd;
 340         int i;
 341 
 342         /*
 343          * Don't re-setup console if it is working and ready already; just
 344          * skip ahead to making devlinks, which we do for sanity's sake.
 345          */
 346         ndevs = count_console_devs(zlogp);
 347         if (ndevs == 1) {
 348                 goto devlinks;
 349         } else if (ndevs > 1 || ndevs == -1) {
 350                 /*
 351                  * For now, this seems like a reasonable but harsh punishment.
 352                  * If needed, we could try to get clever and delete all but
 353                  * the console which is pointed at by the current symlink.
 354                  */
 355                 if (destroy_console_devs(zlogp) == -1) {
 356                         goto error;
 357                 }
 358         }
 359 
 360         /*
 361          * Time to make the consoles!
 362          */
 363         if ((bus_hdl = devctl_bus_acquire(ZCONSNEX_FILEPATH, 0)) == NULL) {
 364                 zerror(zlogp, B_TRUE, "%s failed", "devctl_bus_acquire");
 365                 goto error;
 366         }
 367         if ((ddef_hdl = devctl_ddef_alloc("zcons", 0)) == NULL) {
 368                 zerror(zlogp, B_TRUE, "failed to allocate ddef handle");
 369                 goto error;
 370         }
 371         /*
 372          * Set three properties on this node; the first is the name of the
 373          * zone; the second is a flag which lets pseudo know that it is
 374          * OK to automatically allocate an instance # for this device;
 375          * the third tells the device framework not to auto-detach this
 376          * node-- we need the node to still be there when we ask devfsadmd
 377          * to make links, and when we need to open it.
 378          */
 379         if (devctl_ddef_string(ddef_hdl, "zonename", zone_name) == -1) {
 380                 zerror(zlogp, B_TRUE, "failed to create zonename property");
 381                 goto error;
 382         }
 383         if (devctl_ddef_int(ddef_hdl, "auto-assign-instance", 1) == -1) {
 384                 zerror(zlogp, B_TRUE, "failed to create auto-assign-instance "
 385                     "property");
 386                 goto error;
 387         }
 388         if (devctl_ddef_int(ddef_hdl, "ddi-no-autodetach", 1) == -1) {
 389                 zerror(zlogp, B_TRUE, "failed to create ddi-no-auto-detach "
 390                     "property");
 391                 goto error;
 392         }
 393         if (devctl_bus_dev_create(bus_hdl, ddef_hdl, 0, &dev_hdl) == -1) {
 394                 zerror(zlogp, B_TRUE, "failed to create console node");
 395                 goto error;
 396         }
 397 
 398 devlinks:
 399         if ((dl = di_devlink_init("zcons", DI_MAKE_LINK)) != NULL) {
 400                 (void) di_devlink_fini(&dl);
 401         } else {
 402                 zerror(zlogp, B_TRUE, "failed to create devlinks");
 403                 goto error;
 404         }
 405 
 406         /*
 407          * Open the master side of the console and issue the ZC_HOLDSLAVE ioctl,
 408          * which will cause the master to retain a reference to the slave.
 409          * This prevents ttymon from blowing through the slave's STREAMS anchor.
 410          */
 411         (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
 412             zone_name, ZCONS_MASTER_NAME);
 413         if ((masterfd = open(conspath, O_RDWR | O_NOCTTY)) == -1) {
 414                 zerror(zlogp, B_TRUE, "ERROR: could not open master side of "
 415                     "zone console for %s to acquire slave handle", zone_name);
 416                 goto error;
 417         }
 418         (void) snprintf(conspath, sizeof (conspath), "/dev/zcons/%s/%s",
 419             zone_name, ZCONS_SLAVE_NAME);
 420         if ((slavefd = open(conspath, O_RDWR | O_NOCTTY)) == -1) {
 421                 zerror(zlogp, B_TRUE, "ERROR: could not open slave side of zone"
 422                     " console for %s to acquire slave handle", zone_name);
 423                 (void) close(masterfd);
 424                 goto error;
 425         }
 426         /*
 427          * This ioctl can occasionally return ENXIO if devfs doesn't have
 428          * everything plumbed up yet due to heavy zone startup load. Wait for
 429          * 1 sec. and retry a few times before we fail to boot the zone.
 430          */
 431         for (i = 0; i < 5; i++) {
 432                 if (ioctl(masterfd, ZC_HOLDSLAVE, (caddr_t)(intptr_t)slavefd)
 433                     == 0) {
 434                         rv = 0;
 435                         break;
 436                 } else if (errno != ENXIO) {
 437                         break;
 438                 }
 439                 (void) sleep(1);
 440         }
 441         if (rv != 0)
 442                 zerror(zlogp, B_TRUE, "ERROR: error while acquiring slave "
 443                     "handle of zone console for %s", zone_name);
 444 
 445         (void) close(slavefd);
 446         (void) close(masterfd);
 447 
 448 error:
 449         if (ddef_hdl)
 450                 devctl_ddef_free(ddef_hdl);
 451         if (bus_hdl)
 452                 devctl_release(bus_hdl);
 453         if (dev_hdl)
 454                 devctl_release(dev_hdl);
 455         return (rv);
 456 }
 457 
 458 static int
 459 init_console_sock(zlog_t *zlogp)
 460 {
 461         int servfd;
 462         struct sockaddr_un servaddr;
 463 
 464         bzero(&servaddr, sizeof (servaddr));
 465         servaddr.sun_family = AF_UNIX;
 466         (void) snprintf(servaddr.sun_path, sizeof (servaddr.sun_path),
 467             CONSOLE_SOCKPATH, zone_name);
 468 
 469         if ((servfd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
 470                 zerror(zlogp, B_TRUE, "console setup: could not create socket");
 471                 return (-1);
 472         }
 473         (void) unlink(servaddr.sun_path);
 474 
 475         if (bind(servfd, (struct sockaddr *)&servaddr,
 476             sizeof (servaddr)) == -1) {
 477                 zerror(zlogp, B_TRUE,
 478                     "console setup: could not bind to socket");
 479                 goto out;
 480         }
 481 
 482         if (listen(servfd, 4) == -1) {
 483                 zerror(zlogp, B_TRUE,
 484                     "console setup: could not listen on socket");
 485                 goto out;
 486         }
 487         return (servfd);
 488 
 489 out:
 490         (void) unlink(servaddr.sun_path);
 491         (void) close(servfd);
 492         return (-1);
 493 }
 494 
 495 static void
 496 destroy_console_sock(int servfd)
 497 {
 498         char path[MAXPATHLEN];
 499 
 500         (void) snprintf(path, sizeof (path), CONSOLE_SOCKPATH, zone_name);
 501         (void) unlink(path);
 502         (void) shutdown(servfd, SHUT_RDWR);
 503         (void) close(servfd);
 504 }
 505 
 506 /*
 507  * Read the "ident" string from the client's descriptor; this routine also
 508  * tolerates being called with pid=NULL, for times when you want to "eat"
 509  * the ident string from a client without saving it.
 510  */
 511 static int
 512 get_client_ident(int clifd, pid_t *pid, char *locale, size_t locale_len)
 513 {
 514         char buf[BUFSIZ], *bufp;
 515         size_t buflen = sizeof (buf);
 516         char c = '\0';
 517         int i = 0, r;
 518 
 519         /* "eat up the ident string" case, for simplicity */
 520         if (pid == NULL) {
 521                 assert(locale == NULL && locale_len == 0);
 522                 while (read(clifd, &c, 1) == 1) {
 523                         if (c == '\n')
 524                                 return (0);
 525                 }
 526         }
 527 
 528         bzero(buf, sizeof (buf));
 529         while ((buflen > 1) && (r = read(clifd, &c, 1)) == 1) {
 530                 buflen--;
 531                 if (c == '\n')
 532                         break;
 533 
 534                 buf[i] = c;
 535                 i++;
 536         }
 537         if (r == -1)
 538                 return (-1);
 539 
 540         /*
 541          * We've filled the buffer, but still haven't seen \n.  Keep eating
 542          * until we find it; we don't expect this to happen, but this is
 543          * defensive.
 544          */
 545         if (c != '\n') {
 546                 while ((r = read(clifd, &c, sizeof (c))) > 0)
 547                         if (c == '\n')
 548                                 break;
 549         }
 550 
 551         /*
 552          * Parse buffer for message of the form: IDENT <pid> <locale>
 553          */
 554         bufp = buf;
 555         if (strncmp(bufp, "IDENT ", 6) != 0)
 556                 return (-1);
 557         bufp += 6;
 558         errno = 0;
 559         *pid = strtoll(bufp, &bufp, 10);
 560         if (errno != 0)
 561                 return (-1);
 562 
 563         while (*bufp != '\0' && isspace(*bufp))
 564                 bufp++;
 565         (void) strlcpy(locale, bufp, locale_len);
 566 
 567         return (0);
 568 }
 569 
 570 static int
 571 accept_client(int servfd, pid_t *pid, char *locale, size_t locale_len)
 572 {
 573         int connfd;
 574         struct sockaddr_un cliaddr;
 575         socklen_t clilen;
 576 
 577         clilen = sizeof (cliaddr);
 578         connfd = accept(servfd, (struct sockaddr *)&cliaddr, &clilen);
 579         if (connfd == -1)
 580                 return (-1);
 581         if (get_client_ident(connfd, pid, locale, locale_len) == -1) {
 582                 (void) shutdown(connfd, SHUT_RDWR);
 583                 (void) close(connfd);
 584                 return (-1);
 585         }
 586         (void) write(connfd, "OK\n", 3);
 587         return (connfd);
 588 }
 589 
 590 static void
 591 reject_client(int servfd, pid_t clientpid)
 592 {
 593         int connfd;
 594         struct sockaddr_un cliaddr;
 595         socklen_t clilen;
 596         char nak[MAXPATHLEN];
 597 
 598         clilen = sizeof (cliaddr);
 599         connfd = accept(servfd, (struct sockaddr *)&cliaddr, &clilen);
 600 
 601         /*
 602          * After hear its ident string, tell client to get lost.
 603          */
 604         if (get_client_ident(connfd, NULL, NULL, 0) == 0) {
 605                 (void) snprintf(nak, sizeof (nak), "%lu\n",
 606                     clientpid);
 607                 (void) write(connfd, nak, strlen(nak));
 608         }
 609         (void) shutdown(connfd, SHUT_RDWR);
 610         (void) close(connfd);
 611 }
 612 
 613 static void
 614 event_message(int clifd, char *clilocale, zone_evt_t evt)
 615 {
 616         char *str, *lstr = NULL;
 617         char lmsg[BUFSIZ];
 618         char outbuf[BUFSIZ];
 619 
 620         if (clifd == -1)
 621                 return;
 622 
 623         switch (evt) {
 624         case Z_EVT_ZONE_BOOTING:
 625                 if (*boot_args == '\0') {
 626                         str = "NOTICE: Zone booting up";
 627                         break;
 628                 }
 629                 /*LINTED*/
 630                 (void) snprintf(lmsg, sizeof (lmsg), localize_msg(clilocale,
 631                     "NOTICE: Zone booting up with arguments: %s"), boot_args);
 632                 lstr = lmsg;
 633                 break;
 634         case Z_EVT_ZONE_READIED:
 635                 str = "NOTICE: Zone readied";
 636                 break;
 637         case Z_EVT_ZONE_HALTED:
 638                 str = "NOTICE: Zone halted";
 639                 break;
 640         case Z_EVT_ZONE_REBOOTING:
 641                 if (*boot_args == '\0') {
 642                         str = "NOTICE: Zone rebooting";
 643                         break;
 644                 }
 645                 /*LINTED*/
 646                 (void) snprintf(lmsg, sizeof (lmsg), localize_msg(clilocale,
 647                     "NOTICE: Zone rebooting with arguments: %s"), boot_args);
 648                 lstr = lmsg;
 649                 break;
 650         case Z_EVT_ZONE_UNINSTALLING:
 651                 str = "NOTICE: Zone is being uninstalled.  Disconnecting...";
 652                 break;
 653         case Z_EVT_ZONE_BOOTFAILED:
 654                 str = "NOTICE: Zone boot failed";
 655                 break;
 656         case Z_EVT_ZONE_BADARGS:
 657                 /*LINTED*/
 658                 (void) snprintf(lmsg, sizeof (lmsg),
 659                     localize_msg(clilocale,
 660                     "WARNING: Ignoring invalid boot arguments: %s"),
 661                     bad_boot_arg);
 662                 lstr = lmsg;
 663                 break;
 664         default:
 665                 return;
 666         }
 667 
 668         if (lstr == NULL)
 669                 lstr = localize_msg(clilocale, str);
 670         (void) snprintf(outbuf, sizeof (outbuf), "\r\n[%s]\r\n", lstr);
 671         (void) write(clifd, outbuf, strlen(outbuf));
 672 }
 673 
 674 /*
 675  * Check to see if the client at the other end of the socket is still
 676  * alive; we know it is not if it throws EPIPE at us when we try to write
 677  * an otherwise harmless 0-length message to it.
 678  */
 679 static int
 680 test_client(int clifd)
 681 {
 682         if ((write(clifd, "", 0) == -1) && errno == EPIPE)
 683                 return (-1);
 684         return (0);
 685 }
 686 
 687 /*
 688  * This routine drives the console I/O loop.  It polls for input from the
 689  * master side of the console (output to the console), and from the client
 690  * (input from the console user).  Additionally, it polls on the server fd,
 691  * and disconnects any clients that might try to hook up with the zone while
 692  * the console is in use.
 693  *
 694  * When the client first calls us up, it is expected to send a line giving
 695  * its "identity"; this consists of the string 'IDENT <pid> <locale>'.
 696  * This is so that we can report that the console is busy along with
 697  * some diagnostics about who has it busy; the locale is used so that
 698  * asynchronous messages about zone state (like the NOTICE: zone halted
 699  * messages) can be output in the user's locale.
 700  */
 701 static void
 702 do_console_io(zlog_t *zlogp, int consfd, int servfd)
 703 {
 704         struct pollfd pollfds[4];
 705         char ibuf[BUFSIZ];
 706         int cc, ret;
 707         int clifd = -1;
 708         int pollerr = 0;
 709         char clilocale[MAXPATHLEN];
 710         pid_t clipid = 0;
 711 
 712         /* console side, watch for read events */
 713         pollfds[0].fd = consfd;
 714         pollfds[0].events = POLLIN | POLLRDNORM | POLLRDBAND |
 715             POLLPRI | POLLERR | POLLHUP | POLLNVAL;
 716 
 717         /* client side, watch for read events */
 718         pollfds[1].fd = clifd;
 719         pollfds[1].events = pollfds[0].events;
 720 
 721         /* the server socket; watch for events (new connections) */
 722         pollfds[2].fd = servfd;
 723         pollfds[2].events = pollfds[0].events;
 724 
 725         /* the eventstram; watch for events (e.g.: zone halted) */
 726         pollfds[3].fd = eventstream[1];
 727         pollfds[3].events = pollfds[0].events;
 728 
 729         for (;;) {
 730                 pollfds[0].revents = pollfds[1].revents = 0;
 731                 pollfds[2].revents = pollfds[3].revents = 0;
 732 
 733                 ret = poll(pollfds,
 734                     sizeof (pollfds) / sizeof (struct pollfd), -1);
 735                 if (ret == -1 && errno != EINTR) {
 736                         zerror(zlogp, B_TRUE, "poll failed");
 737                         /* we are hosed, close connection */
 738                         break;
 739                 }
 740 
 741                 /* event from console side */
 742                 if (pollfds[0].revents) {
 743                         if (pollfds[0].revents &
 744                             (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) {
 745                                 errno = 0;
 746                                 cc = read(consfd, ibuf, BUFSIZ);
 747                                 if (cc <= 0 && (errno != EINTR) &&
 748                                     (errno != EAGAIN))
 749                                         break;
 750                                 /*
 751                                  * Lose I/O if no one is listening
 752                                  */
 753                                 if (clifd != -1 && cc > 0)
 754                                         (void) write(clifd, ibuf, cc);
 755                         } else {
 756                                 pollerr = pollfds[0].revents;
 757                                 zerror(zlogp, B_FALSE,
 758                                     "closing connection with (console) "
 759                                     "pollerr %d\n", pollerr);
 760                                 break;
 761                         }
 762                 }
 763 
 764                 /* event from client side */
 765                 if (pollfds[1].revents) {
 766                         if (pollfds[1].revents &
 767                             (POLLIN | POLLRDNORM | POLLRDBAND | POLLPRI)) {
 768                                 errno = 0;
 769                                 cc = read(clifd, ibuf, BUFSIZ);
 770                                 if (cc <= 0 && (errno != EINTR) &&
 771                                     (errno != EAGAIN))
 772                                         break;
 773                                 (void) write(consfd, ibuf, cc);
 774                         } else {
 775                                 pollerr = pollfds[1].revents;
 776                                 zerror(zlogp, B_FALSE,
 777                                     "closing connection with (client) "
 778                                     "pollerr %d\n", pollerr);
 779                                 break;
 780                         }
 781                 }
 782 
 783                 /* event from server socket */
 784                 if (pollfds[2].revents &&
 785                     (pollfds[2].revents & (POLLIN | POLLRDNORM))) {
 786                         if (clifd != -1) {
 787                                 /*
 788                                  * Test the client to see if it is really
 789                                  * still alive.  If it has died but we
 790                                  * haven't yet detected that, we might
 791                                  * deny a legitimate connect attempt.  If it
 792                                  * is dead, we break out; once we tear down
 793                                  * the old connection, the new connection
 794                                  * will happen.
 795                                  */
 796                                 if (test_client(clifd) == -1) {
 797                                         break;
 798                                 }
 799                                 /* we're already handling a client */
 800                                 reject_client(servfd, clipid);
 801 
 802 
 803                         } else if ((clifd = accept_client(servfd, &clipid,
 804                             clilocale, sizeof (clilocale))) != -1) {
 805                                 pollfds[1].fd = clifd;
 806 
 807                         } else {
 808                                 break;
 809                         }
 810                 }
 811 
 812                 /*
 813                  * Watch for events on the eventstream.  This is how we get
 814                  * notified of the zone halting, etc.  It provides us a
 815                  * "wakeup" from poll when important things happen, which
 816                  * is good.
 817                  */
 818                 if (pollfds[3].revents) {
 819                         int evt = eventstream_read();
 820                         /*
 821                          * After we drain out the event, if we aren't servicing
 822                          * a console client, we hop back out to our caller,
 823                          * which will check to see if it is time to shutdown
 824                          * the daemon, or if we should take another console
 825                          * service lap.
 826                          */
 827                         if (clifd == -1) {
 828                                 break;
 829                         }
 830                         event_message(clifd, clilocale, evt);
 831                         /*
 832                          * Special handling for the message that the zone is
 833                          * uninstalling; we boot the client, then break out
 834                          * of this function.  When we return to the
 835                          * serve_console loop, we will see that the zone is
 836                          * in a state < READY, and so zoneadmd will shutdown.
 837                          */
 838                         if (evt == Z_EVT_ZONE_UNINSTALLING) {
 839                                 break;
 840                         }
 841                 }
 842 
 843         }
 844 
 845         if (clifd != -1) {
 846                 (void) shutdown(clifd, SHUT_RDWR);
 847                 (void) close(clifd);
 848         }
 849 }
 850 
 851 int
 852 init_console(zlog_t *zlogp)
 853 {
 854         if (init_console_dev(zlogp) == -1) {
 855                 zerror(zlogp, B_FALSE,
 856                     "console setup: device initialization failed");
 857                 return (-1);
 858         }
 859 
 860         if ((serverfd = init_console_sock(zlogp)) == -1) {
 861                 zerror(zlogp, B_FALSE,
 862                     "console setup: socket initialization failed");
 863                 return (-1);
 864         }
 865         return (0);
 866 }
 867 
 868 /*
 869  * serve_console() is the master loop for driving console I/O.  It is also the
 870  * routine which is ultimately responsible for "pulling the plug" on zoneadmd
 871  * when it realizes that the daemon should shut down.
 872  *
 873  * The rules for shutdown are: there must be no console client, and the zone
 874  * state must be < ready.  However, we need to give things a chance to actually
 875  * get going when the daemon starts up-- otherwise the daemon would immediately
 876  * exit on startup if the zone was in the installed state, so we first drop
 877  * into the do_console_io() loop in order to give *something* a chance to
 878  * happen.
 879  */
 880 void
 881 serve_console(zlog_t *zlogp)
 882 {
 883         int masterfd;
 884         zone_state_t zstate;
 885         char conspath[MAXPATHLEN];
 886 
 887         (void) snprintf(conspath, sizeof (conspath),
 888             "/dev/zcons/%s/%s", zone_name, ZCONS_MASTER_NAME);
 889 
 890         for (;;) {
 891                 masterfd = open(conspath, O_RDWR|O_NONBLOCK|O_NOCTTY);
 892                 if (masterfd == -1) {
 893                         zerror(zlogp, B_TRUE, "failed to open console master");
 894                         (void) mutex_lock(&lock);
 895                         goto death;
 896                 }
 897 
 898                 /*
 899                  * Setting RPROTDIS on the stream means that the control
 900                  * portion of messages received (which we don't care about)
 901                  * will be discarded by the stream head.  If we allowed such
 902                  * messages, we wouldn't be able to use read(2), as it fails
 903                  * (EBADMSG) when a message with a control element is received.
 904                  */
 905                 if (ioctl(masterfd, I_SRDOPT, RNORM|RPROTDIS) == -1) {
 906                         zerror(zlogp, B_TRUE, "failed to set options on "
 907                             "console master");
 908                         (void) mutex_lock(&lock);
 909                         goto death;
 910                 }
 911 
 912                 do_console_io(zlogp, masterfd, serverfd);
 913 
 914                 /*
 915                  * We would prefer not to do this, but hostile zone processes
 916                  * can cause the stream to become tainted, and reads will
 917                  * fail.  So, in case something has gone seriously ill,
 918                  * we dismantle the stream and reopen the console when we
 919                  * take another lap.
 920                  */
 921                 (void) close(masterfd);
 922 
 923                 (void) mutex_lock(&lock);
 924                 /*
 925                  * We need to set death_throes (see below) atomically with
 926                  * respect to noticing that (a) we have no console client and
 927                  * (b) the zone is not installed.  Otherwise we could get a
 928                  * request to boot during this time.  Once we set death_throes,
 929                  * any incoming door stuff will be turned away.
 930                  */
 931                 if (zone_get_state(zone_name, &zstate) == Z_OK) {
 932                         if (zstate < ZONE_STATE_READY)
 933                                 goto death;
 934                 } else {
 935                         zerror(zlogp, B_FALSE,
 936                             "unable to determine state of zone");
 937                         goto death;
 938                 }
 939                 /*
 940                  * Even if zone_get_state() fails, stay conservative, and
 941                  * take another lap.
 942                  */
 943                 (void) mutex_unlock(&lock);
 944         }
 945 
 946 death:
 947         assert(MUTEX_HELD(&lock));
 948         in_death_throes = B_TRUE;
 949         (void) mutex_unlock(&lock);
 950 
 951         destroy_console_sock(serverfd);
 952         (void) destroy_console_devs(zlogp);
 953 }