slock.c

   1 /* See LICENSE file for license details. */
   2 #define _XOPEN_SOURCE 500
   3 #if HAVE_SHADOW_H
   4 #include <shadow.h>
   5 #endif
   6
   7 #include <ctype.h>
   8 #include <errno.h>
   9 #include <grp.h>
  10 #include <pwd.h>
  11 #include <stdarg.h>
  12 #include <stdlib.h>
  13 #include <stdio.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <time.h>
  17 #include <sys/types.h>
  18 #include <X11/extensions/Xrandr.h>
  19 #include <X11/extensions/dpms.h>
  20 #include <X11/keysym.h>
  21 #include <X11/Xlib.h>
  22 #include <X11/Xutil.h>
  23
  24 #include "arg.h"
  25 #include "util.h"
  26
  27 char *argv0;
  28
  29 static time_t locktime;
  30
  31 enum {
  32         INIT,
  33         INPUT,
  34         FAILED,
  35         NUMCOLS
  36 };
  37
  38 struct lock {
  39         int screen;
  40         Window root, win;
  41         Pixmap pmap;
  42         unsigned long colors[NUMCOLS];
  43 };
  44
  45 struct xrandr {
  46         int active;
  47         int evbase;
  48         int errbase;
  49 };
  50
  51 #include "config.h"
  52
  53 static void
  54 die(const char *errstr, ...)
  55 {
  56         va_list ap;
  57
  58         va_start(ap, errstr);
  59         vfprintf(stderr, errstr, ap);
  60         va_end(ap);
  61         exit(1);
  62 }
  63
  64 #ifdef __linux__
  65 #include <fcntl.h>
  66 #include <linux/oom.h>
  67
  68 static void
  69 dontkillme(void)
  70 {
  71         FILE *f;
  72         const char oomfile[] = "/proc/self/oom_score_adj";
  73
  74         if (!(f = fopen(oomfile, "w"))) {
  75                 if (errno == ENOENT)
  76                         return;
  77                 die("slock: fopen %s: %s\n", oomfile, strerror(errno));
  78         }
  79         fprintf(f, "%d", OOM_SCORE_ADJ_MIN);
  80         if (fclose(f)) {
  81                 if (errno == EACCES)
  82                         die("slock: unable to disable OOM killer. "
  83                             "Make sure to suid or sgid slock.\n");
  84                 else
  85                         die("slock: fclose %s: %s\n", oomfile, strerror(errno));
  86         }
  87 }
  88 #endif
  89
  90 static const char *
  91 gethash(void)
  92 {
  93         const char *hash;
  94         struct passwd *pw;
  95
  96         /* Check if the current user has a password entry */
  97         errno = 0;
  98         if (!(pw = getpwuid(getuid()))) {
  99                 if (errno)
 100                         die("slock: getpwuid: %s\n", strerror(errno));
 101                 else
 102                         die("slock: cannot retrieve password entry\n");
 103         }
 104         hash = pw->pw_passwd;
 105
 106 #if HAVE_SHADOW_H
 107         if (!strcmp(hash, "x")) {
 108                 struct spwd *sp;
 109                 if (!(sp = getspnam(pw->pw_name)))
 110                         die("slock: getspnam: cannot retrieve shadow entry. "
 111                             "Make sure to suid or sgid slock.\n");
 112                 hash = sp->sp_pwdp;
 113         }
 114 #else
 115         if (!strcmp(hash, "*")) {
 116 #ifdef __OpenBSD__
 117                 if (!(pw = getpwuid_shadow(getuid())))
 118                         die("slock: getpwnam_shadow: cannot retrieve shadow entry. "
 119                             "Make sure to suid or sgid slock.\n");
 120                 hash = pw->pw_passwd;
 121 #else
 122                 die("slock: getpwuid: cannot retrieve shadow entry. "
 123                     "Make sure to suid or sgid slock.\n");
 124 #endif /* __OpenBSD__ */
 125         }
 126 #endif /* HAVE_SHADOW_H */
 127
 128         return hash;
 129 }
 130
 131 static void
 132 readpw(Display *dpy, struct xrandr *rr, struct lock **locks, int nscreens,
 133        const char *hash)
 134 {
 135         XRRScreenChangeNotifyEvent *rre;
 136         char buf[32], passwd[256], *inputhash;
 137         int num, screen, running, failure, oldc;
 138         unsigned int len, color;
 139         KeySym ksym;
 140         XEvent ev;
 141
 142         len = 0;
 143         running = 1;
 144         failure = 0;
 145         oldc = INIT;
 146
 147         while (running && !XNextEvent(dpy, &ev)) {
 148                 running = !((time(NULL) - locktime < timetocancel) && (ev.type == MotionNotify));
 149                 if (ev.type == KeyPress) {
 150                         explicit_bzero(&buf, sizeof(buf));
 151                         num = XLookupString(&ev.xkey, buf, sizeof(buf), &ksym, 0);
 152                         if (IsKeypadKey(ksym)) {
 153                                 if (ksym == XK_KP_Enter)
 154                                         ksym = XK_Return;
 155                                 else if (ksym >= XK_KP_0 && ksym <= XK_KP_9)
 156                                         ksym = (ksym - XK_KP_0) + XK_0;
 157                         }
 158                         if (IsFunctionKey(ksym) ||
 159                             IsKeypadKey(ksym) ||
 160                             IsMiscFunctionKey(ksym) ||
 161                             IsPFKey(ksym) ||
 162                             IsPrivateKeypadKey(ksym))
 163                                 continue;
 164                         if (ev.xkey.state & ControlMask) {
 165                                 switch (ksym) {
 166                                 case XK_u:
 167                                         ksym = XK_Escape;
 168                                         break;
 169                                 case XK_m:
 170                                         ksym = XK_Return;
 171                                         break;
 172                                 case XK_j:
 173                                         ksym = XK_Return;
 174                                         break;
 175                                 case XK_h:
 176                                        ksym = XK_BackSpace;
 177                                         break;
 178                                 }
 179                         }
 180                         switch (ksym) {
 181                         case XK_Return:
 182                                 passwd[len] = '\0';
 183                                 errno = 0;
 184                                 if (!(inputhash = crypt(passwd, hash)))
 185                                         fprintf(stderr, "slock: crypt: %s\n", strerror(errno));
 186                                 else
 187                                         running = !!strcmp(inputhash, hash);
 188                                 if (running) {
 189                                         XBell(dpy, 100);
 190                                         failure = 1;
 191                                 }
 192                                 explicit_bzero(&passwd, sizeof(passwd));
 193                                 len = 0;
 194                                 break;
 195                         case XK_Escape:
 196                                 explicit_bzero(&passwd, sizeof(passwd));
 197                                 len = 0;
 198                                 break;
 199                         case XK_BackSpace:
 200                                 if (len)
 201                                         passwd[--len] = '\0';
 202                                 break;
 203                         default:
 204                                 if (num && !iscntrl((int)buf[0]) &&
 205                                     (len + num < sizeof(passwd))) {
 206                                         memcpy(passwd + len, buf, num);
 207                                         len += num;
 208                                 }
 209                                 break;
 210                         }
 211                         color = len ? INPUT : ((failure || failonclear) ? FAILED : INIT);
 212                         if (running && oldc != color) {
 213                                 for (screen = 0; screen < nscreens; screen++) {
 214                                         XSetWindowBackground(dpy,
 215                                                              locks[screen]->win,
 216                                                              locks[screen]->colors[color]);
 217                                         XClearWindow(dpy, locks[screen]->win);
 218                                 }
 219                                 oldc = color;
 220                         }
 221                 } else if (rr->active && ev.type == rr->evbase + RRScreenChangeNotify) {
 222                         rre = (XRRScreenChangeNotifyEvent*)&ev;
 223                         for (screen = 0; screen < nscreens; screen++) {
 224                                 if (locks[screen]->win == rre->window) {
 225                                         if (rre->rotation == RR_Rotate_90 ||
 226                                             rre->rotation == RR_Rotate_270)
 227                                                 XResizeWindow(dpy, locks[screen]->win,
 228                                                               rre->height, rre->width);
 229                                         else
 230                                                 XResizeWindow(dpy, locks[screen]->win,
 231                                                               rre->width, rre->height);
 232                                         XClearWindow(dpy, locks[screen]->win);
 233                                         break;
 234                                 }
 235                         }
 236                 } else {
 237                         for (screen = 0; screen < nscreens; screen++)
 238                                 XRaiseWindow(dpy, locks[screen]->win);
 239                 }
 240         }
 241 }
 242
 243 static struct lock *
 244 lockscreen(Display *dpy, struct xrandr *rr, int screen)
 245 {
 246         char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
 247         int i, ptgrab, kbgrab;
 248         struct lock *lock;
 249         XColor color, dummy;
 250         XSetWindowAttributes wa;
 251         Cursor invisible;
 252
 253         if (dpy == NULL || screen < 0 || !(lock = malloc(sizeof(struct lock))))
 254                 return NULL;
 255
 256         lock->screen = screen;
 257         lock->root = RootWindow(dpy, lock->screen);
 258
 259         for (i = 0; i < NUMCOLS; i++) {
 260                 XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen),
 261                                  colorname[i], &color, &dummy);
 262                 lock->colors[i] = color.pixel;
 263         }
 264
 265         /* init */
 266         wa.override_redirect = 1;
 267         wa.background_pixel = lock->colors[INIT];
 268         lock->win = XCreateWindow(dpy, lock->root, 0, 0,
 269                                   DisplayWidth(dpy, lock->screen),
 270                                   DisplayHeight(dpy, lock->screen),
 271                                   0, DefaultDepth(dpy, lock->screen),
 272                                   CopyFromParent,
 273                                   DefaultVisual(dpy, lock->screen),
 274                                   CWOverrideRedirect | CWBackPixel, &wa);
 275         lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8);
 276         invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap,
 277                                         &color, &color, 0, 0);
 278         XDefineCursor(dpy, lock->win, invisible);
 279
 280         /* Try to grab mouse pointer *and* keyboard for 600ms, else fail the lock */
 281         for (i = 0, ptgrab = kbgrab = -1; i < 6; i++) {
 282                 if (ptgrab != GrabSuccess) {
 283                         ptgrab = XGrabPointer(dpy, lock->root, False,
 284                                               ButtonPressMask | ButtonReleaseMask |
 285                                               PointerMotionMask, GrabModeAsync,
 286                                               GrabModeAsync, None, invisible, CurrentTime);
 287                 }
 288                 if (kbgrab != GrabSuccess) {
 289                         kbgrab = XGrabKeyboard(dpy, lock->root, True,
 290                                                GrabModeAsync, GrabModeAsync, CurrentTime);
 291                 }
 292
 293                 /* input is grabbed: we can lock the screen */
 294                 if (ptgrab == GrabSuccess && kbgrab == GrabSuccess) {
 295                         XMapRaised(dpy, lock->win);
 296                         if (rr->active)
 297                                 XRRSelectInput(dpy, lock->win, RRScreenChangeNotifyMask);
 298
 299                         XSelectInput(dpy, lock->root, SubstructureNotifyMask);
 300                         locktime = time(NULL);
 301                         return lock;
 302                 }
 303
 304                 /* retry on AlreadyGrabbed but fail on other errors */
 305                 if ((ptgrab != AlreadyGrabbed && ptgrab != GrabSuccess) ||
 306                     (kbgrab != AlreadyGrabbed && kbgrab != GrabSuccess))
 307                         break;
 308
 309                 usleep(100000);
 310         }
 311
 312         /* we couldn't grab all input: fail out */
 313         if (ptgrab != GrabSuccess)
 314                 fprintf(stderr, "slock: unable to grab mouse pointer for screen %d\n",
 315                         screen);
 316         if (kbgrab != GrabSuccess)
 317                 fprintf(stderr, "slock: unable to grab keyboard for screen %d\n",
 318                         screen);
 319         return NULL;
 320 }
 321
 322 static void
 323 usage(void)
 324 {
 325         die("usage: slock [-v] [cmd [arg ...]]\n");
 326 }
 327
 328 int
 329 main(int argc, char **argv) {
 330         struct xrandr rr;
 331         struct lock **locks;
 332         struct passwd *pwd;
 333         struct group *grp;
 334         uid_t duid;
 335         gid_t dgid;
 336         const char *hash;
 337         Display *dpy;
 338         int s, nlocks, nscreens;
 339         CARD16 standby, suspend, off;
 340
 341         ARGBEGIN {
 342         case 'v':
 343                 fprintf(stderr, "slock-"VERSION"\n");
 344                 return 0;
 345         default:
 346                 usage();
 347         } ARGEND
 348
 349         /* validate drop-user and -group */
 350         errno = 0;
 351         if (!(pwd = getpwnam(user)))
 352                 die("slock: getpwnam %s: %s\n", user,
 353                     errno ? strerror(errno) : "user entry not found");
 354         duid = pwd->pw_uid;
 355         errno = 0;
 356         if (!(grp = getgrnam(group)))
 357                 die("slock: getgrnam %s: %s\n", group,
 358                     errno ? strerror(errno) : "group entry not found");
 359         dgid = grp->gr_gid;
 360
 361 #ifdef __linux__
 362         dontkillme();
 363 #endif
 364
 365         hash = gethash();
 366         errno = 0;
 367         if (!crypt("", hash))
 368                 die("slock: crypt: %s\n", strerror(errno));
 369
 370         if (!(dpy = XOpenDisplay(NULL)))
 371                 die("slock: cannot open display\n");
 372
 373         /* drop privileges */
 374         if (setgroups(0, NULL) < 0)
 375                 die("slock: setgroups: %s\n", strerror(errno));
 376         if (setgid(dgid) < 0)
 377                 die("slock: setgid: %s\n", strerror(errno));
 378         if (setuid(duid) < 0)
 379                 die("slock: setuid: %s\n", strerror(errno));
 380
 381         /* check for Xrandr support */
 382         rr.active = XRRQueryExtension(dpy, &rr.evbase, &rr.errbase);
 383
 384         /* get number of screens in display "dpy" and blank them */
 385         nscreens = ScreenCount(dpy);
 386         if (!(locks = calloc(nscreens, sizeof(struct lock *))))
 387                 die("slock: out of memory\n");
 388         for (nlocks = 0, s = 0; s < nscreens; s++) {
 389                 if ((locks[s] = lockscreen(dpy, &rr, s)) != NULL)
 390                         nlocks++;
 391                 else
 392                         break;
 393         }
 394         XSync(dpy, 0);
 395
 396         /* did we manage to lock everything? */
 397         if (nlocks != nscreens)
 398                 return 1;
 399
 400         /* DPMS magic to disable the monitor */
 401         if (!DPMSCapable(dpy))
 402                 die("slock: DPMSCapable failed\n");
 403         if (!DPMSEnable(dpy))
 404                 die("slock: DPMSEnable failed\n");
 405         if (!DPMSGetTimeouts(dpy, &standby, &suspend, &off))
 406                 die("slock: DPMSGetTimeouts failed\n");
 407         if (!standby || !suspend || !off)
 408                 die("slock: at least one DPMS variable is zero\n");
 409         if (!DPMSSetTimeouts(dpy, monitortime, monitortime, monitortime))
 410                 die("slock: DPMSSetTimeouts failed\n");
 411
 412         XSync(dpy, 0);
 413
 414         /* run post-lock command */
 415         if (argc > 0) {
 416                 switch (fork()) {
 417                 case -1:
 418                         die("slock: fork failed: %s\n", strerror(errno));
 419                 case 0:
 420                         if (close(ConnectionNumber(dpy)) < 0)
 421                                 die("slock: close: %s\n", strerror(errno));
 422                         execvp(argv[0], argv);
 423                         fprintf(stderr, "slock: execvp %s: %s\n", argv[0], strerror(errno));
 424                         _exit(1);
 425                 }
 426         }
 427
 428         /* everything is now blank. Wait for the correct password */
 429         readpw(dpy, &rr, locks, nscreens, hash);
 430
 431         /* reset DPMS values to inital ones */
 432         DPMSSetTimeouts(dpy, standby, suspend, off);
 433         XSync(dpy, 0);
 434
 435         return 0;
 436 }