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