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-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 
32 
33 static int xkb_event_base;
34 
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' */
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 */
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) */
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");
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 
202 
204  DLOG("Re-grabbing...\n");
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  fprintf(stderr, "Received signal %d, terminating\n", sig);
237  if (*shmlogname != '\0') {
238  fprintf(stderr, "Closing SHM log \"%s\"\n", shmlogname);
239  shm_unlink(shmlogname);
240  }
241  fflush(stderr);
242  raise(sig);
243 }
244 
245 int main(int argc, char *argv[]) {
246  /* Keep a symbol pointing to the I3_VERSION string constant so that we have
247  * it in gdb backtraces. */
248  const char *i3_version __attribute__ ((unused)) = I3_VERSION;
249  char *override_configpath = NULL;
250  bool autostart = true;
251  char *layout_path = NULL;
252  bool delete_layout_path = false;
253  bool force_xinerama = false;
254  char *fake_outputs = NULL;
255  bool disable_signalhandler = false;
256  static struct option long_options[] = {
257  {"no-autostart", no_argument, 0, 'a'},
258  {"config", required_argument, 0, 'c'},
259  {"version", no_argument, 0, 'v'},
260  {"moreversion", no_argument, 0, 'm'},
261  {"more-version", no_argument, 0, 'm'},
262  {"more_version", no_argument, 0, 'm'},
263  {"help", no_argument, 0, 'h'},
264  {"layout", required_argument, 0, 'L'},
265  {"restart", required_argument, 0, 0},
266  {"force-xinerama", no_argument, 0, 0},
267  {"force_xinerama", no_argument, 0, 0},
268  {"disable-signalhandler", no_argument, 0, 0},
269  {"shmlog-size", required_argument, 0, 0},
270  {"shmlog_size", required_argument, 0, 0},
271  {"get-socketpath", no_argument, 0, 0},
272  {"get_socketpath", no_argument, 0, 0},
273  {"fake_outputs", required_argument, 0, 0},
274  {"fake-outputs", required_argument, 0, 0},
275  {0, 0, 0, 0}
276  };
277  int option_index = 0, opt;
278 
279  setlocale(LC_ALL, "");
280 
281  /* Get the RLIMIT_CORE limit at startup time to restore this before
282  * starting processes. */
283  getrlimit(RLIMIT_CORE, &original_rlimit_core);
284 
285  /* Disable output buffering to make redirects in .xsession actually useful for debugging */
286  if (!isatty(fileno(stdout)))
287  setbuf(stdout, NULL);
288 
289  srand(time(NULL));
290 
291  /* Init logging *before* initializing debug_build to guarantee early
292  * (file) logging. */
293  init_logging();
294 
295  /* On non-release builds, disable SHM logging by default. */
296  shmlog_size = (is_debug_build() ? 25 * 1024 * 1024 : 0);
297 
298  start_argv = argv;
299 
300  while ((opt = getopt_long(argc, argv, "c:CvmaL:hld:V", long_options, &option_index)) != -1) {
301  switch (opt) {
302  case 'a':
303  LOG("Autostart disabled using -a\n");
304  autostart = false;
305  break;
306  case 'L':
307  FREE(layout_path);
308  layout_path = sstrdup(optarg);
309  delete_layout_path = false;
310  break;
311  case 'c':
312  FREE(override_configpath);
313  override_configpath = sstrdup(optarg);
314  break;
315  case 'C':
316  LOG("Checking configuration file only (-C)\n");
317  only_check_config = true;
318  break;
319  case 'v':
320  printf("i3 version " I3_VERSION " © 2009-2012 Michael Stapelberg and contributors\n");
321  exit(EXIT_SUCCESS);
322  break;
323  case 'm':
324  printf("Binary i3 version: " I3_VERSION " © 2009-2012 Michael Stapelberg and contributors\n");
326  exit(EXIT_SUCCESS);
327  break;
328  case 'V':
329  set_verbosity(true);
330  break;
331  case 'd':
332  LOG("Enabling debug logging\n");
333  set_debug_logging(true);
334  break;
335  case 'l':
336  /* DEPRECATED, ignored for the next 3 versions (3.e, 3.f, 3.g) */
337  break;
338  case 0:
339  if (strcmp(long_options[option_index].name, "force-xinerama") == 0 ||
340  strcmp(long_options[option_index].name, "force_xinerama") == 0) {
341  force_xinerama = true;
342  ELOG("Using Xinerama instead of RandR. This option should be "
343  "avoided at all cost because it does not refresh the list "
344  "of screens, so you cannot configure displays at runtime. "
345  "Please check if your driver really does not support RandR "
346  "and disable this option as soon as you can.\n");
347  break;
348  } else if (strcmp(long_options[option_index].name, "disable-signalhandler") == 0) {
349  disable_signalhandler = true;
350  break;
351  } else if (strcmp(long_options[option_index].name, "get-socketpath") == 0 ||
352  strcmp(long_options[option_index].name, "get_socketpath") == 0) {
353  char *socket_path = root_atom_contents("I3_SOCKET_PATH");
354  if (socket_path) {
355  printf("%s\n", socket_path);
356  exit(EXIT_SUCCESS);
357  }
358 
359  exit(EXIT_FAILURE);
360  } else if (strcmp(long_options[option_index].name, "shmlog-size") == 0 ||
361  strcmp(long_options[option_index].name, "shmlog_size") == 0) {
362  shmlog_size = atoi(optarg);
363  /* Re-initialize logging immediately to get as many
364  * logmessages as possible into the SHM log. */
365  init_logging();
366  LOG("Limiting SHM log size to %d bytes\n", shmlog_size);
367  break;
368  } else if (strcmp(long_options[option_index].name, "restart") == 0) {
369  FREE(layout_path);
370  layout_path = sstrdup(optarg);
371  delete_layout_path = true;
372  break;
373  } else if (strcmp(long_options[option_index].name, "fake-outputs") == 0 ||
374  strcmp(long_options[option_index].name, "fake_outputs") == 0) {
375  LOG("Initializing fake outputs: %s\n", optarg);
376  fake_outputs = sstrdup(optarg);
377  break;
378  }
379  /* fall-through */
380  default:
381  fprintf(stderr, "Usage: %s [-c configfile] [-d all] [-a] [-v] [-V] [-C]\n", argv[0]);
382  fprintf(stderr, "\n");
383  fprintf(stderr, "\t-a disable autostart ('exec' lines in config)\n");
384  fprintf(stderr, "\t-c <file> use the provided configfile instead\n");
385  fprintf(stderr, "\t-C validate configuration file and exit\n");
386  fprintf(stderr, "\t-d all enable debug output\n");
387  fprintf(stderr, "\t-L <file> path to the serialized layout during restarts\n");
388  fprintf(stderr, "\t-v display version and exit\n");
389  fprintf(stderr, "\t-V enable verbose mode\n");
390  fprintf(stderr, "\n");
391  fprintf(stderr, "\t--force-xinerama\n"
392  "\tUse Xinerama instead of RandR.\n"
393  "\tThis option should only be used if you are stuck with the\n"
394  "\told nVidia closed source driver (older than 302.17), which does\n"
395  "\tnot support RandR.\n");
396  fprintf(stderr, "\n");
397  fprintf(stderr, "\t--get-socketpath\n"
398  "\tRetrieve the i3 IPC socket path from X11, print it, then exit.\n");
399  fprintf(stderr, "\n");
400  fprintf(stderr, "\t--shmlog-size <limit>\n"
401  "\tLimits the size of the i3 SHM log to <limit> bytes. Setting this\n"
402  "\tto 0 disables SHM logging entirely.\n"
403  "\tThe default is %d bytes.\n", shmlog_size);
404  fprintf(stderr, "\n");
405  fprintf(stderr, "If you pass plain text arguments, i3 will interpret them as a command\n"
406  "to send to a currently running i3 (like i3-msg). This allows you to\n"
407  "use nice and logical commands, such as:\n"
408  "\n"
409  "\ti3 border none\n"
410  "\ti3 floating toggle\n"
411  "\ti3 kill window\n"
412  "\n");
413  exit(EXIT_FAILURE);
414  }
415  }
416 
417  /* If the user passes more arguments, we act like i3-msg would: Just send
418  * the arguments as an IPC message to i3. This allows for nice semantic
419  * commands such as 'i3 border none'. */
420  if (!only_check_config && optind < argc) {
421  /* We enable verbose mode so that the user knows what’s going on.
422  * This should make it easier to find mistakes when the user passes
423  * arguments by mistake. */
424  set_verbosity(true);
425 
426  LOG("Additional arguments passed. Sending them as a command to i3.\n");
427  char *payload = NULL;
428  while (optind < argc) {
429  if (!payload) {
430  payload = sstrdup(argv[optind]);
431  } else {
432  char *both;
433  sasprintf(&both, "%s %s", payload, argv[optind]);
434  free(payload);
435  payload = both;
436  }
437  optind++;
438  }
439  DLOG("Command is: %s (%zd bytes)\n", payload, strlen(payload));
440  char *socket_path = root_atom_contents("I3_SOCKET_PATH");
441  if (!socket_path) {
442  ELOG("Could not get i3 IPC socket path\n");
443  return 1;
444  }
445 
446  int sockfd = socket(AF_LOCAL, SOCK_STREAM, 0);
447  if (sockfd == -1)
448  err(EXIT_FAILURE, "Could not create socket");
449 
450  struct sockaddr_un addr;
451  memset(&addr, 0, sizeof(struct sockaddr_un));
452  addr.sun_family = AF_LOCAL;
453  strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);
454  if (connect(sockfd, (const struct sockaddr*)&addr, sizeof(struct sockaddr_un)) < 0)
455  err(EXIT_FAILURE, "Could not connect to i3");
456 
457  if (ipc_send_message(sockfd, strlen(payload), I3_IPC_MESSAGE_TYPE_COMMAND,
458  (uint8_t*)payload) == -1)
459  err(EXIT_FAILURE, "IPC: write()");
460 
461  uint32_t reply_length;
462  uint8_t *reply;
463  int ret;
464  if ((ret = ipc_recv_message(sockfd, I3_IPC_MESSAGE_TYPE_COMMAND,
465  &reply_length, &reply)) != 0) {
466  if (ret == -1)
467  err(EXIT_FAILURE, "IPC: read()");
468  return 1;
469  }
470  printf("%.*s\n", reply_length, reply);
471  return 0;
472  }
473 
474  /* Enable logging to handle the case when the user did not specify --shmlog-size */
475  init_logging();
476 
477  /* Try to enable core dumps by default when running a debug build */
478  if (is_debug_build()) {
479  struct rlimit limit = { RLIM_INFINITY, RLIM_INFINITY };
480  setrlimit(RLIMIT_CORE, &limit);
481 
482  /* The following code is helpful, but not required. We thus don’t pay
483  * much attention to error handling, non-linux or other edge cases. */
484  char cwd[PATH_MAX];
485  LOG("CORE DUMPS: You are running a development version of i3, so coredumps were automatically enabled (ulimit -c unlimited).\n");
486  if (getcwd(cwd, sizeof(cwd)) != NULL)
487  LOG("CORE DUMPS: Your current working directory is \"%s\".\n", cwd);
488  int patternfd;
489  if ((patternfd = open("/proc/sys/kernel/core_pattern", O_RDONLY)) >= 0) {
490  memset(cwd, '\0', sizeof(cwd));
491  if (read(patternfd, cwd, sizeof(cwd)) > 0)
492  /* a trailing newline is included in cwd */
493  LOG("CORE DUMPS: Your core_pattern is: %s", cwd);
494  close(patternfd);
495  }
496  }
497 
498  LOG("i3 " I3_VERSION " starting\n");
499 
500  conn = xcb_connect(NULL, &conn_screen);
501  if (xcb_connection_has_error(conn))
502  errx(EXIT_FAILURE, "Cannot open display\n");
503 
504  sndisplay = sn_xcb_display_new(conn, NULL, NULL);
505 
506  /* Initialize the libev event loop. This needs to be done before loading
507  * the config file because the parser will install an ev_child watcher
508  * for the nagbar when config errors are found. */
509  main_loop = EV_DEFAULT;
510  if (main_loop == NULL)
511  die("Could not initialize libev. Bad LIBEV_FLAGS?\n");
512 
513  root_screen = xcb_aux_get_screen(conn, conn_screen);
514  root = root_screen->root;
515 
516  /* By default, we use the same depth and visual as the root window, which
517  * usually is TrueColor (24 bit depth) and the corresponding visual.
518  * However, we also check if a 32 bit depth and visual are available (for
519  * transparency) and use it if so. */
520  root_depth = root_screen->root_depth;
521  visual_id = root_screen->root_visual;
522  colormap = root_screen->default_colormap;
523 
524  DLOG("root_depth = %d, visual_id = 0x%08x.\n", root_depth, visual_id);
525 
526  xcb_get_geometry_cookie_t gcookie = xcb_get_geometry(conn, root);
527  xcb_query_pointer_cookie_t pointercookie = xcb_query_pointer(conn, root);
528 
529  load_configuration(conn, override_configpath, false);
530  if (only_check_config) {
531  LOG("Done checking configuration file. Exiting.\n");
532  exit(0);
533  }
534 
535  if (config.ipc_socket_path == NULL) {
536  /* Fall back to a file name in /tmp/ based on the PID */
537  if ((config.ipc_socket_path = getenv("I3SOCK")) == NULL)
539  else
541  }
542 
543  uint32_t mask = XCB_CW_EVENT_MASK;
544  uint32_t values[] = { XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT |
545  XCB_EVENT_MASK_STRUCTURE_NOTIFY | /* when the user adds a screen (e.g. video
546  projector), the root window gets a
547  ConfigureNotify */
548  XCB_EVENT_MASK_POINTER_MOTION |
549  XCB_EVENT_MASK_PROPERTY_CHANGE |
550  XCB_EVENT_MASK_ENTER_WINDOW };
551  xcb_void_cookie_t cookie;
552  cookie = xcb_change_window_attributes_checked(conn, root, mask, values);
553  check_error(conn, cookie, "Another window manager seems to be running");
554 
555  xcb_get_geometry_reply_t *greply = xcb_get_geometry_reply(conn, gcookie, NULL);
556  if (greply == NULL) {
557  ELOG("Could not get geometry of the root window, exiting\n");
558  return 1;
559  }
560  DLOG("root geometry reply: (%d, %d) %d x %d\n", greply->x, greply->y, greply->width, greply->height);
561 
562  /* Place requests for the atoms we need as soon as possible */
563  #define xmacro(atom) \
564  xcb_intern_atom_cookie_t atom ## _cookie = xcb_intern_atom(conn, 0, strlen(#atom), #atom);
565  #include "atoms.xmacro"
566  #undef xmacro
567 
568  /* Initialize the Xlib connection */
569  xlibdpy = xkbdpy = XOpenDisplay(NULL);
570 
571  /* Try to load the X cursors and initialize the XKB extension */
572  if (xlibdpy == NULL) {
573  ELOG("ERROR: XOpenDisplay() failed, disabling libXcursor/XKB support\n");
574  xcursor_supported = false;
575  xkb_supported = false;
576  } else if (fcntl(ConnectionNumber(xlibdpy), F_SETFD, FD_CLOEXEC) == -1) {
577  ELOG("Could not set FD_CLOEXEC on xkbdpy\n");
578  return 1;
579  } else {
581  /*init_xkb();*/
582  }
583 
584  /* Set a cursor for the root window (otherwise the root window will show no
585  cursor until the first client is launched). */
586  if (xcursor_supported)
589 
590  if (xkb_supported) {
591  int errBase,
592  major = XkbMajorVersion,
593  minor = XkbMinorVersion;
594 
595  if (fcntl(ConnectionNumber(xkbdpy), F_SETFD, FD_CLOEXEC) == -1) {
596  fprintf(stderr, "Could not set FD_CLOEXEC on xkbdpy\n");
597  return 1;
598  }
599 
600  int i1;
601  if (!XkbQueryExtension(xkbdpy,&i1,&xkb_event_base,&errBase,&major,&minor)) {
602  fprintf(stderr, "XKB not supported by X-server\n");
603  return 1;
604  }
605  /* end of ugliness */
606 
607  if (!XkbSelectEvents(xkbdpy, XkbUseCoreKbd,
608  XkbMapNotifyMask | XkbStateNotifyMask,
609  XkbMapNotifyMask | XkbStateNotifyMask)) {
610  fprintf(stderr, "Could not set XKB event mask\n");
611  return 1;
612  }
613  }
614 
615  /* Setup NetWM atoms */
616  #define xmacro(name) \
617  do { \
618  xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply(conn, name ## _cookie, NULL); \
619  if (!reply) { \
620  ELOG("Could not get atom " #name "\n"); \
621  exit(-1); \
622  } \
623  A_ ## name = reply->atom; \
624  free(reply); \
625  } while (0);
626  #include "atoms.xmacro"
627  #undef xmacro
628 
630 
632 
633  keysyms = xcb_key_symbols_alloc(conn);
634 
636 
638  grab_all_keys(conn, false);
639 
640  bool needs_tree_init = true;
641  if (layout_path) {
642  LOG("Trying to restore the layout from %s...", layout_path);
643  needs_tree_init = !tree_restore(layout_path, greply);
644  if (delete_layout_path)
645  unlink(layout_path);
646  free(layout_path);
647  }
648  if (needs_tree_init)
649  tree_init(greply);
650 
651  free(greply);
652 
653  /* Setup fake outputs for testing */
654  if (fake_outputs == NULL && config.fake_outputs != NULL)
655  fake_outputs = config.fake_outputs;
656 
657  if (fake_outputs != NULL) {
658  fake_outputs_init(fake_outputs);
659  FREE(fake_outputs);
660  config.fake_outputs = NULL;
661  } else if (force_xinerama || config.force_xinerama) {
662  /* Force Xinerama (for drivers which don't support RandR yet, esp. the
663  * nVidia binary graphics driver), when specified either in the config
664  * file or on command-line */
665  xinerama_init();
666  } else {
667  DLOG("Checking for XRandR...\n");
669  }
670 
672 
673  xcb_query_pointer_reply_t *pointerreply;
674  Output *output = NULL;
675  if (!(pointerreply = xcb_query_pointer_reply(conn, pointercookie, NULL))) {
676  ELOG("Could not query pointer position, using first screen\n");
677  } else {
678  DLOG("Pointer at %d, %d\n", pointerreply->root_x, pointerreply->root_y);
679  output = get_output_containing(pointerreply->root_x, pointerreply->root_y);
680  if (!output) {
681  ELOG("ERROR: No screen at (%d, %d), starting on the first screen\n",
682  pointerreply->root_x, pointerreply->root_y);
683  output = get_first_output();
684  }
685 
687  }
688 
689  tree_render();
690 
691  /* Create the UNIX domain socket for IPC */
692  int ipc_socket = ipc_create_socket(config.ipc_socket_path);
693  if (ipc_socket == -1) {
694  ELOG("Could not create the IPC socket, IPC disabled\n");
695  } else {
696  free(config.ipc_socket_path);
697  struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
698  ev_io_init(ipc_io, ipc_new_client, ipc_socket, EV_READ);
699  ev_io_start(main_loop, ipc_io);
700  }
701 
702  /* Also handle the UNIX domain sockets passed via socket activation. The
703  * parameter 1 means "remove the environment variables", we don’t want to
704  * pass these to child processes. */
706  if (listen_fds < 0)
707  ELOG("socket activation: Error in sd_listen_fds\n");
708  else if (listen_fds == 0)
709  DLOG("socket activation: no sockets passed\n");
710  else {
711  int flags;
712  for (int fd = SD_LISTEN_FDS_START;
714  fd++) {
715  DLOG("socket activation: also listening on fd %d\n", fd);
716 
717  /* sd_listen_fds() enables FD_CLOEXEC by default.
718  * However, we need to keep the file descriptors open for in-place
719  * restarting, therefore we explicitly disable FD_CLOEXEC. */
720  if ((flags = fcntl(fd, F_GETFD)) < 0 ||
721  fcntl(fd, F_SETFD, flags & ~FD_CLOEXEC) < 0) {
722  ELOG("Could not disable FD_CLOEXEC on fd %d\n", fd);
723  }
724 
725  struct ev_io *ipc_io = scalloc(sizeof(struct ev_io));
726  ev_io_init(ipc_io, ipc_new_client, fd, EV_READ);
727  ev_io_start(main_loop, ipc_io);
728  }
729  }
730 
731  /* Set up i3 specific atoms like I3_SOCKET_PATH and I3_CONFIG_PATH */
732  x_set_i3_atoms();
733 
734  struct ev_io *xcb_watcher = scalloc(sizeof(struct ev_io));
735  struct ev_io *xkb = scalloc(sizeof(struct ev_io));
736  struct ev_check *xcb_check = scalloc(sizeof(struct ev_check));
737  struct ev_prepare *xcb_prepare = scalloc(sizeof(struct ev_prepare));
738 
739  ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
740  ev_io_start(main_loop, xcb_watcher);
741 
742 
743  if (xkb_supported) {
744  ev_io_init(xkb, xkb_got_event, ConnectionNumber(xkbdpy), EV_READ);
745  ev_io_start(main_loop, xkb);
746 
747  /* Flush the buffer so that libev can properly get new events */
748  XFlush(xkbdpy);
749  }
750 
751  ev_check_init(xcb_check, xcb_check_cb);
752  ev_check_start(main_loop, xcb_check);
753 
754  ev_prepare_init(xcb_prepare, xcb_prepare_cb);
755  ev_prepare_start(main_loop, xcb_prepare);
756 
757  xcb_flush(conn);
758 
759  /* What follows is a fugly consequence of X11 protocol race conditions like
760  * the following: In an i3 in-place restart, i3 will reparent all windows
761  * to the root window, then exec() itself. In the new process, it calls
762  * manage_existing_windows. However, in case any application sent a
763  * generated UnmapNotify message to the WM (as GIMP does), this message
764  * will be handled by i3 *after* managing the window, thus i3 thinks the
765  * window just closed itself. In reality, the message was sent in the time
766  * period where i3 wasn’t running yet.
767  *
768  * To prevent this, we grab the server (disables processing of any other
769  * connections), then discard all pending events (since we didn’t do
770  * anything, there cannot be any meaningful responses), then ungrab the
771  * server. */
772  xcb_grab_server(conn);
773  {
774  xcb_aux_sync(conn);
775  xcb_generic_event_t *event;
776  while ((event = xcb_poll_for_event(conn)) != NULL) {
777  free(event);
778  }
780  }
781  xcb_ungrab_server(conn);
782 
783  struct sigaction action;
784 
785  action.sa_sigaction = handle_signal;
786  action.sa_flags = SA_NODEFER | SA_RESETHAND | SA_SIGINFO;
787  sigemptyset(&action.sa_mask);
788 
789  if (!disable_signalhandler)
791  else {
792  /* Catch all signals with default action "Core", see signal(7) */
793  if (sigaction(SIGQUIT, &action, NULL) == -1 ||
794  sigaction(SIGILL, &action, NULL) == -1 ||
795  sigaction(SIGABRT, &action, NULL) == -1 ||
796  sigaction(SIGFPE, &action, NULL) == -1 ||
797  sigaction(SIGSEGV, &action, NULL) == -1)
798  ELOG("Could not setup signal handler");
799  }
800 
801  /* Catch all signals with default action "Term", see signal(7) */
802  if (sigaction(SIGHUP, &action, NULL) == -1 ||
803  sigaction(SIGINT, &action, NULL) == -1 ||
804  sigaction(SIGALRM, &action, NULL) == -1 ||
805  sigaction(SIGUSR1, &action, NULL) == -1 ||
806  sigaction(SIGUSR2, &action, NULL) == -1)
807  ELOG("Could not setup signal handler");
808 
809  /* Ignore SIGPIPE to survive errors when an IPC client disconnects
810  * while we are sending him a message */
811  signal(SIGPIPE, SIG_IGN);
812 
813  /* Autostarting exec-lines */
814  if (autostart) {
815  struct Autostart *exec;
817  LOG("auto-starting %s\n", exec->command);
819  }
820  }
821 
822  /* Autostarting exec_always-lines */
823  struct Autostart *exec_always;
825  LOG("auto-starting (always!) %s\n", exec_always->command);
826  start_application(exec_always->command, exec_always->no_startup_id);
827  }
828 
829  /* Start i3bar processes for all configured bars */
830  Barconfig *barconfig;
831  TAILQ_FOREACH(barconfig, &barconfigs, configs) {
832  char *command = NULL;
833  sasprintf(&command, "%s --bar_id=%s --socket=\"%s\"",
834  barconfig->i3bar_command ? barconfig->i3bar_command : "i3bar",
835  barconfig->id, current_socketpath);
836  LOG("Starting bar process: %s\n", command);
837  start_application(command, true);
838  free(command);
839  }
840 
841  /* Make sure to destroy the event loop to invoke the cleeanup callbacks
842  * when calling exit() */
843  atexit(i3_exit);
844 
845  ev_loop(main_loop, 0);
846 }