src/weston-launch.c

   1 /*
   2  * Copyright © 2012 Benjamin Franzke
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and
   5  * its documentation for any purpose is hereby granted without fee, provided
   6  * that the above copyright notice appear in all copies and that both that
   7  * copyright notice and this permission notice appear in supporting
   8  * documentation, and that the name of the copyright holders not be used in
   9  * advertising or publicity pertaining to distribution of the software
  10  * without specific, written prior permission.  The copyright holders make
  11  * no representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
  15  * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
  16  * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
  17  * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
  18  * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
  19  * CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  20  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21  */
  22
  23 #define _GNU_SOURCE
  24
  25 #include "config.h"
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <assert.h>
  31 #include <errno.h>
  32
  33 #include <error.h>
  34 #include <getopt.h>
  35
  36 #include <sys/types.h>
  37 #include <sys/ioctl.h>
  38 #include <sys/stat.h>
  39 #include <sys/wait.h>
  40 #include <sys/socket.h>
  41 #include <sys/epoll.h>
  42 #include <sys/signalfd.h>
  43 #include <signal.h>
  44 #include <unistd.h>
  45 #include <fcntl.h>
  46
  47 #include <termios.h>
  48 #include <linux/vt.h>
  49 #include <linux/major.h>
  50
  51 #include <pwd.h>
  52 #include <grp.h>
  53 #include <security/pam_appl.h>
  54
  55 #include <xf86drm.h>
  56
  57 #ifdef HAVE_SYSTEMD_LOGIN
  58 #include <systemd/sd-login.h>
  59 #endif
  60
  61 #include "weston-launch.h"
  62
  63 struct weston_launch {
  64         struct pam_conv pc;
  65         pam_handle_t *ph;
  66         int tty;
  67         int ttynr;
  68         int sock[2];
  69         struct passwd *pw;
  70
  71         int epollfd;
  72         int signalfd;
  73
  74         pid_t child;
  75         int verbose;
  76 };
  77
  78 union cmsg_data { unsigned char b[4]; int fd; };
  79
  80 static gid_t *
  81 read_groups(void)
  82 {
  83         int n;
  84         gid_t *groups;
  85
  86         n = getgroups(0, NULL);
  87         groups = malloc(n * sizeof(gid_t));
  88         if (!groups)
  89                 return NULL;
  90
  91         if (getgroups(n, groups) < 0) {
  92                 free(groups);
  93                 return NULL;
  94         }
  95         return groups;
  96 }
  97
  98 static int
  99 weston_launch_allowed(struct weston_launch *wl)
 100 {
 101         struct group *gr;
 102         gid_t *groups;
 103         int i;
 104 #ifdef HAVE_SYSTEMD_LOGIN
 105         char *session, *seat;
 106         int err;
 107 #endif
 108
 109         if (getuid() == 0)
 110                 return 1;
 111
 112         gr = getgrnam("weston-launch");
 113         if (gr) {
 114                 groups = read_groups();
 115                 if (groups) {
 116                         for (i = 0; groups[i]; ++i) {
 117                                 if (groups[i] == gr->gr_gid) {
 118                                         free(groups);
 119                                         return 1;
 120                                 }
 121                         }
 122                         free(groups);
 123                 }
 124         }
 125
 126 #ifdef HAVE_SYSTEMD_LOGIN
 127         err = sd_pid_get_session(getpid(), &session);
 128         if (err == 0 && session) {
 129                 if (sd_session_is_active(session) &&
 130                     sd_session_get_seat(session, &seat) == 0) {
 131                         free(seat);
 132                         free(session);
 133                         return 1;
 134                 }
 135                 free(session);
 136         }
 137 #endif
 138
 139         return 0;
 140 }
 141
 142 static int
 143 pam_conversation_fn(int msg_count,
 144                     const struct pam_message **messages,
 145                     struct pam_response **responses,
 146                     void *user_data)
 147 {
 148         return PAM_SUCCESS;
 149 }
 150
 151 static int
 152 setup_pam(struct weston_launch *wl)
 153 {
 154         int err;
 155
 156         wl->pc.conv = pam_conversation_fn;
 157         wl->pc.appdata_ptr = wl;
 158
 159         err = pam_start("login", wl->pw->pw_name, &wl->pc, &wl->ph);
 160         err = pam_set_item(wl->ph, PAM_TTY, ttyname(wl->tty));
 161         if (err != PAM_SUCCESS) {
 162                 fprintf(stderr, "failed to set PAM_TTY item: %d: %s\n",
 163                         err, pam_strerror(wl->ph, err));
 164                 return -1;
 165         }
 166
 167         err = pam_open_session(wl->ph, 0);
 168         if (err != PAM_SUCCESS) {
 169                 fprintf(stderr, "failed to open pam session: %d: %s\n",
 170                         err, pam_strerror(wl->ph, err));
 171                 return -1;
 172         }
 173
 174         return 0;
 175 }
 176
 177 static int
 178 setup_launcher_socket(struct weston_launch *wl)
 179 {
 180         struct epoll_event ev;
 181
 182         if (socketpair(AF_LOCAL, SOCK_DGRAM, 0, wl->sock) < 0)
 183                 error(1, errno, "socketpair failed");
 184
 185         fcntl(wl->sock[0], F_SETFD, O_CLOEXEC);
 186
 187         memset(&ev, 0, sizeof ev);
 188         ev.events = EPOLLIN;
 189         ev.data.fd = wl->sock[0];
 190         if (epoll_ctl(wl->epollfd, EPOLL_CTL_ADD, ev.data.fd, &ev) < 0)
 191                 return -errno;
 192
 193         return 0;
 194 }
 195
 196 static int
 197 setup_signals(struct weston_launch *wl)
 198 {
 199         sigset_t mask;
 200         struct sigaction sa;
 201         struct epoll_event ev;
 202
 203         memset(&sa, 0, sizeof sa);
 204         sa.sa_handler = SIG_DFL;
 205         sa.sa_flags = SA_NOCLDSTOP | SA_RESTART;
 206         assert(sigaction(SIGCHLD, &sa, NULL) == 0);
 207
 208         assert(sigemptyset(&mask) == 0);
 209         sigaddset(&mask, SIGCHLD);
 210         sigaddset(&mask, SIGINT);
 211         sigaddset(&mask, SIGTERM);
 212         assert(sigprocmask(SIG_BLOCK, &mask, NULL) == 0);
 213
 214         wl->signalfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
 215         if (wl->signalfd < 0)
 216                 return -errno;
 217
 218         memset(&ev, 0, sizeof ev);
 219         ev.events = EPOLLIN;
 220         ev.data.fd = wl->signalfd;
 221         if (epoll_ctl(wl->epollfd, EPOLL_CTL_ADD, ev.data.fd, &ev) < 0)
 222                 return -errno;
 223
 224         return 0;
 225 }
 226
 227 static void
 228 setenv_fd(const char *env, int fd)
 229 {
 230         char buf[32];
 231
 232         snprintf(buf, sizeof buf, "%d", fd);
 233         setenv(env, buf, 1);
 234 }
 235
 236 static int
 237 handle_setmaster(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
 238 {
 239         int ret = -1;
 240         struct cmsghdr *cmsg;
 241         struct weston_launcher_set_master *message;
 242         union cmsg_data *data;
 243
 244         if (len != sizeof(*message)) {
 245                 error(0, 0, "missing value in setmaster request");
 246                 goto out;
 247         }
 248
 249         message = msg->msg_iov->iov_base;
 250
 251         cmsg = CMSG_FIRSTHDR(msg);
 252         if (!cmsg ||
 253             cmsg->cmsg_level != SOL_SOCKET ||
 254             cmsg->cmsg_type != SCM_RIGHTS) {
 255                 error(0, 0, "invalid control message");
 256                 goto out;
 257         }
 258
 259         data = (union cmsg_data *) CMSG_DATA(cmsg);
 260         if (data->fd == -1) {
 261                 error(0, 0, "missing drm fd in socket request");
 262                 goto out;
 263         }
 264
 265         if (message->set_master)
 266                 ret = drmSetMaster(data->fd);
 267         else
 268                 ret = drmDropMaster(data->fd);
 269
 270         close(data->fd);
 271 out:
 272         do {
 273                 len = send(wl->sock[0], &ret, sizeof ret, 0);
 274         } while (len < 0 && errno == EINTR);
 275         if (len < 0)
 276                 return -1;
 277
 278         return 0;
 279 }
 280
 281 static int
 282 handle_open(struct weston_launch *wl, struct msghdr *msg, ssize_t len)
 283 {
 284         int fd = -1, ret = -1;
 285         char control[CMSG_SPACE(sizeof(fd))];
 286         struct cmsghdr *cmsg;
 287         struct stat s;
 288         struct msghdr nmsg;
 289         struct iovec iov;
 290         struct weston_launcher_open *message;
 291         union cmsg_data *data;
 292
 293         message = msg->msg_iov->iov_base;
 294         if ((size_t)len < sizeof(*message))
 295                 goto err0;
 296
 297         /* Ensure path is null-terminated */
 298         ((char *) message)[len-1] = '\0';
 299
 300         if (stat(message->path, &s) < 0)
 301                 goto err0;
 302
 303         fd = open(message->path, message->flags);
 304         if (fd < 0)
 305                 goto err0;
 306
 307         if (major(s.st_rdev) != INPUT_MAJOR) {
 308                 close(fd);
 309                 fd = -1;
 310                 goto err0;
 311         }
 312
 313 err0:
 314         memset(&nmsg, 0, sizeof nmsg);
 315         nmsg.msg_iov = &iov;
 316         nmsg.msg_iovlen = 1;
 317         if (fd != -1) {
 318                 nmsg.msg_control = control;
 319                 nmsg.msg_controllen = sizeof control;
 320                 cmsg = CMSG_FIRSTHDR(&nmsg);
 321                 cmsg->cmsg_level = SOL_SOCKET;
 322                 cmsg->cmsg_type = SCM_RIGHTS;
 323                 cmsg->cmsg_len = CMSG_LEN(sizeof(fd));
 324                 data = (union cmsg_data *) CMSG_DATA(cmsg);
 325                 data->fd = fd;
 326                 nmsg.msg_controllen = cmsg->cmsg_len;
 327                 ret = 0;
 328         }
 329         iov.iov_base = &ret;
 330         iov.iov_len = sizeof ret;
 331
 332         if (wl->verbose)
 333                 fprintf(stderr, "weston-launch: opened %s: ret: %d, fd: %d\n",
 334                         message->path, ret, fd);
 335         do {
 336                 len = sendmsg(wl->sock[0], &nmsg, 0);
 337         } while (len < 0 && errno == EINTR);
 338
 339         if (len < 0)
 340                 return -1;
 341
 342         return 0;
 343 }
 344
 345 static int
 346 handle_socket_msg(struct weston_launch *wl)
 347 {
 348         char control[CMSG_SPACE(sizeof(int))];
 349         char buf[BUFSIZ];
 350         struct msghdr msg;
 351         struct iovec iov;
 352         int ret = -1;
 353         ssize_t len;
 354         struct weston_launcher_message *message;
 355
 356         memset(&msg, 0, sizeof(msg));
 357         iov.iov_base = buf;
 358         iov.iov_len  = sizeof buf;
 359         msg.msg_iov = &iov;
 360         msg.msg_iovlen = 1;
 361         msg.msg_control = control;
 362         msg.msg_controllen = sizeof control;
 363
 364         do {
 365                 len = recvmsg(wl->sock[0], &msg, 0);
 366         } while (len < 0 && errno == EINTR);
 367
 368         if (len < 1)
 369                 return -1;
 370
 371         message = (void *) buf;
 372         switch (message->opcode) {
 373         case WESTON_LAUNCHER_OPEN:
 374                 ret = handle_open(wl, &msg, len);
 375                 break;
 376         case WESTON_LAUNCHER_DRM_SET_MASTER:
 377                 ret = handle_setmaster(wl, &msg, len);
 378                 break;
 379         }
 380
 381         return ret;
 382 }
 383
 384 static void
 385 quit(struct weston_launch *wl, int status)
 386 {
 387         int err;
 388
 389         close(wl->epollfd);
 390         close(wl->signalfd);
 391         close(wl->sock[0]);
 392
 393         err = pam_close_session(wl->ph, 0);
 394         if (err)
 395                 fprintf(stderr, "pam_close_session failed: %d: %s\n",
 396                         err, pam_strerror(wl->ph, err));
 397         pam_end(wl->ph, err);
 398
 399         exit(status);
 400 }
 401
 402 static int
 403 handle_signal(struct weston_launch *wl)
 404 {
 405         struct signalfd_siginfo sig;
 406         int pid, status;
 407
 408         if (read(wl->signalfd, &sig, sizeof sig) != sizeof sig) {
 409                 error(0, errno, "reading signalfd failed");
 410                 return -1;
 411         }
 412
 413         switch (sig.ssi_signo) {
 414         case SIGCHLD:
 415                 pid = waitpid(-1, &status, 0);
 416                 if (pid == wl->child) {
 417                         wl->child = 0;
 418                         quit(wl, WIFEXITED(status) ? WEXITSTATUS(status) : 0);
 419                 }
 420                 break;
 421         case SIGTERM:
 422                 if (wl->child)
 423                         kill(wl->child, SIGTERM);
 424                 quit(wl, 0);
 425                 break;
 426         case SIGINT:
 427                 if (wl->child)
 428                         kill(wl->child, SIGTERM);
 429                 break;
 430         default:
 431                 return -1;
 432         }
 433
 434         return 0;
 435 }
 436
 437 static int
 438 setup_tty(struct weston_launch *wl, const char *tty)
 439 {
 440         struct stat buf;
 441         char *t;
 442
 443         if (tty) {
 444                 t = ttyname(STDIN_FILENO);
 445                 if (t && strcmp(t, tty) == 0)
 446                         wl->tty = STDIN_FILENO;
 447                 else
 448                         wl->tty = open(tty, O_RDWR | O_NOCTTY);
 449         } else {
 450                 int tty0 = open("/dev/tty0", O_WRONLY | O_CLOEXEC);
 451                 char filename[16];
 452
 453                 if (tty0 < 0)
 454                         error(1, errno, "could not open tty0");
 455
 456                 if (ioctl(tty0, VT_OPENQRY, &wl->ttynr) < 0 || wl->ttynr == -1)
 457                         error(1, errno, "failed to find non-opened console");
 458
 459                 snprintf(filename, sizeof filename, "/dev/tty%d", wl->ttynr);
 460                 wl->tty = open(filename, O_RDWR | O_NOCTTY);
 461                 close(tty0);
 462         }
 463
 464         if (wl->tty < 0)
 465                 error(1, errno, "failed to open tty");
 466
 467         if (tty) {
 468                 if (fstat(wl->tty, &buf) < 0)
 469                         error(1, errno, "stat %s failed", tty);
 470
 471                 if (major(buf.st_rdev) != TTY_MAJOR)
 472                         error(1, 0, "invalid tty device: %s", tty);
 473
 474                 wl->ttynr = minor(buf.st_rdev);
 475         }
 476
 477         return 0;
 478 }
 479
 480 static void
 481 help(const char *name)
 482 {
 483         fprintf(stderr, "Usage: %s [args...] [-- [weston args..]]\n", name);
 484         fprintf(stderr, "  -u, --user      Start session as specified username\n");
 485         fprintf(stderr, "  -t, --tty       Start session on alternative tty\n");
 486         fprintf(stderr, "  -v, --verbose   Be verbose\n");
 487         fprintf(stderr, "  -s, --sleep     Sleep specified amount of time before exec\n");
 488         fprintf(stderr, "  -h, --help      Display this help message\n");
 489 }
 490
 491 int
 492 main(int argc, char *argv[])
 493 {
 494         struct weston_launch wl;
 495         char **env;
 496         int i, c;
 497         char **child_argv;
 498         char *tty = NULL, *new_user = NULL;
 499         int sleep_fork = 0;
 500         struct option opts[] = {
 501                 { "user",    required_argument, NULL, 'u' },
 502                 { "tty",     required_argument, NULL, 't' },
 503                 { "verbose", no_argument,       NULL, 'v' },
 504                 { "sleep",   optional_argument, NULL, 's' },
 505                 { "help",    no_argument,       NULL, 'h' },
 506                 { 0,         0,                 NULL,  0  }
 507         };
 508
 509         memset(&wl, 0, sizeof wl);
 510
 511         while ((c = getopt_long(argc, argv, "u:t:s::vh", opts, &i)) != -1) {
 512                 switch (c) {
 513                 case 'u':
 514                         new_user = optarg;
 515                         if (getuid() != 0)
 516                                 error(1, 0, "Permission denied. -u allowed for root only");
 517                         break;
 518                 case 't':
 519                         tty = optarg;
 520                         break;
 521                 case 'v':
 522                         wl.verbose = 1;
 523                         break;
 524                 case 's':
 525                         if (optarg)
 526                                 sleep_fork = atoi(optarg);
 527                         else
 528                                 sleep_fork = 10;
 529                         break;
 530                 case 'h':
 531                         help("weston");
 532                         exit(1);
 533                 }
 534         }
 535
 536         child_argv = &argv[optind-1];
 537         child_argv[0] = BINDIR "/weston";
 538
 539         if (new_user)
 540                 wl.pw = getpwnam(new_user);
 541         else
 542                 wl.pw = getpwuid(getuid());
 543         if (wl.pw == NULL)
 544                 error(1, errno, "failed to get username");
 545
 546         if (!weston_launch_allowed(&wl))
 547                 error(1, 0, "Permission denied. You should either:\n"
 548 #ifdef HAVE_SYSTEMD_LOGIN
 549                       " - run from an active and local (systemd) session.\n"
 550 #else
 551                       " - enable systemd session support for weston-launch.\n"
 552 #endif
 553                       " - or add yourself to the 'weston-launch' group.");
 554
 555         if (setup_tty(&wl, tty) < 0)
 556                 return 1;
 557
 558         if (setup_pam(&wl) < 0)
 559                 return 1;
 560
 561         wl.epollfd = epoll_create1(EPOLL_CLOEXEC);
 562         if (wl.epollfd < 0)
 563                 error(1, errno, "epoll create failed");
 564
 565         if (setup_launcher_socket(&wl) < 0)
 566                 return 1;
 567
 568         if (setup_signals(&wl) < 0)
 569                 return 1;
 570
 571         switch ((wl.child = fork())) {
 572         case -1:
 573                 error(1, errno, "fork failed");
 574                 break;
 575         case 0:
 576                 if (wl.verbose)
 577                         printf("weston-launch: spawned weston with pid: %d\n", getpid());
 578                 if (wl.tty != STDIN_FILENO) {
 579                         if (setsid() < 0)
 580                                 error(1, errno, "setsid failed");
 581                         if (ioctl(wl.tty, TIOCSCTTY, 0) < 0)
 582                                 error(1, errno, "TIOCSCTTY failed - tty is in use");
 583                 }
 584
 585                 if (setgid(wl.pw->pw_gid) < 0 ||
 586                     setuid(wl.pw->pw_uid) < 0)
 587                         error(1, errno, "dropping privilidges failed");
 588
 589                 if (sleep_fork) {
 590                         if (wl.verbose)
 591                                 printf("weston-launch: waiting %d seconds\n", sleep_fork);
 592                         sleep(sleep_fork);
 593                 }
 594
 595                 if (new_user) {
 596                         setenv("USER", wl.pw->pw_name, 1);
 597                         setenv("LOGNAME", wl.pw->pw_name, 1);
 598                         setenv("HOME", wl.pw->pw_dir, 1);
 599                         setenv("SHELL", wl.pw->pw_shell, 1);
 600                 }
 601                 env = pam_getenvlist(wl.ph);
 602                 if (env) {
 603                         for (i = 0; env[i]; ++i) {
 604                                 if (putenv(env[i]) < 0)
 605                                         error(0, 0, "putenv %s failed", env[i]);
 606                         }
 607                         free(env);
 608                 }
 609
 610                 if (wl.tty != STDIN_FILENO)
 611                         setenv_fd("WESTON_TTY_FD", wl.tty);
 612
 613                 setenv_fd("WESTON_LAUNCHER_SOCK", wl.sock[1]);
 614
 615                 unsetenv("DISPLAY");
 616
 617                 execv(child_argv[0], child_argv);
 618                 error(1, errno, "exec failed");
 619                 break;
 620         default:
 621                 close(wl.sock[1]);
 622                 if (wl.tty != STDIN_FILENO)
 623                         close(wl.tty);
 624
 625                 while (1) {
 626                         struct epoll_event ev;
 627                         int n;
 628
 629                         n = epoll_wait(wl.epollfd, &ev, 1, -1);
 630                         if (n < 0)
 631                                 error(0, errno, "epoll_wait failed");
 632                         if (n != 1)
 633                                 continue;
 634
 635                         if (ev.data.fd == wl.sock[0])
 636                                 handle_socket_msg(&wl);
 637                         else if (ev.data.fd == wl.signalfd)
 638                                 handle_signal(&wl);
 639                 }
 640                 break;
 641         }
 642
 643         return 0;
 644 }