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