X-Git-Url: https://git.armaanb.net/?a=blobdiff_plain;f=slock.c;h=be10f5da92369dc48b0cd8cb1c003702b024ba4b;hb=ede2935e10fdab76994676d5052b571907612199;hp=0c02d964e2c9bd8ef667bf1ae6367e4801bdc094;hpb=50bc1a788e8900cb40e8a64a22ddf99393dbe788;p=slock.git diff --git a/slock.c b/slock.c index 0c02d96..be10f5d 100644 --- a/slock.c +++ b/slock.c @@ -1,8 +1,13 @@ -/* (C)opyright MMIV-MMV Anselm R. Garbe - * See LICENSE file for license details. - */ -#define _XOPEN_SOURCE +/* See LICENSE file for license details. */ +#define _XOPEN_SOURCE 500 +#if HAVE_SHADOW_H #include +#endif + +#include +#include +#include +#include #include #include #include @@ -12,95 +17,252 @@ #include #include -int -main(int argc, char **argv) { +#if HAVE_BSD_AUTH +#include +#include +#endif + +struct st_lock { + int screen; + Window root, w; + Pixmap pmap; +}; + +extern const char *__progname; + +static void +die(const char *errstr, ...) { + va_list ap; + + fprintf(stderr, "%s: ", __progname); + va_start(ap, errstr); + vfprintf(stderr, errstr, ap); + va_end(ap); + fprintf(stderr, "\n"); + fflush(stderr); + + exit(EXIT_FAILURE); +} + +#ifndef HAVE_BSD_AUTH +static const char * +get_password(void) { /* only run as root */ + const char *rval; + struct passwd *pw; + + if(geteuid() != 0) + die("cannot retrieve password entry (make sure to suid slock)"); + pw = getpwuid(getuid()); + endpwent(); + rval = pw->pw_passwd; + +#if HAVE_SHADOW_H + { + struct spwd *sp; + sp = getspnam(getenv("USER")); + endspent(); + rval = sp->sp_pwdp; + } +#endif + + /* drop privileges */ + if(setgid(pw->pw_gid) < 0 || setuid(pw->pw_uid) < 0) + die("cannot drop privileges"); + return rval; +} +#endif + +static void +#ifdef HAVE_BSD_AUTH +read_password(Display *dpy) +#else +read_password(Display *dpy, const char *pws) +#endif +{ char buf[32], passwd[256]; - int num, prev_nitem, screen; - struct spwd *sp; - unsigned int i, len; + int num; + + unsigned int len; Bool running = True; KeySym ksym; - Display *dpy; - Window w; XEvent ev; - XSetWindowAttributes wa; - if((argc > 1) && !strncmp(argv[1], "-v", 3)) { - fputs("slock-"VERSION", (C)opyright MMVI Anselm R. Garbe\n", stdout); - exit(EXIT_SUCCESS); - } - if(!(sp = getspnam(getenv("USER")))) { - fputs("slock: cannot retrieve password entry (make sure to suid slock)\n", stderr); - exit(EXIT_FAILURE); - } - endspent(); - if(!(dpy = XOpenDisplay(0))) { - fputs("slock: cannot open display\n", stderr); - exit(EXIT_FAILURE); - } - screen = DefaultScreen(dpy); - - /* init */ - passwd[0] = 0; - while(XGrabKeyboard(dpy, RootWindow(dpy, screen), True, GrabModeAsync, - GrabModeAsync, CurrentTime) != GrabSuccess) - usleep(1000); + len = 0; + running = True; - wa.override_redirect = 1; - wa.background_pixel = BlackPixel(dpy, screen); - w = XCreateWindow(dpy, RootWindow(dpy, screen), 0, 0, - DisplayWidth(dpy, screen), DisplayHeight(dpy, screen), - 0, DefaultDepth(dpy, screen), CopyFromParent, - DefaultVisual(dpy, screen), CWOverrideRedirect | CWBackPixel, &wa); - XMapRaised(dpy, w); - XSync(dpy, False); + /* As "slock" stands for "Simple X display locker", the DPMS settings + * had been removed and you can set it with "xset" or some other + * utility. This way the user can easily set a customized DPMS + * timeout. */ - /* main event loop */ - while(running && !XNextEvent(dpy, &ev)) + while(running && !XNextEvent(dpy, &ev)) { if(ev.type == KeyPress) { - len = strlen(passwd); buf[0] = 0; - num = XLookupString(&ev.xkey, buf, sizeof(buf), &ksym, 0); + num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0); + if(IsKeypadKey(ksym)) { + if(ksym == XK_KP_Enter) + ksym = XK_Return; + else if(ksym >= XK_KP_0 && ksym <= XK_KP_9) + ksym = (ksym - XK_KP_0) + XK_0; + } if(IsFunctionKey(ksym) || IsKeypadKey(ksym) || IsMiscFunctionKey(ksym) || IsPFKey(ksym) || IsPrivateKeypadKey(ksym)) continue; - /* first check if a control mask is omitted */ - if(ev.xkey.state & ControlMask) { - switch (ksym) { - case XK_h: - case XK_H: ksym = XK_BackSpace; - break; - case XK_u: - case XK_U: passwd[0] = 0; - continue; - } - } switch(ksym) { case XK_Return: - if((running = strncmp(crypt(passwd, sp->sp_pwdp), sp->sp_pwdp, sizeof(passwd)))) + passwd[len] = 0; +#ifdef HAVE_BSD_AUTH + running = !auth_userokay(getlogin(), NULL, "auth-xlock", passwd); +#else + running = strcmp(crypt(passwd, pws), pws); +#endif + if (running != 0) XBell(dpy, 100); - passwd[0] = 0; + len = 0; break; case XK_Escape: - passwd[0] = 0; + len = 0; break; case XK_BackSpace: if(len) - passwd[--len] = 0; + --len; break; default: - if(num && !iscntrl((int) buf[0])) { - buf[num] = 0; - if(len) - strncat(passwd, buf, sizeof(passwd)); - else - strncpy(passwd, buf, sizeof(passwd)); + if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) { + memcpy(passwd + len, buf, num); + len += num; } break; } } - XDestroyWindow(dpy, w); + } +} + +static void +unlockscreen(Display *dpy, struct st_lock *lock) { + if (dpy == NULL || lock == NULL) + return; + + XUngrabPointer(dpy, CurrentTime); + XFreePixmap(dpy, lock->pmap); + XDestroyWindow(dpy, lock->w); + + free(lock); +} + +static struct st_lock * +lockscreen(Display *dpy, int screen) { + char curs[] = {0, 0, 0, 0, 0, 0, 0, 0}; + unsigned int len; + struct st_lock *lock; + Bool running = True; + XColor black, dummy; + XSetWindowAttributes wa; + Cursor invisible; + + if (dpy == NULL || screen < 0) + return NULL; + + lock = malloc(sizeof(struct st_lock)); + if (lock == NULL) + return NULL; + + lock->screen = screen; + + lock->root = RootWindow(dpy, lock->screen); + + /* init */ + wa.override_redirect = 1; + wa.background_pixel = BlackPixel(dpy, lock->screen); + lock->w = XCreateWindow(dpy, lock->root, 0, 0, DisplayWidth(dpy, lock->screen), DisplayHeight(dpy, lock->screen), + 0, DefaultDepth(dpy, lock->screen), CopyFromParent, + DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa); + XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), "black", &black, &dummy); + lock->pmap = XCreateBitmapFromData(dpy, lock->w, curs, 8, 8); + invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &black, &black, 0, 0); + XDefineCursor(dpy, lock->w, invisible); + XMapRaised(dpy, lock->w); + for(len = 1000; len; len--) { + if(XGrabPointer(dpy, lock->root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask, + GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess) + break; + usleep(1000); + } + if((running = running && (len > 0))) { + for(len = 1000; len; len--) { + if(XGrabKeyboard(dpy, lock->root, True, GrabModeAsync, GrabModeAsync, CurrentTime) + == GrabSuccess) + break; + usleep(1000); + } + running = (len > 0); + } + + if (!running) { + unlockscreen(dpy, lock); + lock = NULL; + } + + return lock; +} + +static void +usage(void) { + fprintf(stderr, "usage: %s -v", __progname); + exit(EXIT_FAILURE); +} + +int +main(int argc, char **argv) { +#ifndef HAVE_BSD_AUTH + const char *pws; +#endif + Display *dpy; + int nscreens, screen; + + struct st_lock **locks; + + if((argc == 2) && !strcmp("-v", argv[1])) + die("slock-%s, © 2006-2008 Anselm R Garbe", VERSION); + else if(argc != 1) + usage(); + + if(!getpwuid(getuid())) + die("no passwd entry for you"); + +#ifndef HAVE_BSD_AUTH + pws = get_password(); +#endif + + if(!(dpy = XOpenDisplay(0))) + die("cannot open display"); + + /* Get the number of screens in display "dpy" and blank them all. */ + nscreens = ScreenCount(dpy); + locks = malloc(sizeof(struct st_lock *) * nscreens); + if (locks == NULL) + die("malloc: %s", strerror(errno)); + + for (screen = 0; screen < nscreens; screen++) + locks[screen] = lockscreen(dpy, screen); + + XSync(dpy, False); + + /* Everything is now blank. Now wait for the correct password. */ +#ifdef HAVE_BSD_AUTH + read_password(dpy); +#else + read_password(dpy, pws); +#endif + + /* Password ok, unlock everything and quit. */ + for (screen = 0; screen < nscreens; screen++) + unlockscreen(dpy, locks[screen]); + + free(locks); + XCloseDisplay(dpy); + return 0; }