applied Dimitris' style patch from Dec'14, with some minor modifications - slock - simple X display locker utility
 (HTM) git clone git://git.suckless.org/slock
 (DIR) Log
 (DIR) Files
 (DIR) Refs
 (DIR) README
 (DIR) LICENSE
       ---
 (DIR) commit a31b9191111572dafaa8366415b89a4472aa4626
 (DIR) parent 66e31556db4921b5f24ced47dae5e1c7ea3bd150
 (HTM) Author: Anselm R Garbe <garbeam@gmail.com>
       Date:   Tue, 27 Jan 2015 22:16:52 +0100
       
       applied Dimitris' style patch from Dec'14, with some minor modifications
       
       Diffstat:
         M slock.c                             |     112 +++++++++++++++++--------------
       
       1 file changed, 60 insertions(+), 52 deletions(-)
       ---
 (DIR) diff --git a/slock.c b/slock.c
       @@ -1,4 +1,3 @@
       -
        /* See LICENSE file for license details. */
        #define _XOPEN_SOURCE 500
        #if HAVE_SHADOW_H
       @@ -37,20 +36,22 @@ static int nscreens;
        static Bool running = True;
        
        static void
       -die(const char *errstr, ...) {
       +die(const char *errstr, ...)
       +{
                va_list ap;
        
                va_start(ap, errstr);
                vfprintf(stderr, errstr, ap);
                va_end(ap);
       -        exit(EXIT_FAILURE);
       +        exit(1);
        }
        
        #ifdef __linux__
        #include <fcntl.h>
        
        static void
       -dontkillme(void) {
       +dontkillme(void)
       +{
                int fd;
        
                fd = open("/proc/self/oom_score_adj", O_WRONLY);
       @@ -62,8 +63,10 @@ dontkillme(void) {
        #endif
        
        #ifndef HAVE_BSD_AUTH
       +/* only run as root */
        static const char *
       -getpw(void) { /* only run as root */
       +getpw(void)
       +{
                const char *rval;
                struct passwd *pw;
        
       @@ -73,7 +76,7 @@ getpw(void) { /* only run as root */
                        if (errno)
                                die("slock: getpwuid: %s\n", strerror(errno));
                        else
       -                        die("slock: cannot retrieve password entry (make sure to suid or sgid slock)\n");
       +                        die("slock: cannot retrieve password entry\n");
                }
                rval =  pw->pw_passwd;
        
       @@ -81,15 +84,15 @@ getpw(void) { /* only run as root */
                if (rval[0] == 'x' && rval[1] == '\0') {
                        struct spwd *sp;
                        sp = getspnam(getenv("USER"));
       -                if(!sp)
       +                if (!sp)
                                die("slock: cannot retrieve shadow entry (make sure to suid or sgid slock)\n");
                        rval = sp->sp_pwdp;
                }
        #endif
        
                /* drop privileges */
       -        if (geteuid() == 0
       -           && ((getegid() != pw->pw_gid && setgid(pw->pw_gid) < 0) || setuid(pw->pw_uid) < 0))
       +        if (geteuid() == 0 &&
       +            ((getegid() != pw->pw_gid && setgid(pw->pw_gid) < 0) || setuid(pw->pw_uid) < 0))
                        die("slock: cannot drop privileges\n");
                return rval;
        }
       @@ -115,21 +118,23 @@ readpw(Display *dpy, const char *pws)
                 * 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. */
       -        while(running && !XNextEvent(dpy, &ev)) {
       -                if(ev.type == KeyPress) {
       +        while (running && !XNextEvent(dpy, &ev)) {
       +                if (ev.type == KeyPress) {
                                buf[0] = 0;
                                num = XLookupString(&ev.xkey, buf, sizeof buf, &ksym, 0);
       -                        if(IsKeypadKey(ksym)) {
       -                                if(ksym == XK_KP_Enter)
       +                        if (IsKeypadKey(ksym)) {
       +                                if (ksym == XK_KP_Enter)
                                                ksym = XK_Return;
       -                                else if(ksym >= XK_KP_0 && ksym <= XK_KP_9)
       +                                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))
       +                        if (IsFunctionKey(ksym) ||
       +                            IsKeypadKey(ksym) ||
       +                            IsMiscFunctionKey(ksym) ||
       +                            IsPFKey(ksym) ||
       +                            IsPrivateKeypadKey(ksym))
                                        continue;
       -                        switch(ksym) {
       +                        switch (ksym) {
                                case XK_Return:
                                        passwd[len] = 0;
        #ifdef HAVE_BSD_AUTH
       @@ -137,7 +142,7 @@ readpw(Display *dpy, const char *pws)
        #else
                                        running = !!strcmp(crypt(passwd, pws), pws);
        #endif
       -                                if(running)
       +                                if (running)
                                                XBell(dpy, 100);
                                        len = 0;
                                        break;
       @@ -145,36 +150,37 @@ readpw(Display *dpy, const char *pws)
                                        len = 0;
                                        break;
                                case XK_BackSpace:
       -                                if(len)
       +                                if (len)
                                                --len;
                                        break;
                                default:
       -                                if(num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
       +                                if (num && !iscntrl((int) buf[0]) && (len + num < sizeof passwd)) {
                                                memcpy(passwd + len, buf, num);
                                                len += num;
                                        }
                                        break;
                                }
       -                        if(llen == 0 && len != 0) {
       -                                for(screen = 0; screen < nscreens; screen++) {
       +                        if (llen == 0 && len != 0) {
       +                                for (screen = 0; screen < nscreens; screen++) {
                                                XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[1]);
                                                XClearWindow(dpy, locks[screen]->win);
                                        }
       -                        } else if(llen != 0 && len == 0) {
       -                                for(screen = 0; screen < nscreens; screen++) {
       +                        } else if (llen != 0 && len == 0) {
       +                                for (screen = 0; screen < nscreens; screen++) {
                                                XSetWindowBackground(dpy, locks[screen]->win, locks[screen]->colors[0]);
                                                XClearWindow(dpy, locks[screen]->win);
                                        }
                                }
                                llen = len;
                        }
       -                else for(screen = 0; screen < nscreens; screen++)
       +                else for (screen = 0; screen < nscreens; screen++)
                                XRaiseWindow(dpy, locks[screen]->win);
                }
        }
        
        static void
       -unlockscreen(Display *dpy, Lock *lock) {
       +unlockscreen(Display *dpy, Lock *lock)
       +{
                if(dpy == NULL || lock == NULL)
                        return;
        
       @@ -187,7 +193,8 @@ unlockscreen(Display *dpy, Lock *lock) {
        }
        
        static Lock *
       -lockscreen(Display *dpy, int screen) {
       +lockscreen(Display *dpy, int screen)
       +{
                char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
                unsigned int len;
                Lock *lock;
       @@ -195,11 +202,11 @@ lockscreen(Display *dpy, int screen) {
                XSetWindowAttributes wa;
                Cursor invisible;
        
       -        if(dpy == NULL || screen < 0)
       +        if (dpy == NULL || screen < 0)
                        return NULL;
        
                lock = malloc(sizeof(Lock));
       -        if(lock == NULL)
       +        if (lock == NULL)
                        return NULL;
        
                lock->screen = screen;
       @@ -210,8 +217,8 @@ lockscreen(Display *dpy, int screen) {
                wa.override_redirect = 1;
                wa.background_pixel = BlackPixel(dpy, lock->screen);
                lock->win = 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);
       +                                  0, DefaultDepth(dpy, lock->screen), CopyFromParent,
       +                                  DefaultVisual(dpy, lock->screen), CWOverrideRedirect | CWBackPixel, &wa);
                XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR2, &color, &dummy);
                lock->colors[1] = color.pixel;
                XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR1, &color, &dummy);
       @@ -220,36 +227,37 @@ lockscreen(Display *dpy, int screen) {
                invisible = XCreatePixmapCursor(dpy, lock->pmap, lock->pmap, &color, &color, 0, 0);
                XDefineCursor(dpy, lock->win, invisible);
                XMapRaised(dpy, lock->win);
       -        for(len = 1000; len; len--) {
       -                if(XGrabPointer(dpy, lock->root, False, ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
       -                        GrabModeAsync, GrabModeAsync, None, invisible, CurrentTime) == GrabSuccess)
       +        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 && (len > 0)) {
       -                for(len = 1000; len; len--) {
       -                        if(XGrabKeyboard(dpy, lock->root, True, GrabModeAsync, GrabModeAsync, CurrentTime)
       -                                == GrabSuccess)
       +        if (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) {
       +        if (!running) {
                        unlockscreen(dpy, lock);
                        lock = NULL;
                }
       -        else 
       +        else {
                        XSelectInput(dpy, lock->root, SubstructureNotifyMask);
       +        }
        
                return lock;
        }
        
        static void
       -usage(void) {
       +usage(void)
       +{
                fprintf(stderr, "usage: slock [-v]\n");
       -        exit(EXIT_FAILURE);
       +        exit(1);
        }
        
        int
       @@ -260,38 +268,38 @@ main(int argc, char **argv) {
                Display *dpy;
                int screen;
        
       -        if((argc == 2) && !strcmp("-v", argv[1]))
       -                die("slock-%s, © 2006-2014 slock engineers\n", VERSION);
       -        else if(argc != 1)
       +        if ((argc == 2) && !strcmp("-v", argv[1]))
       +                die("slock-%s, © 2006-2015 slock engineers\n", VERSION);
       +        else if (argc != 1)
                        usage();
        
        #ifdef __linux__
                dontkillme();
        #endif
        
       -        if(!getpwuid(getuid()))
       +        if (!getpwuid(getuid()))
                        die("slock: no passwd entry for you\n");
        
        #ifndef HAVE_BSD_AUTH
                pws = getpw();
        #endif
        
       -        if(!(dpy = XOpenDisplay(0)))
       +        if (!(dpy = XOpenDisplay(0)))
                        die("slock: cannot open display\n");
                /* Get the number of screens in display "dpy" and blank them all. */
                nscreens = ScreenCount(dpy);
                locks = malloc(sizeof(Lock *) * nscreens);
       -        if(locks == NULL)
       +        if (locks == NULL)
                        die("slock: malloc: %s\n", strerror(errno));
                int nlocks = 0;
       -        for(screen = 0; screen < nscreens; screen++) {
       +        for (screen = 0; screen < nscreens; screen++) {
                        if ( (locks[screen] = lockscreen(dpy, screen)) != NULL)
                                nlocks++;
                }
                XSync(dpy, False);
        
                /* Did we actually manage to lock something? */
       -        if (nlocks == 0) { // nothing to protect
       +        if (nlocks == 0) { /* nothing to protect */
                        free(locks);
                        XCloseDisplay(dpy);
                        return 1;
       @@ -305,7 +313,7 @@ main(int argc, char **argv) {
        #endif
        
                /* Password ok, unlock everything and quit. */
       -        for(screen = 0; screen < nscreens; screen++)
       +        for (screen = 0; screen < nscreens; screen++)
                        unlockscreen(dpy, locks[screen]);
        
                free(locks);