2 #define I3__FILE__ "main.c"
4 * vim:ts=4:sw=4:expandtab
6 * i3 - an improved dynamic tiling window manager
7 * © 2009-2012 Michael Stapelberg and contributors (see also: LICENSE)
9 * main.c: Initialization, main loop
14 #include <sys/types.h>
15 #include <sys/socket.h>
18 #include <sys/resource.h>
23 #include "sd-daemon.h"
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;
30 /** The number of file descriptors passed via socket activation. */
33 static int xkb_event_base;
35 int xkb_current_group;
41 xcb_connection_t *conn;
42 /* The screen (0 when you are using DISPLAY=:0) of the connection 'conn' */
45 /* Display handle for libstartup-notification */
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
51 xcb_timestamp_t last_timestamp = XCB_CURRENT_TIME;
53 xcb_screen_t *root_screen;
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). */
60 xcb_visualid_t visual_id;
61 xcb_colormap_t colormap;
63 struct ev_loop *main_loop;
65 xcb_key_symbols_t *keysyms;
67 /* Those are our connections to X11 for use with libXcursor and XKB */
68 Display *xlibdpy, *xkbdpy;
70 /* The list of key bindings */
71 struct bindings_head *bindings;
73 /* The list of exec-lines */
74 struct autostarts_head autostarts = TAILQ_HEAD_INITIALIZER(autostarts);
76 /* The list of exec_always lines */
77 struct autostarts_always_head autostarts_always = TAILQ_HEAD_INITIALIZER(autostarts_always);
79 /* The list of assignments */
80 struct assignments_head assignments = TAILQ_HEAD_INITIALIZER(assignments);
82 /* The list of workspace assignments (which workspace should end up on which
84 struct ws_assignments_head ws_assignments = TAILQ_HEAD_INITIALIZER(ws_assignments);
86 /* We hope that those are supported and set them to true */
87 bool xcursor_supported = true;
88 bool xkb_supported = true;
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;
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
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 */
105 * Flush before blocking (and waiting for new events)
108 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
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.
117 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
118 xcb_generic_event_t *event;
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);
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);
133 /* Strip off the highest bit (set if the event is generated) */
134 int type = (event->response_type & 0x7F);
136 handle_event(type, event);
144 * When using xmodmap to change the keyboard mapping, this event
145 * is only sent via XKB. Therefore, we need this special handler.
148 static void xkb_got_event(EV_P_ struct ev_io *w, int revents) {
149 DLOG("Handling XKB event\n");
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)
163 if (ev.any.xkb_type == XkbMapNotify) {
164 mapping_changed = true;
168 if (ev.any.xkb_type != XkbStateNotify) {
169 ELOG("Unknown XKB event received (type %d)\n", ev.any.xkb_type);
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)
180 xkb_current_group = ev.state.group;
182 if (ev.state.group == XkbGroup2Index) {
183 DLOG("Mode_switch enabled\n");
184 grab_all_keys(conn, true);
187 if (ev.state.group == XkbGroup1Index) {
188 DLOG("Mode_switch disabled\n");
189 ungrab_all_keys(conn);
190 grab_all_keys(conn, false);
194 if (!mapping_changed)
197 DLOG("Keyboard mapping changed, updating keybindings\n");
198 xcb_key_symbols_free(keysyms);
199 keysyms = xcb_key_symbols_alloc(conn);
201 xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
203 ungrab_all_keys(conn);
204 DLOG("Re-grabbing...\n");
206 grab_all_keys(conn, (xkb_current_group == XkbGroup2Index));
211 * Exit handler which destroys the main_loop. Will trigger cleanup handlers.
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);
222 if (*shmlogname != '\0') {
223 fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
225 shm_unlink(shmlogname);
230 * (One-shot) Handler for all signals with default action "Term", see signal(7)
232 * Unlinks the SHM log and re-raises the signal.
235 static void handle_signal(int sig, siginfo_t *info, void *data) {
236 if (*shmlogname != '\0') {
237 shm_unlink(shmlogname);
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},
275 int option_index = 0, opt;
277 setlocale(LC_ALL, "");
279 /* Get the RLIMIT_CORE limit at startup time to restore this before
280 * starting processes. */
281 getrlimit(RLIMIT_CORE, &original_rlimit_core);
283 /* Disable output buffering to make redirects in .xsession actually useful for debugging */
284 if (!isatty(fileno(stdout)))
285 setbuf(stdout, NULL);
289 /* Init logging *before* initializing debug_build to guarantee early
293 /* On non-release builds, disable SHM logging by default. */
294 shmlog_size = (is_debug_build() ? 25 * 1024 * 1024 : 0);
298 while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
301 LOG("Autostart disabled using -a\n");
306 layout_path = sstrdup(optarg);
307 delete_layout_path = false;
310 FREE(override_configpath);
311 override_configpath = sstrdup(optarg);
314 LOG("Checking configuration file only (-C)\n");
315 only_check_config = true;
318 printf("i3 version " I3_VERSION " © 2009-2012 Michael Stapelberg and contributors\n");
322 printf("Binary i3 version: " I3_VERSION " © 2009-2012 Michael Stapelberg and contributors\n");
323 display_running_version();
330 LOG("Enabling debug logging\n");
331 set_debug_logging(true);
334 /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
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");
346 } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
347 disable_signalhandler = true;
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");
353 printf("%s\n", socket_path);
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. */
364 LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
366 } else if (strcmp(long_options[option_index].name, "restart") == 0) {
368 layout_path = sstrdup(optarg);
369 delete_layout_path = true;
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);
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");
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"
411 "\ti3 floating toggle\n"
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. */
427 LOG("Additional arguments passed. Sending them as a command to i3.\n");
428 char *payload = NULL;
429 while (optind < argc) {
431 payload = sstrdup(argv[optind]);
434 sasprintf(&both, "%s %s", payload, argv[optind]);
440 DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
441 char *socket_path = root_atom_contents("I3_SOCKET_PATH");
443 ELOG("Could not get i3 IPC socket path\n");
447 int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
449 err(EXIT_FAILURE, "Could not create socket");
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");
458 if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
459 (uint8_t*)payload) == -1)
460 err(EXIT_FAILURE, "IPC: write()");
462 uint32_t reply_length;
465 if ((ret = ipc_recv_message(sockfd, I3_IPC_MESSAGE_TYPE_COMMAND,
466 &reply_length, &reply)) != 0) {
468 err(EXIT_FAILURE, "IPC: read()");
471 printf("%.*s\n", reply_length, reply);
475 /* Enable logging to handle the case when the user did not specify --shmlog-size */
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);
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. */
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);
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);
499 LOG("i3 " I3_VERSION " starting\n");
501 conn = xcb_connect(NULL, &conn_screen);
502 if (xcb_connection_has_error(conn))
503 errx(EXIT_FAILURE, "Cannot open display\n");
505 sndisplay = sn_xcb_display_new(conn, NULL, NULL);
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");
514 root_screen = xcb_aux_get_screen(conn, conn_screen);
515 root = root_screen->root;
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;
525 DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
527 xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
528 xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
530 load_configuration(conn, override_configpath, false);
531 if (only_check_config) {
532 LOG("Done checking configuration file. Exiting.\n");
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");
541 config.ipc_socket_path = sstrdup(config.ipc_socket_path);
544 uint32_t mask = XCB_CW_EVENT_MASK;
545 uint32_t values[] = { XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
546 XCB_EVENT_MASK_BUTTON_PRESS |
547 XCB_EVENT_MASK_STRUCTURE_NOTIFY | /* when the user adds a screen (e.g. video
548 projector), the root window gets a
550 XCB_EVENT_MASK_POINTER_MOTION |
551 XCB_EVENT_MASK_PROPERTY_CHANGE |
552 XCB_EVENT_MASK_ENTER_WINDOW };
553 xcb_void_cookie_t cookie;
554 cookie = xcb_change_window_attributes_checked(conn, root, mask, values);
555 check_error(conn, cookie, "Another window manager seems to be running");
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 /* Place requests for the atoms we need as soon as possible */
565 #define xmacro(atom) \
566 xcb_intern_atom_cookie_t atom ## _cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
567 #include "atoms.xmacro"
570 /* Initialize the Xlib connection */
571 xlibdpy = xkbdpy = XOpenDisplay(NULL);
573 /* Try to load the X cursors and initialize the XKB extension */
574 if (xlibdpy == NULL) {
575 ELOG("ERROR: XOpenDisplay() failed, disabling libXcursor/XKB support\n");
576 xcursor_supported = false;
577 xkb_supported = false;
578 } else if (fcntl(ConnectionNumber(xlibdpy), F_SETFD, FD_CLOEXEC) == -1) {
579 ELOG("Could not set FD_CLOEXEC on xkbdpy\n");
582 xcursor_load_cursors();
586 /* Set a cursor for the root window (otherwise the root window will show no
587 cursor until the first client is launched). */
588 if (xcursor_supported)
589 xcursor_set_root_cursor(XCURSOR_CURSOR_POINTER);
590 else xcb_set_root_cursor(XCURSOR_CURSOR_POINTER);
594 major = XkbMajorVersion,
595 minor = XkbMinorVersion;
597 if (fcntl(ConnectionNumber(xkbdpy), F_SETFD, FD_CLOEXEC) == -1) {
598 fprintf(stderr, "Could not set FD_CLOEXEC on xkbdpy\n");
603 if (!XkbQueryExtension(xkbdpy,&i1,&xkb_event_base,&errBase,&major,&minor)) {
604 fprintf(stderr, "XKB not supported by X-server\n");
607 /* end of ugliness */
609 if (!XkbSelectEvents(xkbdpy, XkbUseCoreKbd,
610 XkbMapNotifyMask | XkbStateNotifyMask,
611 XkbMapNotifyMask | XkbStateNotifyMask)) {
612 fprintf(stderr, "Could not set XKB event mask\n");
617 /* Setup NetWM atoms */
618 #define xmacro(name) \
620 xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name ## _cookie, NULL); \
622 ELOG("Could not get atom " #name "\n"); \
625 A_ ## name = reply->atom; \
628 #include "atoms.xmacro"
631 property_handlers_init();
635 keysyms = xcb_key_symbols_alloc(conn);
637 xcb_numlock_mask = aio_get_mod_mask_for(XCB_NUM_LOCK, keysyms);
640 grab_all_keys(conn, false);
642 bool needs_tree_init = true;
644 LOG("Trying to restore the layout from %s...", layout_path);
645 needs_tree_init = !tree_restore(layout_path, greply);
646 if (delete_layout_path)
655 /* Setup fake outputs for testing */
656 if (fake_outputs == NULL && config.fake_outputs != NULL)
657 fake_outputs = config.fake_outputs;
659 if (fake_outputs != NULL) {
660 fake_outputs_init(fake_outputs);
662 config.fake_outputs = NULL;
663 } else if (force_xinerama || config.force_xinerama) {
664 /* Force Xinerama (for drivers which don't support RandR yet, esp. the
665 * nVidia binary graphics driver), when specified either in the config
666 * file or on command-line */
669 DLOG("Checking for XRandR...\n");
670 randr_init(&randr_base);
673 scratchpad_fix_resolution();
675 xcb_query_pointer_reply_t *pointerreply;
676 Output *output = NULL;
677 if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
678 ELOG("Could not query pointer position, using first screen\n");
680 DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
681 output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
683 ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
684 pointerreply->root_x, pointerreply->root_y);
685 output = get_first_output();
688 con_focus(con_descend_focused(output_get_content(output->con)));
693 /* Create the UNIX domain socket for IPC */
694 int ipc_socket = ipc_create_socket(config.ipc_socket_path);
695 if (ipc_socket == -1) {
696 ELOG("Could not create the IPC socket, IPC disabled\n");
698 free(config.ipc_socket_path);
699 struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
700 ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
701 ev_io_start(main_loop, ipc_io);
704 /* Also handle the UNIX domain sockets passed via socket activation. The
705 * parameter 1 means "remove the environment variables", we don’t want to
706 * pass these to child processes. */
707 listen_fds = sd_listen_fds(0);
709 ELOG("socket activation: Error in sd_listen_fds\n");
710 else if (listen_fds == 0)
711 DLOG("socket activation: no sockets passed\n");
714 for (int fd = SD_LISTEN_FDS_START;
715 fd < (SD_LISTEN_FDS_START + listen_fds);
717 DLOG("socket activation: also listening on fd %d\n", fd);
719 /* sd_listen_fds() enables FD_CLOEXEC by default.
720 * However, we need to keep the file descriptors open for in-place
721 * restarting, therefore we explicitly disable FD_CLOEXEC. */
722 if ((flags = fcntl(fd, F_GETFD)) < 0 ||
723 fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
724 ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
727 struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
728 ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
729 ev_io_start(main_loop, ipc_io);
733 /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
736 struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
737 struct ev_io *xkb = scalloc(sizeof(struct ev_io));
738 struct ev_check *xcb_check = scalloc(sizeof(struct ev_check));
739 struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
741 ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
742 ev_io_start(main_loop, xcb_watcher);
746 ev_io_init(xkb, xkb_got_event, ConnectionNumber(xkbdpy), EV_READ);
747 ev_io_start(main_loop, xkb);
749 /* Flush the buffer so that libev can properly get new events */
753 ev_check_init(xcb_check, xcb_check_cb);
754 ev_check_start(main_loop, xcb_check);
756 ev_prepare_init(xcb_prepare, xcb_prepare_cb);
757 ev_prepare_start(main_loop, xcb_prepare);
761 /* What follows is a fugly consequence of X11 protocol race conditions like
762 * the following: In an i3 in-place restart, i3 will reparent all windows
763 * to the root window, then exec() itself. In the new process, it calls
764 * manage_existing_windows. However, in case any application sent a
765 * generated UnmapNotify message to the WM (as GIMP does), this message
766 * will be handled by i3 *after* managing the window, thus i3 thinks the
767 * window just closed itself. In reality, the message was sent in the time
768 * period where i3 wasn’t running yet.
770 * To prevent this, we grab the server (disables processing of any other
771 * connections), then discard all pending events (since we didn’t do
772 * anything, there cannot be any meaningful responses), then ungrab the
774 xcb_grab_server(conn);
777 xcb_generic_event_t *event;
778 while ((event = xcb_poll_for_event(conn)) != NULL) {
779 if (event->response_type == 0) {
784 /* Strip off the highest bit (set if the event is generated) */
785 int type = (event->response_type & 0x7F);
787 /* We still need to handle MapRequests which are sent in the
788 * timespan starting from when we register as a window manager and
789 * this piece of code which drops events. */
790 if (type == XCB_MAP_REQUEST)
791 handle_event(type, event);
795 manage_existing_windows(root);
797 xcb_ungrab_server(conn);
799 struct sigaction action;
801 action.sa_sigaction = handle_signal;
802 action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
803 sigemptyset(&action.sa_mask);
805 if (!disable_signalhandler)
806 setup_signal_handler();
808 /* Catch all signals with default action "Core", see signal(7) */
809 if (sigaction(SIGQUIT, &action, NULL) == -1 ||
810 sigaction(SIGILL, &action, NULL) == -1 ||
811 sigaction(SIGABRT, &action, NULL) == -1 ||
812 sigaction(SIGFPE, &action, NULL) == -1 ||
813 sigaction(SIGSEGV, &action, NULL) == -1)
814 ELOG("Could not setup signal handler");
817 /* Catch all signals with default action "Term", see signal(7) */
818 if (sigaction(SIGHUP, &action, NULL) == -1 ||
819 sigaction(SIGINT, &action, NULL) == -1 ||
820 sigaction(SIGALRM, &action, NULL) == -1 ||
821 sigaction(SIGUSR1, &action, NULL) == -1 ||
822 sigaction(SIGUSR2, &action, NULL) == -1)
823 ELOG("Could not setup signal handler");
825 /* Ignore SIGPIPE to survive errors when an IPC client disconnects
826 * while we are sending him a message */
827 signal(SIGPIPE, SIG_IGN);
829 /* Autostarting exec-lines */
831 struct Autostart *exec;
832 TAILQ_FOREACH(exec, &autostarts, autostarts) {
833 LOG("auto-starting %s\n", exec->command);
834 start_application(exec->command, exec->no_startup_id);
838 /* Autostarting exec_always-lines */
839 struct Autostart *exec_always;
840 TAILQ_FOREACH(exec_always, &autostarts_always, autostarts_always) {
841 LOG("auto-starting (always!) %s\n", exec_always->command);
842 start_application(exec_always->command, exec_always->no_startup_id);
845 /* Start i3bar processes for all configured bars */
846 Barconfig *barconfig;
847 TAILQ_FOREACH(barconfig, &barconfigs, configs) {
848 char *command = NULL;
849 sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
850 barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
851 barconfig->id, current_socketpath);
852 LOG("Starting bar process: %s\n", command);
853 start_application(command, true);
857 /* Make sure to destroy the event loop to invoke the cleeanup callbacks
858 * when calling exit() */
861 ev_loop(main_loop, 0);