git.sur5r.net Git - i3/i3/blob - src/main.c

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