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         {0, 0, 0, 0}
 273     };
 274     int option_index = 0, opt;
 275
 276     setlocale(LC_ALL, "");
 277
 278     /* Get the RLIMIT_CORE limit at startup time to restore this before
 279      * starting processes. */
 280     getrlimit(RLIMIT_CORE, &original_rlimit_core);
 281
 282     /* Disable output buffering to make redirects in .xsession actually useful for debugging */
 283     if (!isatty(fileno(stdout)))
 284         setbuf(stdout, NULL);
 285
 286     srand(time(NULL));
 287
 288     /* Init logging *before* initializing debug_build to guarantee early
 289      * (file) logging. */
 290     init_logging();
 291
 292     /* On non-release builds, disable SHM logging by default. */
 293     shmlog_size = (is_debug_build() ? 25 * 1024 * 1024 : 0);
 294
 295     start_argv = argv;
 296
 297     while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
 298         switch (opt) {
 299             case 'a':
 300                 LOG("Autostart disabled using -a\n");
 301                 autostart = false;
 302                 break;
 303             case 'L':
 304                 FREE(layout_path);
 305                 layout_path = sstrdup(optarg);
 306                 delete_layout_path = false;
 307                 break;
 308             case 'c':
 309                 FREE(override_configpath);
 310                 override_configpath = sstrdup(optarg);
 311                 break;
 312             case 'C':
 313                 LOG("Checking configuration file only (-C)\n");
 314                 only_check_config = true;
 315                 break;
 316             case 'v':
 317                 printf("i3 version " I3_VERSION " © 2009-2012 Michael Stapelberg and contributors\n");
 318                 exit(EXIT_SUCCESS);
 319                 break;
 320             case 'm':
 321                 printf("Binary i3 version:  " I3_VERSION " © 2009-2012 Michael Stapelberg and contributors\n");
 322                 display_running_version();
 323                 exit(EXIT_SUCCESS);
 324                 break;
 325             case 'V':
 326                 set_verbosity(true);
 327                 break;
 328             case 'd':
 329                 LOG("Enabling debug logging\n");
 330                 set_debug_logging(true);
 331                 break;
 332             case 'l':
 333                 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
 334                 break;
 335             case 0:
 336                 if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
 337                     strcmp(long_options[option_index].name, "force_xinerama") == 0) {
 338                     force_xinerama = true;
 339                     ELOG("Using Xinerama instead of RandR. This option should be "
 340                          "avoided at all cost because it does not refresh the list "
 341                          "of screens, so you cannot configure displays at runtime. "
 342                          "Please check if your driver really does not support RandR "
 343                          "and disable this option as soon as you can.\n");
 344                     break;
 345                 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
 346                     disable_signalhandler = true;
 347                     break;
 348                 } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
 349                            strcmp(long_options[option_index].name, "get_socketpath") == 0) {
 350                     char *socket_path = root_atom_contents("I3_SOCKET_PATH");
 351                     if (socket_path) {
 352                         printf("%s\n", socket_path);
 353                         exit(EXIT_SUCCESS);
 354                     }
 355
 356                     exit(EXIT_FAILURE);
 357                 } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
 358                            strcmp(long_options[option_index].name, "shmlog_size") == 0) {
 359                     shmlog_size = atoi(optarg);
 360                     /* Re-initialize logging immediately to get as many
 361                      * logmessages as possible into the SHM log. */
 362                     init_logging();
 363                     LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
 364                     break;
 365                 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
 366                     FREE(layout_path);
 367                     layout_path = sstrdup(optarg);
 368                     delete_layout_path = true;
 369                     break;
 370                 } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
 371                            strcmp(long_options[option_index].name, "fake_outputs") == 0) {
 372                     LOG("Initializing fake outputs: %s\n", optarg);
 373                     fake_outputs = sstrdup(optarg);
 374                     break;
 375                 }
 376                 /* fall-through */
 377             default:
 378                 fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
 379                 fprintf(stderr, "\n");
 380                 fprintf(stderr, "\t-a          disable autostart ('exec' lines in config)\n");
 381                 fprintf(stderr, "\t-c <file>   use the provided configfile instead\n");
 382                 fprintf(stderr, "\t-C          validate configuration file and exit\n");
 383                 fprintf(stderr, "\t-d all      enable debug output\n");
 384                 fprintf(stderr, "\t-L <file>   path to the serialized layout during restarts\n");
 385                 fprintf(stderr, "\t-v          display version and exit\n");
 386                 fprintf(stderr, "\t-V          enable verbose mode\n");
 387                 fprintf(stderr, "\n");
 388                 fprintf(stderr, "\t--force-xinerama\n"
 389                                 "\tUse Xinerama instead of RandR.\n"
 390                                 "\tThis option should only be used if you are stuck with the\n"
 391                                 "\told nVidia closed source driver (older than 302.17), which does\n"
 392                                 "\tnot support RandR.\n");
 393                 fprintf(stderr, "\n");
 394                 fprintf(stderr, "\t--get-socketpath\n"
 395                                 "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
 396                 fprintf(stderr, "\n");
 397                 fprintf(stderr, "\t--shmlog-size <limit>\n"
 398                                 "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
 399                                 "\tto 0 disables SHM logging entirely.\n"
 400                                 "\tThe default is %d bytes.\n", shmlog_size);
 401                 fprintf(stderr, "\n");
 402                 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
 403                                 "to send to a currently running i3 (like i3-msg). This allows you to\n"
 404                                 "use nice and logical commands, such as:\n"
 405                                 "\n"
 406                                 "\ti3 border none\n"
 407                                 "\ti3 floating toggle\n"
 408                                 "\ti3 kill window\n"
 409                                 "\n");
 410                 exit(EXIT_FAILURE);
 411         }
 412     }
 413
 414     /* If the user passes more arguments, we act like i3-msg would: Just send
 415      * the arguments as an IPC message to i3. This allows for nice semantic
 416      * commands such as 'i3 border none'. */
 417     if (!only_check_config && optind < argc) {
 418         /* We enable verbose mode so that the user knows what’s going on.
 419          * This should make it easier to find mistakes when the user passes
 420          * arguments by mistake. */
 421         set_verbosity(true);
 422
 423         LOG("Additional arguments passed. Sending them as a command to i3.\n");
 424         char *payload = NULL;
 425         while (optind < argc) {
 426             if (!payload) {
 427                 payload = sstrdup(argv[optind]);
 428             } else {
 429                 char *both;
 430                 sasprintf(&both, "%s %s", payload, argv[optind]);
 431                 free(payload);
 432                 payload = both;
 433             }
 434             optind++;
 435         }
 436         DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
 437         char *socket_path = root_atom_contents("I3_SOCKET_PATH");
 438         if (!socket_path) {
 439             ELOG("Could not get i3 IPC socket path\n");
 440             return 1;
 441         }
 442
 443         int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
 444         if (sockfd == -1)
 445             err(EXIT_FAILURE, "Could not create socket");
 446
 447         struct sockaddr_un addr;
 448         memset(&addr, 0, sizeof(struct sockaddr_un));
 449         addr.sun_family = AF_LOCAL;
 450         strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
 451         if (connect(sockfd, (const struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0)
 452             err(EXIT_FAILURE, "Could not connect to i3");
 453
 454         if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
 455                              (uint8_t*)payload) == -1)
 456             err(EXIT_FAILURE, "IPC: write()");
 457
 458         uint32_t reply_length;
 459         uint8_t *reply;
 460         int ret;
 461         if ((ret = ipc_recv_message(sockfd, I3_IPC_MESSAGE_TYPE_COMMAND,
 462                                     &reply_length, &reply)) != 0) {
 463             if (ret == -1)
 464                 err(EXIT_FAILURE, "IPC: read()");
 465             return 1;
 466         }
 467         printf("%.*s\n", reply_length, reply);
 468         return 0;
 469     }
 470
 471     /* Enable logging to handle the case when the user did not specify --shmlog-size */
 472     init_logging();
 473
 474     /* Try to enable core dumps by default when running a debug build */
 475     if (is_debug_build()) {
 476         struct rlimit limit = { RLIM_INFINITY, RLIM_INFINITY };
 477         setrlimit(RLIMIT_CORE, &limit);
 478
 479         /* The following code is helpful, but not required. We thus don’t pay
 480          * much attention to error handling, non-linux or other edge cases. */
 481         char cwd[PATH_MAX];
 482         LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
 483         if (getcwd(cwd, sizeof(cwd)) != NULL)
 484             LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
 485         int patternfd;
 486         if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
 487             memset(cwd, '\0', sizeof(cwd));
 488             if (read(patternfd, cwd, sizeof(cwd)) > 0)
 489                 /* a trailing newline is included in cwd */
 490                 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
 491             close(patternfd);
 492         }
 493     }
 494
 495     LOG("i3 " I3_VERSION " starting\n");
 496
 497     conn = xcb_connect(NULL, &conn_screen);
 498     if (xcb_connection_has_error(conn))
 499         errx(EXIT_FAILURE, "Cannot open display\n");
 500
 501     sndisplay = sn_xcb_display_new(conn, NULL, NULL);
 502
 503     /* Initialize the libev event loop. This needs to be done before loading
 504      * the config file because the parser will install an ev_child watcher
 505      * for the nagbar when config errors are found. */
 506     main_loop = EV_DEFAULT;
 507     if (main_loop == NULL)
 508             die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
 509
 510     root_screen = xcb_aux_get_screen(conn, conn_screen);
 511     root = root_screen->root;
 512
 513     /* By default, we use the same depth and visual as the root window, which
 514      * usually is TrueColor (24 bit depth) and the corresponding visual.
 515      * However, we also check if a 32 bit depth and visual are available (for
 516      * transparency) and use it if so. */
 517     root_depth = root_screen->root_depth;
 518     visual_id = root_screen->root_visual;
 519     colormap = root_screen->default_colormap;
 520
 521     DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
 522
 523     xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
 524     xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
 525
 526     load_configuration(conn, override_configpath, false);
 527     if (only_check_config) {
 528         LOG("Done checking configuration file. Exiting.\n");
 529         exit(0);
 530     }
 531
 532     if (config.ipc_socket_path == NULL) {
 533         /* Fall back to a file name in /tmp/ based on the PID */
 534         if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
 535             config.ipc_socket_path = get_process_filename("ipc-socket");
 536         else
 537             config.ipc_socket_path = sstrdup(config.ipc_socket_path);
 538     }
 539
 540     uint32_t mask = XCB_CW_EVENT_MASK;
 541     uint32_t values[] = { XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
 542                           XCB_EVENT_MASK_BUTTON_PRESS |
 543                           XCB_EVENT_MASK_STRUCTURE_NOTIFY |         /* when the user adds a screen (e.g. video
 544                                                                            projector), the root window gets a
 545                                                                            ConfigureNotify */
 546                           XCB_EVENT_MASK_POINTER_MOTION |
 547                           XCB_EVENT_MASK_PROPERTY_CHANGE |
 548                           XCB_EVENT_MASK_ENTER_WINDOW };
 549     xcb_void_cookie_t cookie;
 550     cookie = xcb_change_window_attributes_checked(conn, root, mask, values);
 551     check_error(conn, cookie, "Another window manager seems to be running");
 552
 553     xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
 554     if (greply == NULL) {
 555         ELOG("Could not get geometry of the root window, exiting\n");
 556         return 1;
 557     }
 558     DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
 559
 560     /* Place requests for the atoms we need as soon as possible */
 561     #define xmacro(atom) \
 562         xcb_intern_atom_cookie_t atom ## _cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
 563     #include "atoms.xmacro"
 564     #undef xmacro
 565
 566     /* Initialize the Xlib connection */
 567     xlibdpy = xkbdpy = XOpenDisplay(NULL);
 568
 569     /* Try to load the X cursors and initialize the XKB extension */
 570     if (xlibdpy == NULL) {
 571         ELOG("ERROR: XOpenDisplay() failed, disabling libXcursor/XKB support\n");
 572         xcursor_supported = false;
 573         xkb_supported = false;
 574     } else if (fcntl(ConnectionNumber(xlibdpy), F_SETFD, FD_CLOEXEC) == -1) {
 575         ELOG("Could not set FD_CLOEXEC on xkbdpy\n");
 576         return 1;
 577     } else {
 578         xcursor_load_cursors();
 579         /*init_xkb();*/
 580     }
 581
 582     /* Set a cursor for the root window (otherwise the root window will show no
 583        cursor until the first client is launched). */
 584     if (xcursor_supported)
 585         xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
 586     else xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
 587
 588     if (xkb_supported) {
 589         int errBase,
 590             major = XkbMajorVersion,
 591             minor = XkbMinorVersion;
 592
 593         if (fcntl(ConnectionNumber(xkbdpy), F_SETFD, FD_CLOEXEC) == -1) {
 594             fprintf(stderr, "Could not set FD_CLOEXEC on xkbdpy\n");
 595             return 1;
 596         }
 597
 598         int i1;
 599         if (!XkbQueryExtension(xkbdpy,&i1,&xkb_event_base,&errBase,&major,&minor)) {
 600             fprintf(stderr, "XKB not supported by X-server\n");
 601             return 1;
 602         }
 603         /* end of ugliness */
 604
 605         if (!XkbSelectEvents(xkbdpy, XkbUseCoreKbd,
 606                              XkbMapNotifyMask | XkbStateNotifyMask,
 607                              XkbMapNotifyMask | XkbStateNotifyMask)) {
 608             fprintf(stderr, "Could not set XKB event mask\n");
 609             return 1;
 610         }
 611     }
 612
 613     /* Setup NetWM atoms */
 614     #define xmacro(name) \
 615         do { \
 616             xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name ## _cookie, NULL); \
 617             if (!reply) { \
 618                 ELOG("Could not get atom " #name "\n"); \
 619                 exit(-1); \
 620             } \
 621             A_ ## name = reply->atom; \
 622             free(reply); \
 623         } while (0);
 624     #include "atoms.xmacro"
 625     #undef xmacro
 626
 627     property_handlers_init();
 628
 629     ewmh_setup_hints();
 630
 631     keysyms = xcb_key_symbols_alloc(conn);
 632
 633     xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
 634
 635     translate_keysyms();
 636     grab_all_keys(conn, false);
 637
 638     bool needs_tree_init = true;
 639     if (layout_path) {
 640         LOG("Trying to restore the layout from %s...", layout_path);
 641         needs_tree_init = !tree_restore(layout_path, greply);
 642         if (delete_layout_path)
 643             unlink(layout_path);
 644         free(layout_path);
 645     }
 646     if (needs_tree_init)
 647         tree_init(greply);
 648
 649     free(greply);
 650
 651     /* Setup fake outputs for testing */
 652     if (fake_outputs == NULL && config.fake_outputs != NULL)
 653         fake_outputs = config.fake_outputs;
 654
 655     if (fake_outputs != NULL) {
 656         fake_outputs_init(fake_outputs);
 657         FREE(fake_outputs);
 658         config.fake_outputs = NULL;
 659     } else if (force_xinerama || config.force_xinerama) {
 660         /* Force Xinerama (for drivers which don't support RandR yet, esp. the
 661          * nVidia binary graphics driver), when specified either in the config
 662          * file or on command-line */
 663         xinerama_init();
 664     } else {
 665         DLOG("Checking for XRandR...\n");
 666         randr_init(&randr_base);
 667     }
 668
 669     scratchpad_fix_resolution();
 670
 671     xcb_query_pointer_reply_t *pointerreply;
 672     Output *output = NULL;
 673     if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
 674         ELOG("Could not query pointer position, using first screen\n");
 675     } else {
 676         DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
 677         output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
 678         if (!output) {
 679             ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
 680                  pointerreply->root_x, pointerreply->root_y);
 681             output = get_first_output();
 682         }
 683
 684         con_focus(con_descend_focused(output_get_content(output->con)));
 685     }
 686
 687     tree_render();
 688
 689     /* Create the UNIX domain socket for IPC */
 690     int ipc_socket = ipc_create_socket(config.ipc_socket_path);
 691     if (ipc_socket == -1) {
 692         ELOG("Could not create the IPC socket, IPC disabled\n");
 693     } else {
 694         free(config.ipc_socket_path);
 695         struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
 696         ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
 697         ev_io_start(main_loop, ipc_io);
 698     }
 699
 700     /* Also handle the UNIX domain sockets passed via socket activation. The
 701      * parameter 1 means "remove the environment variables", we don’t want to
 702      * pass these to child processes. */
 703     listen_fds = sd_listen_fds(0);
 704     if (listen_fds < 0)
 705         ELOG("socket activation: Error in sd_listen_fds\n");
 706     else if (listen_fds == 0)
 707         DLOG("socket activation: no sockets passed\n");
 708     else {
 709         int flags;
 710         for (int fd = SD_LISTEN_FDS_START;
 711              fd < (SD_LISTEN_FDS_START + listen_fds);
 712              fd++) {
 713             DLOG("socket activation: also listening on fd %d\n", fd);
 714
 715             /* sd_listen_fds() enables FD_CLOEXEC by default.
 716              * However, we need to keep the file descriptors open for in-place
 717              * restarting, therefore we explicitly disable FD_CLOEXEC. */
 718             if ((flags = fcntl(fd, F_GETFD)) < 0 ||
 719                 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
 720                 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
 721             }
 722
 723             struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
 724             ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
 725             ev_io_start(main_loop, ipc_io);
 726         }
 727     }
 728
 729     /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
 730     x_set_i3_atoms();
 731
 732     struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
 733     struct ev_io *xkb = scalloc(sizeof(struct ev_io));
 734     struct ev_check *xcb_check = scalloc(sizeof(struct ev_check));
 735     struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
 736
 737     ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
 738     ev_io_start(main_loop, xcb_watcher);
 739
 740
 741     if (xkb_supported) {
 742         ev_io_init(xkb, xkb_got_event, ConnectionNumber(xkbdpy), EV_READ);
 743         ev_io_start(main_loop, xkb);
 744
 745         /* Flush the buffer so that libev can properly get new events */
 746         XFlush(xkbdpy);
 747     }
 748
 749     ev_check_init(xcb_check, xcb_check_cb);
 750     ev_check_start(main_loop, xcb_check);
 751
 752     ev_prepare_init(xcb_prepare, xcb_prepare_cb);
 753     ev_prepare_start(main_loop, xcb_prepare);
 754
 755     xcb_flush(conn);
 756
 757     /* What follows is a fugly consequence of X11 protocol race conditions like
 758      * the following: In an i3 in-place restart, i3 will reparent all windows
 759      * to the root window, then exec() itself. In the new process, it calls
 760      * manage_existing_windows. However, in case any application sent a
 761      * generated UnmapNotify message to the WM (as GIMP does), this message
 762      * will be handled by i3 *after* managing the window, thus i3 thinks the
 763      * window just closed itself. In reality, the message was sent in the time
 764      * period where i3 wasn’t running yet.
 765      *
 766      * To prevent this, we grab the server (disables processing of any other
 767      * connections), then discard all pending events (since we didn’t do
 768      * anything, there cannot be any meaningful responses), then ungrab the
 769      * server. */
 770     xcb_grab_server(conn);
 771     {
 772         xcb_aux_sync(conn);
 773         xcb_generic_event_t *event;
 774         while ((event = xcb_poll_for_event(conn)) != NULL) {
 775             free(event);
 776         }
 777         manage_existing_windows(root);
 778     }
 779     xcb_ungrab_server(conn);
 780
 781     struct sigaction action;
 782
 783     action.sa_sigaction = handle_signal;
 784     action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 785     sigemptyset(&action.sa_mask);
 786
 787     if (!disable_signalhandler)
 788         setup_signal_handler();
 789     else {
 790         /* Catch all signals with default action "Core", see signal(7) */
 791         if (sigaction(SIGQUIT, &action, NULL) == -1 ||
 792             sigaction(SIGILL, &action, NULL) == -1 ||
 793             sigaction(SIGABRT, &action, NULL) == -1 ||
 794             sigaction(SIGFPE, &action, NULL) == -1 ||
 795             sigaction(SIGSEGV, &action, NULL) == -1)
 796             ELOG("Could not setup signal handler");
 797     }
 798
 799     /* Catch all signals with default action "Term", see signal(7) */
 800     if (sigaction(SIGHUP, &action, NULL) == -1 ||
 801         sigaction(SIGINT, &action, NULL) == -1 ||
 802         sigaction(SIGALRM, &action, NULL) == -1 ||
 803         sigaction(SIGUSR1, &action, NULL) == -1 ||
 804         sigaction(SIGUSR2, &action, NULL) == -1)
 805         ELOG("Could not setup signal handler");
 806
 807     /* Ignore SIGPIPE to survive errors when an IPC client disconnects
 808      * while we are sending him a message */
 809     signal(SIGPIPE, SIG_IGN);
 810
 811     /* Autostarting exec-lines */
 812     if (autostart) {
 813         struct Autostart *exec;
 814         TAILQ_FOREACH(exec, &autostarts, autostarts) {
 815             LOG("auto-starting %s\n", exec->command);
 816             start_application(exec->command, exec->no_startup_id);
 817         }
 818     }
 819
 820     /* Autostarting exec_always-lines */
 821     struct Autostart *exec_always;
 822     TAILQ_FOREACH(exec_always, &autostarts_always, autostarts_always) {
 823         LOG("auto-starting (always!) %s\n", exec_always->command);
 824         start_application(exec_always->command, exec_always->no_startup_id);
 825     }
 826
 827     /* Start i3bar processes for all configured bars */
 828     Barconfig *barconfig;
 829     TAILQ_FOREACH(barconfig, &barconfigs, configs) {
 830         char *command = NULL;
 831         sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
 832                 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
 833                 barconfig->id, current_socketpath);
 834         LOG("Starting bar process: %s\n", command);
 835         start_application(command, true);
 836         free(command);
 837     }
 838
 839     /* Make sure to destroy the event loop to invoke the cleeanup callbacks
 840      * when calling exit() */
 841     atexit(i3_exit);
 842
 843     ev_loop(main_loop, 0);
 844 }