slock modified version

Utils/.gitignore

@@ -0,0 +1 @@
+slock

Utils/octopus.sh

@@ -137,11 +137,12 @@ case $1 in
 
 	"suspend")
 		systemctl suspend
-		xlock -mode blank
+		slock
 		;;
 
 	"lock")
-		xlock -mode blank -dpmsoff 1
+		xset dpms force off
+		slock
 		;;
 
 esac

Utils/slock_bis/LICENSE

@@ -0,0 +1,22 @@
+MIT/X Consortium License
+
+© 2006-2013 Anselm R Garbe <anselm@garbe.us>
+Modified by Frank Villaro-Dixon for reading pwd from file
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

Utils/slock_bis/Makefile

@@ -0,0 +1,7 @@
+LIBS= -L/usr/X11R6/lib -lX11 -lXext
+INCS= -I/usr/X11R6/include
+
+LDFLAGS= -s ${LIBS}
+
+all:
+	$(CC) $(LDFLAGS) $(INCS) slock.c -o ../slock

Utils/slock_bis/TODO

@@ -0,0 +1 @@
+Support encrypted password ? maybe

Utils/slock_bis/slock.c

@@ -0,0 +1,303 @@
+
+/* See LICENSE file for license details. */
+#define _XOPEN_SOURCE 500
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <X11/keysym.h>
+#include <X11/Xlib.h>
+#include <X11/Xutil.h>
+
+#define PWD_MAX_LEN 100
+
+#define COLOR1 "black"
+#define COLOR2 "#FF0000"
+#define VERSION "42.1337"
+
+typedef struct {
+	int screen;
+	Window root, win;
+	Pixmap pmap;
+	unsigned long colors[2];
+} Lock;
+
+static Lock **locks;
+static int nscreens;
+static Bool running = True;
+
+static void
+die(const char *errstr, ...) {
+	va_list ap;
+
+	va_start(ap, errstr);
+	vfprintf(stderr, errstr, ap);
+	va_end(ap);
+	exit(EXIT_FAILURE);
+}
+
+#ifdef __linux__
+#include <fcntl.h>
+static void
+dontkillme(void) {
+	int fd;
+
+	fd = open("/proc/self/oom_score_adj", O_WRONLY);
+	if (fd < 0 && errno == ENOENT)
+		return;
+	if (fd < 0 || write(fd, "-1000\n", 6) != 6 || close(fd) != 0)
+		die("cannot disable the out-of-memory killer for this process\n");
+}
+#endif
+
+char *
+getpw(void) {
+	FILE *pwd_file;
+	char *pwd;
+
+	if(!(pwd = malloc(PWD_MAX_LEN * sizeof(*pwd)))) {
+		die("could not malloc memory");
+	}
+
+#define PWD_FILE "/home/frank/Private/.lock_pwd"
+	pwd_file = fopen(PWD_FILE, "r");
+	if(!pwd_file) {
+		die("Could not open "PWD_FILE" for reading\n");
+	}
+
+	fgets(pwd, PWD_MAX_LEN, pwd_file);
+	if(pwd[strlen(pwd)-1] == '\n')
+		pwd[strlen(pwd)-1] = '\0';
+	if(strlen(pwd) <= 1) {
+		die("Password seems to short: %s\n", pwd);
+	}
+	fclose(pwd_file);
+
+	return pwd;
+
+}
+
+static void
+readpw(Display *dpy, char *pws)
+{
+	char buf[32], passwd[256];
+	int num, screen;
+	unsigned int len, llen;
+	KeySym ksym;
+	XEvent ev;
+
+	len = llen = 0;
+	running = True;
+
+	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)
+					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;
+
+			switch(ksym) {
+			case XK_Return:
+				passwd[len] = 0;
+				running = !!strcmp(passwd, pws);
+				if(running)
+					XBell(dpy, 100);
+				len = 0;
+				break;
+			case XK_Escape:
+				len = 0;
+				break;
+			case XK_BackSpace:
+				if(len)
+					--len;
+				break;
+			default:
+				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++) {
+					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++) {
+					XSetWindowBackground(dpy,
+					                     locks[screen]->win,
+					                     locks[screen]->colors[0]);
+					XClearWindow(dpy, locks[screen]->win);
+				}
+			}
+			llen = len;
+		}
+		else for(screen = 0; screen < nscreens; screen++)
+			XRaiseWindow(dpy, locks[screen]->win);
+	}
+}
+
+static void
+unlockscreen(Display *dpy, Lock *lock)
+{
+	if(dpy == NULL || lock == NULL)
+		return;
+
+	XUngrabPointer(dpy, CurrentTime);
+	XFreeColors(dpy, DefaultColormap(dpy, lock->screen), lock->colors, 2, 0);
+	XFreePixmap(dpy, lock->pmap);
+	XDestroyWindow(dpy, lock->win);
+
+	free(lock);
+}
+
+static Lock *
+lockscreen(Display *dpy, int screen)
+{
+	char curs[] = {0, 0, 0, 0, 0, 0, 0, 0};
+	unsigned int len;
+	Lock *lock;
+	XColor color, dummy;
+	XSetWindowAttributes wa;
+	Cursor invisible;
+
+	if(dpy == NULL || screen < 0)
+		return NULL;
+
+	lock = malloc(sizeof(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->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);
+
+	XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR2,
+	                 &color, &dummy);
+	lock->colors[1] = color.pixel;
+
+	XAllocNamedColor(dpy, DefaultColormap(dpy, lock->screen), COLOR1,
+	                 &color, &dummy);
+	lock->colors[0] = color.pixel;
+
+	lock->pmap = XCreateBitmapFromData(dpy, lock->win, curs, 8, 8);
+	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)
+			break;
+		usleep(1000);
+	}
+	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) {
+		unlockscreen(dpy, lock);
+		lock = NULL;
+	}
+	else 
+		XSelectInput(dpy, lock->root, SubstructureNotifyMask);
+
+	return lock;
+}
+
+static void
+usage(void) {
+	fprintf(stderr, "usage: slock [-v]\n");
+	exit(EXIT_FAILURE);
+}
+
+int
+main(int argc, char **argv) {
+	char *pws;
+	Display *dpy;
+	int screen;
+
+	if((argc == 2) && !strcmp("-v", argv[1]))
+		die("slock-%s, © 2006-2012 Anselm R Garbe\n", VERSION);
+	else if(argc != 1)
+		usage();
+
+#ifdef __linux__
+	//dontkillme();
+#endif
+
+	pws = getpw();
+
+	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)
+		die("slock: malloc: %s\n", strerror(errno));
+
+	int nlocks = 0;
+	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
+		free(locks);
+		XCloseDisplay(dpy);
+		return 1;
+	}
+
+	/* Everything is now blank. Now wait for the correct password. */
+	readpw(dpy, pws);
+
+	/* Password ok, unlock everything and quit. */
+	for(screen = 0; screen < nscreens; screen++)
+		unlockscreen(dpy, locks[screen]);
+
+	free(locks);
+	free(pws);
+	XCloseDisplay(dpy);
+
+	return 0;
+}