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