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

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