compositor/main.c

   1 /*
   2  * Copyright © 2010-2011 Intel Corporation
   3  * Copyright © 2008-2011 Kristian Høgsberg
   4  * Copyright © 2012-2015 Collabora, Ltd.
   5  * Copyright © 2010-2011 Benjamin Franzke
   6  * Copyright © 2013 Jason Ekstrand
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining
   9  * a copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sublicense, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * The above copyright notice and this permission notice (including the
  17  * next paragraph) shall be included in all copies or substantial
  18  * portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  */
  29
  30 #include "config.h"
  31
  32 #include <unistd.h>
  33 #include <signal.h>
  34 #include <errno.h>
  35 #include <dlfcn.h>
  36 #include <stdint.h>
  37 #include <string.h>
  38 #include <sys/utsname.h>
  39 #include <sys/stat.h>
  40 #include <sys/wait.h>
  41 #include <sys/socket.h>
  42 #include <libinput.h>
  43 #include <sys/time.h>
  44 #include <linux/limits.h>
  45
  46 #ifdef HAVE_LIBUNWIND
  47 #define UNW_LOCAL_ONLY
  48 #include <libunwind.h>
  49 #endif
  50
  51 #include "weston.h"
  52 #include "compositor.h"
  53 #include "../shared/os-compatibility.h"
  54 #include "../shared/helpers.h"
  55 #include "../shared/string-helpers.h"
  56 #include "git-version.h"
  57 #include "version.h"
  58 #include "weston.h"
  59
  60 #include "compositor-drm.h"
  61 #include "compositor-headless.h"
  62 #include "compositor-rdp.h"
  63 #include "compositor-fbdev.h"
  64 #include "compositor-x11.h"
  65 #include "compositor-wayland.h"
  66 #include "windowed-output-api.h"
  67
  68 #define WINDOW_TITLE "Weston Compositor"
  69
  70 struct wet_output_config {
  71         int width;
  72         int height;
  73         int32_t scale;
  74         uint32_t transform;
  75 };
  76
  77 struct wet_compositor {
  78         struct weston_config *config;
  79         struct wet_output_config *parsed_options;
  80         struct wl_listener pending_output_listener;
  81 };
  82
  83 static FILE *weston_logfile = NULL;
  84
  85 static int cached_tm_mday = -1;
  86
  87 static int weston_log_timestamp(void)
  88 {
  89         struct timeval tv;
  90         struct tm *brokendown_time;
  91         char string[128];
  92
  93         gettimeofday(&tv, NULL);
  94
  95         brokendown_time = localtime(&tv.tv_sec);
  96         if (brokendown_time == NULL)
  97                 return fprintf(weston_logfile, "[(NULL)localtime] ");
  98
  99         if (brokendown_time->tm_mday != cached_tm_mday) {
 100                 strftime(string, sizeof string, "%Y-%m-%d %Z", brokendown_time);
 101                 fprintf(weston_logfile, "Date: %s\n", string);
 102
 103                 cached_tm_mday = brokendown_time->tm_mday;
 104         }
 105
 106         strftime(string, sizeof string, "%H:%M:%S", brokendown_time);
 107
 108         return fprintf(weston_logfile, "[%s.%03li] ", string, tv.tv_usec/1000);
 109 }
 110
 111 static void
 112 custom_handler(const char *fmt, va_list arg)
 113 {
 114         weston_log_timestamp();
 115         fprintf(weston_logfile, "libwayland: ");
 116         vfprintf(weston_logfile, fmt, arg);
 117 }
 118
 119 static void
 120 weston_log_file_open(const char *filename)
 121 {
 122         wl_log_set_handler_server(custom_handler);
 123
 124         if (filename != NULL) {
 125                 weston_logfile = fopen(filename, "a");
 126                 if (weston_logfile)
 127                         os_fd_set_cloexec(fileno(weston_logfile));
 128         }
 129
 130         if (weston_logfile == NULL)
 131                 weston_logfile = stderr;
 132         else
 133                 setvbuf(weston_logfile, NULL, _IOLBF, 256);
 134 }
 135
 136 static void
 137 weston_log_file_close(void)
 138 {
 139         if ((weston_logfile != stderr) && (weston_logfile != NULL))
 140                 fclose(weston_logfile);
 141         weston_logfile = stderr;
 142 }
 143
 144 static int
 145 vlog(const char *fmt, va_list ap)
 146 {
 147         int l;
 148
 149         l = weston_log_timestamp();
 150         l += vfprintf(weston_logfile, fmt, ap);
 151
 152         return l;
 153 }
 154
 155 static int
 156 vlog_continue(const char *fmt, va_list argp)
 157 {
 158         return vfprintf(weston_logfile, fmt, argp);
 159 }
 160
 161 static struct wl_list child_process_list;
 162 static struct weston_compositor *segv_compositor;
 163
 164 static int
 165 sigchld_handler(int signal_number, void *data)
 166 {
 167         struct weston_process *p;
 168         int status;
 169         pid_t pid;
 170
 171         while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
 172                 wl_list_for_each(p, &child_process_list, link) {
 173                         if (p->pid == pid)
 174                                 break;
 175                 }
 176
 177                 if (&p->link == &child_process_list) {
 178                         weston_log("unknown child process exited\n");
 179                         continue;
 180                 }
 181
 182                 wl_list_remove(&p->link);
 183                 p->cleanup(p, status);
 184         }
 185
 186         if (pid < 0 && errno != ECHILD)
 187                 weston_log("waitpid error %m\n");
 188
 189         return 1;
 190 }
 191
 192 #ifdef HAVE_LIBUNWIND
 193
 194 static void
 195 print_backtrace(void)
 196 {
 197         unw_cursor_t cursor;
 198         unw_context_t context;
 199         unw_word_t off;
 200         unw_proc_info_t pip;
 201         int ret, i = 0;
 202         char procname[256];
 203         const char *filename;
 204         Dl_info dlinfo;
 205
 206         pip.unwind_info = NULL;
 207         ret = unw_getcontext(&context);
 208         if (ret) {
 209                 weston_log("unw_getcontext: %d\n", ret);
 210                 return;
 211         }
 212
 213         ret = unw_init_local(&cursor, &context);
 214         if (ret) {
 215                 weston_log("unw_init_local: %d\n", ret);
 216                 return;
 217         }
 218
 219         ret = unw_step(&cursor);
 220         while (ret > 0) {
 221                 ret = unw_get_proc_info(&cursor, &pip);
 222                 if (ret) {
 223                         weston_log("unw_get_proc_info: %d\n", ret);
 224                         break;
 225                 }
 226
 227                 ret = unw_get_proc_name(&cursor, procname, 256, &off);
 228                 if (ret && ret != -UNW_ENOMEM) {
 229                         if (ret != -UNW_EUNSPEC)
 230                                 weston_log("unw_get_proc_name: %d\n", ret);
 231                         procname[0] = '?';
 232                         procname[1] = 0;
 233                 }
 234
 235                 if (dladdr((void *)(pip.start_ip + off), &dlinfo) && dlinfo.dli_fname &&
 236                     *dlinfo.dli_fname)
 237                         filename = dlinfo.dli_fname;
 238                 else
 239                         filename = "?";
 240
 241                 weston_log("%u: %s (%s%s+0x%x) [%p]\n", i++, filename, procname,
 242                            ret == -UNW_ENOMEM ? "..." : "", (int)off, (void *)(pip.start_ip + off));
 243
 244                 ret = unw_step(&cursor);
 245                 if (ret < 0)
 246                         weston_log("unw_step: %d\n", ret);
 247         }
 248 }
 249
 250 #else
 251
 252 static void
 253 print_backtrace(void)
 254 {
 255         void *buffer[32];
 256         int i, count;
 257         Dl_info info;
 258
 259         count = backtrace(buffer, ARRAY_LENGTH(buffer));
 260         for (i = 0; i < count; i++) {
 261                 dladdr(buffer[i], &info);
 262                 weston_log("  [%016lx]  %s  (%s)\n",
 263                         (long) buffer[i],
 264                         info.dli_sname ? info.dli_sname : "--",
 265                         info.dli_fname);
 266         }
 267 }
 268
 269 #endif
 270
 271 static void
 272 child_client_exec(int sockfd, const char *path)
 273 {
 274         int clientfd;
 275         char s[32];
 276         sigset_t allsigs;
 277
 278         /* do not give our signal mask to the new process */
 279         sigfillset(&allsigs);
 280         sigprocmask(SIG_UNBLOCK, &allsigs, NULL);
 281
 282         /* Launch clients as the user. Do not lauch clients with wrong euid.*/
 283         if (seteuid(getuid()) == -1) {
 284                 weston_log("compositor: failed seteuid\n");
 285                 return;
 286         }
 287
 288         /* SOCK_CLOEXEC closes both ends, so we dup the fd to get a
 289          * non-CLOEXEC fd to pass through exec. */
 290         clientfd = dup(sockfd);
 291         if (clientfd == -1) {
 292                 weston_log("compositor: dup failed: %m\n");
 293                 return;
 294         }
 295
 296         snprintf(s, sizeof s, "%d", clientfd);
 297         setenv("WAYLAND_SOCKET", s, 1);
 298
 299         if (execl(path, path, NULL) < 0)
 300                 weston_log("compositor: executing '%s' failed: %m\n",
 301                         path);
 302 }
 303
 304 WL_EXPORT struct wl_client *
 305 weston_client_launch(struct weston_compositor *compositor,
 306                      struct weston_process *proc,
 307                      const char *path,
 308                      weston_process_cleanup_func_t cleanup)
 309 {
 310         int sv[2];
 311         pid_t pid;
 312         struct wl_client *client;
 313
 314         weston_log("launching '%s'\n", path);
 315
 316         if (os_socketpair_cloexec(AF_UNIX, SOCK_STREAM, 0, sv) < 0) {
 317                 weston_log("weston_client_launch: "
 318                         "socketpair failed while launching '%s': %m\n",
 319                         path);
 320                 return NULL;
 321         }
 322
 323         pid = fork();
 324         if (pid == -1) {
 325                 close(sv[0]);
 326                 close(sv[1]);
 327                 weston_log("weston_client_launch: "
 328                         "fork failed while launching '%s': %m\n", path);
 329                 return NULL;
 330         }
 331
 332         if (pid == 0) {
 333                 child_client_exec(sv[1], path);
 334                 _exit(-1);
 335         }
 336
 337         close(sv[1]);
 338
 339         client = wl_client_create(compositor->wl_display, sv[0]);
 340         if (!client) {
 341                 close(sv[0]);
 342                 weston_log("weston_client_launch: "
 343                         "wl_client_create failed while launching '%s'.\n",
 344                         path);
 345                 return NULL;
 346         }
 347
 348         proc->pid = pid;
 349         proc->cleanup = cleanup;
 350         weston_watch_process(proc);
 351
 352         return client;
 353 }
 354
 355 WL_EXPORT void
 356 weston_watch_process(struct weston_process *process)
 357 {
 358         wl_list_insert(&child_process_list, &process->link);
 359 }
 360
 361 struct process_info {
 362         struct weston_process proc;
 363         char *path;
 364 };
 365
 366 static void
 367 process_handle_sigchld(struct weston_process *process, int status)
 368 {
 369         struct process_info *pinfo =
 370                 container_of(process, struct process_info, proc);
 371
 372         /*
 373          * There are no guarantees whether this runs before or after
 374          * the wl_client destructor.
 375          */
 376
 377         if (WIFEXITED(status)) {
 378                 weston_log("%s exited with status %d\n", pinfo->path,
 379                            WEXITSTATUS(status));
 380         } else if (WIFSIGNALED(status)) {
 381                 weston_log("%s died on signal %d\n", pinfo->path,
 382                            WTERMSIG(status));
 383         } else {
 384                 weston_log("%s disappeared\n", pinfo->path);
 385         }
 386
 387         free(pinfo->path);
 388         free(pinfo);
 389 }
 390
 391 WL_EXPORT struct wl_client *
 392 weston_client_start(struct weston_compositor *compositor, const char *path)
 393 {
 394         struct process_info *pinfo;
 395         struct wl_client *client;
 396
 397         pinfo = zalloc(sizeof *pinfo);
 398         if (!pinfo)
 399                 return NULL;
 400
 401         pinfo->path = strdup(path);
 402         if (!pinfo->path)
 403                 goto out_free;
 404
 405         client = weston_client_launch(compositor, &pinfo->proc, path,
 406                                       process_handle_sigchld);
 407         if (!client)
 408                 goto out_str;
 409
 410         return client;
 411
 412 out_str:
 413         free(pinfo->path);
 414
 415 out_free:
 416         free(pinfo);
 417
 418         return NULL;
 419 }
 420
 421 static void
 422 log_uname(void)
 423 {
 424         struct utsname usys;
 425
 426         uname(&usys);
 427
 428         weston_log("OS: %s, %s, %s, %s\n", usys.sysname, usys.release,
 429                                                 usys.version, usys.machine);
 430 }
 431
 432 static struct wet_compositor *
 433 to_wet_compositor(struct weston_compositor *compositor)
 434 {
 435         return weston_compositor_get_user_data(compositor);
 436 }
 437
 438 static void
 439 wet_set_pending_output_handler(struct weston_compositor *ec,
 440                                wl_notify_func_t handler)
 441 {
 442         struct wet_compositor *compositor = to_wet_compositor(ec);
 443
 444         compositor->pending_output_listener.notify = handler;
 445         wl_signal_add(&ec->output_pending_signal, &compositor->pending_output_listener);
 446 }
 447
 448 static struct wet_output_config *
 449 wet_init_parsed_options(struct weston_compositor *ec)
 450 {
 451         struct wet_compositor *compositor = to_wet_compositor(ec);
 452         struct wet_output_config *config;
 453
 454         config = zalloc(sizeof *config);
 455
 456         if (!config) {
 457                 perror("out of memory");
 458                 return NULL;
 459         }
 460
 461         config->width = 0;
 462         config->height = 0;
 463         config->scale = 0;
 464         config->transform = UINT32_MAX;
 465
 466         compositor->parsed_options = config;
 467
 468         return config;
 469 }
 470
 471 WL_EXPORT struct weston_config *
 472 wet_get_config(struct weston_compositor *ec)
 473 {
 474         struct wet_compositor *compositor = to_wet_compositor(ec);
 475
 476         return compositor->config;
 477 }
 478
 479 static const char xdg_error_message[] =
 480         "fatal: environment variable XDG_RUNTIME_DIR is not set.\n";
 481
 482 static const char xdg_wrong_message[] =
 483         "fatal: environment variable XDG_RUNTIME_DIR\n"
 484         "is set to \"%s\", which is not a directory.\n";
 485
 486 static const char xdg_wrong_mode_message[] =
 487         "warning: XDG_RUNTIME_DIR \"%s\" is not configured\n"
 488         "correctly.  Unix access mode must be 0700 (current mode is %o),\n"
 489         "and must be owned by the user (current owner is UID %d).\n";
 490
 491 static const char xdg_detail_message[] =
 492         "Refer to your distribution on how to get it, or\n"
 493         "http://www.freedesktop.org/wiki/Specifications/basedir-spec\n"
 494         "on how to implement it.\n";
 495
 496 static void
 497 verify_xdg_runtime_dir(void)
 498 {
 499         char *dir = getenv("XDG_RUNTIME_DIR");
 500         struct stat s;
 501
 502         if (!dir) {
 503                 weston_log(xdg_error_message);
 504                 weston_log_continue(xdg_detail_message);
 505                 exit(EXIT_FAILURE);
 506         }
 507
 508         if (stat(dir, &s) || !S_ISDIR(s.st_mode)) {
 509                 weston_log(xdg_wrong_message, dir);
 510                 weston_log_continue(xdg_detail_message);
 511                 exit(EXIT_FAILURE);
 512         }
 513
 514         if ((s.st_mode & 0777) != 0700 || s.st_uid != getuid()) {
 515                 weston_log(xdg_wrong_mode_message,
 516                            dir, s.st_mode & 0777, s.st_uid);
 517                 weston_log_continue(xdg_detail_message);
 518         }
 519 }
 520
 521 static int
 522 usage(int error_code)
 523 {
 524         fprintf(stderr,
 525                 "Usage: weston [OPTIONS]\n\n"
 526                 "This is weston version " VERSION ", the Wayland reference compositor.\n"
 527                 "Weston supports multiple backends, and depending on which backend is in use\n"
 528                 "different options will be accepted.\n\n"
 529
 530
 531                 "Core options:\n\n"
 532                 "  --version\t\tPrint weston version\n"
 533                 "  -B, --backend=MODULE\tBackend module, one of\n"
 534 #if defined(BUILD_DRM_COMPOSITOR)
 535                         "\t\t\t\tdrm-backend.so\n"
 536 #endif
 537 #if defined(BUILD_FBDEV_COMPOSITOR)
 538                         "\t\t\t\tfbdev-backend.so\n"
 539 #endif
 540 #if defined(BUILD_HEADLESS_COMPOSITOR)
 541                         "\t\t\t\theadless-backend.so\n"
 542 #endif
 543 #if defined(BUILD_RDP_COMPOSITOR)
 544                         "\t\t\t\trdp-backend.so\n"
 545 #endif
 546 #if defined(BUILD_WAYLAND_COMPOSITOR)
 547                         "\t\t\t\twayland-backend.so\n"
 548 #endif
 549 #if defined(BUILD_X11_COMPOSITOR)
 550                         "\t\t\t\tx11-backend.so\n"
 551 #endif
 552                 "  --shell=MODULE\tShell module, defaults to desktop-shell.so\n"
 553                 "  -S, --socket=NAME\tName of socket to listen on\n"
 554                 "  -i, --idle-time=SECS\tIdle time in seconds\n"
 555                 "  --modules\t\tLoad the comma-separated list of modules\n"
 556                 "  --log=FILE\t\tLog to the given file\n"
 557                 "  -c, --config=FILE\tConfig file to load, defaults to weston.ini\n"
 558                 "  --no-config\t\tDo not read weston.ini\n"
 559                 "  -h, --help\t\tThis help message\n\n");
 560
 561 #if defined(BUILD_DRM_COMPOSITOR)
 562         fprintf(stderr,
 563                 "Options for drm-backend.so:\n\n"
 564                 "  --connector=ID\tBring up only this connector\n"
 565                 "  --seat=SEAT\t\tThe seat that weston should run on\n"
 566                 "  --tty=TTY\t\tThe tty to use\n"
 567                 "  --use-pixman\t\tUse the pixman (CPU) renderer\n"
 568                 "  --current-mode\tPrefer current KMS mode over EDID preferred mode\n\n");
 569 #endif
 570
 571 #if defined(BUILD_FBDEV_COMPOSITOR)
 572         fprintf(stderr,
 573                 "Options for fbdev-backend.so:\n\n"
 574                 "  --tty=TTY\t\tThe tty to use\n"
 575                 "  --device=DEVICE\tThe framebuffer device to use\n"
 576                 "\n");
 577 #endif
 578
 579 #if defined(BUILD_HEADLESS_COMPOSITOR)
 580         fprintf(stderr,
 581                 "Options for headless-backend.so:\n\n"
 582                 "  --width=WIDTH\t\tWidth of memory surface\n"
 583                 "  --height=HEIGHT\tHeight of memory surface\n"
 584                 "  --transform=TR\tThe output transformation, TR is one of:\n"
 585                 "\tnormal 90 180 270 flipped flipped-90 flipped-180 flipped-270\n"
 586                 "  --use-pixman\t\tUse the pixman (CPU) renderer (default: no rendering)\n"
 587                 "  --no-outputs\t\tDo not create any virtual outputs\n"
 588                 "\n");
 589 #endif
 590
 591 #if defined(BUILD_RDP_COMPOSITOR)
 592         fprintf(stderr,
 593                 "Options for rdp-backend.so:\n\n"
 594                 "  --width=WIDTH\t\tWidth of desktop\n"
 595                 "  --height=HEIGHT\tHeight of desktop\n"
 596                 "  --env-socket\t\tUse socket defined in RDP_FD env variable as peer connection\n"
 597                 "  --address=ADDR\tThe address to bind\n"
 598                 "  --port=PORT\t\tThe port to listen on\n"
 599                 "  --no-clients-resize\tThe RDP peers will be forced to the size of the desktop\n"
 600                 "  --rdp4-key=FILE\tThe file containing the key for RDP4 encryption\n"
 601                 "  --rdp-tls-cert=FILE\tThe file containing the certificate for TLS encryption\n"
 602                 "  --rdp-tls-key=FILE\tThe file containing the private key for TLS encryption\n"
 603                 "\n");
 604 #endif
 605
 606 #if defined(BUILD_WAYLAND_COMPOSITOR)
 607         fprintf(stderr,
 608                 "Options for wayland-backend.so:\n\n"
 609                 "  --width=WIDTH\t\tWidth of Wayland surface\n"
 610                 "  --height=HEIGHT\tHeight of Wayland surface\n"
 611                 "  --scale=SCALE\t\tScale factor of output\n"
 612                 "  --fullscreen\t\tRun in fullscreen mode\n"
 613                 "  --use-pixman\t\tUse the pixman (CPU) renderer\n"
 614                 "  --output-count=COUNT\tCreate multiple outputs\n"
 615                 "  --sprawl\t\tCreate one fullscreen output for every parent output\n"
 616                 "  --display=DISPLAY\tWayland display to connect to\n\n");
 617 #endif
 618
 619 #if defined(BUILD_X11_COMPOSITOR)
 620         fprintf(stderr,
 621                 "Options for x11-backend.so:\n\n"
 622                 "  --width=WIDTH\t\tWidth of X window\n"
 623                 "  --height=HEIGHT\tHeight of X window\n"
 624                 "  --scale=SCALE\t\tScale factor of output\n"
 625                 "  --fullscreen\t\tRun in fullscreen mode\n"
 626                 "  --use-pixman\t\tUse the pixman (CPU) renderer\n"
 627                 "  --output-count=COUNT\tCreate multiple outputs\n"
 628                 "  --no-input\t\tDont create input devices\n\n");
 629 #endif
 630
 631         exit(error_code);
 632 }
 633
 634 static int on_term_signal(int signal_number, void *data)
 635 {
 636         struct wl_display *display = data;
 637
 638         weston_log("caught signal %d\n", signal_number);
 639         wl_display_terminate(display);
 640
 641         return 1;
 642 }
 643
 644 static void
 645 on_caught_signal(int s, siginfo_t *siginfo, void *context)
 646 {
 647         /* This signal handler will do a best-effort backtrace, and
 648          * then call the backend restore function, which will switch
 649          * back to the vt we launched from or ungrab X etc and then
 650          * raise SIGTRAP.  If we run weston under gdb from X or a
 651          * different vt, and tell gdb "handle *s* nostop", this
 652          * will allow weston to switch back to gdb on crash and then
 653          * gdb will catch the crash with SIGTRAP.*/
 654
 655         weston_log("caught signal: %d\n", s);
 656
 657         print_backtrace();
 658
 659         segv_compositor->backend->restore(segv_compositor);
 660
 661         raise(SIGTRAP);
 662 }
 663
 664 static void
 665 catch_signals(void)
 666 {
 667         struct sigaction action;
 668
 669         action.sa_flags = SA_SIGINFO | SA_RESETHAND;
 670         action.sa_sigaction = on_caught_signal;
 671         sigemptyset(&action.sa_mask);
 672         sigaction(SIGSEGV, &action, NULL);
 673         sigaction(SIGABRT, &action, NULL);
 674 }
 675
 676 static const char *
 677 clock_name(clockid_t clk_id)
 678 {
 679         static const char *names[] = {
 680                 [CLOCK_REALTIME] =              "CLOCK_REALTIME",
 681                 [CLOCK_MONOTONIC] =             "CLOCK_MONOTONIC",
 682                 [CLOCK_MONOTONIC_RAW] =         "CLOCK_MONOTONIC_RAW",
 683                 [CLOCK_REALTIME_COARSE] =       "CLOCK_REALTIME_COARSE",
 684                 [CLOCK_MONOTONIC_COARSE] =      "CLOCK_MONOTONIC_COARSE",
 685 #ifdef CLOCK_BOOTTIME
 686                 [CLOCK_BOOTTIME] =              "CLOCK_BOOTTIME",
 687 #endif
 688         };
 689
 690         if (clk_id < 0 || (unsigned)clk_id >= ARRAY_LENGTH(names))
 691                 return "unknown";
 692
 693         return names[clk_id];
 694 }
 695
 696 static const struct {
 697         uint32_t bit; /* enum weston_capability */
 698         const char *desc;
 699 } capability_strings[] = {
 700         { WESTON_CAP_ROTATION_ANY, "arbitrary surface rotation:" },
 701         { WESTON_CAP_CAPTURE_YFLIP, "screen capture uses y-flip:" },
 702 };
 703
 704 static void
 705 weston_compositor_log_capabilities(struct weston_compositor *compositor)
 706 {
 707         unsigned i;
 708         int yes;
 709         struct timespec res;
 710
 711         weston_log("Compositor capabilities:\n");
 712         for (i = 0; i < ARRAY_LENGTH(capability_strings); i++) {
 713                 yes = compositor->capabilities & capability_strings[i].bit;
 714                 weston_log_continue(STAMP_SPACE "%s %s\n",
 715                                     capability_strings[i].desc,
 716                                     yes ? "yes" : "no");
 717         }
 718
 719         weston_log_continue(STAMP_SPACE "presentation clock: %s, id %d\n",
 720                             clock_name(compositor->presentation_clock),
 721                             compositor->presentation_clock);
 722
 723         if (clock_getres(compositor->presentation_clock, &res) == 0)
 724                 weston_log_continue(STAMP_SPACE
 725                                 "presentation clock resolution: %d.%09ld s\n",
 726                                 (int)res.tv_sec, res.tv_nsec);
 727         else
 728                 weston_log_continue(STAMP_SPACE
 729                                 "presentation clock resolution: N/A\n");
 730 }
 731
 732 static void
 733 handle_primary_client_destroyed(struct wl_listener *listener, void *data)
 734 {
 735         struct wl_client *client = data;
 736
 737         weston_log("Primary client died.  Closing...\n");
 738
 739         wl_display_terminate(wl_client_get_display(client));
 740 }
 741
 742 static int
 743 weston_create_listening_socket(struct wl_display *display, const char *socket_name)
 744 {
 745         if (socket_name) {
 746                 if (wl_display_add_socket(display, socket_name)) {
 747                         weston_log("fatal: failed to add socket: %m\n");
 748                         return -1;
 749                 }
 750         } else {
 751                 socket_name = wl_display_add_socket_auto(display);
 752                 if (!socket_name) {
 753                         weston_log("fatal: failed to add socket: %m\n");
 754                         return -1;
 755                 }
 756         }
 757
 758         setenv("WAYLAND_DISPLAY", socket_name, 1);
 759
 760         return 0;
 761 }
 762
 763 WL_EXPORT void *
 764 wet_load_module(const char *name, const char *entrypoint)
 765 {
 766         const char *builddir = getenv("WESTON_BUILD_DIR");
 767         char path[PATH_MAX];
 768         void *module, *init;
 769
 770         if (name == NULL)
 771                 return NULL;
 772
 773         if (name[0] != '/') {
 774                 if (builddir)
 775                         snprintf(path, sizeof path, "%s/.libs/%s", builddir, name);
 776                 else
 777                         snprintf(path, sizeof path, "%s/%s", MODULEDIR, name);
 778         } else {
 779                 snprintf(path, sizeof path, "%s", name);
 780         }
 781
 782         module = dlopen(path, RTLD_NOW | RTLD_NOLOAD);
 783         if (module) {
 784                 weston_log("Module '%s' already loaded\n", path);
 785                 dlclose(module);
 786                 return NULL;
 787         }
 788
 789         weston_log("Loading module '%s'\n", path);
 790         module = dlopen(path, RTLD_NOW);
 791         if (!module) {
 792                 weston_log("Failed to load module: %s\n", dlerror());
 793                 return NULL;
 794         }
 795
 796         init = dlsym(module, entrypoint);
 797         if (!init) {
 798                 weston_log("Failed to lookup init function: %s\n", dlerror());
 799                 dlclose(module);
 800                 return NULL;
 801         }
 802
 803         return init;
 804 }
 805
 806 static int
 807 load_modules(struct weston_compositor *ec, const char *modules,
 808              int *argc, char *argv[])
 809 {
 810         const char *p, *end;
 811         char buffer[256];
 812         int (*module_init)(struct weston_compositor *ec,
 813                            int *argc, char *argv[]);
 814
 815         if (modules == NULL)
 816                 return 0;
 817
 818         p = modules;
 819         while (*p) {
 820                 end = strchrnul(p, ',');
 821                 snprintf(buffer, sizeof buffer, "%.*s", (int) (end - p), p);
 822
 823                 if (strstr(buffer, "xwayland.so")) {
 824                         if (wet_load_xwayland(ec) < 0)
 825                                 return -1;
 826                 } else {
 827                         module_init = wet_load_module(buffer, "module_init");
 828                         if (!module_init)
 829                                 return -1;
 830                         if (module_init(ec, argc, argv) < 0)
 831                                 return -1;
 832                 }
 833                 p = end;
 834                 while (*p == ',')
 835                         p++;
 836
 837         }
 838
 839         return 0;
 840 }
 841
 842 static int
 843 weston_compositor_init_config(struct weston_compositor *ec,
 844                               struct weston_config *config)
 845 {
 846         struct xkb_rule_names xkb_names;
 847         struct weston_config_section *s;
 848         int repaint_msec;
 849         int vt_switching;
 850
 851         s = weston_config_get_section(config, "keyboard", NULL, NULL);
 852         weston_config_section_get_string(s, "keymap_rules",
 853                                          (char **) &xkb_names.rules, NULL);
 854         weston_config_section_get_string(s, "keymap_model",
 855                                          (char **) &xkb_names.model, NULL);
 856         weston_config_section_get_string(s, "keymap_layout",
 857                                          (char **) &xkb_names.layout, NULL);
 858         weston_config_section_get_string(s, "keymap_variant",
 859                                          (char **) &xkb_names.variant, NULL);
 860         weston_config_section_get_string(s, "keymap_options",
 861                                          (char **) &xkb_names.options, NULL);
 862
 863         if (weston_compositor_set_xkb_rule_names(ec, &xkb_names) < 0)
 864                 return -1;
 865
 866         weston_config_section_get_int(s, "repeat-rate",
 867                                       &ec->kb_repeat_rate, 40);
 868         weston_config_section_get_int(s, "repeat-delay",
 869                                       &ec->kb_repeat_delay, 400);
 870
 871         weston_config_section_get_bool(s, "vt-switching",
 872                                        &vt_switching, true);
 873         ec->vt_switching = vt_switching;
 874
 875         s = weston_config_get_section(config, "core", NULL, NULL);
 876         weston_config_section_get_int(s, "repaint-window", &repaint_msec,
 877                                       ec->repaint_msec);
 878         if (repaint_msec < -10 || repaint_msec > 1000) {
 879                 weston_log("Invalid repaint_window value in config: %d\n",
 880                            repaint_msec);
 881         } else {
 882                 ec->repaint_msec = repaint_msec;
 883         }
 884         weston_log("Output repaint window is %d ms maximum.\n",
 885                    ec->repaint_msec);
 886
 887         return 0;
 888 }
 889
 890 static char *
 891 weston_choose_default_backend(void)
 892 {
 893         char *backend = NULL;
 894
 895         if (getenv("WAYLAND_DISPLAY") || getenv("WAYLAND_SOCKET"))
 896                 backend = strdup("wayland-backend.so");
 897         else if (getenv("DISPLAY"))
 898                 backend = strdup("x11-backend.so");
 899         else
 900                 backend = strdup(WESTON_NATIVE_BACKEND);
 901
 902         return backend;
 903 }
 904
 905 static const struct { const char *name; uint32_t token; } transforms[] = {
 906         { "normal",     WL_OUTPUT_TRANSFORM_NORMAL },
 907         { "90",         WL_OUTPUT_TRANSFORM_90 },
 908         { "180",        WL_OUTPUT_TRANSFORM_180 },
 909         { "270",        WL_OUTPUT_TRANSFORM_270 },
 910         { "flipped",    WL_OUTPUT_TRANSFORM_FLIPPED },
 911         { "flipped-90", WL_OUTPUT_TRANSFORM_FLIPPED_90 },
 912         { "flipped-180", WL_OUTPUT_TRANSFORM_FLIPPED_180 },
 913         { "flipped-270", WL_OUTPUT_TRANSFORM_FLIPPED_270 },
 914 };
 915
 916 WL_EXPORT int
 917 weston_parse_transform(const char *transform, uint32_t *out)
 918 {
 919         unsigned int i;
 920
 921         for (i = 0; i < ARRAY_LENGTH(transforms); i++)
 922                 if (strcmp(transforms[i].name, transform) == 0) {
 923                         *out = transforms[i].token;
 924                         return 0;
 925                 }
 926
 927         *out = WL_OUTPUT_TRANSFORM_NORMAL;
 928         return -1;
 929 }
 930
 931 WL_EXPORT const char *
 932 weston_transform_to_string(uint32_t output_transform)
 933 {
 934         unsigned int i;
 935
 936         for (i = 0; i < ARRAY_LENGTH(transforms); i++)
 937                 if (transforms[i].token == output_transform)
 938                         return transforms[i].name;
 939
 940         return "<illegal value>";
 941 }
 942
 943 static int
 944 load_configuration(struct weston_config **config, int32_t noconfig,
 945                    const char *config_file)
 946 {
 947         const char *file = "weston.ini";
 948         const char *full_path;
 949
 950         *config = NULL;
 951
 952         if (config_file)
 953                 file = config_file;
 954
 955         if (noconfig == 0)
 956                 *config = weston_config_parse(file);
 957
 958         if (*config) {
 959                 full_path = weston_config_get_full_path(*config);
 960
 961                 weston_log("Using config file '%s'\n", full_path);
 962                 setenv(WESTON_CONFIG_FILE_ENV_VAR, full_path, 1);
 963
 964                 return 0;
 965         }
 966
 967         if (config_file && noconfig == 0) {
 968                 weston_log("fatal: error opening or reading config file"
 969                            " '%s'.\n", config_file);
 970
 971                 return -1;
 972         }
 973
 974         weston_log("Starting with no config file.\n");
 975         setenv(WESTON_CONFIG_FILE_ENV_VAR, "", 1);
 976
 977         return 0;
 978 }
 979
 980 static void
 981 handle_exit(struct weston_compositor *c)
 982 {
 983         wl_display_terminate(c->wl_display);
 984 }
 985
 986 static void
 987 wet_output_set_scale(struct weston_output *output,
 988                      struct weston_config_section *section,
 989                      int32_t default_scale,
 990                      int32_t parsed_scale)
 991 {
 992         int32_t scale = default_scale;
 993
 994         if (section)
 995                 weston_config_section_get_int(section, "scale", &scale, default_scale);
 996
 997         if (parsed_scale)
 998                 scale = parsed_scale;
 999
1000         weston_output_set_scale(output, scale);
1001 }
1002
1003 /* UINT32_MAX is treated as invalid because 0 is a valid
1004  * enumeration value and the parameter is unsigned
1005  */
1006 static void
1007 wet_output_set_transform(struct weston_output *output,
1008                          struct weston_config_section *section,
1009                          uint32_t default_transform,
1010                          uint32_t parsed_transform)
1011 {
1012         char *t;
1013         uint32_t transform = default_transform;
1014
1015         if (section) {
1016                 weston_config_section_get_string(section,
1017                                                  "transform", &t, "normal");
1018
1019                 if (weston_parse_transform(t, &transform) < 0) {
1020                         weston_log("Invalid transform \"%s\" for output %s\n",
1021                                    t, output->name);
1022                         transform = default_transform;
1023                 }
1024                 free(t);
1025         }
1026
1027         if (parsed_transform != UINT32_MAX)
1028                 transform = parsed_transform;
1029
1030         weston_output_set_transform(output, transform);
1031 }
1032
1033 static int
1034 wet_configure_windowed_output_from_config(struct weston_output *output,
1035                                           struct wet_output_config *defaults)
1036 {
1037         const struct weston_windowed_output_api *api =
1038                 weston_windowed_output_get_api(output->compositor);
1039
1040         struct weston_config *wc = wet_get_config(output->compositor);
1041         struct weston_config_section *section = NULL;
1042         struct wet_compositor *compositor = to_wet_compositor(output->compositor);
1043         struct wet_output_config *parsed_options = compositor->parsed_options;
1044         int width = defaults->width;
1045         int height = defaults->height;
1046
1047         assert(parsed_options);
1048
1049         if (!api) {
1050                 weston_log("Cannot use weston_windowed_output_api.\n");
1051                 return -1;
1052         }
1053
1054         section = weston_config_get_section(wc, "output", "name", output->name);
1055
1056         if (section) {
1057                 char *mode;
1058
1059                 weston_config_section_get_string(section, "mode", &mode, NULL);
1060                 if (!mode || sscanf(mode, "%dx%d", &width,
1061                                     &height) != 2) {
1062                         weston_log("Invalid mode for output %s. Using defaults.\n",
1063                                    output->name);
1064                         width = defaults->width;
1065                         height = defaults->height;
1066                 }
1067                 free(mode);
1068         }
1069
1070         if (parsed_options->width)
1071                 width = parsed_options->width;
1072
1073         if (parsed_options->height)
1074                 height = parsed_options->height;
1075
1076         wet_output_set_scale(output, section, defaults->scale, parsed_options->scale);
1077         wet_output_set_transform(output, section, defaults->transform, parsed_options->transform);
1078
1079         if (api->output_set_size(output, width, height) < 0) {
1080                 weston_log("Cannot configure output \"%s\" using weston_windowed_output_api.\n",
1081                            output->name);
1082                 return -1;
1083         }
1084
1085         weston_output_enable(output);
1086
1087         return 0;
1088 }
1089
1090 static void
1091 configure_input_device(struct weston_compositor *compositor,
1092                        struct libinput_device *device)
1093 {
1094         struct weston_config_section *s;
1095         struct weston_config *config = wet_get_config(compositor);
1096         int enable_tap;
1097         int enable_tap_default;
1098
1099         s = weston_config_get_section(config,
1100                                       "libinput", NULL, NULL);
1101
1102         if (libinput_device_config_tap_get_finger_count(device) > 0) {
1103                 enable_tap_default =
1104                         libinput_device_config_tap_get_default_enabled(
1105                                 device);
1106                 weston_config_section_get_bool(s, "enable_tap",
1107                                                &enable_tap,
1108                                                enable_tap_default);
1109                 libinput_device_config_tap_set_enabled(device,
1110                                                        enable_tap);
1111         }
1112 }
1113
1114 static void
1115 drm_backend_output_configure(struct wl_listener *listener, void *data)
1116 {
1117         struct weston_output *output = data;
1118         struct weston_config *wc = wet_get_config(output->compositor);
1119         struct weston_config_section *section;
1120         const struct weston_drm_output_api *api = weston_drm_output_get_api(output->compositor);
1121         enum weston_drm_backend_output_mode mode =
1122                 WESTON_DRM_BACKEND_OUTPUT_PREFERRED;
1123
1124         char *s;
1125         char *modeline = NULL;
1126         char *gbm_format = NULL;
1127         char *seat = NULL;
1128
1129         if (!api) {
1130                 weston_log("Cannot use weston_drm_output_api.\n");
1131                 return;
1132         }
1133
1134         section = weston_config_get_section(wc, "output", "name", output->name);
1135         weston_config_section_get_string(section, "mode", &s, "preferred");
1136
1137         if (strcmp(s, "off") == 0) {
1138                 weston_output_disable(output);
1139                 free(s);
1140                 return;
1141         } else if (strcmp(s, "current") == 0) {
1142                 mode = WESTON_DRM_BACKEND_OUTPUT_CURRENT;
1143         } else if (strcmp(s, "preferred") != 0) {
1144                 modeline = s;
1145                 s = NULL;
1146         }
1147         free(s);
1148
1149         if (api->set_mode(output, mode, modeline) < 0) {
1150                 weston_log("Cannot configure an output using weston_drm_output_api.\n");
1151                 free(modeline);
1152                 return;
1153         }
1154         free(modeline);
1155
1156         wet_output_set_scale(output, section, 1, 0);
1157         wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX);
1158
1159         weston_config_section_get_string(section,
1160                                          "gbm-format", &gbm_format, NULL);
1161
1162         api->set_gbm_format(output, gbm_format);
1163         free(gbm_format);
1164
1165         weston_config_section_get_string(section, "seat", &seat, "");
1166
1167         api->set_seat(output, seat);
1168         free(seat);
1169
1170         weston_output_enable(output);
1171 }
1172
1173 static int
1174 load_drm_backend(struct weston_compositor *c,
1175                  int *argc, char **argv, struct weston_config *wc)
1176 {
1177         struct weston_drm_backend_config config = {{ 0, }};
1178         struct weston_config_section *section;
1179         int ret = 0;
1180
1181         const struct weston_option options[] = {
1182                 { WESTON_OPTION_INTEGER, "connector", 0, &config.connector },
1183                 { WESTON_OPTION_STRING, "seat", 0, &config.seat_id },
1184                 { WESTON_OPTION_INTEGER, "tty", 0, &config.tty },
1185                 { WESTON_OPTION_BOOLEAN, "current-mode", 0, &config.use_current_mode },
1186                 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1187         };
1188
1189         parse_options(options, ARRAY_LENGTH(options), argc, argv);
1190
1191         section = weston_config_get_section(wc, "core", NULL, NULL);
1192         weston_config_section_get_string(section,
1193                                          "gbm-format", &config.gbm_format,
1194                                          NULL);
1195
1196         config.base.struct_version = WESTON_DRM_BACKEND_CONFIG_VERSION;
1197         config.base.struct_size = sizeof(struct weston_drm_backend_config);
1198         config.configure_device = configure_input_device;
1199
1200         ret = weston_compositor_load_backend(c, WESTON_BACKEND_DRM,
1201                                              &config.base);
1202
1203         wet_set_pending_output_handler(c, drm_backend_output_configure);
1204
1205         free(config.gbm_format);
1206         free(config.seat_id);
1207
1208         return ret;
1209 }
1210
1211 static void
1212 headless_backend_output_configure(struct wl_listener *listener, void *data)
1213 {
1214         struct weston_output *output = data;
1215         struct wet_output_config defaults = {
1216                 .width = 1024,
1217                 .height = 640,
1218                 .scale = 1,
1219                 .transform = WL_OUTPUT_TRANSFORM_NORMAL
1220         };
1221
1222         if (wet_configure_windowed_output_from_config(output, &defaults) < 0)
1223                 weston_log("Cannot configure output \"%s\".\n", output->name);
1224 }
1225
1226 static int
1227 load_headless_backend(struct weston_compositor *c,
1228                       int *argc, char **argv, struct weston_config *wc)
1229 {
1230         const struct weston_windowed_output_api *api;
1231         struct weston_headless_backend_config config = {{ 0, }};
1232         int no_outputs = 0;
1233         int ret = 0;
1234         char *transform = NULL;
1235
1236         struct wet_output_config *parsed_options = wet_init_parsed_options(c);
1237         if (!parsed_options)
1238                 return -1;
1239
1240         const struct weston_option options[] = {
1241                 { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width },
1242                 { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height },
1243                 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1244                 { WESTON_OPTION_STRING, "transform", 0, &transform },
1245                 { WESTON_OPTION_BOOLEAN, "no-outputs", 0, &no_outputs },
1246         };
1247
1248         parse_options(options, ARRAY_LENGTH(options), argc, argv);
1249
1250         if (transform) {
1251                 if (weston_parse_transform(transform, &parsed_options->transform) < 0) {
1252                         weston_log("Invalid transform \"%s\"\n", transform);
1253                         parsed_options->transform = UINT32_MAX;
1254                 }
1255                 free(transform);
1256         }
1257
1258         config.base.struct_version = WESTON_HEADLESS_BACKEND_CONFIG_VERSION;
1259         config.base.struct_size = sizeof(struct weston_headless_backend_config);
1260
1261         /* load the actual wayland backend and configure it */
1262         ret = weston_compositor_load_backend(c, WESTON_BACKEND_HEADLESS,
1263                                              &config.base);
1264
1265         if (ret < 0)
1266                 return ret;
1267
1268         wet_set_pending_output_handler(c, headless_backend_output_configure);
1269
1270         if (!no_outputs) {
1271                 api = weston_windowed_output_get_api(c);
1272
1273                 if (!api) {
1274                         weston_log("Cannot use weston_windowed_output_api.\n");
1275                         return -1;
1276                 }
1277
1278                 if (api->output_create(c, "headless") < 0)
1279                         return -1;
1280         }
1281
1282         return 0;
1283 }
1284
1285 static void
1286 rdp_backend_output_configure(struct wl_listener *listener, void *data)
1287 {
1288         struct weston_output *output = data;
1289         struct wet_compositor *compositor = to_wet_compositor(output->compositor);
1290         struct wet_output_config *parsed_options = compositor->parsed_options;
1291         const struct weston_rdp_output_api *api = weston_rdp_output_get_api(output->compositor);
1292         int width = 640;
1293         int height = 480;
1294
1295         assert(parsed_options);
1296
1297         if (!api) {
1298                 weston_log("Cannot use weston_rdp_output_api.\n");
1299                 return;
1300         }
1301
1302         if (parsed_options->width)
1303                 width = parsed_options->width;
1304
1305         if (parsed_options->height)
1306                 height = parsed_options->height;
1307
1308         weston_output_set_scale(output, 1);
1309         weston_output_set_transform(output, WL_OUTPUT_TRANSFORM_NORMAL);
1310
1311         if (api->output_set_size(output, width, height) < 0) {
1312                 weston_log("Cannot configure output \"%s\" using weston_rdp_output_api.\n",
1313                            output->name);
1314                 return;
1315         }
1316
1317         weston_output_enable(output);
1318 }
1319
1320 static void
1321 weston_rdp_backend_config_init(struct weston_rdp_backend_config *config)
1322 {
1323         config->base.struct_version = WESTON_RDP_BACKEND_CONFIG_VERSION;
1324         config->base.struct_size = sizeof(struct weston_rdp_backend_config);
1325
1326         config->bind_address = NULL;
1327         config->port = 3389;
1328         config->rdp_key = NULL;
1329         config->server_cert = NULL;
1330         config->server_key = NULL;
1331         config->env_socket = 0;
1332         config->no_clients_resize = 0;
1333 }
1334
1335 static int
1336 load_rdp_backend(struct weston_compositor *c,
1337                 int *argc, char *argv[], struct weston_config *wc)
1338 {
1339         struct weston_rdp_backend_config config  = {{ 0, }};
1340         int ret = 0;
1341
1342         struct wet_output_config *parsed_options = wet_init_parsed_options(c);
1343         if (!parsed_options)
1344                 return -1;
1345
1346         weston_rdp_backend_config_init(&config);
1347
1348         const struct weston_option rdp_options[] = {
1349                 { WESTON_OPTION_BOOLEAN, "env-socket", 0, &config.env_socket },
1350                 { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width },
1351                 { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height },
1352                 { WESTON_OPTION_STRING,  "address", 0, &config.bind_address },
1353                 { WESTON_OPTION_INTEGER, "port", 0, &config.port },
1354                 { WESTON_OPTION_BOOLEAN, "no-clients-resize", 0, &config.no_clients_resize },
1355                 { WESTON_OPTION_STRING,  "rdp4-key", 0, &config.rdp_key },
1356                 { WESTON_OPTION_STRING,  "rdp-tls-cert", 0, &config.server_cert },
1357                 { WESTON_OPTION_STRING,  "rdp-tls-key", 0, &config.server_key }
1358         };
1359
1360         parse_options(rdp_options, ARRAY_LENGTH(rdp_options), argc, argv);
1361
1362         ret = weston_compositor_load_backend(c, WESTON_BACKEND_RDP,
1363                                              &config.base);
1364
1365         if (ret < 0)
1366                 goto out;
1367
1368         wet_set_pending_output_handler(c, rdp_backend_output_configure);
1369
1370 out:
1371         free(config.bind_address);
1372         free(config.rdp_key);
1373         free(config.server_cert);
1374         free(config.server_key);
1375
1376         return ret;
1377 }
1378
1379 static void
1380 fbdev_backend_output_configure(struct wl_listener *listener, void *data)
1381 {
1382         struct weston_output *output = data;
1383         struct weston_config *wc = wet_get_config(output->compositor);
1384         struct weston_config_section *section;
1385
1386         section = weston_config_get_section(wc, "output", "name", "fbdev");
1387
1388         wet_output_set_transform(output, section, WL_OUTPUT_TRANSFORM_NORMAL, UINT32_MAX);
1389         weston_output_set_scale(output, 1);
1390
1391         weston_output_enable(output);
1392 }
1393
1394 static int
1395 load_fbdev_backend(struct weston_compositor *c,
1396                       int *argc, char **argv, struct weston_config *wc)
1397 {
1398         struct weston_fbdev_backend_config config = {{ 0, }};
1399         int ret = 0;
1400
1401         const struct weston_option fbdev_options[] = {
1402                 { WESTON_OPTION_INTEGER, "tty", 0, &config.tty },
1403                 { WESTON_OPTION_STRING, "device", 0, &config.device },
1404         };
1405
1406         parse_options(fbdev_options, ARRAY_LENGTH(fbdev_options), argc, argv);
1407
1408         if (!config.device)
1409                 config.device = strdup("/dev/fb0");
1410
1411         config.base.struct_version = WESTON_FBDEV_BACKEND_CONFIG_VERSION;
1412         config.base.struct_size = sizeof(struct weston_fbdev_backend_config);
1413         config.configure_device = configure_input_device;
1414
1415         /* load the actual wayland backend and configure it */
1416         ret = weston_compositor_load_backend(c, WESTON_BACKEND_FBDEV,
1417                                              &config.base);
1418
1419         if (ret < 0)
1420                 goto out;
1421
1422         wet_set_pending_output_handler(c, fbdev_backend_output_configure);
1423
1424 out:
1425         free(config.device);
1426         return ret;
1427 }
1428
1429 static void
1430 x11_backend_output_configure(struct wl_listener *listener, void *data)
1431 {
1432         struct weston_output *output = data;
1433         struct wet_output_config defaults = {
1434                 .width = 1024,
1435                 .height = 600,
1436                 .scale = 1,
1437                 .transform = WL_OUTPUT_TRANSFORM_NORMAL
1438         };
1439
1440         if (wet_configure_windowed_output_from_config(output, &defaults) < 0)
1441                 weston_log("Cannot configure output \"%s\".\n", output->name);
1442 }
1443
1444 static int
1445 load_x11_backend(struct weston_compositor *c,
1446                  int *argc, char **argv, struct weston_config *wc)
1447 {
1448         char *default_output;
1449         const struct weston_windowed_output_api *api;
1450         struct weston_x11_backend_config config = {{ 0, }};
1451         struct weston_config_section *section;
1452         int ret = 0;
1453         int option_count = 1;
1454         int output_count = 0;
1455         char const *section_name;
1456         int i;
1457
1458         struct wet_output_config *parsed_options = wet_init_parsed_options(c);
1459         if (!parsed_options)
1460                 return -1;
1461
1462         const struct weston_option options[] = {
1463                { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width },
1464                { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height },
1465                { WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale },
1466                { WESTON_OPTION_BOOLEAN, "fullscreen", 'f', &config.fullscreen },
1467                { WESTON_OPTION_INTEGER, "output-count", 0, &option_count },
1468                { WESTON_OPTION_BOOLEAN, "no-input", 0, &config.no_input },
1469                { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1470         };
1471
1472         parse_options(options, ARRAY_LENGTH(options), argc, argv);
1473
1474         config.base.struct_version = WESTON_X11_BACKEND_CONFIG_VERSION;
1475         config.base.struct_size = sizeof(struct weston_x11_backend_config);
1476
1477         /* load the actual backend and configure it */
1478         ret = weston_compositor_load_backend(c, WESTON_BACKEND_X11,
1479                                              &config.base);
1480
1481         if (ret < 0)
1482                 return ret;
1483
1484         wet_set_pending_output_handler(c, x11_backend_output_configure);
1485
1486         api = weston_windowed_output_get_api(c);
1487
1488         if (!api) {
1489                 weston_log("Cannot use weston_windowed_output_api.\n");
1490                 return -1;
1491         }
1492
1493         section = NULL;
1494         while (weston_config_next_section(wc, &section, &section_name)) {
1495                 char *output_name;
1496
1497                 if (output_count >= option_count)
1498                         break;
1499
1500                 if (strcmp(section_name, "output") != 0) {
1501                         continue;
1502                 }
1503
1504                 weston_config_section_get_string(section, "name", &output_name, NULL);
1505                 if (output_name == NULL || output_name[0] != 'X') {
1506                         free(output_name);
1507                         continue;
1508                 }
1509
1510                 if (api->output_create(c, output_name) < 0) {
1511                         free(output_name);
1512                         return -1;
1513                 }
1514                 free(output_name);
1515
1516                 output_count++;
1517         }
1518
1519         default_output = NULL;
1520
1521         for (i = output_count; i < option_count; i++) {
1522                 if (asprintf(&default_output, "screen%d", i) < 0) {
1523                         return -1;
1524                 }
1525
1526                 if (api->output_create(c, default_output) < 0) {
1527                         free(default_output);
1528                         return -1;
1529                 }
1530                 free(default_output);
1531         }
1532
1533         return 0;
1534 }
1535
1536 static void
1537 wayland_backend_output_configure_hotplug(struct wl_listener *listener, void *data)
1538 {
1539         struct weston_output *output = data;
1540
1541         /* This backend has all values hardcoded, so nothing can be configured here */
1542         weston_output_enable(output);
1543 }
1544
1545 static void
1546 wayland_backend_output_configure(struct wl_listener *listener, void *data)
1547 {
1548         struct weston_output *output = data;
1549         struct wet_output_config defaults = {
1550                 .width = 1024,
1551                 .height = 640,
1552                 .scale = 1,
1553                 .transform = WL_OUTPUT_TRANSFORM_NORMAL
1554         };
1555
1556         if (wet_configure_windowed_output_from_config(output, &defaults) < 0)
1557                 weston_log("Cannot configure output \"%s\".\n", output->name);
1558 }
1559
1560 static int
1561 load_wayland_backend(struct weston_compositor *c,
1562                      int *argc, char **argv, struct weston_config *wc)
1563 {
1564         struct weston_wayland_backend_config config = {{ 0, }};
1565         struct weston_config_section *section;
1566         const struct weston_windowed_output_api *api;
1567         const char *section_name;
1568         char *output_name = NULL;
1569         int count = 1;
1570         int ret = 0;
1571         int i;
1572
1573         struct wet_output_config *parsed_options = wet_init_parsed_options(c);
1574         if (!parsed_options)
1575                 return -1;
1576
1577         config.cursor_size = 32;
1578         config.cursor_theme = NULL;
1579         config.display_name = NULL;
1580         config.fullscreen = 0;
1581         config.sprawl = 0;
1582         config.use_pixman = false;
1583
1584         const struct weston_option wayland_options[] = {
1585                 { WESTON_OPTION_INTEGER, "width", 0, &parsed_options->width },
1586                 { WESTON_OPTION_INTEGER, "height", 0, &parsed_options->height },
1587                 { WESTON_OPTION_INTEGER, "scale", 0, &parsed_options->scale },
1588                 { WESTON_OPTION_STRING, "display", 0, &config.display_name },
1589                 { WESTON_OPTION_BOOLEAN, "use-pixman", 0, &config.use_pixman },
1590                 { WESTON_OPTION_INTEGER, "output-count", 0, &count },
1591                 { WESTON_OPTION_BOOLEAN, "fullscreen", 0, &config.fullscreen },
1592                 { WESTON_OPTION_BOOLEAN, "sprawl", 0, &config.sprawl },
1593         };
1594
1595         parse_options(wayland_options, ARRAY_LENGTH(wayland_options), argc, argv);
1596
1597         section = weston_config_get_section(wc, "shell", NULL, NULL);
1598         weston_config_section_get_string(section, "cursor-theme",
1599                                          &config.cursor_theme, NULL);
1600         weston_config_section_get_int(section, "cursor-size",
1601                                       &config.cursor_size, 32);
1602
1603         config.base.struct_size = sizeof(struct weston_wayland_backend_config);
1604         config.base.struct_version = WESTON_WAYLAND_BACKEND_CONFIG_VERSION;
1605
1606         /* load the actual wayland backend and configure it */
1607         ret = weston_compositor_load_backend(c, WESTON_BACKEND_WAYLAND,
1608                                              &config.base);
1609
1610         free(config.cursor_theme);
1611         free(config.display_name);
1612
1613         if (ret < 0)
1614                 return ret;
1615
1616         api = weston_windowed_output_get_api(c);
1617
1618         if (api == NULL) {
1619                 /* We will just assume if load_backend() finished cleanly and
1620                  * windowed_output_api is not present that wayland backend is
1621                  * started with --sprawl or runs on fullscreen-shell. */
1622                 wet_set_pending_output_handler(c, wayland_backend_output_configure_hotplug);
1623
1624                 return 0;
1625         }
1626
1627         wet_set_pending_output_handler(c, wayland_backend_output_configure);
1628
1629         section = NULL;
1630         while (weston_config_next_section(wc, &section, &section_name)) {
1631                 if (count == 0)
1632                         break;
1633
1634                 if (strcmp(section_name, "output") != 0) {
1635                         continue;
1636                 }
1637
1638                 weston_config_section_get_string(section, "name", &output_name, NULL);
1639
1640                 if (output_name == NULL)
1641                         continue;
1642
1643                 if (output_name[0] != 'W' || output_name[1] != 'L') {
1644                         free(output_name);
1645                         continue;
1646                 }
1647
1648                 if (api->output_create(c, output_name) < 0) {
1649                         free(output_name);
1650                         return -1;
1651                 }
1652                 free(output_name);
1653
1654                 --count;
1655         }
1656
1657         for (i = 0; i < count; i++) {
1658                 if (asprintf(&output_name, "wayland%d", i) < 0)
1659                         return -1;
1660
1661                 if (api->output_create(c, output_name) < 0) {
1662                         free(output_name);
1663                         return -1;
1664                 }
1665                 free(output_name);
1666         }
1667
1668         return 0;
1669 }
1670
1671
1672 static int
1673 load_backend(struct weston_compositor *compositor, const char *backend,
1674              int *argc, char **argv, struct weston_config *config)
1675 {
1676         if (strstr(backend, "headless-backend.so"))
1677                 return load_headless_backend(compositor, argc, argv, config);
1678         else if (strstr(backend, "rdp-backend.so"))
1679                 return load_rdp_backend(compositor, argc, argv, config);
1680         else if (strstr(backend, "fbdev-backend.so"))
1681                 return load_fbdev_backend(compositor, argc, argv, config);
1682         else if (strstr(backend, "drm-backend.so"))
1683                 return load_drm_backend(compositor, argc, argv, config);
1684         else if (strstr(backend, "x11-backend.so"))
1685                 return load_x11_backend(compositor, argc, argv, config);
1686         else if (strstr(backend, "wayland-backend.so"))
1687                 return load_wayland_backend(compositor, argc, argv, config);
1688
1689         weston_log("Error: unknown backend \"%s\"\n", backend);
1690         return -1;
1691 }
1692
1693 static char *
1694 copy_command_line(int argc, char * const argv[])
1695 {
1696         FILE *fp;
1697         char *str = NULL;
1698         size_t size = 0;
1699         int i;
1700
1701         fp = open_memstream(&str, &size);
1702         if (!fp)
1703                 return NULL;
1704
1705         fprintf(fp, "%s", argv[0]);
1706         for (i = 1; i < argc; i++)
1707                 fprintf(fp, " %s", argv[i]);
1708         fclose(fp);
1709
1710         return str;
1711 }
1712
1713 int main(int argc, char *argv[])
1714 {
1715         int ret = EXIT_FAILURE;
1716         char *cmdline;
1717         struct wl_display *display;
1718         struct weston_compositor *ec;
1719         struct wl_event_source *signals[4];
1720         struct wl_event_loop *loop;
1721         int i, fd;
1722         char *backend = NULL;
1723         char *shell = NULL;
1724         char *modules = NULL;
1725         char *option_modules = NULL;
1726         char *log = NULL;
1727         char *server_socket = NULL;
1728         int32_t idle_time = -1;
1729         int32_t help = 0;
1730         char *socket_name = NULL;
1731         int32_t version = 0;
1732         int32_t noconfig = 0;
1733         int32_t numlock_on;
1734         char *config_file = NULL;
1735         struct weston_config *config = NULL;
1736         struct weston_config_section *section;
1737         struct wl_client *primary_client;
1738         struct wl_listener primary_client_destroyed;
1739         struct weston_seat *seat;
1740         struct wet_compositor user_data;
1741
1742         const struct weston_option core_options[] = {
1743                 { WESTON_OPTION_STRING, "backend", 'B', &backend },
1744                 { WESTON_OPTION_STRING, "shell", 0, &shell },
1745                 { WESTON_OPTION_STRING, "socket", 'S', &socket_name },
1746                 { WESTON_OPTION_INTEGER, "idle-time", 'i', &idle_time },
1747                 { WESTON_OPTION_STRING, "modules", 0, &option_modules },
1748                 { WESTON_OPTION_STRING, "log", 0, &log },
1749                 { WESTON_OPTION_BOOLEAN, "help", 'h', &help },
1750                 { WESTON_OPTION_BOOLEAN, "version", 0, &version },
1751                 { WESTON_OPTION_BOOLEAN, "no-config", 0, &noconfig },
1752                 { WESTON_OPTION_STRING, "config", 'c', &config_file },
1753         };
1754
1755         cmdline = copy_command_line(argc, argv);
1756         parse_options(core_options, ARRAY_LENGTH(core_options), &argc, argv);
1757
1758         if (help) {
1759                 free(cmdline);
1760                 usage(EXIT_SUCCESS);
1761         }
1762
1763         if (version) {
1764                 printf(PACKAGE_STRING "\n");
1765                 free(cmdline);
1766
1767                 return EXIT_SUCCESS;
1768         }
1769
1770         weston_log_set_handler(vlog, vlog_continue);
1771         weston_log_file_open(log);
1772
1773         weston_log("%s\n"
1774                    STAMP_SPACE "%s\n"
1775                    STAMP_SPACE "Bug reports to: %s\n"
1776                    STAMP_SPACE "Build: %s\n",
1777                    PACKAGE_STRING, PACKAGE_URL, PACKAGE_BUGREPORT,
1778                    BUILD_ID);
1779         weston_log("Command line: %s\n", cmdline);
1780         free(cmdline);
1781         log_uname();
1782
1783         verify_xdg_runtime_dir();
1784
1785         display = wl_display_create();
1786
1787         loop = wl_display_get_event_loop(display);
1788         signals[0] = wl_event_loop_add_signal(loop, SIGTERM, on_term_signal,
1789                                               display);
1790         signals[1] = wl_event_loop_add_signal(loop, SIGINT, on_term_signal,
1791                                               display);
1792         signals[2] = wl_event_loop_add_signal(loop, SIGQUIT, on_term_signal,
1793                                               display);
1794
1795         wl_list_init(&child_process_list);
1796         signals[3] = wl_event_loop_add_signal(loop, SIGCHLD, sigchld_handler,
1797                                               NULL);
1798
1799         if (!signals[0] || !signals[1] || !signals[2] || !signals[3])
1800                 goto out_signals;
1801
1802         if (load_configuration(&config, noconfig, config_file) < 0)
1803                 goto out_signals;
1804         user_data.config = config;
1805         user_data.parsed_options = NULL;
1806
1807         section = weston_config_get_section(config, "core", NULL, NULL);
1808
1809         if (!backend) {
1810                 weston_config_section_get_string(section, "backend", &backend,
1811                                                  NULL);
1812                 if (!backend)
1813                         backend = weston_choose_default_backend();
1814         }
1815
1816         ec = weston_compositor_create(display, &user_data);
1817         if (ec == NULL) {
1818                 weston_log("fatal: failed to create compositor\n");
1819                 goto out;
1820         }
1821
1822         if (weston_compositor_init_config(ec, config) < 0)
1823                 goto out;
1824
1825         if (load_backend(ec, backend, &argc, argv, config) < 0) {
1826                 weston_log("fatal: failed to create compositor backend\n");
1827                 goto out;
1828         }
1829
1830         weston_pending_output_coldplug(ec);
1831
1832         catch_signals();
1833         segv_compositor = ec;
1834
1835         if (idle_time < 0)
1836                 weston_config_section_get_int(section, "idle-time", &idle_time, -1);
1837         if (idle_time < 0)
1838                 idle_time = 300; /* default idle timeout, in seconds */
1839
1840         ec->idle_time = idle_time;
1841         ec->default_pointer_grab = NULL;
1842         ec->exit = handle_exit;
1843
1844         weston_compositor_log_capabilities(ec);
1845
1846         server_socket = getenv("WAYLAND_SERVER_SOCKET");
1847         if (server_socket) {
1848                 weston_log("Running with single client\n");
1849                 if (!safe_strtoint(server_socket, &fd))
1850                         fd = -1;
1851         } else {
1852                 fd = -1;
1853         }
1854
1855         if (fd != -1) {
1856                 primary_client = wl_client_create(display, fd);
1857                 if (!primary_client) {
1858                         weston_log("fatal: failed to add client: %m\n");
1859                         goto out;
1860                 }
1861                 primary_client_destroyed.notify =
1862                         handle_primary_client_destroyed;
1863                 wl_client_add_destroy_listener(primary_client,
1864                                                &primary_client_destroyed);
1865         } else if (weston_create_listening_socket(display, socket_name)) {
1866                 goto out;
1867         }
1868
1869         if (!shell)
1870                 weston_config_section_get_string(section, "shell", &shell,
1871                                                  "desktop-shell.so");
1872
1873         if (load_modules(ec, shell, &argc, argv) < 0)
1874                 goto out;
1875
1876         weston_config_section_get_string(section, "modules", &modules, "");
1877         if (load_modules(ec, modules, &argc, argv) < 0)
1878                 goto out;
1879
1880         if (load_modules(ec, option_modules, &argc, argv) < 0)
1881                 goto out;
1882
1883         section = weston_config_get_section(config, "keyboard", NULL, NULL);
1884         weston_config_section_get_bool(section, "numlock-on", &numlock_on, 0);
1885         if (numlock_on) {
1886                 wl_list_for_each(seat, &ec->seat_list, link) {
1887                         struct weston_keyboard *keyboard =
1888                                 weston_seat_get_keyboard(seat);
1889
1890                         if (keyboard)
1891                                 weston_keyboard_set_locks(keyboard,
1892                                                           WESTON_NUM_LOCK,
1893                                                           WESTON_NUM_LOCK);
1894                 }
1895         }
1896
1897         for (i = 1; i < argc; i++)
1898                 weston_log("fatal: unhandled option: %s\n", argv[i]);
1899         if (argc > 1)
1900                 goto out;
1901
1902         weston_compositor_wake(ec);
1903
1904         wl_display_run(display);
1905
1906         /* Allow for setting return exit code after
1907         * wl_display_run returns normally. This is
1908         * useful for devs/testers and automated tests
1909         * that want to indicate failure status to
1910         * testing infrastructure above
1911         */
1912         ret = ec->exit_code;
1913
1914 out:
1915         /* free(NULL) is valid, and it won't be NULL if it's used */
1916         free(user_data.parsed_options);
1917
1918         weston_compositor_destroy(ec);
1919
1920 out_signals:
1921         for (i = ARRAY_LENGTH(signals) - 1; i >= 0; i--)
1922                 if (signals[i])
1923                         wl_event_source_remove(signals[i]);
1924
1925         wl_display_destroy(display);
1926
1927         weston_log_file_close();
1928
1929         if (config)
1930                 weston_config_destroy(config);
1931         free(config_file);
1932         free(backend);
1933         free(shell);
1934         free(socket_name);
1935         free(option_modules);
1936         free(log);
1937         free(modules);
1938
1939         return ret;
1940 }