git.sur5r.net Git - i3/i3/blob - src/main.c

   1 #undef I3__FILE__
   2 #define I3__FILE__ "main.c"
   3 /*
   4  * vim:ts=4:sw=4:expandtab
   5  *
   6  * i3 - an improved dynamic tiling window manager
   7  * © 2009-2013 Michael Stapelberg and contributors (see also: LICENSE)
   8  *
   9  * main.c: Initialization, main loop
  10  *
  11  */
  12 #include <ev.h>
  13 #include <fcntl.h>
  14 #include <sys/types.h>
  15 #include <sys/socket.h>
  16 #include <sys/un.h>
  17 #include <sys/time.h>
  18 #include <sys/resource.h>
  19 #include <sys/mman.h>
  20 #include <sys/stat.h>
  21 #include <libgen.h>
  22 #include "all.h"
  23 #include "shmlog.h"
  24
  25 #include "sd-daemon.h"
  26
  27 /* The original value of RLIMIT_CORE when i3 was started. We need to restore
  28  * this before starting any other process, since we set RLIMIT_CORE to
  29  * RLIM_INFINITY for i3 debugging versions. */
  30 struct rlimit original_rlimit_core;
  31
  32 /** The number of file descriptors passed via socket activation. */
  33 int listen_fds;
  34
  35 /* We keep the xcb_check watcher around to be able to enable and disable it
  36  * temporarily for drag_pointer(). */
  37 static struct ev_check *xcb_check;
  38
  39 extern Con *focused;
  40
  41 char **start_argv;
  42
  43 xcb_connection_t *conn;
  44 /* The screen (0 when you are using DISPLAY=:0) of the connection 'conn' */
  45 int conn_screen;
  46
  47 /* Display handle for libstartup-notification */
  48 SnDisplay *sndisplay;
  49
  50 /* The last timestamp we got from X11 (timestamps are included in some events
  51  * and are used for some things, like determining a unique ID in startup
  52  * notification). */
  53 xcb_timestamp_t last_timestamp = XCB_CURRENT_TIME;
  54
  55 xcb_screen_t *root_screen;
  56 xcb_window_t root;
  57
  58 /* Color depth, visual id and colormap to use when creating windows and
  59  * pixmaps. Will use 32 bit depth and an appropriate visual, if available,
  60  * otherwise the root window’s default (usually 24 bit TrueColor). */
  61 uint8_t root_depth;
  62 xcb_visualid_t visual_id;
  63 xcb_colormap_t colormap;
  64
  65 struct ev_loop *main_loop;
  66
  67 xcb_key_symbols_t *keysyms;
  68
  69 /* Default shmlog size if not set by user. */
  70 const int default_shmlog_size = 25 * 1024 * 1024;
  71
  72 /* The list of key bindings */
  73 struct bindings_head *bindings;
  74
  75 /* The list of exec-lines */
  76 struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts);
  77
  78 /* The list of exec_always lines */
  79 struct autostarts_always_head autostarts_always = TAILQ_HEAD_INITIALIZER(autostarts_always);
  80
  81 /* The list of assignments */
  82 struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments);
  83
  84 /* The list of workspace assignments (which workspace should end up on which
  85  * output) */
  86 struct ws_assignments_head ws_assignments = TAILQ_HEAD_INITIALIZER(ws_assignments);
  87
  88 /* We hope that those are supported and set them to true */
  89 bool xcursor_supported = true;
  90
  91 /* This will be set to true when -C is used so that functions can behave
  92  * slightly differently. We don’t want i3-nagbar to be started when validating
  93  * the config, for example. */
  94 bool only_check_config = false;
  95
  96 /*
  97  * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
  98  * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
  99  *
 100  */
 101 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
 102     /* empty, because xcb_prepare_cb and xcb_check_cb are used */
 103 }
 104
 105 /*
 106  * Flush before blocking (and waiting for new events)
 107  *
 108  */
 109 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
 110     xcb_flush(conn);
 111 }
 112
 113 /*
 114  * Instead of polling the X connection socket we leave this to
 115  * xcb_poll_for_event() which knows better than we can ever know.
 116  *
 117  */
 118 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
 119     xcb_generic_event_t *event;
 120
 121     while ((event = xcb_poll_for_event(conn)) != NULL) {
 122         if (event->response_type == 0) {
 123             if (event_is_ignored(event->sequence, 0))
 124                 DLOG("Expected X11 Error received for sequence %x\n", event->sequence);
 125             else {
 126                 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
 127                 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
 128                      error->sequence, error->error_code);
 129             }
 130             free(event);
 131             continue;
 132         }
 133
 134         /* Strip off the highest bit (set if the event is generated) */
 135         int type = (event->response_type & 0x7F);
 136
 137         handle_event(type, event);
 138
 139         free(event);
 140     }
 141 }
 142
 143 /*
 144  * Enable or disable the main X11 event handling function.
 145  * This is used by drag_pointer() which has its own, modal event handler, which
 146  * takes precedence over the normal event handler.
 147  *
 148  */
 149 void main_set_x11_cb(bool enable) {
 150     DLOG("Setting main X11 callback to enabled=%d\n", enable);
 151     if (enable) {
 152         ev_check_start(main_loop, xcb_check);
 153         /* Trigger the watcher explicitly to handle all remaining X11 events.
 154          * drag_pointer()’s event handler exits in the middle of the loop. */
 155         ev_feed_event(main_loop, xcb_check, 0);
 156     } else {
 157         ev_check_stop(main_loop, xcb_check);
 158     }
 159 }
 160
 161 /*
 162  * Exit handler which destroys the main_loop. Will trigger cleanup handlers.
 163  *
 164  */
 165 static void i3_exit(void) {
 166 /* We need ev >= 4 for the following code. Since it is not *that* important (it
 167  * only makes sure that there are no i3-nagbar instances left behind) we still
 168  * support old systems with libev 3. */
 169 #if EV_VERSION_MAJOR >= 4
 170     ev_loop_destroy(main_loop);
 171 #endif
 172
 173     if (*shmlogname != '\0') {
 174         fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
 175         fflush(stderr);
 176         shm_unlink(shmlogname);
 177     }
 178 }
 179
 180 /*
 181  * (One-shot) Handler for all signals with default action "Term", see signal(7)
 182  *
 183  * Unlinks the SHM log and re-raises the signal.
 184  *
 185  */
 186 static void handle_signal(int sig, siginfo_t *info, void *data) {
 187     if (*shmlogname != '\0') {
 188         shm_unlink(shmlogname);
 189     }
 190     raise(sig);
 191 }
 192
 193 int main(int argc, char *argv[]) {
 194     /* Keep a symbol pointing to the I3_VERSION string constant so that we have
 195      * it in gdb backtraces. */
 196     const char *i3_version __attribute__((unused)) = I3_VERSION;
 197     char *override_configpath = NULL;
 198     bool autostart = true;
 199     char *layout_path = NULL;
 200     bool delete_layout_path = false;
 201     bool force_xinerama = false;
 202     char *fake_outputs = NULL;
 203     bool disable_signalhandler = false;
 204     static struct option long_options[] = {
 205         {"no-autostart", no_argument, 0, 'a'},
 206         {"config", required_argument, 0, 'c'},
 207         {"version", no_argument, 0, 'v'},
 208         {"moreversion", no_argument, 0, 'm'},
 209         {"more-version", no_argument, 0, 'm'},
 210         {"more_version", no_argument, 0, 'm'},
 211         {"help", no_argument, 0, 'h'},
 212         {"layout", required_argument, 0, 'L'},
 213         {"restart", required_argument, 0, 0},
 214         {"force-xinerama", no_argument, 0, 0},
 215         {"force_xinerama", no_argument, 0, 0},
 216         {"disable-signalhandler", no_argument, 0, 0},
 217         {"shmlog-size", required_argument, 0, 0},
 218         {"shmlog_size", required_argument, 0, 0},
 219         {"get-socketpath", no_argument, 0, 0},
 220         {"get_socketpath", no_argument, 0, 0},
 221         {"fake_outputs", required_argument, 0, 0},
 222         {"fake-outputs", required_argument, 0, 0},
 223         {"force-old-config-parser-v4.4-only", no_argument, 0, 0},
 224         {0, 0, 0, 0}};
 225     int option_index = 0, opt;
 226
 227     setlocale(LC_ALL, "");
 228
 229     /* Get the RLIMIT_CORE limit at startup time to restore this before
 230      * starting processes. */
 231     getrlimit(RLIMIT_CORE, &original_rlimit_core);
 232
 233     /* Disable output buffering to make redirects in .xsession actually useful for debugging */
 234     if (!isatty(fileno(stdout)))
 235         setbuf(stdout, NULL);
 236
 237     srand(time(NULL));
 238
 239     /* Init logging *before* initializing debug_build to guarantee early
 240      * (file) logging. */
 241     init_logging();
 242
 243     /* On release builds, disable SHM logging by default. */
 244     shmlog_size = (is_debug_build() || strstr(argv[0], "i3-with-shmlog") != NULL ? default_shmlog_size : 0);
 245
 246     start_argv = argv;
 247
 248     while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
 249         switch (opt) {
 250             case 'a':
 251                 LOG("Autostart disabled using -a\n");
 252                 autostart = false;
 253                 break;
 254             case 'L':
 255                 FREE(layout_path);
 256                 layout_path = sstrdup(optarg);
 257                 delete_layout_path = false;
 258                 break;
 259             case 'c':
 260                 FREE(override_configpath);
 261                 override_configpath = sstrdup(optarg);
 262                 break;
 263             case 'C':
 264                 LOG("Checking configuration file only (-C)\n");
 265                 only_check_config = true;
 266                 break;
 267             case 'v':
 268                 printf("i3 version " I3_VERSION " © 2009-2014 Michael Stapelberg and contributors\n");
 269                 exit(EXIT_SUCCESS);
 270                 break;
 271             case 'm':
 272                 printf("Binary i3 version:  " I3_VERSION " © 2009-2014 Michael Stapelberg and contributors\n");
 273                 display_running_version();
 274                 exit(EXIT_SUCCESS);
 275                 break;
 276             case 'V':
 277                 set_verbosity(true);
 278                 break;
 279             case 'd':
 280                 LOG("Enabling debug logging\n");
 281                 set_debug_logging(true);
 282                 break;
 283             case 'l':
 284                 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
 285                 break;
 286             case 0:
 287                 if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
 288                     strcmp(long_options[option_index].name, "force_xinerama") == 0) {
 289                     force_xinerama = true;
 290                     ELOG("Using Xinerama instead of RandR. This option should be "
 291                          "avoided at all cost because it does not refresh the list "
 292                          "of screens, so you cannot configure displays at runtime. "
 293                          "Please check if your driver really does not support RandR "
 294                          "and disable this option as soon as you can.\n");
 295                     break;
 296                 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
 297                     disable_signalhandler = true;
 298                     break;
 299                 } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
 300                            strcmp(long_options[option_index].name, "get_socketpath") == 0) {
 301                     char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
 302                     if (socket_path) {
 303                         printf("%s\n", socket_path);
 304                         exit(EXIT_SUCCESS);
 305                     }
 306
 307                     exit(EXIT_FAILURE);
 308                 } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
 309                            strcmp(long_options[option_index].name, "shmlog_size") == 0) {
 310                     shmlog_size = atoi(optarg);
 311                     /* Re-initialize logging immediately to get as many
 312                      * logmessages as possible into the SHM log. */
 313                     init_logging();
 314                     LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
 315                     break;
 316                 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
 317                     FREE(layout_path);
 318                     layout_path = sstrdup(optarg);
 319                     delete_layout_path = true;
 320                     break;
 321                 } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
 322                            strcmp(long_options[option_index].name, "fake_outputs") == 0) {
 323                     LOG("Initializing fake outputs: %s\n", optarg);
 324                     fake_outputs = sstrdup(optarg);
 325                     break;
 326                 } else if (strcmp(long_options[option_index].name, "force-old-config-parser-v4.4-only") == 0) {
 327                     ELOG("You are passing --force-old-config-parser-v4.4-only, but that flag was removed by now.\n");
 328                     break;
 329                 }
 330             /* fall-through */
 331             default:
 332                 fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
 333                 fprintf(stderr, "\n");
 334                 fprintf(stderr, "\t-a          disable autostart ('exec' lines in config)\n");
 335                 fprintf(stderr, "\t-c <file>   use the provided configfile instead\n");
 336                 fprintf(stderr, "\t-C          validate configuration file and exit\n");
 337                 fprintf(stderr, "\t-d all      enable debug output\n");
 338                 fprintf(stderr, "\t-L <file>   path to the serialized layout during restarts\n");
 339                 fprintf(stderr, "\t-v          display version and exit\n");
 340                 fprintf(stderr, "\t-V          enable verbose mode\n");
 341                 fprintf(stderr, "\n");
 342                 fprintf(stderr, "\t--force-xinerama\n"
 343                                 "\tUse Xinerama instead of RandR.\n"
 344                                 "\tThis option should only be used if you are stuck with the\n"
 345                                 "\told nVidia closed source driver (older than 302.17), which does\n"
 346                                 "\tnot support RandR.\n");
 347                 fprintf(stderr, "\n");
 348                 fprintf(stderr, "\t--get-socketpath\n"
 349                                 "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
 350                 fprintf(stderr, "\n");
 351                 fprintf(stderr, "\t--shmlog-size <limit>\n"
 352                                 "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
 353                                 "\tto 0 disables SHM logging entirely.\n"
 354                                 "\tThe default is %d bytes.\n",
 355                         shmlog_size);
 356                 fprintf(stderr, "\n");
 357                 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
 358                                 "to send to a currently running i3 (like i3-msg). This allows you to\n"
 359                                 "use nice and logical commands, such as:\n"
 360                                 "\n"
 361                                 "\ti3 border none\n"
 362                                 "\ti3 floating toggle\n"
 363                                 "\ti3 kill window\n"
 364                                 "\n");
 365                 exit(EXIT_FAILURE);
 366         }
 367     }
 368
 369     /* If the user passes more arguments, we act like i3-msg would: Just send
 370      * the arguments as an IPC message to i3. This allows for nice semantic
 371      * commands such as 'i3 border none'. */
 372     if (!only_check_config && optind < argc) {
 373         /* We enable verbose mode so that the user knows what’s going on.
 374          * This should make it easier to find mistakes when the user passes
 375          * arguments by mistake. */
 376         set_verbosity(true);
 377
 378         LOG("Additional arguments passed. Sending them as a command to i3.\n");
 379         char *payload = NULL;
 380         while (optind < argc) {
 381             if (!payload) {
 382                 payload = sstrdup(argv[optind]);
 383             } else {
 384                 char *both;
 385                 sasprintf(&both, "%s %s", payload, argv[optind]);
 386                 free(payload);
 387                 payload = both;
 388             }
 389             optind++;
 390         }
 391         DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
 392         char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
 393         if (!socket_path) {
 394             ELOG("Could not get i3 IPC socket path\n");
 395             return 1;
 396         }
 397
 398         int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
 399         if (sockfd == -1)
 400             err(EXIT_FAILURE, "Could not create socket");
 401
 402         struct sockaddr_un addr;
 403         memset(&addr, 0, sizeof(struct sockaddr_un));
 404         addr.sun_family = AF_LOCAL;
 405         strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
 406         if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
 407             err(EXIT_FAILURE, "Could not connect to i3");
 408
 409         if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
 410                              (uint8_t *)payload) == -1)
 411             err(EXIT_FAILURE, "IPC: write()");
 412
 413         uint32_t reply_length;
 414         uint32_t reply_type;
 415         uint8_t *reply;
 416         int ret;
 417         if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
 418             if (ret == -1)
 419                 err(EXIT_FAILURE, "IPC: read()");
 420             return 1;
 421         }
 422         if (reply_type != I3_IPC_MESSAGE_TYPE_COMMAND)
 423             errx(EXIT_FAILURE, "IPC: received reply of type %d but expected %d (COMMAND)", reply_type, I3_IPC_MESSAGE_TYPE_COMMAND);
 424         printf("%.*s\n", reply_length, reply);
 425         return 0;
 426     }
 427
 428     /* Enable logging to handle the case when the user did not specify --shmlog-size */
 429     init_logging();
 430
 431     /* Try to enable core dumps by default when running a debug build */
 432     if (is_debug_build()) {
 433         struct rlimit limit = {RLIM_INFINITY, RLIM_INFINITY};
 434         setrlimit(RLIMIT_CORE, &limit);
 435
 436         /* The following code is helpful, but not required. We thus don’t pay
 437          * much attention to error handling, non-linux or other edge cases. */
 438         LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
 439         size_t cwd_size = 1024;
 440         char *cwd = smalloc(cwd_size);
 441         char *cwd_ret;
 442         while ((cwd_ret = getcwd(cwd, cwd_size)) == NULL && errno == ERANGE) {
 443             cwd_size = cwd_size * 2;
 444             cwd = srealloc(cwd, cwd_size);
 445         }
 446         if (cwd_ret != NULL)
 447             LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
 448         int patternfd;
 449         if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
 450             memset(cwd, '\0', cwd_size);
 451             if (read(patternfd, cwd, cwd_size) > 0)
 452                 /* a trailing newline is included in cwd */
 453                 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
 454             close(patternfd);
 455         }
 456         free(cwd);
 457     }
 458
 459     LOG("i3 " I3_VERSION " starting\n");
 460
 461     conn = xcb_connect(NULL, &conn_screen);
 462     if (xcb_connection_has_error(conn))
 463         errx(EXIT_FAILURE, "Cannot open display\n");
 464
 465     sndisplay = sn_xcb_display_new(conn, NULL, NULL);
 466
 467     /* Initialize the libev event loop. This needs to be done before loading
 468      * the config file because the parser will install an ev_child watcher
 469      * for the nagbar when config errors are found. */
 470     main_loop = EV_DEFAULT;
 471     if (main_loop == NULL)
 472         die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
 473
 474     root_screen = xcb_aux_get_screen(conn, conn_screen);
 475     root = root_screen->root;
 476
 477     /* By default, we use the same depth and visual as the root window, which
 478      * usually is TrueColor (24 bit depth) and the corresponding visual.
 479      * However, we also check if a 32 bit depth and visual are available (for
 480      * transparency) and use it if so. */
 481     root_depth = root_screen->root_depth;
 482     visual_id = root_screen->root_visual;
 483     colormap = root_screen->default_colormap;
 484
 485     DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
 486
 487     xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
 488     xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
 489
 490     load_configuration(conn, override_configpath, false);
 491     if (only_check_config) {
 492         LOG("Done checking configuration file. Exiting.\n");
 493         exit(0);
 494     }
 495
 496     if (config.ipc_socket_path == NULL) {
 497         /* Fall back to a file name in /tmp/ based on the PID */
 498         if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
 499             config.ipc_socket_path = get_process_filename("ipc-socket");
 500         else
 501             config.ipc_socket_path = sstrdup(config.ipc_socket_path);
 502     }
 503
 504     xcb_void_cookie_t cookie;
 505     cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]) {ROOT_EVENT_MASK});
 506     check_error(conn, cookie, "Another window manager seems to be running");
 507
 508     xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
 509     if (greply == NULL) {
 510         ELOG("Could not get geometry of the root window, exiting\n");
 511         return 1;
 512     }
 513     DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
 514
 515 /* Place requests for the atoms we need as soon as possible */
 516 #define xmacro(atom) \
 517     xcb_intern_atom_cookie_t atom##_cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
 518 #include "atoms.xmacro"
 519 #undef xmacro
 520
 521     xcursor_load_cursors();
 522
 523     /* Set a cursor for the root window (otherwise the root window will show no
 524        cursor until the first client is launched). */
 525     if (xcursor_supported)
 526         xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
 527     else
 528         xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
 529
 530     const xcb_query_extension_reply_t *extreply;
 531     extreply = xcb_get_extension_data(conn, &xcb_xkb_id);
 532     if (!extreply->present) {
 533         DLOG("xkb is not present on this server\n");
 534     } else {
 535         DLOG("initializing xcb-xkb\n");
 536         xcb_xkb_use_extension(conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
 537         xcb_xkb_select_events(conn,
 538                               XCB_XKB_ID_USE_CORE_KBD,
 539                               XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY,
 540                               0,
 541                               XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY,
 542                               0xff,
 543                               0xff,
 544                               NULL);
 545         xkb_base = extreply->first_event;
 546     }
 547
 548     restore_connect();
 549
 550 /* Setup NetWM atoms */
 551 #define xmacro(name)                                                                       \
 552     do {                                                                                   \
 553         xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name##_cookie, NULL); \
 554         if (!reply) {                                                                      \
 555             ELOG("Could not get atom " #name "\n");                                        \
 556             exit(-1);                                                                      \
 557         }                                                                                  \
 558         A_##name = reply->atom;                                                            \
 559         free(reply);                                                                       \
 560     } while (0);
 561 #include "atoms.xmacro"
 562 #undef xmacro
 563
 564     property_handlers_init();
 565
 566     ewmh_setup_hints();
 567
 568     keysyms = xcb_key_symbols_alloc(conn);
 569
 570     xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
 571
 572     translate_keysyms();
 573     grab_all_keys(conn, false);
 574
 575     bool needs_tree_init = true;
 576     if (layout_path) {
 577         LOG("Trying to restore the layout from %s...", layout_path);
 578         needs_tree_init = !tree_restore(layout_path, greply);
 579         if (delete_layout_path) {
 580             unlink(layout_path);
 581             const char *dir = dirname(layout_path);
 582             /* possibly fails with ENOTEMPTY if there are files (or
 583              * sockets) left. */
 584             rmdir(dir);
 585         }
 586         free(layout_path);
 587     }
 588     if (needs_tree_init)
 589         tree_init(greply);
 590
 591     free(greply);
 592
 593     /* Setup fake outputs for testing */
 594     if (fake_outputs == NULL && config.fake_outputs != NULL)
 595         fake_outputs = config.fake_outputs;
 596
 597     if (fake_outputs != NULL) {
 598         fake_outputs_init(fake_outputs);
 599         FREE(fake_outputs);
 600         config.fake_outputs = NULL;
 601     } else if (force_xinerama || config.force_xinerama) {
 602         /* Force Xinerama (for drivers which don't support RandR yet, esp. the
 603          * nVidia binary graphics driver), when specified either in the config
 604          * file or on command-line */
 605         xinerama_init();
 606     } else {
 607         DLOG("Checking for XRandR...\n");
 608         randr_init(&randr_base);
 609     }
 610
 611     scratchpad_fix_resolution();
 612
 613     xcb_query_pointer_reply_t *pointerreply;
 614     Output *output = NULL;
 615     if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
 616         ELOG("Could not query pointer position, using first screen\n");
 617     } else {
 618         DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
 619         output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
 620         if (!output) {
 621             ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
 622                  pointerreply->root_x, pointerreply->root_y);
 623             output = get_first_output();
 624         }
 625
 626         con_focus(con_descend_focused(output_get_content(output->con)));
 627     }
 628
 629     tree_render();
 630
 631     /* Create the UNIX domain socket for IPC */
 632     int ipc_socket = ipc_create_socket(config.ipc_socket_path);
 633     if (ipc_socket == -1) {
 634         ELOG("Could not create the IPC socket, IPC disabled\n");
 635     } else {
 636         struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
 637         ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
 638         ev_io_start(main_loop, ipc_io);
 639     }
 640
 641     /* Also handle the UNIX domain sockets passed via socket activation. The
 642      * parameter 1 means "remove the environment variables", we don’t want to
 643      * pass these to child processes. */
 644     listen_fds = sd_listen_fds(0);
 645     if (listen_fds < 0)
 646         ELOG("socket activation: Error in sd_listen_fds\n");
 647     else if (listen_fds == 0)
 648         DLOG("socket activation: no sockets passed\n");
 649     else {
 650         int flags;
 651         for (int fd = SD_LISTEN_FDS_START;
 652              fd < (SD_LISTEN_FDS_START + listen_fds);
 653              fd++) {
 654             DLOG("socket activation: also listening on fd %d\n", fd);
 655
 656             /* sd_listen_fds() enables FD_CLOEXEC by default.
 657              * However, we need to keep the file descriptors open for in-place
 658              * restarting, therefore we explicitly disable FD_CLOEXEC. */
 659             if ((flags = fcntl(fd, F_GETFD)) < 0 ||
 660                 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
 661                 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
 662             }
 663
 664             struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
 665             ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
 666             ev_io_start(main_loop, ipc_io);
 667         }
 668     }
 669
 670     /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
 671     x_set_i3_atoms();
 672     ewmh_update_workarea();
 673
 674     /* Set the ewmh desktop properties. */
 675     ewmh_update_current_desktop();
 676     ewmh_update_number_of_desktops();
 677     ewmh_update_desktop_viewport();
 678
 679     struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
 680     xcb_check = scalloc(sizeof(struct ev_check));
 681     struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
 682
 683     ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
 684     ev_io_start(main_loop, xcb_watcher);
 685
 686     ev_check_init(xcb_check, xcb_check_cb);
 687     ev_check_start(main_loop, xcb_check);
 688
 689     ev_prepare_init(xcb_prepare, xcb_prepare_cb);
 690     ev_prepare_start(main_loop, xcb_prepare);
 691
 692     xcb_flush(conn);
 693
 694     /* What follows is a fugly consequence of X11 protocol race conditions like
 695      * the following: In an i3 in-place restart, i3 will reparent all windows
 696      * to the root window, then exec() itself. In the new process, it calls
 697      * manage_existing_windows. However, in case any application sent a
 698      * generated UnmapNotify message to the WM (as GIMP does), this message
 699      * will be handled by i3 *after* managing the window, thus i3 thinks the
 700      * window just closed itself. In reality, the message was sent in the time
 701      * period where i3 wasn’t running yet.
 702      *
 703      * To prevent this, we grab the server (disables processing of any other
 704      * connections), then discard all pending events (since we didn’t do
 705      * anything, there cannot be any meaningful responses), then ungrab the
 706      * server. */
 707     xcb_grab_server(conn);
 708     {
 709         xcb_aux_sync(conn);
 710         xcb_generic_event_t *event;
 711         while ((event = xcb_poll_for_event(conn)) != NULL) {
 712             if (event->response_type == 0) {
 713                 free(event);
 714                 continue;
 715             }
 716
 717             /* Strip off the highest bit (set if the event is generated) */
 718             int type = (event->response_type & 0x7F);
 719
 720             /* We still need to handle MapRequests which are sent in the
 721              * timespan starting from when we register as a window manager and
 722              * this piece of code which drops events. */
 723             if (type == XCB_MAP_REQUEST)
 724                 handle_event(type, event);
 725
 726             free(event);
 727         }
 728         manage_existing_windows(root);
 729     }
 730     xcb_ungrab_server(conn);
 731
 732     if (autostart) {
 733         LOG("This is not an in-place restart, copying root window contents to a pixmap\n");
 734         xcb_screen_t *root = xcb_aux_get_screen(conn, conn_screen);
 735         uint16_t width = root->width_in_pixels;
 736         uint16_t height = root->height_in_pixels;
 737         xcb_pixmap_t pixmap = xcb_generate_id(conn);
 738         xcb_gcontext_t gc = xcb_generate_id(conn);
 739
 740         xcb_create_pixmap(conn, root->root_depth, pixmap, root->root, width, height);
 741
 742         xcb_create_gc(conn, gc, root->root,
 743                       XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
 744                       (uint32_t[]) {XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS});
 745
 746         xcb_copy_area(conn, root->root, pixmap, gc, 0, 0, 0, 0, width, height);
 747         xcb_change_window_attributes_checked(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]) {pixmap});
 748         xcb_flush(conn);
 749         xcb_free_gc(conn, gc);
 750         xcb_free_pixmap(conn, pixmap);
 751     }
 752
 753     struct sigaction action;
 754
 755     action.sa_sigaction = handle_signal;
 756     action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 757     sigemptyset(&action.sa_mask);
 758
 759     if (!disable_signalhandler)
 760         setup_signal_handler();
 761     else {
 762         /* Catch all signals with default action "Core", see signal(7) */
 763         if (sigaction(SIGQUIT, &action, NULL) == -1 ||
 764             sigaction(SIGILL, &action, NULL) == -1 ||
 765             sigaction(SIGABRT, &action, NULL) == -1 ||
 766             sigaction(SIGFPE, &action, NULL) == -1 ||
 767             sigaction(SIGSEGV, &action, NULL) == -1)
 768             ELOG("Could not setup signal handler");
 769     }
 770
 771     /* Catch all signals with default action "Term", see signal(7) */
 772     if (sigaction(SIGHUP, &action, NULL) == -1 ||
 773         sigaction(SIGINT, &action, NULL) == -1 ||
 774         sigaction(SIGALRM, &action, NULL) == -1 ||
 775         sigaction(SIGUSR1, &action, NULL) == -1 ||
 776         sigaction(SIGUSR2, &action, NULL) == -1)
 777         ELOG("Could not setup signal handler");
 778
 779     /* Ignore SIGPIPE to survive errors when an IPC client disconnects
 780      * while we are sending him a message */
 781     signal(SIGPIPE, SIG_IGN);
 782
 783     /* Autostarting exec-lines */
 784     if (autostart) {
 785         struct Autostart *exec;
 786         TAILQ_FOREACH(exec, &autostarts, autostarts) {
 787             LOG("auto-starting %s\n", exec->command);
 788             start_application(exec->command, exec->no_startup_id);
 789         }
 790     }
 791
 792     /* Autostarting exec_always-lines */
 793     struct Autostart *exec_always;
 794     TAILQ_FOREACH(exec_always, &autostarts_always, autostarts_always) {
 795         LOG("auto-starting (always!) %s\n", exec_always->command);
 796         start_application(exec_always->command, exec_always->no_startup_id);
 797     }
 798
 799     /* Start i3bar processes for all configured bars */
 800     Barconfig *barconfig;
 801     TAILQ_FOREACH(barconfig, &barconfigs, configs) {
 802         char *command = NULL;
 803         sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
 804                   barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
 805                   barconfig->id, current_socketpath);
 806         LOG("Starting bar process: %s\n", command);
 807         start_application(command, true);
 808         free(command);
 809     }
 810
 811     /* Make sure to destroy the event loop to invoke the cleeanup callbacks
 812      * when calling exit() */
 813     atexit(i3_exit);
 814
 815     ev_loop(main_loop, 0);
 816 }