git.sur5r.net Git - i3/i3lock/blob - i3lock.c

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * © 2010-2011 Michael Stapelberg
   5  *
   6  * See LICENSE for licensing information
   7  *
   8  */
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13 #include <stdbool.h>
  14 #include <stdint.h>
  15 #include <xcb/xcb.h>
  16 #include <xcb/dpms.h>
  17 #include <xcb/xcb_keysyms.h>
  18 #include <err.h>
  19 #include <assert.h>
  20 #include <security/pam_appl.h>
  21 /* FIXME: can we get rid of this header? */
  22 #include <X11/keysym.h>
  23 #include <getopt.h>
  24 #include <string.h>
  25 #include <math.h>
  26 #include <ev.h>
  27
  28
  29 #ifndef NOLIBCAIRO
  30 #include <cairo.h>
  31 #include <cairo/cairo-xcb.h>
  32 #endif
  33
  34 #include "keysym2ucs.h"
  35 #include "ucs2_to_utf8.h"
  36 #include "xcb.h"
  37 #include "cursors.h"
  38
  39 #define BUTTON_RADIUS 90
  40 #define BUTTON_SPACE (BUTTON_RADIUS + 5)
  41 #define BUTTON_CENTER (BUTTON_RADIUS + 5)
  42 #define BUTTON_DIAMETER (5 * BUTTON_SPACE)
  43
  44 static char color[7] = "ffffff";
  45 static uint32_t last_resolution[2];
  46 static xcb_connection_t *conn;
  47 static xcb_window_t win;
  48 static xcb_visualtype_t *vistype;
  49 static xcb_cursor_t cursor;
  50 static xcb_key_symbols_t *symbols;
  51 static xcb_screen_t *scr;
  52 static pam_handle_t *pam_handle;
  53 static int input_position = 0;
  54 /* holds the password you enter (in UTF-8) */
  55 static char password[512];
  56 static bool modeswitch_active = false;
  57 static bool iso_level3_shift_active = false;
  58 static int modeswitchmask;
  59 static int numlockmask;
  60 static bool beep = false;
  61 static bool debug_mode = false;
  62 static bool dpms = false;
  63 static bool unlock_indicator = true;
  64 static struct ev_loop *main_loop;
  65 static struct ev_timer *clear_pam_wrong_timeout;
  66 static struct ev_timer *clear_indicator_timeout;
  67
  68 static enum {
  69     STATE_STARTED = 0,          /* default state */
  70     STATE_KEY_PRESSED = 1,      /* key was pressed, show unlock indicator */
  71     STATE_KEY_ACTIVE = 2,       /* a key was pressed recently, highlight part
  72                                    of the unlock indicator. */
  73     STATE_BACKSPACE_ACTIVE = 3  /* backspace was pressed recently, highlight
  74                                    part of the unlock indicator in red. */
  75 } unlock_state;
  76
  77 static enum {
  78     STATE_PAM_IDLE = 0,         /* no PAM interaction at the moment */
  79     STATE_PAM_VERIFY = 1,       /* currently verifying the password via PAM */
  80     STATE_PAM_WRONG = 2         /* the password was wrong */
  81 } pam_state;
  82
  83 #define DEBUG(fmt, ...) do { \
  84     if (debug_mode) \
  85         printf("[i3lock-debug] " fmt, ##__VA_ARGS__); \
  86 } while (0)
  87
  88 #ifndef NOLIBCAIRO
  89 static cairo_surface_t *img = NULL;
  90 static bool tile = false;
  91 #endif
  92
  93 /*
  94  * Draws global image with fill color onto a pixmap with the given
  95  * resolution and returns it.
  96  *
  97  */
  98 static xcb_pixmap_t draw_image(xcb_visualtype_t *vistype, u_int32_t* resolution) {
  99     xcb_pixmap_t bg_pixmap = XCB_NONE;
 100
 101 #ifndef NOLIBCAIRO
 102     bg_pixmap = create_bg_pixmap(conn, scr, resolution, color);
 103     /* Initialize cairo */
 104     cairo_surface_t *output;
 105     output = cairo_xcb_surface_create(conn, bg_pixmap, vistype,
 106              resolution[0], resolution[1]);
 107     cairo_t *ctx = cairo_create(output);
 108     if (img) {
 109         if (!tile) {
 110             cairo_set_source_surface(ctx, img, 0, 0);
 111             cairo_paint(ctx);
 112         } else {
 113             /* create a pattern and fill a rectangle as big as the screen */
 114             cairo_pattern_t *pattern;
 115             pattern = cairo_pattern_create_for_surface(img);
 116             cairo_set_source(ctx, pattern);
 117             cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT);
 118             cairo_rectangle(ctx, 0, 0, resolution[0], resolution[1]);
 119             cairo_fill(ctx);
 120             cairo_pattern_destroy(pattern);
 121         }
 122     }
 123
 124     if (unlock_state >= STATE_KEY_PRESSED && unlock_indicator) {
 125         cairo_pattern_t *outer_pat = NULL;
 126
 127         outer_pat = cairo_pattern_create_linear(0, 0, 0, BUTTON_DIAMETER);
 128         switch (pam_state) {
 129             case STATE_PAM_VERIFY:
 130                 cairo_pattern_add_color_stop_rgb(outer_pat, 0, 139.0/255, 0, 250.0/255);
 131                 cairo_pattern_add_color_stop_rgb(outer_pat, 1, 51.0/255, 0, 250.0/255);
 132                 break;
 133             case STATE_PAM_WRONG:
 134                 cairo_pattern_add_color_stop_rgb(outer_pat, 0, 255.0/250, 139.0/255, 0);
 135                 cairo_pattern_add_color_stop_rgb(outer_pat, 1, 125.0/255, 51.0/255, 0);
 136                 break;
 137             case STATE_PAM_IDLE:
 138                 cairo_pattern_add_color_stop_rgb(outer_pat, 0, 139.0/255, 125.0/255, 0);
 139                 cairo_pattern_add_color_stop_rgb(outer_pat, 1, 51.0/255, 125.0/255, 0);
 140                 break;
 141         }
 142
 143         /* Draw a (centered) circle with transparent background. */
 144         cairo_set_line_width(ctx, 10.0);
 145         cairo_arc(ctx,
 146                   (resolution[0] / 2) /* x */,
 147                   (resolution[1] / 2) /* y */,
 148                   BUTTON_RADIUS /* radius */,
 149                   0 /* start */,
 150                   2 * M_PI /* end */);
 151
 152         /* Use the appropriate color for the different PAM states
 153          * (currently verifying, wrong password, or default) */
 154         switch (pam_state) {
 155             case STATE_PAM_VERIFY:
 156                 cairo_set_source_rgba(ctx, 0, 114.0/255, 255.0/255, 0.75);
 157                 break;
 158             case STATE_PAM_WRONG:
 159                 cairo_set_source_rgba(ctx, 250.0/255, 0, 0, 0.75);
 160                 break;
 161             default:
 162                 cairo_set_source_rgba(ctx, 0, 0, 0, 0.75);
 163                 break;
 164         }
 165         cairo_fill_preserve(ctx);
 166         cairo_set_source(ctx, outer_pat);
 167         cairo_stroke(ctx);
 168
 169         /* Draw an inner seperator line. */
 170         cairo_set_source_rgb(ctx, 0, 0, 0);
 171         cairo_set_line_width(ctx, 2.0);
 172         cairo_arc(ctx,
 173                   (resolution[0] / 2) /* x */,
 174                   (resolution[1] / 2) /* y */,
 175                   BUTTON_RADIUS - 5 /* radius */,
 176                   0,
 177                   2 * M_PI);
 178         cairo_stroke(ctx);
 179
 180         cairo_set_line_width(ctx, 10.0);
 181
 182         /* Display a (centered) text of the current PAM state. */
 183         char *text = NULL;
 184         switch (pam_state) {
 185             case STATE_PAM_VERIFY:
 186                 text = "verifying…";
 187                 break;
 188             case STATE_PAM_WRONG:
 189                 text = "wrong!";
 190                 break;
 191             default:
 192                 break;
 193         }
 194
 195         if (text) {
 196             cairo_text_extents_t extents;
 197             double x, y;
 198
 199             cairo_set_source_rgb(ctx, 0, 0, 0);
 200             cairo_set_font_size(ctx, 28.0);
 201
 202             cairo_text_extents(ctx, text, &extents);
 203             x = (resolution[0] / 2.0) - ((extents.width / 2) + extents.x_bearing);
 204             y = (resolution[1] / 2.0) - ((extents.height / 2) + extents.y_bearing);
 205
 206             cairo_move_to(ctx, x, y);
 207             cairo_show_text(ctx, text);
 208             cairo_close_path(ctx);
 209         }
 210
 211         /* After the user pressed any valid key or the backspace key, we
 212          * highlight a random part of the unlock indicator to confirm this
 213          * keypress. */
 214         if (unlock_state == STATE_KEY_ACTIVE ||
 215             unlock_state == STATE_BACKSPACE_ACTIVE) {
 216             cairo_new_sub_path(ctx);
 217             double highlight_start = (rand() % (int)(2 * M_PI * 100)) / 100.0;
 218             DEBUG("Highlighting part %.2f\n", highlight_start);
 219             cairo_arc(ctx, resolution[0] / 2 /* x */, resolution[1] / 2 /* y */,
 220                       BUTTON_RADIUS /* radius */, highlight_start,
 221                       highlight_start + (M_PI / 3.0));
 222             if (unlock_state == STATE_KEY_ACTIVE) {
 223                 /* For normal keys, we use a lighter green. */
 224                 outer_pat = cairo_pattern_create_linear(0, 0, 0, BUTTON_DIAMETER);
 225                 cairo_pattern_add_color_stop_rgb(outer_pat, 0, 139.0/255, 219.0/255, 0);
 226                 cairo_pattern_add_color_stop_rgb(outer_pat, 1, 51.0/255, 219.0/255, 0);
 227             } else {
 228                 /* For backspace, we use red. */
 229                 outer_pat = cairo_pattern_create_linear(0, 0, 0, BUTTON_DIAMETER);
 230                 cairo_pattern_add_color_stop_rgb(outer_pat, 0, 219.0/255, 139.0/255, 0);
 231                 cairo_pattern_add_color_stop_rgb(outer_pat, 1, 219.0/255, 51.0/255, 0);
 232             }
 233             cairo_set_source(ctx, outer_pat);
 234             cairo_stroke(ctx);
 235
 236             /* Draw two little separators for the highlighted part of the
 237              * unlock indicator. */
 238             cairo_set_source_rgb(ctx, 0, 0, 0);
 239             cairo_arc(ctx,
 240                       (resolution[0] / 2) /* x */,
 241                       (resolution[1] / 2) /* y */,
 242                       BUTTON_RADIUS /* radius */,
 243                       highlight_start /* start */,
 244                       highlight_start + (M_PI / 128.0) /* end */);
 245             cairo_stroke(ctx);
 246             cairo_arc(ctx,
 247                       (resolution[0] / 2) /* x */,
 248                       (resolution[1] / 2) /* y */,
 249                       BUTTON_RADIUS /* radius */,
 250                       highlight_start + (M_PI / 3.0) /* start */,
 251                       (highlight_start + (M_PI / 3.0)) + (M_PI / 128.0) /* end */);
 252             cairo_stroke(ctx);
 253         }
 254     }
 255
 256     cairo_surface_destroy(output);
 257     cairo_destroy(ctx);
 258 #endif
 259     return bg_pixmap;
 260 }
 261
 262 /*
 263  * Calls draw_image on a new pixmap and swaps that with the current pixmap
 264  *
 265  */
 266 static void redraw_screen() {
 267     xcb_pixmap_t bg_pixmap = draw_image(vistype, last_resolution);
 268     xcb_change_window_attributes(conn, win, XCB_CW_BACK_PIXMAP, (uint32_t[1]){ bg_pixmap });
 269     /* XXX: Possible optimization: Only update the area in the middle of the
 270      * screen instead of the whole screen. */
 271     xcb_clear_area(conn, 0, win, 0, 0, scr->width_in_pixels, scr->height_in_pixels);
 272     xcb_free_pixmap(conn, bg_pixmap);
 273     xcb_flush(conn);
 274 }
 275
 276 /*
 277  * Resets pam_state to STATE_PAM_IDLE 2 seconds after an unsuccesful
 278  * authentication event.
 279  *
 280  */
 281 static void clear_pam_wrong(EV_P_ ev_timer *w, int revents) {
 282     pam_state = STATE_PAM_IDLE;
 283     unlock_state = STATE_STARTED;
 284     redraw_screen();
 285 }
 286
 287 /*
 288  * Hides the unlock indicator completely when there is no content in the
 289  * password buffer.
 290  *
 291  */
 292 static void clear_indicator(EV_P_ ev_timer *w, int revents) {
 293     DEBUG("Clear indicator\n");
 294     unlock_state = STATE_STARTED;
 295     redraw_screen();
 296 }
 297
 298 /*
 299  * (Re-)starts the clear_indicator timeout. Called after pressing backspace or
 300  * after an unsuccessful authentication attempt.
 301  *
 302  */
 303 static void start_clear_indicator_timeout() {
 304     if (clear_indicator_timeout) {
 305         ev_timer_stop(main_loop, clear_indicator_timeout);
 306         ev_timer_set(clear_indicator_timeout, 1.0, 0.);
 307         ev_timer_start(main_loop, clear_indicator_timeout);
 308     } else {
 309         clear_indicator_timeout = calloc(sizeof(struct ev_timer), 1);
 310         ev_timer_init(clear_indicator_timeout, clear_indicator, 1.0, 0.);
 311         ev_timer_start(main_loop, clear_indicator_timeout);
 312     }
 313 }
 314
 315 static void input_done() {
 316     if (input_position == 0)
 317         return;
 318
 319     if (clear_pam_wrong_timeout) {
 320         ev_timer_stop(main_loop, clear_pam_wrong_timeout);
 321         clear_pam_wrong_timeout = NULL;
 322     }
 323
 324     pam_state = STATE_PAM_VERIFY;
 325     redraw_screen();
 326
 327     if (pam_authenticate(pam_handle, 0) == PAM_SUCCESS) {
 328         printf("successfully authenticated\n");
 329         exit(0);
 330     }
 331
 332     fprintf(stderr, "Authentication failure\n");
 333
 334     pam_state = STATE_PAM_WRONG;
 335     redraw_screen();
 336
 337     /* Clear this state after 2 seconds (unless the user enters another
 338      * password during that time). */
 339     ev_now_update(main_loop);
 340     clear_pam_wrong_timeout = calloc(sizeof(struct ev_timer), 1);
 341     ev_timer_init(clear_pam_wrong_timeout, clear_pam_wrong, 2.0, 0.);
 342     ev_timer_start(main_loop, clear_pam_wrong_timeout);
 343
 344     /* beep on authentication failure, if enabled */
 345     if (beep) {
 346         xcb_bell(conn, 100);
 347         xcb_flush(conn);
 348     }
 349 }
 350
 351 /*
 352  * Called when the user releases a key. We need to leave the Mode_switch
 353  * state when the user releases the Mode_switch key.
 354  *
 355  */
 356 static void handle_key_release(xcb_key_release_event_t *event) {
 357     DEBUG("releasing key %d, state raw = %d, modeswitch_active = %d, iso_level3_shift_active = %d\n",
 358           event->detail, event->state, modeswitch_active, iso_level3_shift_active);
 359
 360     /* We don’t care about the column here and just use the first symbol. Since
 361      * we only check for Mode_switch and ISO_Level3_Shift, this *should* work.
 362      * Also, if we would use the current column, we would look in the wrong
 363      * place. */
 364     xcb_keysym_t sym = xcb_key_press_lookup_keysym(symbols, event, 0);
 365     if (sym == XK_Mode_switch) {
 366         //printf("Mode switch disabled\n");
 367         modeswitch_active = false;
 368     } else if (sym == XK_ISO_Level3_Shift) {
 369         iso_level3_shift_active = false;
 370     }
 371     DEBUG("release done. modeswitch_active = %d, iso_level3_shift_active = %d\n",
 372           modeswitch_active, iso_level3_shift_active);
 373 }
 374
 375 static void redraw_timeout(EV_P_ ev_timer *w, int revents) {
 376     redraw_screen();
 377 }
 378
 379 /*
 380  * Handle key presses. Fixes state, then looks up the key symbol for the
 381  * given keycode, then looks up the key symbol (as UCS-2), converts it to
 382  * UTF-8 and stores it in the password array.
 383  *
 384  */
 385 static void handle_key_press(xcb_key_press_event_t *event) {
 386     DEBUG("keypress %d, state raw = %d, modeswitch_active = %d, iso_level3_shift_active = %d\n",
 387           event->detail, event->state, modeswitch_active, iso_level3_shift_active);
 388
 389     xcb_keysym_t sym0, sym1, sym;
 390     /* For each keycode, there is a list of symbols. The list could look like this:
 391      * $ xmodmap -pke | grep 'keycode  38'
 392      * keycode  38 = a A adiaeresis Adiaeresis o O
 393      * In non-X11 terminology, the symbols for the keycode 38 (the key labeled
 394      * with "a" on my keyboard) are "a A ä Ä o O".
 395      * Another form to display the same information is using xkbcomp:
 396      * $ xkbcomp $DISPLAY /tmp/xkb.dump
 397      * Then open /tmp/xkb.dump and search for '\<a\>' (in VIM regexp-language):
 398      *
 399      * symbols[Group1]= [               a,               A,               o,               O ],
 400      * symbols[Group2]= [      adiaeresis,      Adiaeresis ]
 401      *
 402      * So there are two *groups*, one containing 'a A' and one containing 'ä
 403      * Ä'. You can use Mode_switch to switch between these groups. You can use
 404      * ISO_Level3_Shift to reach the 'o O' part of the first group (it’s the
 405      * same group, just an even higher shift level).
 406      *
 407      * So, using the "logical" XKB information, the following lookup will be
 408      * performed:
 409      *
 410      * Neither Mode_switch nor ISO_Level3_Shift active: group 1, column 0 and 1
 411      * Mode_switch active: group 2, column 0 and 1
 412      * ISO_Level3_Shift active: group 1, column 2 and 3
 413      *
 414      * Using the column index which xcb_key_press_lookup_keysym uses (and
 415      * xmodmap prints out), the following lookup will be performed:
 416      *
 417      * Neither Mode_switch nor ISO_Level3_Shift active: column 0 and 1
 418      * Mode_switch active: column 2 and 3
 419      * ISO_Level3_Shift active: column 4 and 5
 420      */
 421     int base_column = 0;
 422     if (modeswitch_active)
 423         base_column = 2;
 424     if (iso_level3_shift_active)
 425         base_column = 4;
 426     sym0 = xcb_key_press_lookup_keysym(symbols, event, base_column);
 427     sym1 = xcb_key_press_lookup_keysym(symbols, event, base_column + 1);
 428     switch (sym0) {
 429     case XK_Mode_switch:
 430         DEBUG("Mode switch enabled\n");
 431         modeswitch_active = true;
 432         return;
 433     case XK_ISO_Level3_Shift:
 434         DEBUG("ISO_Level3_Shift enabled\n");
 435         iso_level3_shift_active = true;
 436         return;
 437     case XK_Return:
 438     case XK_KP_Enter:
 439         input_done();
 440     case XK_Escape:
 441         input_position = 0;
 442         password[input_position] = '\0';
 443         return;
 444
 445     case XK_BackSpace:
 446         if (input_position == 0)
 447             return;
 448
 449         /* decrement input_position to point to the previous glyph */
 450         u8_dec(password, &input_position);
 451         password[input_position] = '\0';
 452
 453         /* Clear this state after 2 seconds (unless the user enters another
 454          * password during that time). */
 455         start_clear_indicator_timeout();
 456         unlock_state = STATE_BACKSPACE_ACTIVE;
 457         redraw_screen();
 458         unlock_state = STATE_KEY_PRESSED;
 459         //printf("new input position = %d, new password = %s\n", input_position, password);
 460         return;
 461     }
 462
 463     if ((input_position + 8) >= sizeof(password))
 464         return;
 465
 466     if ((event->state & numlockmask) && xcb_is_keypad_key(sym1)) {
 467         /* this key was a keypad key */
 468         if ((event->state & XCB_MOD_MASK_SHIFT))
 469             sym = sym0;
 470         else sym = sym1;
 471     } else {
 472         if ((event->state & XCB_MOD_MASK_SHIFT))
 473             sym = sym1;
 474         else sym = sym0;
 475     }
 476
 477 #if 0
 478     /* FIXME: handle all of these? */
 479     printf("is_keypad_key = %d\n", xcb_is_keypad_key(sym));
 480     printf("is_private_keypad_key = %d\n", xcb_is_private_keypad_key(sym));
 481     printf("xcb_is_cursor_key = %d\n", xcb_is_cursor_key(sym));
 482     printf("xcb_is_pf_key = %d\n", xcb_is_pf_key(sym));
 483     printf("xcb_is_function_key = %d\n", xcb_is_function_key(sym));
 484     printf("xcb_is_misc_function_key = %d\n", xcb_is_misc_function_key(sym));
 485     printf("xcb_is_modifier_key = %d\n", xcb_is_modifier_key(sym));
 486 #endif
 487
 488     if (xcb_is_modifier_key(sym) || xcb_is_cursor_key(sym))
 489         return;
 490
 491     DEBUG("resolved to keysym = %c (%d)\n", sym, sym);
 492
 493     /* convert the keysym to UCS */
 494     uint16_t ucs = keysym2ucs(sym);
 495     if ((int16_t)ucs == -1) {
 496         fprintf(stderr, "Keysym could not be converted to UCS, skipping\n");
 497         return;
 498     }
 499
 500     /* store the UCS in a string to convert it */
 501     uint8_t inp[3] = {(ucs & 0xFF00) >> 8, (ucs & 0xFF), 0};
 502     DEBUG("input part = %s\n", inp);
 503
 504     /* store it in the password array as UTF-8 */
 505     input_position += convert_ucs_to_utf8((char*)inp, password + input_position);
 506     password[input_position] = '\0';
 507     DEBUG("current password = %s\n", password);
 508
 509     unlock_state = STATE_KEY_ACTIVE;
 510     redraw_screen();
 511     unlock_state = STATE_KEY_PRESSED;
 512
 513     struct ev_timer *timeout = calloc(sizeof(struct ev_timer), 1);
 514     ev_timer_init(timeout, redraw_timeout, 0.25, 0.);
 515     ev_timer_start(main_loop, timeout);
 516
 517     if (clear_indicator_timeout) {
 518         ev_timer_stop(main_loop, clear_indicator_timeout);
 519         clear_indicator_timeout = NULL;
 520     }
 521 }
 522
 523 /*
 524  * A visibility notify event will be received when the visibility (= can the
 525  * user view the complete window) changes, so for example when a popup overlays
 526  * some area of the i3lock window.
 527  *
 528  * In this case, we raise our window on top so that the popup (or whatever is
 529  * hiding us) gets hidden.
 530  *
 531  */
 532 static void handle_visibility_notify(xcb_visibility_notify_event_t *event) {
 533     if (event->state != XCB_VISIBILITY_UNOBSCURED) {
 534         uint32_t values[] = { XCB_STACK_MODE_ABOVE };
 535         xcb_configure_window(conn, event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
 536         xcb_flush(conn);
 537     }
 538 }
 539
 540 /*
 541  * Called when the keyboard mapping changes. We update our symbols.
 542  *
 543  */
 544 static void handle_mapping_notify(xcb_mapping_notify_event_t *event) {
 545     xcb_refresh_keyboard_mapping(symbols, event);
 546
 547     modeswitchmask = get_mod_mask(conn, symbols, XK_Mode_switch);
 548     numlockmask = get_mod_mask(conn, symbols, XK_Num_Lock);
 549 }
 550
 551 /*
 552  * Called when the properties on the root window change, e.g. when the screen
 553  * resolution changes. If so we update the window to cover the whole screen
 554  * and also redraw the image, if any.
 555  *
 556  */
 557 void handle_screen_resize(xcb_visualtype_t *vistype, xcb_window_t win, uint32_t* last_resolution) {
 558     xcb_get_geometry_cookie_t geomc;
 559     xcb_get_geometry_reply_t *geom;
 560     geomc = xcb_get_geometry(conn, scr->root);
 561     if ((geom = xcb_get_geometry_reply(conn, geomc, 0)) == NULL) {
 562       return;
 563     }
 564
 565     if (last_resolution[0] == geom->width && last_resolution[1] == geom->height)
 566       return;
 567
 568     last_resolution[0] = geom->width;
 569     last_resolution[1] = geom->height;
 570
 571 #ifndef NOLIBCAIRO
 572     if (img) {
 573         xcb_pixmap_t bg_pixmap = draw_image(vistype, last_resolution);
 574         xcb_change_window_attributes(conn, win, XCB_CW_BACK_PIXMAP, (uint32_t[1]){ bg_pixmap });
 575         xcb_free_pixmap(conn, bg_pixmap);
 576     }
 577 #endif
 578
 579     uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
 580     xcb_configure_window(conn, win, mask, last_resolution);
 581     xcb_flush(conn);
 582 }
 583
 584 /*
 585  * Callback function for PAM. We only react on password request callbacks.
 586  *
 587  */
 588 static int conv_callback(int num_msg, const struct pam_message **msg,
 589                          struct pam_response **resp, void *appdata_ptr)
 590 {
 591     if (num_msg == 0)
 592         return 1;
 593
 594     /* PAM expects an array of responses, one for each message */
 595     if ((*resp = calloc(num_msg, sizeof(struct pam_message))) == NULL) {
 596         perror("calloc");
 597         return 1;
 598     }
 599
 600     for (int c = 0; c < num_msg; c++) {
 601         if (msg[c]->msg_style != PAM_PROMPT_ECHO_OFF &&
 602             msg[c]->msg_style != PAM_PROMPT_ECHO_ON)
 603             continue;
 604
 605         /* return code is currently not used but should be set to zero */
 606         resp[c]->resp_retcode = 0;
 607         if ((resp[c]->resp = strdup(password)) == NULL) {
 608             perror("strdup");
 609             return 1;
 610         }
 611     }
 612
 613     return 0;
 614 }
 615
 616 /*
 617  * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
 618  * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
 619  *
 620  */
 621 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
 622     /* empty, because xcb_prepare_cb and xcb_check_cb are used */
 623 }
 624
 625 /*
 626  * Flush before blocking (and waiting for new events)
 627  *
 628  */
 629 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
 630     xcb_flush(conn);
 631 }
 632
 633 /*
 634  * Instead of polling the X connection socket we leave this to
 635  * xcb_poll_for_event() which knows better than we can ever know.
 636  *
 637  */
 638 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
 639     xcb_generic_event_t *event;
 640
 641     while ((event = xcb_poll_for_event(conn)) != NULL) {
 642         if (event->response_type == 0) {
 643             xcb_generic_error_t *error = (xcb_generic_error_t*)event;
 644             fprintf(stderr, "X11 Error received! sequence 0x%x, error_code = %d\n",
 645                     error->sequence, error->error_code);
 646             free(event);
 647             continue;
 648         }
 649
 650         /* Strip off the highest bit (set if the event is generated) */
 651         int type = (event->response_type & 0x7F);
 652
 653         if (type == XCB_KEY_PRESS) {
 654             handle_key_press((xcb_key_press_event_t*)event);
 655             continue;
 656         }
 657
 658         if (type == XCB_KEY_RELEASE) {
 659             handle_key_release((xcb_key_release_event_t*)event);
 660
 661             /* If this was the backspace or escape key we are back at an
 662              * empty input, so turn off the screen if DPMS is enabled */
 663             if (dpms && input_position == 0)
 664                 dpms_turn_off_screen(conn);
 665
 666             continue;
 667         }
 668
 669         if (type == XCB_VISIBILITY_NOTIFY) {
 670             handle_visibility_notify((xcb_visibility_notify_event_t*)event);
 671             continue;
 672         }
 673
 674         if (type == XCB_MAPPING_NOTIFY) {
 675             handle_mapping_notify((xcb_mapping_notify_event_t*)event);
 676             continue;
 677         }
 678
 679         if (type == XCB_CONFIGURE_NOTIFY) {
 680             handle_screen_resize(vistype, win, last_resolution);
 681             continue;
 682         }
 683
 684         printf("WARNING: unhandled event of type %d\n", type);
 685
 686         free(event);
 687     }
 688 }
 689
 690 int main(int argc, char *argv[]) {
 691     bool dont_fork = false;
 692     char *username;
 693 #ifndef NOLIBCAIRO
 694     char *image_path = NULL;
 695 #endif
 696     int ret;
 697     struct pam_conv conv = {conv_callback, NULL};
 698     int screen;
 699     int curs_choice = CURS_NONE;
 700     char o;
 701     int optind = 0;
 702     struct option longopts[] = {
 703         {"version", no_argument, NULL, 'v'},
 704         {"nofork", no_argument, NULL, 'n'},
 705         {"beep", no_argument, NULL, 'b'},
 706         {"dpms", no_argument, NULL, 'd'},
 707         {"color", required_argument, NULL, 'c'},
 708         {"pointer", required_argument, NULL , 'p'},
 709         {"debug", no_argument, NULL, 0},
 710         {"help", no_argument, NULL, 'h'},
 711         {"no-unlock-indicator", no_argument, NULL, 'u'},
 712 #ifndef NOLIBCAIRO
 713         {"image", required_argument, NULL, 'i'},
 714         {"tiling", no_argument, NULL, 't'},
 715 #endif
 716         {NULL, no_argument, NULL, 0}
 717     };
 718
 719     if ((username = getenv("USER")) == NULL)
 720         errx(1, "USER environment variable not set, please set it.\n");
 721
 722     while ((o = getopt_long(argc, argv, "hvnbdc:p:u"
 723 #ifndef NOLIBCAIRO
 724         "i:t"
 725 #endif
 726         , longopts, &optind)) != -1) {
 727         switch (o) {
 728         case 'v':
 729             errx(EXIT_SUCCESS, "version " VERSION " © 2010-2011 Michael Stapelberg");
 730         case 'n':
 731             dont_fork = true;
 732             break;
 733         case 'b':
 734             beep = true;
 735             break;
 736         case 'd':
 737             dpms = true;
 738             break;
 739         case 'c': {
 740             char *arg = optarg;
 741
 742             /* Skip # if present */
 743             if (arg[0] == '#')
 744                 arg++;
 745
 746             if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1)
 747                 errx(1, "color is invalid, color must be given in 6-byte format: rrggbb\n");
 748
 749             break;
 750         }
 751         case 'u':
 752             unlock_indicator = false;
 753             break;
 754 #ifndef NOLIBCAIRO
 755         case 'i':
 756             image_path = strdup(optarg);
 757             break;
 758         case 't':
 759             tile = true;
 760             break;
 761 #endif
 762         case 'p':
 763             if (!strcmp(optarg, "win")) {
 764                 curs_choice = CURS_WIN;
 765             } else if (!strcmp(optarg, "default")) {
 766                 curs_choice = CURS_DEFAULT;
 767             } else {
 768                 errx(1, "i3lock: Invalid pointer type given. Expected one of \"win\" or \"default\".\n");
 769             }
 770             break;
 771         case 0:
 772             if (strcmp(longopts[optind].name, "debug") == 0)
 773                 debug_mode = true;
 774             break;
 775         default:
 776             errx(1, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default]"
 777 #ifndef NOLIBCAIRO
 778             " [-i image.png] [-t]"
 779 #else
 780             " (compiled with NOLIBCAIRO)"
 781 #endif
 782             );
 783         }
 784     }
 785
 786     /* We need (relatively) random numbers for highlighting a random part of
 787      * the unlock indicator upon keypresses. */
 788     srand(time(NULL));
 789
 790     /* Initialize PAM */
 791     ret = pam_start("i3lock", username, &conv, &pam_handle);
 792     if (ret != PAM_SUCCESS)
 793         errx(EXIT_FAILURE, "PAM: %s\n", pam_strerror(pam_handle, ret));
 794
 795     /* Initialize connection to X11 */
 796     if ((conn = xcb_connect(NULL, &screen)) == NULL ||
 797         xcb_connection_has_error(conn))
 798         errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
 799
 800     if (!dont_fork) {
 801         /* In the parent process, we exit */
 802         if (fork() != 0)
 803             return 0;
 804     }
 805
 806     /* if DPMS is enabled, check if the X server really supports it */
 807     if (dpms) {
 808         xcb_dpms_capable_cookie_t dpmsc = xcb_dpms_capable(conn);
 809         xcb_dpms_capable_reply_t *dpmsr;
 810         if ((dpmsr = xcb_dpms_capable_reply(conn, dpmsc, NULL)) && !dpmsr->capable) {
 811             fprintf(stderr, "Disabling DPMS, X server not DPMS capable\n");
 812             dpms = false;
 813         }
 814     }
 815
 816     scr = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
 817     vistype = get_root_visual_type(scr);
 818
 819     last_resolution[0] = scr->width_in_pixels;
 820     last_resolution[1] = scr->height_in_pixels;
 821
 822
 823 #ifndef NOLIBCAIRO
 824     if (image_path) {
 825         /* Create a pixmap to render on, fill it with the background color */
 826         img = cairo_image_surface_create_from_png(image_path);
 827     }
 828 #endif
 829
 830     /* Pixmap on which the image is rendered to (if any) */
 831     xcb_pixmap_t bg_pixmap = draw_image(vistype, last_resolution);
 832
 833     /* open the fullscreen window, already with the correct pixmap in place */
 834     win = open_fullscreen_window(conn, scr, color, bg_pixmap);
 835     xcb_free_pixmap(conn, bg_pixmap);
 836
 837     cursor = create_cursor(conn, scr, win, curs_choice);
 838
 839     grab_pointer_and_keyboard(conn, scr, cursor);
 840
 841     symbols = xcb_key_symbols_alloc(conn);
 842     modeswitchmask = get_mod_mask(conn, symbols, XK_Mode_switch);
 843     numlockmask = get_mod_mask(conn, symbols, XK_Num_Lock);
 844
 845     if (dpms)
 846         dpms_turn_off_screen(conn);
 847
 848     /* Initialize the libev event loop. */
 849     main_loop = EV_DEFAULT;
 850     if (main_loop == NULL)
 851         errx(EXIT_FAILURE, "Could not initialize libev. Bad LIBEV_FLAGS?\n");
 852
 853     struct ev_io *xcb_watcher = calloc(sizeof(struct ev_io), 1);
 854     struct ev_check *xcb_check = calloc(sizeof(struct ev_check), 1);
 855     struct ev_prepare *xcb_prepare = calloc(sizeof(struct ev_prepare), 1);
 856
 857     ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
 858     ev_io_start(main_loop, xcb_watcher);
 859
 860     ev_check_init(xcb_check, xcb_check_cb);
 861     ev_check_start(main_loop, xcb_check);
 862
 863     ev_prepare_init(xcb_prepare, xcb_prepare_cb);
 864     ev_prepare_start(main_loop, xcb_prepare);
 865
 866     xcb_flush(conn);
 867     ev_loop(main_loop, 0);
 868 }