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