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

   1 /*
   2  * vim:ts=4:sw=4:expandtab
   3  *
   4  * © 2010-2013 Michael Stapelberg
   5  *
   6  * See LICENSE for licensing information
   7  *
   8  */
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <pwd.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <stdbool.h>
  15 #include <stdint.h>
  16 #include <xcb/xcb.h>
  17 #include <xcb/xkb.h>
  18 #include <xcb/dpms.h>
  19 #include <err.h>
  20 #include <assert.h>
  21 #include <security/pam_appl.h>
  22 #include <getopt.h>
  23 #include <string.h>
  24 #include <ev.h>
  25 #include <sys/mman.h>
  26 #include <xkbcommon/xkbcommon.h>
  27 #include <xkbcommon/xkbcommon-x11.h>
  28 #include <cairo.h>
  29 #include <cairo/cairo-xcb.h>
  30
  31 #include "i3lock.h"
  32 #include "xcb.h"
  33 #include "cursors.h"
  34 #include "unlock_indicator.h"
  35 #include "xinerama.h"
  36
  37 #define TSTAMP_N_SECS(n) (n * 1.0)
  38 #define TSTAMP_N_MINS(n) (60 * TSTAMP_N_SECS(n))
  39 #define START_TIMER(timer_obj, timeout, callback) \
  40     timer_obj = start_timer(timer_obj, timeout, callback)
  41 #define STOP_TIMER(timer_obj) \
  42     timer_obj = stop_timer(timer_obj)
  43
  44 typedef void (*ev_callback_t)(EV_P_ ev_timer *w, int revents);
  45
  46 /* We need this for libxkbfile */
  47 char color[7] = "ffffff";
  48 int inactivity_timeout = 30;
  49 uint32_t last_resolution[2];
  50 xcb_window_t win;
  51 static xcb_cursor_t cursor;
  52 static pam_handle_t *pam_handle;
  53 int input_position = 0;
  54 /* Holds the password you enter (in UTF-8). */
  55 static char password[512];
  56 static bool beep = false;
  57 bool debug_mode = false;
  58 static bool dpms = false;
  59 bool unlock_indicator = true;
  60 static bool dont_fork = false;
  61 struct ev_loop *main_loop;
  62 static struct ev_timer *clear_pam_wrong_timeout;
  63 static struct ev_timer *clear_indicator_timeout;
  64 static struct ev_timer *dpms_timeout;
  65 static struct ev_timer *discard_passwd_timeout;
  66 extern unlock_state_t unlock_state;
  67 extern pam_state_t pam_state;
  68 int failed_attempts = 0;
  69 bool show_failed_attempts = false;
  70
  71 static struct xkb_state *xkb_state;
  72 static struct xkb_context *xkb_context;
  73 static struct xkb_keymap *xkb_keymap;
  74 static uint8_t xkb_base_event;
  75 static uint8_t xkb_base_error;
  76
  77 cairo_surface_t *img = NULL;
  78 bool tile = false;
  79 bool ignore_empty_password = false;
  80 bool skip_repeated_empty_password = false;
  81
  82 /* isutf, u8_dec © 2005 Jeff Bezanson, public domain */
  83 #define isutf(c) (((c) & 0xC0) != 0x80)
  84
  85 /*
  86  * Decrements i to point to the previous unicode glyph
  87  *
  88  */
  89 void u8_dec(char *s, int *i) {
  90     (void)(isutf(s[--(*i)]) || isutf(s[--(*i)]) || isutf(s[--(*i)]) || --(*i));
  91 }
  92
  93 static void turn_monitors_on(void) {
  94     if (dpms)
  95         dpms_set_mode(conn, XCB_DPMS_DPMS_MODE_ON);
  96 }
  97
  98 static void turn_monitors_off(void) {
  99     if (dpms)
 100         dpms_set_mode(conn, XCB_DPMS_DPMS_MODE_OFF);
 101 }
 102
 103 /*
 104  * Loads the XKB keymap from the X11 server and feeds it to xkbcommon.
 105  * Necessary so that we can properly let xkbcommon track the keyboard state and
 106  * translate keypresses to utf-8.
 107  *
 108  */
 109 static bool load_keymap(void) {
 110     if (xkb_context == NULL) {
 111         if ((xkb_context = xkb_context_new(0)) == NULL) {
 112             fprintf(stderr, "[i3lock] could not create xkbcommon context\n");
 113             return false;
 114         }
 115     }
 116
 117     xkb_keymap_unref(xkb_keymap);
 118
 119     int32_t device_id = xkb_x11_get_core_keyboard_device_id(conn);
 120     DEBUG("device = %d\n", device_id);
 121     if ((xkb_keymap = xkb_x11_keymap_new_from_device(xkb_context, conn, device_id, 0)) == NULL) {
 122         fprintf(stderr, "[i3lock] xkb_x11_keymap_new_from_device failed\n");
 123         return false;
 124     }
 125
 126     struct xkb_state *new_state =
 127         xkb_x11_state_new_from_device(xkb_keymap, conn, device_id);
 128     if (new_state == NULL) {
 129         fprintf(stderr, "[i3lock] xkb_x11_state_new_from_device failed\n");
 130         return false;
 131     }
 132
 133     xkb_state_unref(xkb_state);
 134     xkb_state = new_state;
 135
 136     return true;
 137 }
 138
 139 /*
 140  * Clears the memory which stored the password to be a bit safer against
 141  * cold-boot attacks.
 142  *
 143  */
 144 static void clear_password_memory(void) {
 145     /* A volatile pointer to the password buffer to prevent the compiler from
 146      * optimizing this out. */
 147     volatile char *vpassword = password;
 148     for (int c = 0; c < sizeof(password); c++)
 149         /* We store a non-random pattern which consists of the (irrelevant)
 150          * index plus (!) the value of the beep variable. This prevents the
 151          * compiler from optimizing the calls away, since the value of 'beep'
 152          * is not known at compile-time. */
 153         vpassword[c] = c + (int)beep;
 154 }
 155
 156 ev_timer* start_timer(ev_timer *timer_obj, ev_tstamp timeout, ev_callback_t callback) {
 157     if (timer_obj) {
 158         ev_timer_stop(main_loop, timer_obj);
 159         ev_timer_set(timer_obj, timeout, 0.);
 160         ev_timer_start(main_loop, timer_obj);
 161     } else {
 162         /* When there is no memory, we just don’t have a timeout. We cannot
 163          * exit() here, since that would effectively unlock the screen. */
 164         timer_obj = calloc(sizeof(struct ev_timer), 1);
 165         if (timer_obj) {
 166             ev_timer_init(timer_obj, callback, timeout, 0.);
 167             ev_timer_start(main_loop, timer_obj);
 168         }
 169     }
 170     return timer_obj;
 171 }
 172
 173 ev_timer* stop_timer(ev_timer *timer_obj) {
 174     if (timer_obj) {
 175         ev_timer_stop(main_loop, timer_obj);
 176         free(timer_obj);
 177     }
 178     return NULL;
 179 }
 180
 181 /*
 182  * Resets pam_state to STATE_PAM_IDLE 2 seconds after an unsuccessful
 183  * authentication event.
 184  *
 185  */
 186 static void clear_pam_wrong(EV_P_ ev_timer *w, int revents) {
 187     DEBUG("clearing pam wrong\n");
 188     pam_state = STATE_PAM_IDLE;
 189     unlock_state = STATE_STARTED;
 190     redraw_screen();
 191
 192     /* Now free this timeout. */
 193     STOP_TIMER(clear_pam_wrong_timeout);
 194 }
 195
 196 static void clear_indicator_cb(EV_P_ ev_timer *w, int revents) {
 197     clear_indicator();
 198     STOP_TIMER(clear_indicator_timeout);
 199 }
 200
 201 static void clear_input(void) {
 202     input_position = 0;
 203     clear_password_memory();
 204     password[input_position] = '\0';
 205
 206     /* Hide the unlock indicator after a bit if the password buffer is
 207      * empty. */
 208     START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb);
 209     unlock_state = STATE_BACKSPACE_ACTIVE;
 210     redraw_screen();
 211     unlock_state = STATE_KEY_PRESSED;
 212 }
 213
 214 static void turn_off_monitors_cb(EV_P_ ev_timer *w, int revents) {
 215     if (input_position == 0)
 216         turn_monitors_off();
 217
 218     STOP_TIMER(dpms_timeout);
 219 }
 220
 221 static void discard_passwd_cb(EV_P_ ev_timer *w, int revents) {
 222     clear_input();
 223     turn_monitors_off();
 224     STOP_TIMER(discard_passwd_timeout);
 225 }
 226
 227 static void input_done(void) {
 228     STOP_TIMER(clear_pam_wrong_timeout);
 229     pam_state = STATE_PAM_VERIFY;
 230     redraw_screen();
 231
 232     if (pam_authenticate(pam_handle, 0) == PAM_SUCCESS) {
 233         DEBUG("successfully authenticated\n");
 234         clear_password_memory();
 235         /* Turn the screen on, as it may have been turned off
 236          * on release of the 'enter' key. */
 237         turn_monitors_on();
 238         exit(0);
 239     }
 240
 241     if (debug_mode)
 242         fprintf(stderr, "Authentication failure\n");
 243
 244     pam_state = STATE_PAM_WRONG;
 245     failed_attempts += 1;
 246     clear_input();
 247     redraw_screen();
 248
 249     /* Clear this state after 2 seconds (unless the user enters another
 250      * password during that time). */
 251     ev_now_update(main_loop);
 252     START_TIMER(clear_pam_wrong_timeout, TSTAMP_N_SECS(2), clear_pam_wrong);
 253
 254     /* Cancel the clear_indicator_timeout, it would hide the unlock indicator
 255      * too early. */
 256     STOP_TIMER(clear_indicator_timeout);
 257
 258     /* beep on authentication failure, if enabled */
 259     if (beep) {
 260         xcb_bell(conn, 100);
 261         xcb_flush(conn);
 262     }
 263 }
 264
 265 static void redraw_timeout(EV_P_ ev_timer *w, int revents) {
 266     redraw_screen();
 267     STOP_TIMER(w);
 268 }
 269
 270 static bool skip_without_validation(void) {
 271     if (input_position != 0)
 272         return false;
 273
 274     if (skip_repeated_empty_password || ignore_empty_password)
 275         return true;
 276
 277     return false;
 278 }
 279
 280 /*
 281  * Handle key presses. Fixes state, then looks up the key symbol for the
 282  * given keycode, then looks up the key symbol (as UCS-2), converts it to
 283  * UTF-8 and stores it in the password array.
 284  *
 285  */
 286 static void handle_key_press(xcb_key_press_event_t *event) {
 287     xkb_keysym_t ksym;
 288     char buffer[128];
 289     int n;
 290     bool ctrl;
 291
 292     ksym = xkb_state_key_get_one_sym(xkb_state, event->detail);
 293     ctrl = xkb_state_mod_name_is_active(xkb_state, "Control", XKB_STATE_MODS_DEPRESSED);
 294
 295     /* The buffer will be null-terminated, so n >= 2 for 1 actual character. */
 296     memset(buffer, '\0', sizeof(buffer));
 297     n = xkb_keysym_to_utf8(ksym, buffer, sizeof(buffer));
 298
 299     switch (ksym) {
 300     case XKB_KEY_Return:
 301     case XKB_KEY_KP_Enter:
 302     case XKB_KEY_XF86ScreenSaver:
 303         if (pam_state == STATE_PAM_WRONG)
 304             return;
 305
 306         if (skip_without_validation()) {
 307             clear_input();
 308             return;
 309         }
 310         password[input_position] = '\0';
 311         unlock_state = STATE_KEY_PRESSED;
 312         redraw_screen();
 313         input_done();
 314         skip_repeated_empty_password = true;
 315         return;
 316     default:
 317         skip_repeated_empty_password = false;
 318     }
 319
 320     switch (ksym) {
 321     case XKB_KEY_u:
 322         if (ctrl) {
 323             DEBUG("C-u pressed\n");
 324             clear_input();
 325             return;
 326         }
 327         break;
 328
 329     case XKB_KEY_Escape:
 330         clear_input();
 331         return;
 332
 333     case XKB_KEY_BackSpace:
 334         if (input_position == 0)
 335             return;
 336
 337         /* decrement input_position to point to the previous glyph */
 338         u8_dec(password, &input_position);
 339         password[input_position] = '\0';
 340
 341         /* Hide the unlock indicator after a bit if the password buffer is
 342          * empty. */
 343         START_TIMER(clear_indicator_timeout, 1.0, clear_indicator_cb);
 344         unlock_state = STATE_BACKSPACE_ACTIVE;
 345         redraw_screen();
 346         unlock_state = STATE_KEY_PRESSED;
 347         return;
 348     }
 349
 350     if ((input_position + 8) >= sizeof(password))
 351         return;
 352
 353 #if 0
 354     /* FIXME: handle all of these? */
 355     printf("is_keypad_key = %d\n", xcb_is_keypad_key(sym));
 356     printf("is_private_keypad_key = %d\n", xcb_is_private_keypad_key(sym));
 357     printf("xcb_is_cursor_key = %d\n", xcb_is_cursor_key(sym));
 358     printf("xcb_is_pf_key = %d\n", xcb_is_pf_key(sym));
 359     printf("xcb_is_function_key = %d\n", xcb_is_function_key(sym));
 360     printf("xcb_is_misc_function_key = %d\n", xcb_is_misc_function_key(sym));
 361     printf("xcb_is_modifier_key = %d\n", xcb_is_modifier_key(sym));
 362 #endif
 363
 364     if (n < 2)
 365         return;
 366
 367     /* store it in the password array as UTF-8 */
 368     memcpy(password+input_position, buffer, n-1);
 369     input_position += n-1;
 370     DEBUG("current password = %.*s\n", input_position, password);
 371
 372     unlock_state = STATE_KEY_ACTIVE;
 373     redraw_screen();
 374     unlock_state = STATE_KEY_PRESSED;
 375
 376     struct ev_timer *timeout = NULL;
 377     START_TIMER(timeout, TSTAMP_N_SECS(0.25), redraw_timeout);
 378     STOP_TIMER(clear_indicator_timeout);
 379     START_TIMER(discard_passwd_timeout, TSTAMP_N_MINS(3), discard_passwd_cb);
 380 }
 381
 382 /*
 383  * A visibility notify event will be received when the visibility (= can the
 384  * user view the complete window) changes, so for example when a popup overlays
 385  * some area of the i3lock window.
 386  *
 387  * In this case, we raise our window on top so that the popup (or whatever is
 388  * hiding us) gets hidden.
 389  *
 390  */
 391 static void handle_visibility_notify(xcb_connection_t *conn,
 392     xcb_visibility_notify_event_t *event) {
 393     if (event->state != XCB_VISIBILITY_UNOBSCURED) {
 394         uint32_t values[] = { XCB_STACK_MODE_ABOVE };
 395         xcb_configure_window(conn, event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
 396         xcb_flush(conn);
 397     }
 398 }
 399
 400 /*
 401  * Called when the keyboard mapping changes. We update our symbols.
 402  *
 403  * We ignore errors — if the new keymap cannot be loaded it’s better if the
 404  * screen stays locked and the user intervenes by using killall i3lock.
 405  *
 406  */
 407 static void process_xkb_event(xcb_generic_event_t *gevent) {
 408     union xkb_event {
 409         struct {
 410             uint8_t response_type;
 411             uint8_t xkbType;
 412             uint16_t sequence;
 413             xcb_timestamp_t time;
 414             uint8_t deviceID;
 415         } any;
 416         xcb_xkb_new_keyboard_notify_event_t new_keyboard_notify;
 417         xcb_xkb_map_notify_event_t map_notify;
 418         xcb_xkb_state_notify_event_t state_notify;
 419     } *event = (union xkb_event*)gevent;
 420
 421     DEBUG("process_xkb_event for device %d\n", event->any.deviceID);
 422
 423     if (event->any.deviceID != xkb_x11_get_core_keyboard_device_id(conn))
 424         return;
 425
 426     /*
 427      * XkbNewKkdNotify and XkbMapNotify together capture all sorts of keymap
 428      * updates (e.g. xmodmap, xkbcomp, setxkbmap), with minimal redundent
 429      * recompilations.
 430      */
 431     switch (event->any.xkbType) {
 432         case XCB_XKB_NEW_KEYBOARD_NOTIFY:
 433             if (event->new_keyboard_notify.changed & XCB_XKB_NKN_DETAIL_KEYCODES)
 434                 (void)load_keymap();
 435             break;
 436
 437         case XCB_XKB_MAP_NOTIFY:
 438             (void)load_keymap();
 439             break;
 440
 441         case XCB_XKB_STATE_NOTIFY:
 442             xkb_state_update_mask(xkb_state,
 443                                   event->state_notify.baseMods,
 444                                   event->state_notify.latchedMods,
 445                                   event->state_notify.lockedMods,
 446                                   event->state_notify.baseGroup,
 447                                   event->state_notify.latchedGroup,
 448                                   event->state_notify.lockedGroup);
 449             break;
 450     }
 451 }
 452
 453 /*
 454  * Called when the properties on the root window change, e.g. when the screen
 455  * resolution changes. If so we update the window to cover the whole screen
 456  * and also redraw the image, if any.
 457  *
 458  */
 459 void handle_screen_resize(void) {
 460     xcb_get_geometry_cookie_t geomc;
 461     xcb_get_geometry_reply_t *geom;
 462     geomc = xcb_get_geometry(conn, screen->root);
 463     if ((geom = xcb_get_geometry_reply(conn, geomc, 0)) == NULL)
 464         return;
 465
 466     if (last_resolution[0] == geom->width &&
 467         last_resolution[1] == geom->height) {
 468         free(geom);
 469         return;
 470     }
 471
 472     last_resolution[0] = geom->width;
 473     last_resolution[1] = geom->height;
 474
 475     free(geom);
 476
 477     redraw_screen();
 478
 479     uint32_t mask = XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT;
 480     xcb_configure_window(conn, win, mask, last_resolution);
 481     xcb_flush(conn);
 482
 483     xinerama_query_screens();
 484     redraw_screen();
 485 }
 486
 487 /*
 488  * Callback function for PAM. We only react on password request callbacks.
 489  *
 490  */
 491 static int conv_callback(int num_msg, const struct pam_message **msg,
 492                          struct pam_response **resp, void *appdata_ptr)
 493 {
 494     if (num_msg == 0)
 495         return 1;
 496
 497     /* PAM expects an array of responses, one for each message */
 498     if ((*resp = calloc(num_msg, sizeof(struct pam_response))) == NULL) {
 499         perror("calloc");
 500         return 1;
 501     }
 502
 503     for (int c = 0; c < num_msg; c++) {
 504         if (msg[c]->msg_style != PAM_PROMPT_ECHO_OFF &&
 505             msg[c]->msg_style != PAM_PROMPT_ECHO_ON)
 506             continue;
 507
 508         /* return code is currently not used but should be set to zero */
 509         resp[c]->resp_retcode = 0;
 510         if ((resp[c]->resp = strdup(password)) == NULL) {
 511             perror("strdup");
 512             return 1;
 513         }
 514     }
 515
 516     return 0;
 517 }
 518
 519 /*
 520  * This callback is only a dummy, see xcb_prepare_cb and xcb_check_cb.
 521  * See also man libev(3): "ev_prepare" and "ev_check" - customise your event loop
 522  *
 523  */
 524 static void xcb_got_event(EV_P_ struct ev_io *w, int revents) {
 525     /* empty, because xcb_prepare_cb and xcb_check_cb are used */
 526 }
 527
 528 /*
 529  * Flush before blocking (and waiting for new events)
 530  *
 531  */
 532 static void xcb_prepare_cb(EV_P_ ev_prepare *w, int revents) {
 533     xcb_flush(conn);
 534 }
 535
 536 /*
 537  * Instead of polling the X connection socket we leave this to
 538  * xcb_poll_for_event() which knows better than we can ever know.
 539  *
 540  */
 541 static void xcb_check_cb(EV_P_ ev_check *w, int revents) {
 542     xcb_generic_event_t *event;
 543
 544     if (xcb_connection_has_error(conn))
 545         errx(EXIT_FAILURE, "X11 connection broke, did your server terminate?\n");
 546
 547     while ((event = xcb_poll_for_event(conn)) != NULL) {
 548         if (event->response_type == 0) {
 549             xcb_generic_error_t *error = (xcb_generic_error_t*)event;
 550             if (debug_mode)
 551                 fprintf(stderr, "X11 Error received! sequence 0x%x, error_code = %d\n",
 552                         error->sequence, error->error_code);
 553             free(event);
 554             continue;
 555         }
 556
 557         /* Strip off the highest bit (set if the event is generated) */
 558         int type = (event->response_type & 0x7F);
 559
 560         switch (type) {
 561             case XCB_KEY_PRESS:
 562                 handle_key_press((xcb_key_press_event_t*)event);
 563                 break;
 564
 565             case XCB_KEY_RELEASE:
 566                 /* If this was the backspace or escape key we are back at an
 567                  * empty input, so turn off the screen if DPMS is enabled, but
 568                  * only do that after some timeout: maybe user mistyped and
 569                  * will type again right away */
 570                 START_TIMER(dpms_timeout, TSTAMP_N_SECS(inactivity_timeout),
 571                             turn_off_monitors_cb);
 572                 break;
 573
 574             case XCB_VISIBILITY_NOTIFY:
 575                 handle_visibility_notify(conn, (xcb_visibility_notify_event_t*)event);
 576                 break;
 577
 578             case XCB_MAP_NOTIFY:
 579                 if (!dont_fork) {
 580                     /* After the first MapNotify, we never fork again. We don’t
 581                      * expect to get another MapNotify, but better be sure… */
 582                     dont_fork = true;
 583
 584                     /* In the parent process, we exit */
 585                     if (fork() != 0)
 586                         exit(0);
 587
 588                     ev_loop_fork(EV_DEFAULT);
 589                 }
 590                 break;
 591
 592             case XCB_CONFIGURE_NOTIFY:
 593                 handle_screen_resize();
 594                 break;
 595
 596             default:
 597                 if (type == xkb_base_event)
 598                     process_xkb_event(event);
 599         }
 600
 601         free(event);
 602     }
 603 }
 604
 605 /*
 606  * This function is called from a fork()ed child and will raise the i3lock
 607  * window when the window is obscured, even when the main i3lock process is
 608  * blocked due to PAM.
 609  *
 610  */
 611 static void raise_loop(xcb_window_t window) {
 612     xcb_connection_t *conn;
 613     xcb_generic_event_t *event;
 614     int screens;
 615
 616     if ((conn = xcb_connect(NULL, &screens)) == NULL ||
 617         xcb_connection_has_error(conn))
 618         errx(EXIT_FAILURE, "Cannot open display\n");
 619
 620     /* We need to know about the window being obscured or getting destroyed. */
 621     xcb_change_window_attributes(conn, window, XCB_CW_EVENT_MASK,
 622         (uint32_t[]){
 623             XCB_EVENT_MASK_VISIBILITY_CHANGE |
 624             XCB_EVENT_MASK_STRUCTURE_NOTIFY
 625         });
 626     xcb_flush(conn);
 627
 628     DEBUG("Watching window 0x%08x\n", window);
 629     while ((event = xcb_wait_for_event(conn)) != NULL) {
 630         if (event->response_type == 0) {
 631             xcb_generic_error_t *error = (xcb_generic_error_t*)event;
 632             DEBUG("X11 Error received! sequence 0x%x, error_code = %d\n",
 633                  error->sequence, error->error_code);
 634             free(event);
 635             continue;
 636         }
 637         /* Strip off the highest bit (set if the event is generated) */
 638         int type = (event->response_type & 0x7F);
 639         DEBUG("Read event of type %d\n", type);
 640         switch (type) {
 641             case XCB_VISIBILITY_NOTIFY:
 642                 handle_visibility_notify(conn, (xcb_visibility_notify_event_t*)event);
 643                 break;
 644             case XCB_UNMAP_NOTIFY:
 645                 DEBUG("UnmapNotify for 0x%08x\n", (((xcb_unmap_notify_event_t*)event)->window));
 646                 if (((xcb_unmap_notify_event_t*)event)->window == window)
 647                     exit(EXIT_SUCCESS);
 648                 break;
 649             case XCB_DESTROY_NOTIFY:
 650                 DEBUG("DestroyNotify for 0x%08x\n", (((xcb_destroy_notify_event_t*)event)->window));
 651                 if (((xcb_destroy_notify_event_t*)event)->window == window)
 652                     exit(EXIT_SUCCESS);
 653                 break;
 654             default:
 655                 DEBUG("Unhandled event type %d\n", type);
 656                 break;
 657         }
 658         free(event);
 659     }
 660 }
 661
 662 char* whoami(void) {
 663     uid_t uid = geteuid();
 664     struct passwd *pw = getpwuid(uid);
 665     if (pw) {
 666         return pw->pw_name;
 667      } else {
 668         errx(EXIT_FAILURE, "Username not known!\n");
 669      }
 670 }
 671
 672 int main(int argc, char *argv[]) {
 673     char *username = whoami();
 674     char *image_path = NULL;
 675     int ret;
 676     struct pam_conv conv = {conv_callback, NULL};
 677     int curs_choice = CURS_NONE;
 678     int o;
 679     int optind = 0;
 680     struct option longopts[] = {
 681         {"version", no_argument, NULL, 'v'},
 682         {"nofork", no_argument, NULL, 'n'},
 683         {"beep", no_argument, NULL, 'b'},
 684         {"dpms", no_argument, NULL, 'd'},
 685         {"color", required_argument, NULL, 'c'},
 686         {"pointer", required_argument, NULL , 'p'},
 687         {"debug", no_argument, NULL, 0},
 688         {"help", no_argument, NULL, 'h'},
 689         {"no-unlock-indicator", no_argument, NULL, 'u'},
 690         {"image", required_argument, NULL, 'i'},
 691         {"tiling", no_argument, NULL, 't'},
 692         {"ignore-empty-password", no_argument, NULL, 'e'},
 693         {"inactivity-timeout", required_argument, NULL, 'I'},
 694         {"show-failed-attempts", no_argument, NULL, 'f'},
 695         {NULL, no_argument, NULL, 0}
 696     };
 697
 698     char *optstring = "hvnbdc:p:ui:teI:f";
 699     while ((o = getopt_long(argc, argv, optstring, longopts, &optind)) != -1) {
 700         switch (o) {
 701         case 'v':
 702             errx(EXIT_SUCCESS, "version " VERSION " © 2010-2012 Michael Stapelberg");
 703         case 'n':
 704             dont_fork = true;
 705             break;
 706         case 'b':
 707             beep = true;
 708             break;
 709         case 'd':
 710             dpms = true;
 711             break;
 712         case 'I': {
 713             int time = 0;
 714             if (sscanf(optarg, "%d", &time) != 1 || time < 0)
 715                 errx(EXIT_FAILURE, "invalid timeout, it must be a positive integer\n");
 716             inactivity_timeout = time;
 717             break;
 718         }
 719         case 'c': {
 720             char *arg = optarg;
 721
 722             /* Skip # if present */
 723             if (arg[0] == '#')
 724                 arg++;
 725
 726             if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1)
 727                 errx(EXIT_FAILURE, "color is invalid, it must be given in 3-byte hexadecimal format: rrggbb\n");
 728
 729             break;
 730         }
 731         case 'u':
 732             unlock_indicator = false;
 733             break;
 734         case 'i':
 735             image_path = strdup(optarg);
 736             break;
 737         case 't':
 738             tile = true;
 739             break;
 740         case 'p':
 741             if (!strcmp(optarg, "win")) {
 742                 curs_choice = CURS_WIN;
 743             } else if (!strcmp(optarg, "default")) {
 744                 curs_choice = CURS_DEFAULT;
 745             } else {
 746                 errx(EXIT_FAILURE, "i3lock: Invalid pointer type given. Expected one of \"win\" or \"default\".\n");
 747             }
 748             break;
 749         case 'e':
 750             ignore_empty_password = true;
 751             break;
 752         case 0:
 753             if (strcmp(longopts[optind].name, "debug") == 0)
 754                 debug_mode = true;
 755             break;
 756         case 'f':
 757             show_failed_attempts = true;
 758             break;
 759         default:
 760             errx(EXIT_FAILURE, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default]"
 761             " [-i image.png] [-t] [-e] [-I] [-f]"
 762             );
 763         }
 764     }
 765
 766     /* We need (relatively) random numbers for highlighting a random part of
 767      * the unlock indicator upon keypresses. */
 768     srand(time(NULL));
 769
 770     /* Initialize PAM */
 771     ret = pam_start("i3lock", username, &conv, &pam_handle);
 772     if (ret != PAM_SUCCESS)
 773         errx(EXIT_FAILURE, "PAM: %s", pam_strerror(pam_handle, ret));
 774
 775 /* Using mlock() as non-super-user seems only possible in Linux. Users of other
 776  * operating systems should use encrypted swap/no swap (or remove the ifdef and
 777  * run i3lock as super-user). */
 778 #if defined(__linux__)
 779     /* Lock the area where we store the password in memory, we don’t want it to
 780      * be swapped to disk. Since Linux 2.6.9, this does not require any
 781      * privileges, just enough bytes in the RLIMIT_MEMLOCK limit. */
 782     if (mlock(password, sizeof(password)) != 0)
 783         err(EXIT_FAILURE, "Could not lock page in memory, check RLIMIT_MEMLOCK");
 784 #endif
 785
 786     /* Double checking that connection is good and operatable with xcb */
 787     int screennr;
 788     if ((conn = xcb_connect(NULL, &screennr)) == NULL ||
 789         xcb_connection_has_error(conn))
 790         errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
 791
 792     if (xkb_x11_setup_xkb_extension(conn,
 793             XKB_X11_MIN_MAJOR_XKB_VERSION,
 794             XKB_X11_MIN_MINOR_XKB_VERSION,
 795             0,
 796             NULL,
 797             NULL,
 798             &xkb_base_event,
 799             &xkb_base_error) != 1)
 800         errx(EXIT_FAILURE, "Could not setup XKB extension.");
 801
 802     static const xcb_xkb_map_part_t required_map_parts =
 803         (XCB_XKB_MAP_PART_KEY_TYPES |
 804          XCB_XKB_MAP_PART_KEY_SYMS |
 805          XCB_XKB_MAP_PART_MODIFIER_MAP |
 806          XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
 807          XCB_XKB_MAP_PART_KEY_ACTIONS |
 808          XCB_XKB_MAP_PART_VIRTUAL_MODS |
 809          XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP);
 810
 811     static const xcb_xkb_event_type_t required_events =
 812         (XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
 813          XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
 814          XCB_XKB_EVENT_TYPE_STATE_NOTIFY);
 815
 816     xcb_xkb_select_events(
 817         conn,
 818         xkb_x11_get_core_keyboard_device_id(conn),
 819         required_events,
 820         0,
 821         required_events,
 822         required_map_parts,
 823         required_map_parts,
 824         0);
 825
 826     /* When we cannot initially load the keymap, we better exit */
 827     if (!load_keymap())
 828         errx(EXIT_FAILURE, "Could not load keymap");
 829
 830     xinerama_init();
 831     xinerama_query_screens();
 832
 833     /* if DPMS is enabled, check if the X server really supports it */
 834     if (dpms) {
 835         xcb_dpms_capable_cookie_t dpmsc = xcb_dpms_capable(conn);
 836         xcb_dpms_capable_reply_t *dpmsr;
 837         if ((dpmsr = xcb_dpms_capable_reply(conn, dpmsc, NULL))) {
 838             if (!dpmsr->capable) {
 839                 if (debug_mode)
 840                     fprintf(stderr, "Disabling DPMS, X server not DPMS capable\n");
 841                 dpms = false;
 842             }
 843             free(dpmsr);
 844         }
 845     }
 846
 847     screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
 848
 849     last_resolution[0] = screen->width_in_pixels;
 850     last_resolution[1] = screen->height_in_pixels;
 851
 852     xcb_change_window_attributes(conn, screen->root, XCB_CW_EVENT_MASK,
 853             (uint32_t[]){ XCB_EVENT_MASK_STRUCTURE_NOTIFY });
 854
 855     if (image_path) {
 856         /* Create a pixmap to render on, fill it with the background color */
 857         img = cairo_image_surface_create_from_png(image_path);
 858         /* In case loading failed, we just pretend no -i was specified. */
 859         if (cairo_surface_status(img) != CAIRO_STATUS_SUCCESS) {
 860             fprintf(stderr, "Could not load image \"%s\": %s\n",
 861                     image_path, cairo_status_to_string(cairo_surface_status(img)));
 862             img = NULL;
 863         }
 864     }
 865
 866     /* Pixmap on which the image is rendered to (if any) */
 867     xcb_pixmap_t bg_pixmap = draw_image(last_resolution);
 868
 869     /* open the fullscreen window, already with the correct pixmap in place */
 870     win = open_fullscreen_window(conn, screen, color, bg_pixmap);
 871     xcb_free_pixmap(conn, bg_pixmap);
 872
 873     pid_t pid = fork();
 874     /* The pid == -1 case is intentionally ignored here:
 875      * While the child process is useful for preventing other windows from
 876      * popping up while i3lock blocks, it is not critical. */
 877     if (pid == 0) {
 878         /* Child */
 879         close(xcb_get_file_descriptor(conn));
 880         raise_loop(win);
 881         exit(EXIT_SUCCESS);
 882     }
 883
 884     cursor = create_cursor(conn, screen, win, curs_choice);
 885
 886     grab_pointer_and_keyboard(conn, screen, cursor);
 887     /* Load the keymap again to sync the current modifier state. Since we first
 888      * loaded the keymap, there might have been changes, but starting from now,
 889      * we should get all key presses/releases due to having grabbed the
 890      * keyboard. */
 891     (void)load_keymap();
 892
 893     turn_monitors_off();
 894
 895     /* Initialize the libev event loop. */
 896     main_loop = EV_DEFAULT;
 897     if (main_loop == NULL)
 898         errx(EXIT_FAILURE, "Could not initialize libev. Bad LIBEV_FLAGS?\n");
 899
 900     struct ev_io *xcb_watcher = calloc(sizeof(struct ev_io), 1);
 901     struct ev_check *xcb_check = calloc(sizeof(struct ev_check), 1);
 902     struct ev_prepare *xcb_prepare = calloc(sizeof(struct ev_prepare), 1);
 903
 904     ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
 905     ev_io_start(main_loop, xcb_watcher);
 906
 907     ev_check_init(xcb_check, xcb_check_cb);
 908     ev_check_start(main_loop, xcb_check);
 909
 910     ev_prepare_init(xcb_prepare, xcb_prepare_cb);
 911     ev_prepare_start(main_loop, xcb_prepare);
 912
 913     /* Invoke the event callback once to catch all the events which were
 914      * received up until now. ev will only pick up new events (when the X11
 915      * file descriptor becomes readable). */
 916     ev_invoke(main_loop, xcb_check, 0);
 917     ev_loop(main_loop, 0);
 918 }