2 * vim:ts=4:sw=4:expandtab
4 * i3 - an improved dynamic tiling window manager
5 * © 2009 Michael Stapelberg and contributors (see also: LICENSE)
7 * main.c: Initialization, main loop
14 #include <sys/types.h>
15 #include <sys/socket.h>
18 #include <sys/resource.h>
24 #include "sd-daemon.h"
26 /* The original value of RLIMIT_CORE when i3 was started. We need to restore
27 * this before starting any other process, since we set RLIMIT_CORE to
28 * RLIM_INFINITY for i3 debugging versions. */
29 struct rlimit original_rlimit_core;
31 /** The number of file descriptors passed via socket activation. */
34 /* We keep the xcb_check watcher around to be able to enable and disable it
35 * temporarily for drag_pointer(). */
36 static struct ev_check *xcb_check;
42 xcb_connection_t *conn;
43 /* The screen (0 when you are using DISPLAY=:0) of the connection 'conn' */
46 /* Display handle for libstartup-notification */
49 /* The last timestamp we got from X11 (timestamps are included in some events
50 * and are used for some things, like determining a unique ID in startup
52 xcb_timestamp_t last_timestamp = XCB_CURRENT_TIME;
54 xcb_screen_t *root_screen;
57 /* Color depth, visual id and colormap to use when creating windows and
58 * pixmaps. Will use 32 bit depth and an appropriate visual, if available,
59 * otherwise the root window’s default (usually 24 bit TrueColor). */
61 xcb_visualtype_t *visual_type;
62 xcb_colormap_t colormap;
64 struct ev_loop *main_loop;
66 xcb_key_symbols_t *keysyms;
68 /* Default shmlog size if not set by user. */
69 const int default_shmlog_size = 25 * 1024 * 1024;
71 /* The list of key bindings */
72 struct bindings_head *bindings;
74 /* The list of exec-lines */
75 struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts);
77 /* The list of exec_always lines */
78 struct autostarts_always_head autostarts_always = TAILQ_HEAD_INITIALIZER(autostarts_always);
80 /* The list of assignments */
81 struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments);
83 /* The list of workspace assignments (which workspace should end up on which
85 struct ws_assignments_head ws_assignments = TAILQ_HEAD_INITIALIZER(ws_assignments);
87 /* We hope that those are supported and set them to true */
88 bool xcursor_supported = true;
89 bool xkb_supported = true;
92 * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
93 * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
96 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
97 /* empty, because xcb_prepare_cb and xcb_check_cb are used */
101 * Flush before blocking (and waiting for new events)
104 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
109 * Instead of polling the X connection socket we leave this to
110 * xcb_poll_for_event() which knows better than we can ever know.
113 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
114 xcb_generic_event_t *event;
116 while ((event = xcb_poll_for_event(conn)) != NULL) {
117 if (event->response_type == 0) {
118 if (event_is_ignored(event->sequence, 0))
119 DLOG("Expected X11 Error received for sequence %x\n", event->sequence);
121 xcb_generic_error_t *error = (xcb_generic_error_t *)event;
122 DLOG("X11 Error received (probably harmless)! sequence 0x%x, error_code = %d\n",
123 error->sequence, error->error_code);
129 /* Strip off the highest bit (set if the event is generated) */
130 int type = (event->response_type & 0x7F);
132 handle_event(type, event);
139 * Enable or disable the main X11 event handling function.
140 * This is used by drag_pointer() which has its own, modal event handler, which
141 * takes precedence over the normal event handler.
144 void main_set_x11_cb(bool enable) {
145 DLOG("Setting main X11 callback to enabled=%d\n", enable);
147 ev_check_start(main_loop, xcb_check);
148 /* Trigger the watcher explicitly to handle all remaining X11 events.
149 * drag_pointer()’s event handler exits in the middle of the loop. */
150 ev_feed_event(main_loop, xcb_check, 0);
152 ev_check_stop(main_loop, xcb_check);
157 * Exit handler which destroys the main_loop. Will trigger cleanup handlers.
160 static void i3_exit(void) {
161 /* We need ev >= 4 for the following code. Since it is not *that* important (it
162 * only makes sure that there are no i3-nagbar instances left behind) we still
163 * support old systems with libev 3. */
164 #if EV_VERSION_MAJOR >= 4
165 ev_loop_destroy(main_loop);
168 if (*shmlogname != '\0') {
169 fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
171 shm_unlink(shmlogname);
176 * (One-shot) Handler for all signals with default action "Term", see signal(7)
178 * Unlinks the SHM log and re-raises the signal.
181 static void handle_signal(int sig, siginfo_t *info, void *data) {
182 if (*shmlogname != '\0') {
183 shm_unlink(shmlogname);
188 int main(int argc, char *argv[]) {
189 /* Keep a symbol pointing to the I3_VERSION string constant so that we have
190 * it in gdb backtraces. */
191 static const char *_i3_version __attribute__((used)) = I3_VERSION;
192 char *override_configpath = NULL;
193 bool autostart = true;
194 char *layout_path = NULL;
195 bool delete_layout_path = false;
196 bool force_xinerama = false;
197 bool disable_randr15 = false;
198 char *fake_outputs = NULL;
199 bool disable_signalhandler = false;
200 bool only_check_config = false;
201 static struct option long_options[] = {
202 {"no-autostart", no_argument, 0, 'a'},
203 {"config", required_argument, 0, 'c'},
204 {"version", no_argument, 0, 'v'},
205 {"moreversion", no_argument, 0, 'm'},
206 {"more-version", no_argument, 0, 'm'},
207 {"more_version", no_argument, 0, 'm'},
208 {"help", no_argument, 0, 'h'},
209 {"layout", required_argument, 0, 'L'},
210 {"restart", required_argument, 0, 0},
211 {"force-xinerama", no_argument, 0, 0},
212 {"force_xinerama", no_argument, 0, 0},
213 {"disable-randr15", no_argument, 0, 0},
214 {"disable_randr15", no_argument, 0, 0},
215 {"disable-signalhandler", no_argument, 0, 0},
216 {"shmlog-size", required_argument, 0, 0},
217 {"shmlog_size", required_argument, 0, 0},
218 {"get-socketpath", no_argument, 0, 0},
219 {"get_socketpath", no_argument, 0, 0},
220 {"fake_outputs", required_argument, 0, 0},
221 {"fake-outputs", required_argument, 0, 0},
222 {"force-old-config-parser-v4.4-only", no_argument, 0, 0},
224 int option_index = 0, opt;
226 setlocale(LC_ALL, "");
228 /* Get the RLIMIT_CORE limit at startup time to restore this before
229 * starting processes. */
230 getrlimit(RLIMIT_CORE, &original_rlimit_core);
232 /* Disable output buffering to make redirects in .xsession actually useful for debugging */
233 if (!isatty(fileno(stdout)))
234 setbuf(stdout, NULL);
238 /* Init logging *before* initializing debug_build to guarantee early
242 /* On release builds, disable SHM logging by default. */
243 shmlog_size = (is_debug_build() || strstr(argv[0], "i3-with-shmlog") != NULL ? default_shmlog_size : 0);
247 while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
250 LOG("Autostart disabled using -a\n");
255 layout_path = sstrdup(optarg);
256 delete_layout_path = false;
259 FREE(override_configpath);
260 override_configpath = sstrdup(optarg);
263 LOG("Checking configuration file only (-C)\n");
264 only_check_config = true;
267 printf("i3 version %s © 2009 Michael Stapelberg and contributors\n", i3_version);
271 printf("Binary i3 version: %s © 2009 Michael Stapelberg and contributors\n", i3_version);
272 display_running_version();
279 LOG("Enabling debug logging\n");
280 set_debug_logging(true);
283 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
286 if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
287 strcmp(long_options[option_index].name, "force_xinerama") == 0) {
288 force_xinerama = true;
289 ELOG("Using Xinerama instead of RandR. This option should be "
290 "avoided at all cost because it does not refresh the list "
291 "of screens, so you cannot configure displays at runtime. "
292 "Please check if your driver really does not support RandR "
293 "and disable this option as soon as you can.\n");
295 } else if (strcmp(long_options[option_index].name, "disable-randr15") == 0 ||
296 strcmp(long_options[option_index].name, "disable_randr15") == 0) {
297 disable_randr15 = true;
299 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
300 disable_signalhandler = true;
302 } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
303 strcmp(long_options[option_index].name, "get_socketpath") == 0) {
304 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
306 printf("%s\n", socket_path);
311 } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
312 strcmp(long_options[option_index].name, "shmlog_size") == 0) {
313 shmlog_size = atoi(optarg);
314 /* Re-initialize logging immediately to get as many
315 * logmessages as possible into the SHM log. */
317 LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
319 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
321 layout_path = sstrdup(optarg);
322 delete_layout_path = true;
324 } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
325 strcmp(long_options[option_index].name, "fake_outputs") == 0) {
326 LOG("Initializing fake outputs: %s\n", optarg);
327 fake_outputs = sstrdup(optarg);
329 } else if (strcmp(long_options[option_index].name, "force-old-config-parser-v4.4-only") == 0) {
330 ELOG("You are passing --force-old-config-parser-v4.4-only, but that flag was removed by now.\n");
335 fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
336 fprintf(stderr, "\n");
337 fprintf(stderr, "\t-a disable autostart ('exec' lines in config)\n");
338 fprintf(stderr, "\t-c <file> use the provided configfile instead\n");
339 fprintf(stderr, "\t-C validate configuration file and exit\n");
340 fprintf(stderr, "\t-d all enable debug output\n");
341 fprintf(stderr, "\t-L <file> path to the serialized layout during restarts\n");
342 fprintf(stderr, "\t-v display version and exit\n");
343 fprintf(stderr, "\t-V enable verbose mode\n");
344 fprintf(stderr, "\n");
345 fprintf(stderr, "\t--force-xinerama\n"
346 "\tUse Xinerama instead of RandR.\n"
347 "\tThis option should only be used if you are stuck with the\n"
348 "\told nVidia closed source driver (older than 302.17), which does\n"
349 "\tnot support RandR.\n");
350 fprintf(stderr, "\n");
351 fprintf(stderr, "\t--get-socketpath\n"
352 "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
353 fprintf(stderr, "\n");
354 fprintf(stderr, "\t--shmlog-size <limit>\n"
355 "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
356 "\tto 0 disables SHM logging entirely.\n"
357 "\tThe default is %d bytes.\n",
359 fprintf(stderr, "\n");
360 fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
361 "to send to a currently running i3 (like i3-msg). This allows you to\n"
362 "use nice and logical commands, such as:\n"
365 "\ti3 floating toggle\n"
372 if (only_check_config) {
373 exit(parse_configuration(override_configpath, false) ? 0 : 1);
376 /* If the user passes more arguments, we act like i3-msg would: Just send
377 * the arguments as an IPC message to i3. This allows for nice semantic
378 * commands such as 'i3 border none'. */
380 /* We enable verbose mode so that the user knows what’s going on.
381 * This should make it easier to find mistakes when the user passes
382 * arguments by mistake. */
385 LOG("Additional arguments passed. Sending them as a command to i3.\n");
386 char *payload = NULL;
387 while (optind < argc) {
389 payload = sstrdup(argv[optind]);
392 sasprintf(&both, "%s %s", payload, argv[optind]);
398 DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
399 char *socket_path = root_atom_contents("I3_SOCKET_PATH", NULL, 0);
401 ELOG("Could not get i3 IPC socket path\n");
405 int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
407 err(EXIT_FAILURE, "Could not create socket");
409 struct sockaddr_un addr;
410 memset(&addr, 0, sizeof(struct sockaddr_un));
411 addr.sun_family = AF_LOCAL;
412 strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
414 if (connect(sockfd, (const struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
415 err(EXIT_FAILURE, "Could not connect to i3");
417 if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
418 (uint8_t *)payload) == -1)
419 err(EXIT_FAILURE, "IPC: write()");
422 uint32_t reply_length;
426 if ((ret = ipc_recv_message(sockfd, &reply_type, &reply_length, &reply)) != 0) {
428 err(EXIT_FAILURE, "IPC: read()");
431 if (reply_type != I3_IPC_MESSAGE_TYPE_COMMAND)
432 errx(EXIT_FAILURE, "IPC: received reply of type %d but expected %d (COMMAND)", reply_type, I3_IPC_MESSAGE_TYPE_COMMAND);
433 printf("%.*s\n", reply_length, reply);
438 /* Enable logging to handle the case when the user did not specify --shmlog-size */
441 /* Try to enable core dumps by default when running a debug build */
442 if (is_debug_build()) {
443 struct rlimit limit = {RLIM_INFINITY, RLIM_INFINITY};
444 setrlimit(RLIMIT_CORE, &limit);
446 /* The following code is helpful, but not required. We thus don’t pay
447 * much attention to error handling, non-linux or other edge cases. */
448 LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
449 size_t cwd_size = 1024;
450 char *cwd = smalloc(cwd_size);
452 while ((cwd_ret = getcwd(cwd, cwd_size)) == NULL && errno == ERANGE) {
453 cwd_size = cwd_size * 2;
454 cwd = srealloc(cwd, cwd_size);
457 LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
459 if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
460 memset(cwd, '\0', cwd_size);
461 if (read(patternfd, cwd, cwd_size) > 0)
462 /* a trailing newline is included in cwd */
463 LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
469 LOG("i3 %s starting\n", i3_version);
471 conn = xcb_connect(NULL, &conn_screen);
472 if (xcb_connection_has_error(conn))
473 errx(EXIT_FAILURE, "Cannot open display\n");
475 sndisplay = sn_xcb_display_new(conn, NULL, NULL);
477 /* Initialize the libev event loop. This needs to be done before loading
478 * the config file because the parser will install an ev_child watcher
479 * for the nagbar when config errors are found. */
480 main_loop = EV_DEFAULT;
481 if (main_loop == NULL)
482 die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
484 root_screen = xcb_aux_get_screen(conn, conn_screen);
485 root = root_screen->root;
487 /* Place requests for the atoms we need as soon as possible */
488 #define xmacro(atom) \
489 xcb_intern_atom_cookie_t atom##_cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
490 #include "atoms.xmacro"
493 root_depth = root_screen->root_depth;
494 colormap = root_screen->default_colormap;
495 visual_type = xcb_aux_find_visual_by_attrs(root_screen, -1, 32);
496 if (visual_type != NULL) {
497 root_depth = xcb_aux_get_depth_of_visual(root_screen, visual_type->visual_id);
498 colormap = xcb_generate_id(conn);
500 xcb_void_cookie_t cm_cookie = xcb_create_colormap_checked(conn,
501 XCB_COLORMAP_ALLOC_NONE,
504 visual_type->visual_id);
506 xcb_generic_error_t *error = xcb_request_check(conn, cm_cookie);
508 ELOG("Could not create colormap. Error code: %d\n", error->error_code);
512 visual_type = get_visualtype(root_screen);
517 DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_type->visual_id);
518 DLOG("root_screen->height_in_pixels = %d, root_screen->height_in_millimeters = %d\n",
519 root_screen->height_in_pixels, root_screen->height_in_millimeters);
520 DLOG("One logical pixel corresponds to %d physical pixels on this display.\n", logical_px(1));
522 xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
523 xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
525 /* Setup NetWM atoms */
526 #define xmacro(name) \
528 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name##_cookie, NULL); \
530 ELOG("Could not get atom " #name "\n"); \
533 A_##name = reply->atom; \
536 #include "atoms.xmacro"
539 load_configuration(conn, override_configpath, false);
541 if (config.ipc_socket_path == NULL) {
542 /* Fall back to a file name in /tmp/ based on the PID */
543 if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
544 config.ipc_socket_path = get_process_filename("ipc-socket");
546 config.ipc_socket_path = sstrdup(config.ipc_socket_path);
549 xcb_void_cookie_t cookie;
550 cookie = xcb_change_window_attributes_checked(conn, root, XCB_CW_EVENT_MASK, (uint32_t[]){ROOT_EVENT_MASK});
551 xcb_generic_error_t *error = xcb_request_check(conn, cookie);
553 ELOG("Another window manager seems to be running (X error %d)\n", error->error_code);
557 xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
558 if (greply == NULL) {
559 ELOG("Could not get geometry of the root window, exiting\n");
562 DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
564 xcursor_load_cursors();
566 /* Set a cursor for the root window (otherwise the root window will show no
567 cursor until the first client is launched). */
568 if (xcursor_supported)
569 xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
571 xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
573 const xcb_query_extension_reply_t *extreply;
574 extreply = xcb_get_extension_data(conn, &xcb_xkb_id);
575 xkb_supported = extreply->present;
576 if (!extreply->present) {
577 DLOG("xkb is not present on this server\n");
579 DLOG("initializing xcb-xkb\n");
580 xcb_xkb_use_extension(conn, XCB_XKB_MAJOR_VERSION, XCB_XKB_MINOR_VERSION);
581 xcb_xkb_select_events(conn,
582 XCB_XKB_ID_USE_CORE_KBD,
583 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
585 XCB_XKB_EVENT_TYPE_STATE_NOTIFY | XCB_XKB_EVENT_TYPE_MAP_NOTIFY | XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY,
590 /* Setting both, XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE and
591 * XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED, will lead to the
592 * X server sending us the full XKB state in KeyPress and KeyRelease:
593 * https://sources.debian.net/src/xorg-server/2:1.17.2-1.1/xkb/xkbEvents.c/?hl=927#L927
595 xcb_xkb_per_client_flags_reply_t *pcf_reply;
596 /* The last three parameters are unset because they are only relevant
597 * when using a feature called “automatic reset of boolean controls”:
598 * http://www.x.org/releases/X11R7.7/doc/kbproto/xkbproto.html#Automatic_Reset_of_Boolean_Controls
600 pcf_reply = xcb_xkb_per_client_flags_reply(
602 xcb_xkb_per_client_flags(
604 XCB_XKB_ID_USE_CORE_KBD,
605 XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE | XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED,
606 XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE | XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED,
607 0 /* uint32_t ctrlsToChange */,
608 0 /* uint32_t autoCtrls */,
609 0 /* uint32_t autoCtrlsValues */),
611 if (pcf_reply == NULL ||
612 !(pcf_reply->value & XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE)) {
613 ELOG("Could not set XCB_XKB_PER_CLIENT_FLAG_GRABS_USE_XKB_STATE\n");
615 if (pcf_reply == NULL ||
616 !(pcf_reply->value & XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED)) {
617 ELOG("Could not set XCB_XKB_PER_CLIENT_FLAG_LOOKUP_STATE_WHEN_GRABBED\n");
620 xkb_base = extreply->first_event;
625 property_handlers_init();
629 keysyms = xcb_key_symbols_alloc(conn);
631 xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
634 die("Could not load keymap\n");
639 bool needs_tree_init = true;
640 if (layout_path != NULL) {
641 LOG("Trying to restore the layout from \"%s\".\n", layout_path);
642 needs_tree_init = !tree_restore(layout_path, greply);
643 if (delete_layout_path) {
645 const char *dir = dirname(layout_path);
646 /* possibly fails with ENOTEMPTY if there are files (or
656 /* Setup fake outputs for testing */
657 if (fake_outputs == NULL && config.fake_outputs != NULL)
658 fake_outputs = config.fake_outputs;
660 if (fake_outputs != NULL) {
661 fake_outputs_init(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 */
670 DLOG("Checking for XRandR...\n");
671 randr_init(&randr_base, disable_randr15 || config.disable_randr15);
674 /* We need to force disabling outputs which have been loaded from the
675 * layout file but are no longer active. This can happen if the output has
676 * been disabled in the short time between writing the restart layout file
677 * and restarting i3. See #2326. */
678 if (layout_path != NULL && randr_base > -1) {
680 TAILQ_FOREACH(con, &(croot->nodes_head), nodes) {
682 TAILQ_FOREACH(output, &outputs, outputs) {
683 if (output->active || strcmp(con->name, output->name) != 0)
686 /* This will correctly correlate the output with its content
687 * container. We need to make the connection to properly
688 * disable the output. */
689 if (output->con == NULL) {
690 output_init_con(output);
691 output->changed = false;
694 output->to_be_disabled = true;
695 randr_disable_output(output);
701 scratchpad_fix_resolution();
703 xcb_query_pointer_reply_t *pointerreply;
704 Output *output = NULL;
705 if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
706 ELOG("Could not query pointer position, using first screen\n");
708 DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
709 output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
711 ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
712 pointerreply->root_x, pointerreply->root_y);
713 output = get_first_output();
716 con_focus(con_descend_focused(output_get_content(output->con)));
722 /* Create the UNIX domain socket for IPC */
723 int ipc_socket = ipc_create_socket(config.ipc_socket_path);
724 if (ipc_socket == -1) {
725 ELOG("Could not create the IPC socket, IPC disabled\n");
727 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
728 ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
729 ev_io_start(main_loop, ipc_io);
732 /* Also handle the UNIX domain sockets passed via socket activation. The
733 * parameter 1 means "remove the environment variables", we don’t want to
734 * pass these to child processes. */
735 listen_fds = sd_listen_fds(0);
737 ELOG("socket activation: Error in sd_listen_fds\n");
738 else if (listen_fds == 0)
739 DLOG("socket activation: no sockets passed\n");
742 for (int fd = SD_LISTEN_FDS_START;
743 fd < (SD_LISTEN_FDS_START + listen_fds);
745 DLOG("socket activation: also listening on fd %d\n", fd);
747 /* sd_listen_fds() enables FD_CLOEXEC by default.
748 * However, we need to keep the file descriptors open for in-place
749 * restarting, therefore we explicitly disable FD_CLOEXEC. */
750 if ((flags = fcntl(fd, F_GETFD)) < 0 ||
751 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
752 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
755 struct ev_io *ipc_io = scalloc(1, sizeof(struct ev_io));
756 ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
757 ev_io_start(main_loop, ipc_io);
761 /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
763 ewmh_update_workarea();
765 /* Set the ewmh desktop properties. */
766 ewmh_update_current_desktop();
767 ewmh_update_number_of_desktops();
768 ewmh_update_desktop_names();
769 ewmh_update_desktop_viewport();
771 struct ev_io *xcb_watcher = scalloc(1, sizeof(struct ev_io));
772 xcb_check = scalloc(1, sizeof(struct ev_check));
773 struct ev_prepare *xcb_prepare = scalloc(1, sizeof(struct ev_prepare));
775 ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
776 ev_io_start(main_loop, xcb_watcher);
778 ev_check_init(xcb_check, xcb_check_cb);
779 ev_check_start(main_loop, xcb_check);
781 ev_prepare_init(xcb_prepare, xcb_prepare_cb);
782 ev_prepare_start(main_loop, xcb_prepare);
786 /* What follows is a fugly consequence of X11 protocol race conditions like
787 * the following: In an i3 in-place restart, i3 will reparent all windows
788 * to the root window, then exec() itself. In the new process, it calls
789 * manage_existing_windows. However, in case any application sent a
790 * generated UnmapNotify message to the WM (as GIMP does), this message
791 * will be handled by i3 *after* managing the window, thus i3 thinks the
792 * window just closed itself. In reality, the message was sent in the time
793 * period where i3 wasn’t running yet.
795 * To prevent this, we grab the server (disables processing of any other
796 * connections), then discard all pending events (since we didn’t do
797 * anything, there cannot be any meaningful responses), then ungrab the
799 xcb_grab_server(conn);
802 xcb_generic_event_t *event;
803 while ((event = xcb_poll_for_event(conn)) != NULL) {
804 if (event->response_type == 0) {
809 /* Strip off the highest bit (set if the event is generated) */
810 int type = (event->response_type & 0x7F);
812 /* We still need to handle MapRequests which are sent in the
813 * timespan starting from when we register as a window manager and
814 * this piece of code which drops events. */
815 if (type == XCB_MAP_REQUEST)
816 handle_event(type, event);
820 manage_existing_windows(root);
822 xcb_ungrab_server(conn);
825 LOG("This is not an in-place restart, copying root window contents to a pixmap\n");
826 xcb_screen_t *root = xcb_aux_get_screen(conn, conn_screen);
827 uint16_t width = root->width_in_pixels;
828 uint16_t height = root->height_in_pixels;
829 xcb_pixmap_t pixmap = xcb_generate_id(conn);
830 xcb_gcontext_t gc = xcb_generate_id(conn);
832 xcb_create_pixmap(conn, root->root_depth, pixmap, root->root, width, height);
834 xcb_create_gc(conn, gc, root->root,
835 XCB_GC_FUNCTION | XCB_GC_PLANE_MASK | XCB_GC_FILL_STYLE | XCB_GC_SUBWINDOW_MODE,
836 (uint32_t[]){XCB_GX_COPY, ~0, XCB_FILL_STYLE_SOLID, XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS});
838 xcb_copy_area(conn, root->root, pixmap, gc, 0, 0, 0, 0, width, height);
839 xcb_change_window_attributes(conn, root->root, XCB_CW_BACK_PIXMAP, (uint32_t[]){pixmap});
841 xcb_free_gc(conn, gc);
842 xcb_free_pixmap(conn, pixmap);
845 #if defined(__OpenBSD__)
846 if (pledge("stdio rpath wpath cpath proc exec unix", NULL) == -1)
847 err(EXIT_FAILURE, "pledge");
850 struct sigaction action;
852 action.sa_sigaction = handle_signal;
853 action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
854 sigemptyset(&action.sa_mask);
856 if (!disable_signalhandler)
857 setup_signal_handler();
859 /* Catch all signals with default action "Core", see signal(7) */
860 if (sigaction(SIGQUIT, &action, NULL) == -1 ||
861 sigaction(SIGILL, &action, NULL) == -1 ||
862 sigaction(SIGABRT, &action, NULL) == -1 ||
863 sigaction(SIGFPE, &action, NULL) == -1 ||
864 sigaction(SIGSEGV, &action, NULL) == -1)
865 ELOG("Could not setup signal handler.\n");
868 /* Catch all signals with default action "Term", see signal(7) */
869 if (sigaction(SIGHUP, &action, NULL) == -1 ||
870 sigaction(SIGINT, &action, NULL) == -1 ||
871 sigaction(SIGALRM, &action, NULL) == -1 ||
872 sigaction(SIGUSR1, &action, NULL) == -1 ||
873 sigaction(SIGUSR2, &action, NULL) == -1)
874 ELOG("Could not setup signal handler.\n");
876 /* Ignore SIGPIPE to survive errors when an IPC client disconnects
877 * while we are sending them a message */
878 signal(SIGPIPE, SIG_IGN);
880 /* Autostarting exec-lines */
882 while (!TAILQ_EMPTY(&autostarts)) {
883 struct Autostart *exec = TAILQ_FIRST(&autostarts);
885 LOG("auto-starting %s\n", exec->command);
886 start_application(exec->command, exec->no_startup_id);
889 TAILQ_REMOVE(&autostarts, exec, autostarts);
894 /* Autostarting exec_always-lines */
895 while (!TAILQ_EMPTY(&autostarts_always)) {
896 struct Autostart *exec_always = TAILQ_FIRST(&autostarts_always);
898 LOG("auto-starting (always!) %s\n", exec_always->command);
899 start_application(exec_always->command, exec_always->no_startup_id);
901 FREE(exec_always->command);
902 TAILQ_REMOVE(&autostarts_always, exec_always, autostarts_always);
906 /* Start i3bar processes for all configured bars */
907 Barconfig *barconfig;
908 TAILQ_FOREACH(barconfig, &barconfigs, configs) {
909 char *command = NULL;
910 sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
911 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
912 barconfig->id, current_socketpath);
913 LOG("Starting bar process: %s\n", command);
914 start_application(command, true);
918 /* Make sure to destroy the event loop to invoke the cleeanup callbacks
919 * when calling exit() */
922 ev_loop(main_loop, 0);