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 "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-2013 Michael Stapelberg and contributors\n");
 319                 exit(EXIT_SUCCESS);
 320                 break;
 321             case 'm':
 322                 printf("Binary i3 version:  " I3_VERSION " © 2009-2013 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         uint32_t reply_type;
 464         uint8_t *reply;
 465         int ret;
 466         if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
 467             if (ret == -1)
 468                 err(EXIT_FAILURE, "IPC: read()");
 469             return 1;
 470         }
 471         if (reply_type != I3_IPC_MESSAGE_TYPE_COMMAND)
 472             errx(EXIT_FAILURE, "IPC: received reply of type %d but expected %d (COMMAND)", reply_type, I3_IPC_MESSAGE_TYPE_COMMAND);
 473         printf("%.*s\n", reply_length, reply);
 474         return 0;
 475     }
 476
 477     /* Enable logging to handle the case when the user did not specify --shmlog-size */
 478     init_logging();
 479
 480     /* Try to enable core dumps by default when running a debug build */
 481     if (is_debug_build()) {
 482         struct rlimit limit = { RLIM_INFINITY, RLIM_INFINITY };
 483         setrlimit(RLIMIT_CORE, &limit);
 484
 485         /* The following code is helpful, but not required. We thus don’t pay
 486          * much attention to error handling, non-linux or other edge cases. */
 487         char cwd[PATH_MAX];
 488         LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
 489         if (getcwd(cwd, sizeof(cwd)) != NULL)
 490             LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
 491         int patternfd;
 492         if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
 493             memset(cwd, '\0', sizeof(cwd));
 494             if (read(patternfd, cwd, sizeof(cwd)) > 0)
 495                 /* a trailing newline is included in cwd */
 496                 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
 497             close(patternfd);
 498         }
 499     }
 500
 501     LOG("i3 " I3_VERSION " starting\n");
 502
 503     conn = xcb_connect(NULL, &conn_screen);
 504     if (xcb_connection_has_error(conn))
 505         errx(EXIT_FAILURE, "Cannot open display\n");
 506
 507     sndisplay = sn_xcb_display_new(conn, NULL, NULL);
 508
 509     /* Initialize the libev event loop. This needs to be done before loading
 510      * the config file because the parser will install an ev_child watcher
 511      * for the nagbar when config errors are found. */
 512     main_loop = EV_DEFAULT;
 513     if (main_loop == NULL)
 514             die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
 515
 516     root_screen = xcb_aux_get_screen(conn, conn_screen);
 517     root = root_screen->root;
 518
 519     /* By default, we use the same depth and visual as the root window, which
 520      * usually is TrueColor (24 bit depth) and the corresponding visual.
 521      * However, we also check if a 32 bit depth and visual are available (for
 522      * transparency) and use it if so. */
 523     root_depth = root_screen->root_depth;
 524     visual_id = root_screen->root_visual;
 525     colormap = root_screen->default_colormap;
 526
 527     DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
 528
 529     xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
 530     xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
 531
 532     load_configuration(conn, override_configpath, false);
 533     if (only_check_config) {
 534         LOG("Done checking configuration file. Exiting.\n");
 535         exit(0);
 536     }
 537
 538     if (config.ipc_socket_path == NULL) {
 539         /* Fall back to a file name in /tmp/ based on the PID */
 540         if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
 541             config.ipc_socket_path = get_process_filename("ipc-socket");
 542         else
 543             config.ipc_socket_path = sstrdup(config.ipc_socket_path);
 544     }
 545
 546     xcb_void_cookie_t cookie;
 547     cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ ROOT_EVENT_MASK });
 548     check_error(conn, cookie, "Another window manager seems to be running");
 549
 550     xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
 551     if (greply == NULL) {
 552         ELOG("Could not get geometry of the root window, exiting\n");
 553         return 1;
 554     }
 555     DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
 556
 557     /* Place requests for the atoms we need as soon as possible */
 558     #define xmacro(atom) \
 559         xcb_intern_atom_cookie_t atom ## _cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
 560     #include "atoms.xmacro"
 561     #undef xmacro
 562
 563     /* Initialize the Xlib connection */
 564     xlibdpy = xkbdpy = XOpenDisplay(NULL);
 565
 566     /* Try to load the X cursors and initialize the XKB extension */
 567     if (xlibdpy == NULL) {
 568         ELOG("ERROR: XOpenDisplay() failed, disabling libXcursor/XKB support\n");
 569         xcursor_supported = false;
 570         xkb_supported = false;
 571     } else if (fcntl(ConnectionNumber(xlibdpy), F_SETFD, FD_CLOEXEC) == -1) {
 572         ELOG("Could not set FD_CLOEXEC on xkbdpy\n");
 573         return 1;
 574     } else {
 575         xcursor_load_cursors();
 576         /*init_xkb();*/
 577     }
 578
 579     /* Set a cursor for the root window (otherwise the root window will show no
 580        cursor until the first client is launched). */
 581     if (xcursor_supported)
 582         xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
 583     else xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
 584
 585     if (xkb_supported) {
 586         int errBase,
 587             major = XkbMajorVersion,
 588             minor = XkbMinorVersion;
 589
 590         if (fcntl(ConnectionNumber(xkbdpy), F_SETFD, FD_CLOEXEC) == -1) {
 591             fprintf(stderr, "Could not set FD_CLOEXEC on xkbdpy\n");
 592             return 1;
 593         }
 594
 595         int i1;
 596         if (!XkbQueryExtension(xkbdpy,&i1,&xkb_event_base,&errBase,&major,&minor)) {
 597             fprintf(stderr, "XKB not supported by X-server\n");
 598             xkb_supported = false;
 599         }
 600         /* end of ugliness */
 601
 602         if (xkb_supported && !XkbSelectEvents(xkbdpy, XkbUseCoreKbd,
 603                                               XkbMapNotifyMask | XkbStateNotifyMask,
 604                                               XkbMapNotifyMask | XkbStateNotifyMask)) {
 605             fprintf(stderr, "Could not set XKB event mask\n");
 606             return 1;
 607         }
 608     }
 609
 610     /* Setup NetWM atoms */
 611     #define xmacro(name) \
 612         do { \
 613             xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name ## _cookie, NULL); \
 614             if (!reply) { \
 615                 ELOG("Could not get atom " #name "\n"); \
 616                 exit(-1); \
 617             } \
 618             A_ ## name = reply->atom; \
 619             free(reply); \
 620         } while (0);
 621     #include "atoms.xmacro"
 622     #undef xmacro
 623
 624     property_handlers_init();
 625
 626     ewmh_setup_hints();
 627
 628     keysyms = xcb_key_symbols_alloc(conn);
 629
 630     xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
 631
 632     translate_keysyms();
 633     grab_all_keys(conn, false);
 634
 635     bool needs_tree_init = true;
 636     if (layout_path) {
 637         LOG("Trying to restore the layout from %s...", layout_path);
 638         needs_tree_init = !tree_restore(layout_path, greply);
 639         if (delete_layout_path)
 640             unlink(layout_path);
 641         free(layout_path);
 642     }
 643     if (needs_tree_init)
 644         tree_init(greply);
 645
 646     free(greply);
 647
 648     /* Setup fake outputs for testing */
 649     if (fake_outputs == NULL && config.fake_outputs != NULL)
 650         fake_outputs = config.fake_outputs;
 651
 652     if (fake_outputs != NULL) {
 653         fake_outputs_init(fake_outputs);
 654         FREE(fake_outputs);
 655         config.fake_outputs = NULL;
 656     } else if (force_xinerama || config.force_xinerama) {
 657         /* Force Xinerama (for drivers which don't support RandR yet, esp. the
 658          * nVidia binary graphics driver), when specified either in the config
 659          * file or on command-line */
 660         xinerama_init();
 661     } else {
 662         DLOG("Checking for XRandR...\n");
 663         randr_init(&randr_base);
 664     }
 665
 666     scratchpad_fix_resolution();
 667
 668     xcb_query_pointer_reply_t *pointerreply;
 669     Output *output = NULL;
 670     if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
 671         ELOG("Could not query pointer position, using first screen\n");
 672     } else {
 673         DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
 674         output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
 675         if (!output) {
 676             ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
 677                  pointerreply->root_x, pointerreply->root_y);
 678             output = get_first_output();
 679         }
 680
 681         con_focus(con_descend_focused(output_get_content(output->con)));
 682     }
 683
 684     tree_render();
 685
 686     /* Create the UNIX domain socket for IPC */
 687     int ipc_socket = ipc_create_socket(config.ipc_socket_path);
 688     if (ipc_socket == -1) {
 689         ELOG("Could not create the IPC socket, IPC disabled\n");
 690     } else {
 691         free(config.ipc_socket_path);
 692         struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
 693         ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
 694         ev_io_start(main_loop, ipc_io);
 695     }
 696
 697     /* Also handle the UNIX domain sockets passed via socket activation. The
 698      * parameter 1 means "remove the environment variables", we don’t want to
 699      * pass these to child processes. */
 700     listen_fds = sd_listen_fds(0);
 701     if (listen_fds < 0)
 702         ELOG("socket activation: Error in sd_listen_fds\n");
 703     else if (listen_fds == 0)
 704         DLOG("socket activation: no sockets passed\n");
 705     else {
 706         int flags;
 707         for (int fd = SD_LISTEN_FDS_START;
 708              fd < (SD_LISTEN_FDS_START + listen_fds);
 709              fd++) {
 710             DLOG("socket activation: also listening on fd %d\n", fd);
 711
 712             /* sd_listen_fds() enables FD_CLOEXEC by default.
 713              * However, we need to keep the file descriptors open for in-place
 714              * restarting, therefore we explicitly disable FD_CLOEXEC. */
 715             if ((flags = fcntl(fd, F_GETFD)) < 0 ||
 716                 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
 717                 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
 718             }
 719
 720             struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
 721             ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
 722             ev_io_start(main_loop, ipc_io);
 723         }
 724     }
 725
 726     /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
 727     x_set_i3_atoms();
 728
 729     struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
 730     struct ev_io *xkb = scalloc(sizeof(struct ev_io));
 731     struct ev_check *xcb_check = scalloc(sizeof(struct ev_check));
 732     struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
 733
 734     ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
 735     ev_io_start(main_loop, xcb_watcher);
 736
 737
 738     if (xkb_supported) {
 739         ev_io_init(xkb, xkb_got_event, ConnectionNumber(xkbdpy), EV_READ);
 740         ev_io_start(main_loop, xkb);
 741
 742         /* Flush the buffer so that libev can properly get new events */
 743         XFlush(xkbdpy);
 744     }
 745
 746     ev_check_init(xcb_check, xcb_check_cb);
 747     ev_check_start(main_loop, xcb_check);
 748
 749     ev_prepare_init(xcb_prepare, xcb_prepare_cb);
 750     ev_prepare_start(main_loop, xcb_prepare);
 751
 752     xcb_flush(conn);
 753
 754     /* What follows is a fugly consequence of X11 protocol race conditions like
 755      * the following: In an i3 in-place restart, i3 will reparent all windows
 756      * to the root window, then exec() itself. In the new process, it calls
 757      * manage_existing_windows. However, in case any application sent a
 758      * generated UnmapNotify message to the WM (as GIMP does), this message
 759      * will be handled by i3 *after* managing the window, thus i3 thinks the
 760      * window just closed itself. In reality, the message was sent in the time
 761      * period where i3 wasn’t running yet.
 762      *
 763      * To prevent this, we grab the server (disables processing of any other
 764      * connections), then discard all pending events (since we didn’t do
 765      * anything, there cannot be any meaningful responses), then ungrab the
 766      * server. */
 767     xcb_grab_server(conn);
 768     {
 769         xcb_aux_sync(conn);
 770         xcb_generic_event_t *event;
 771         while ((event = xcb_poll_for_event(conn)) != NULL) {
 772             if (event->response_type == 0) {
 773                 free(event);
 774                 continue;
 775             }
 776
 777             /* Strip off the highest bit (set if the event is generated) */
 778             int type = (event->response_type & 0x7F);
 779
 780             /* We still need to handle MapRequests which are sent in the
 781              * timespan starting from when we register as a window manager and
 782              * this piece of code which drops events. */
 783             if (type == XCB_MAP_REQUEST)
 784                 handle_event(type, event);
 785
 786             free(event);
 787         }
 788         manage_existing_windows(root);
 789     }
 790     xcb_ungrab_server(conn);
 791
 792     struct sigaction action;
 793
 794     action.sa_sigaction = handle_signal;
 795     action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
 796     sigemptyset(&action.sa_mask);
 797
 798     if (!disable_signalhandler)
 799         setup_signal_handler();
 800     else {
 801         /* Catch all signals with default action "Core", see signal(7) */
 802         if (sigaction(SIGQUIT, &action, NULL) == -1 ||
 803             sigaction(SIGILL, &action, NULL) == -1 ||
 804             sigaction(SIGABRT, &action, NULL) == -1 ||
 805             sigaction(SIGFPE, &action, NULL) == -1 ||
 806             sigaction(SIGSEGV, &action, NULL) == -1)
 807             ELOG("Could not setup signal handler");
 808     }
 809
 810     /* Catch all signals with default action "Term", see signal(7) */
 811     if (sigaction(SIGHUP, &action, NULL) == -1 ||
 812         sigaction(SIGINT, &action, NULL) == -1 ||
 813         sigaction(SIGALRM, &action, NULL) == -1 ||
 814         sigaction(SIGUSR1, &action, NULL) == -1 ||
 815         sigaction(SIGUSR2, &action, NULL) == -1)
 816         ELOG("Could not setup signal handler");
 817
 818     /* Ignore SIGPIPE to survive errors when an IPC client disconnects
 819      * while we are sending him a message */
 820     signal(SIGPIPE, SIG_IGN);
 821
 822     /* Autostarting exec-lines */
 823     if (autostart) {
 824         struct Autostart *exec;
 825         TAILQ_FOREACH(exec, &autostarts, autostarts) {
 826             LOG("auto-starting %s\n", exec->command);
 827             start_application(exec->command, exec->no_startup_id);
 828         }
 829     }
 830
 831     /* Autostarting exec_always-lines */
 832     struct Autostart *exec_always;
 833     TAILQ_FOREACH(exec_always, &autostarts_always, autostarts_always) {
 834         LOG("auto-starting (always!) %s\n", exec_always->command);
 835         start_application(exec_always->command, exec_always->no_startup_id);
 836     }
 837
 838     /* Start i3bar processes for all configured bars */
 839     Barconfig *barconfig;
 840     TAILQ_FOREACH(barconfig, &barconfigs, configs) {
 841         char *command = NULL;
 842         sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
 843                 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
 844                 barconfig->id, current_socketpath);
 845         LOG("Starting bar process: %s\n", command);
 846         start_application(command, true);
 847         free(command);
 848     }
 849
 850     /* Make sure to destroy the event loop to invoke the cleeanup callbacks
 851      * when calling exit() */
 852     atexit(i3_exit);
 853
 854     ev_loop(main_loop, 0);
 855 }