diff --git a/Utils/.gitignore b/Utils/.gitignore new file mode 100644 index 0000000..ae7e5a7 --- /dev/null +++ b/Utils/.gitignore @@ -0,0 +1 @@ +slock diff --git a/Utils/octopus.sh b/Utils/octopus.sh index b57c051..f2b156c 100755 --- a/Utils/octopus.sh +++ b/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 diff --git a/Utils/slock_bis/LICENSE b/Utils/slock_bis/LICENSE new file mode 100644 index 0000000..defc27c --- /dev/null +++ b/Utils/slock_bis/LICENSE @@ -0,0 +1,22 @@ +MIT/X Consortium License + +© 2006-2013 Anselm R Garbe +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. diff --git a/Utils/slock_bis/Makefile b/Utils/slock_bis/Makefile new file mode 100644 index 0000000..8477db4 --- /dev/null +++ b/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 diff --git a/Utils/slock_bis/TODO b/Utils/slock_bis/TODO new file mode 100644 index 0000000..d411c74 --- /dev/null +++ b/Utils/slock_bis/TODO @@ -0,0 +1 @@ +Support encrypted password ? maybe diff --git a/Utils/slock_bis/slock.c b/Utils/slock_bis/slock.c new file mode 100644 index 0000000..6b31875 --- /dev/null +++ b/Utils/slock_bis/slock.c @@ -0,0 +1,303 @@ + +/* See LICENSE file for license details. */ +#define _XOPEN_SOURCE 500 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 +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; +}