awesome.c

   1 /*
   2  * awesome.c - awesome main functions
   3  *
   4  * Copyright © 2007-2008 Julien Danjou <julien@danjou.info>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  */
  21
  22 #include <getopt.h>
  23
  24 #include <locale.h>
  25 #include <stdio.h>
  26 #include <unistd.h>
  27 #include <signal.h>
  28
  29 #include <xcb/bigreq.h>
  30 #include <xcb/randr.h>
  31 #include <xcb/xcb_event.h>
  32 #include <xcb/xinerama.h>
  33 #include <xcb/xtest.h>
  34
  35 #include <X11/Xlib-xcb.h>
  36
  37 #include "awesome.h"
  38 #include "spawn.h"
  39 #include "objects/client.h"
  40 #include "xwindow.h"
  41 #include "ewmh.h"
  42 #include "dbus.h"
  43 #include "systray.h"
  44 #include "event.h"
  45 #include "property.h"
  46 #include "screen.h"
  47 #include "luaa.h"
  48 #include "common/version.h"
  49 #include "common/atoms.h"
  50 #include "common/xcursor.h"
  51 #include "common/xutil.h"
  52 #include "common/backtrace.h"
  53
  54 awesome_t globalconf;
  55
  56 /** argv used to run awesome */
  57 static char *awesome_argv;
  58
  59 /** Call before exiting.
  60  */
  61 void
  62 awesome_atexit(bool restart)
  63 {
  64     lua_pushboolean(globalconf.L, restart);
  65     signal_object_emit(globalconf.L, &global_signals, "exit", 1);
  66
  67     a_dbus_cleanup();
  68
  69     systray_cleanup();
  70
  71     /* Close Lua */
  72     lua_close(globalconf.L);
  73
  74     xcb_flush(globalconf.connection);
  75
  76     /* Disconnect *after* closing lua */
  77     xcb_disconnect(globalconf.connection);
  78
  79     ev_default_destroy();
  80 }
  81
  82 /** Scan X to find windows to manage.
  83  */
  84 static void
  85 scan(xcb_query_tree_cookie_t tree_c)
  86 {
  87     int i, tree_c_len;
  88     xcb_query_tree_reply_t *tree_r;
  89     xcb_window_t *wins = NULL;
  90     xcb_get_window_attributes_reply_t *attr_r;
  91     xcb_get_geometry_reply_t *geom_r;
  92     long state;
  93
  94     tree_r = xcb_query_tree_reply(globalconf.connection,
  95                                   tree_c,
  96                                   NULL);
  97
  98     if(!tree_r)
  99         return;
 100
 101     /* Get the tree of the children windows of the current root window */
 102     if(!(wins = xcb_query_tree_children(tree_r)))
 103         fatal("cannot get tree children");
 104
 105     tree_c_len = xcb_query_tree_children_length(tree_r);
 106     xcb_get_window_attributes_cookie_t attr_wins[tree_c_len];
 107     xcb_get_property_cookie_t state_wins[tree_c_len];
 108
 109     for(i = 0; i < tree_c_len; i++)
 110     {
 111         attr_wins[i] = xcb_get_window_attributes_unchecked(globalconf.connection,
 112                                                            wins[i]);
 113
 114         state_wins[i] = xwindow_get_state_unchecked(wins[i]);
 115     }
 116
 117     xcb_get_geometry_cookie_t *geom_wins[tree_c_len];
 118
 119     for(i = 0; i < tree_c_len; i++)
 120     {
 121         attr_r = xcb_get_window_attributes_reply(globalconf.connection,
 122                                                  attr_wins[i],
 123                                                  NULL);
 124
 125         state = xwindow_get_state_reply(state_wins[i]);
 126
 127         if(!attr_r || attr_r->override_redirect
 128            || attr_r->map_state == XCB_MAP_STATE_UNMAPPED
 129            || state == XCB_ICCCM_WM_STATE_WITHDRAWN)
 130         {
 131             geom_wins[i] = NULL;
 132             p_delete(&attr_r);
 133             continue;
 134         }
 135
 136         p_delete(&attr_r);
 137
 138         /* Get the geometry of the current window */
 139         geom_wins[i] = p_alloca(xcb_get_geometry_cookie_t, 1);
 140         *(geom_wins[i]) = xcb_get_geometry_unchecked(globalconf.connection, wins[i]);
 141     }
 142
 143     for(i = 0; i < tree_c_len; i++)
 144     {
 145         if(!geom_wins[i] || !(geom_r = xcb_get_geometry_reply(globalconf.connection,
 146                                                               *(geom_wins[i]), NULL)))
 147             continue;
 148
 149         client_manage(wins[i], geom_r, true);
 150
 151         p_delete(&geom_r);
 152     }
 153
 154     p_delete(&tree_r);
 155 }
 156
 157 static void
 158 a_refresh_cb(EV_P_ ev_prepare *w, int revents)
 159 {
 160     awesome_refresh();
 161 }
 162
 163 static void
 164 a_xcb_check_cb(EV_P_ ev_check *w, int revents)
 165 {
 166     xcb_generic_event_t *mouse = NULL, *event;
 167
 168     while((event = xcb_poll_for_event(globalconf.connection)))
 169     {
 170         /* We will treat mouse events later.
 171          * We cannot afford to treat all mouse motion events,
 172          * because that would be too much CPU intensive, so we just
 173          * take the last we get after a bunch of events. */
 174         if(XCB_EVENT_RESPONSE_TYPE(event) == XCB_MOTION_NOTIFY)
 175         {
 176             p_delete(&mouse);
 177             mouse = event;
 178         }
 179         else
 180         {
 181             uint8_t type = XCB_EVENT_RESPONSE_TYPE(event);
 182             if((type == XCB_ENTER_NOTIFY || type == XCB_LEAVE_NOTIFY) && mouse)
 183             {
 184                 /* Make sure enter/motion/leave events are handled in the
 185                  * correct order */
 186                 event_handle(mouse);
 187                 p_delete(&mouse);
 188                 mouse = NULL;
 189             }
 190             event_handle(event);
 191             p_delete(&event);
 192         }
 193     }
 194
 195     if(mouse)
 196     {
 197         event_handle(mouse);
 198         p_delete(&mouse);
 199     }
 200 }
 201
 202 static void
 203 a_xcb_io_cb(EV_P_ ev_io *w, int revents)
 204 {
 205     /* a_xcb_check_cb() already handled all events */
 206
 207     if(xcb_connection_has_error(globalconf.connection))
 208         fatal("X server connection broke");
 209 }
 210
 211 static void
 212 signal_fatal(int signum)
 213 {
 214     buffer_t buf;
 215     backtrace_get(&buf);
 216     fatal("signal %d, dumping backtrace\n%s", signum, buf.s);
 217 }
 218
 219 /** Function to exit on some signals.
 220  * \param w the signal received, unused
 221  * \param revents currently unused
 222  */
 223 static void
 224 exit_on_signal(EV_P_ ev_signal *w, int revents)
 225 {
 226     ev_unloop(EV_A_ 1);
 227 }
 228
 229 void
 230 awesome_restart(void)
 231 {
 232     awesome_atexit(true);
 233     a_exec(awesome_argv);
 234 }
 235
 236 /** Function to restart awesome on some signals.
 237  * \param w the signal received, unused
 238  * \param revents Currently unused
 239  */
 240 static void
 241 restart_on_signal(EV_P_ ev_signal *w, int revents)
 242 {
 243     awesome_restart();
 244 }
 245
 246 /** Print help and exit(2) with given exit_code.
 247  * \param exit_code The exit code.
 248  */
 249 static void __attribute__ ((noreturn))
 250 exit_help(int exit_code)
 251 {
 252     FILE *outfile = (exit_code == EXIT_SUCCESS) ? stdout : stderr;
 253     fprintf(outfile,
 254 "Usage: awesome [OPTION]\n\
 255   -h, --help             show help\n\
 256   -v, --version          show version\n\
 257   -c, --config FILE      configuration file to use\n\
 258   -k, --check            check configuration file syntax\n");
 259     exit(exit_code);
 260 }
 261
 262 /** Hello, this is main.
 263  * \param argc Who knows.
 264  * \param argv Who knows.
 265  * \return EXIT_SUCCESS I hope.
 266  */
 267 int
 268 main(int argc, char **argv)
 269 {
 270     char *confpath = NULL;
 271     int xfd, i, opt;
 272     ssize_t cmdlen = 1;
 273     xdgHandle xdg;
 274     bool no_argb = false;
 275     xcb_generic_event_t *event;
 276     xcb_query_tree_cookie_t tree_c;
 277     static struct option long_options[] =
 278     {
 279         { "help",    0, NULL, 'h' },
 280         { "version", 0, NULL, 'v' },
 281         { "config",  1, NULL, 'c' },
 282         { "check",   0, NULL, 'k' },
 283         { "no-argb", 0, NULL, 'a' },
 284         { NULL,      0, NULL, 0 }
 285     };
 286
 287     /* event loop watchers */
 288     ev_io xio    = { .fd = -1 };
 289     ev_check xcheck;
 290     ev_prepare a_refresh;
 291     ev_signal sigint;
 292     ev_signal sigterm;
 293     ev_signal sighup;
 294
 295     /* clear the globalconf structure */
 296     p_clear(&globalconf, 1);
 297     globalconf.keygrabber = LUA_REFNIL;
 298     globalconf.mousegrabber = LUA_REFNIL;
 299     buffer_init(&globalconf.startup_errors);
 300
 301     /* save argv */
 302     for(i = 0; i < argc; i++)
 303         cmdlen += a_strlen(argv[i]) + 1;
 304
 305     awesome_argv = p_new(char, cmdlen);
 306     a_strcpy(awesome_argv, cmdlen, argv[0]);
 307
 308     for(i = 1; i < argc; i++)
 309     {
 310         a_strcat(awesome_argv, cmdlen, " ");
 311         a_strcat(awesome_argv, cmdlen, argv[i]);
 312     }
 313
 314     /* Text won't be printed correctly otherwise */
 315     setlocale(LC_CTYPE, "");
 316
 317     /* Get XDG basedir data */
 318     xdgInitHandle(&xdg);
 319
 320     /* init lua */
 321     luaA_init(&xdg);
 322
 323     /* check args */
 324     while((opt = getopt_long(argc, argv, "vhkc:a",
 325                              long_options, NULL)) != -1)
 326         switch(opt)
 327         {
 328           case 'v':
 329             eprint_version();
 330             break;
 331           case 'h':
 332             exit_help(EXIT_SUCCESS);
 333             break;
 334           case 'k':
 335             if(!luaA_parserc(&xdg, confpath, false))
 336             {
 337                 fprintf(stderr, "✘ Configuration file syntax error.\n");
 338                 return EXIT_FAILURE;
 339             }
 340             else
 341             {
 342                 fprintf(stderr, "✔ Configuration file syntax OK.\n");
 343                 return EXIT_SUCCESS;
 344             }
 345           case 'c':
 346             if(a_strlen(optarg))
 347                 confpath = a_strdup(optarg);
 348             else
 349                 fatal("-c option requires a file name");
 350             break;
 351           case 'a':
 352             no_argb = true;
 353             break;
 354         }
 355
 356     globalconf.loop = ev_default_loop(EVFLAG_NOSIGFD);
 357
 358     /* register function for signals */
 359     ev_signal_init(&sigint, exit_on_signal, SIGINT);
 360     ev_signal_init(&sigterm, exit_on_signal, SIGTERM);
 361     ev_signal_init(&sighup, restart_on_signal, SIGHUP);
 362     ev_signal_start(globalconf.loop, &sigint);
 363     ev_signal_start(globalconf.loop, &sigterm);
 364     ev_signal_start(globalconf.loop, &sighup);
 365     ev_unref(globalconf.loop);
 366     ev_unref(globalconf.loop);
 367     ev_unref(globalconf.loop);
 368
 369     struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 };
 370     sigemptyset(&sa.sa_mask);
 371     sigaction(SIGSEGV, &sa, 0);
 372
 373     /* X stuff */
 374     globalconf.display = XOpenDisplay(NULL);
 375     if (globalconf.display == NULL) {
 376         fatal("cannot open display");
 377     }
 378     globalconf.default_screen = XDefaultScreen(globalconf.display);
 379
 380     globalconf.connection = XGetXCBConnection(globalconf.display);
 381
 382     /* Double checking that connection is good and operatable with xcb */
 383     if(xcb_connection_has_error(globalconf.connection))
 384         fatal("cannot open display");
 385
 386     globalconf.screen = xcb_aux_get_screen(globalconf.connection, globalconf.default_screen);
 387     globalconf.default_visual = draw_default_visual(globalconf.screen);
 388     if(!no_argb)
 389         globalconf.visual = draw_argb_visual(globalconf.screen);
 390     if(!globalconf.visual)
 391         globalconf.visual = globalconf.default_visual;
 392     globalconf.default_depth = draw_visual_depth(globalconf.screen, globalconf.visual->visual_id);
 393     globalconf.default_cmap = globalconf.screen->default_colormap;
 394     if(globalconf.default_depth != globalconf.screen->root_depth)
 395     {
 396         // We need our own color map if we aren't using the default depth
 397         globalconf.default_cmap = xcb_generate_id(globalconf.connection);
 398         xcb_create_colormap(globalconf.connection, XCB_COLORMAP_ALLOC_NONE,
 399                 globalconf.default_cmap, globalconf.screen->root,
 400                 globalconf.visual->visual_id);
 401     }
 402
 403     /* Prefetch all the extensions we might need */
 404     xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id);
 405     xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id);
 406     xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id);
 407     xcb_prefetch_extension_data(globalconf.connection, &xcb_xinerama_id);
 408
 409     /* initialize dbus */
 410     a_dbus_init();
 411
 412     /* Get the file descriptor corresponding to the X connection */
 413     xfd = xcb_get_file_descriptor(globalconf.connection);
 414     ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ);
 415     ev_io_start(globalconf.loop, &xio);
 416     ev_check_init(&xcheck, &a_xcb_check_cb);
 417     ev_check_start(globalconf.loop, &xcheck);
 418     ev_unref(globalconf.loop);
 419     ev_prepare_init(&a_refresh, &a_refresh_cb);
 420     ev_prepare_start(globalconf.loop, &a_refresh);
 421     ev_unref(globalconf.loop);
 422
 423     /* Grab server */
 424     xcb_grab_server(globalconf.connection);
 425
 426     /* Make sure there are no pending events. Since we didn't really do anything
 427      * at all yet, we will just discard all events which we received so far.
 428      * The above GrabServer should make sure no new events are generated. */
 429     xcb_aux_sync(globalconf.connection);
 430     while ((event = xcb_poll_for_event(globalconf.connection)) != NULL)
 431     {
 432         /* Make sure errors are printed */
 433         uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event);
 434         if(response_type == 0)
 435             event_handle(event);
 436         p_delete(&event);
 437     }
 438
 439     {
 440         const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT;
 441
 442         /* This causes an error if some other window manager is running */
 443         xcb_change_window_attributes(globalconf.connection,
 444                                      globalconf.screen->root,
 445                                      XCB_CW_EVENT_MASK, &select_input_val);
 446     }
 447
 448     /* Need to xcb_flush to validate error handler */
 449     xcb_aux_sync(globalconf.connection);
 450
 451     /* Process all errors in the queue if any. There can be no events yet, so if
 452      * this function returns something, it must be an error. */
 453     if (xcb_poll_for_event(globalconf.connection) != NULL)
 454         fatal("another window manager is already running");
 455
 456     /* Prefetch the maximum request length */
 457     xcb_prefetch_maximum_request_length(globalconf.connection);
 458
 459     /* check for xtest extension */
 460     const xcb_query_extension_reply_t *xtest_query;
 461     xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id);
 462     globalconf.have_xtest = xtest_query->present;
 463
 464     /* Allocate the key symbols */
 465     globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection);
 466     xcb_get_modifier_mapping_cookie_t xmapping_cookie =
 467         xcb_get_modifier_mapping_unchecked(globalconf.connection);
 468
 469     /* init atom cache */
 470     atoms_init(globalconf.connection);
 471
 472     /* init screens information */
 473     screen_scan();
 474
 475     xutil_lock_mask_get(globalconf.connection, xmapping_cookie,
 476                         globalconf.keysyms, &globalconf.numlockmask,
 477                         &globalconf.shiftlockmask, &globalconf.capslockmask,
 478                         &globalconf.modeswitchmask);
 479
 480     /* do this only for real screen */
 481     ewmh_init();
 482     systray_init();
 483
 484     /* init spawn (sn) */
 485     spawn_init();
 486
 487     /* The default GC is just a newly created associated with a window with
 488      * depth globalconf.default_depth */
 489     xcb_window_t tmp_win = xcb_generate_id(globalconf.connection);
 490     globalconf.gc = xcb_generate_id(globalconf.connection);
 491     xcb_create_window(globalconf.connection, globalconf.default_depth,
 492                       tmp_win, globalconf.screen->root,
 493                       -1, -1, 1, 1, 0,
 494                       XCB_COPY_FROM_PARENT, globalconf.visual->visual_id,
 495                       XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP,
 496                       (const uint32_t [])
 497                       {
 498                           globalconf.screen->black_pixel,
 499                           globalconf.screen->black_pixel,
 500                           globalconf.default_cmap
 501                       });
 502     xcb_create_gc(globalconf.connection, globalconf.gc, tmp_win, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND,
 503                   (const uint32_t[]) { globalconf.screen->black_pixel, globalconf.screen->white_pixel });
 504     xcb_destroy_window(globalconf.connection, tmp_win);
 505
 506     /* Get the window tree associated to this screen */
 507     tree_c = xcb_query_tree_unchecked(globalconf.connection,
 508                                       globalconf.screen->root);
 509
 510     xcb_change_window_attributes(globalconf.connection,
 511                                  globalconf.screen->root,
 512                                  XCB_CW_EVENT_MASK,
 513                                  ROOT_WINDOW_EVENT_MASK);
 514
 515     /* we will receive events, stop grabbing server */
 516     xcb_ungrab_server(globalconf.connection);
 517
 518     /* Parse and run configuration file */
 519     if (!luaA_parserc(&xdg, confpath, true))
 520         fatal("couldn't find any rc file");
 521
 522     p_delete(&confpath);
 523
 524     xdgWipeHandle(&xdg);
 525
 526     /* scan existing windows */
 527     scan(tree_c);
 528
 529     xcb_flush(globalconf.connection);
 530
 531     /* main event loop */
 532     ev_loop(globalconf.loop, 0);
 533
 534     /* cleanup event loop */
 535     ev_ref(globalconf.loop);
 536     ev_check_stop(globalconf.loop, &xcheck);
 537     ev_ref(globalconf.loop);
 538     ev_prepare_stop(globalconf.loop, &a_refresh);
 539     ev_ref(globalconf.loop);
 540     ev_io_stop(globalconf.loop, &xio);
 541
 542     awesome_atexit(false);
 543
 544     return EXIT_SUCCESS;
 545 }
 546
 547 // vim: filetype=c:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80