/* screenlock - lock a terminal */
#include <u.h>
#include <libc.h>
#include <libsec.h>
#include <draw.h>
#include <thread.h>
#include <auth.h>

char pic[] = "/lib/bunny.bit";

int vgactl;
int debug;
int doblank;
int chatty = 0;

char user[256];

void
blankscreen(int blank)
{
	if(vgactl < 0)
		return;
	seek(vgactl, 0, 0);
	if(fprint(vgactl, blank? "blank": "unblank") < 0)
		fprint(2, "blankscreen: can't blank: %r\n");
}

void
error(char *fmt, ...)
{
	Fmt f;
	char buf[64];
	va_list arg;

	fmtfdinit(&f, 1, buf, sizeof buf);
	fmtprint(&f, "screenlock: ");
	va_start(arg, fmt);
	fmtvprint(&f, fmt, arg);
	va_end(arg);
	fmtprint(&f, "\n");
	fmtfdflush(&f);
	threadexitsall("fatal error");
}

void
usage(void)
{
	fprint(2, "usage: %s\n", argv0);
	exits("usage");
}


void
readfile(char *name, char *buf, int nbuf, int addnul)
{
	int fd;

	fd = open(name, OREAD);
	if(fd == -1)
		error("%s - can't open: %r", name);
	nbuf = read(fd, buf, nbuf-addnul);
	close(fd);
	if(nbuf == -1)
		error("%s - can't can't read: %r", name);
	if(addnul)
		buf[nbuf] = '\0';
}

void
readline(char *buf, int nbuf)
{
	char c;
	int i;

	i = 0;
	while(i < nbuf-1)
		if(read(0, &c, 1) != 1 || c == '\04' || c == '\177'){
			i = 0;
			break;
		} else if(c == '\n')
			break;
		else if(c == '\b' && i > 0)
			--i;
		else if(c == ('u' & 037))
			i = 0;
		else
			buf[i++] = c;
	buf[i] = '\0';
}

void
checkpassword(void)
{
	int fd, consctl, must;
	char buf[256];
	AuthInfo *ai;
	static int opened;

	must = 1;
	if(!opened){
		fd = open("/dev/cons", OREAD);
		if(fd == -1)
			error("can't open cons: %r");
		dup(fd, 0);
		close(fd);
		fd = open("/dev/cons", OWRITE);
		if(fd == -1)
			error("can't open cons: %r");
		dup(fd, 1);
		dup(1, 2);
		close(fd);
		consctl = open("/dev/consctl", OWRITE);
		if(consctl == -1)
			error("can't open consctl: %r");
		if(write(consctl, "rawon", 5) != 5)
			error("can't turn off echo\n");
		opened = 1;
	}

	for(;;){
		if(chatty || !must)
			fprint(2, "%s's screenlock password: ", user);
		memset(buf, 0, sizeof buf);
		readline(buf, sizeof buf);
		blankscreen(0);
		if(chatty || !must)
			fprint(2, "\n");
		if(buf[0] == '\0' || buf[0] == '\04'){
			if(must)
				continue;
			error("no password typed");
		}

		/* authenticate */
		ai = auth_userpasswd(user, buf);
		if(ai != nil && ai->cap != nil)
			break;
		auth_freeAI(ai);

		if(chatty || !must)
			fprint(2, "password mismatch\n");
		doblank = 1;
	}
	memset(buf, 0, sizeof buf);
	blankscreen(0);
}

void
blanker(void *)
{
	int tics;

	tics = 0;
	for(;;){
		if(doblank > 0){
			doblank = 0;
			tics = 10;
		}
		if(tics > 0 && --tics == 0)
			blankscreen(1);
		sleep(1000);
	}
}

void
grabmouse(void*)
{
	int fd, x, y;
	char ibuf[256], obuf[256];

	if(debug)
		return;
	fd = open("/dev/mouse", ORDWR);
	if(fd < 0)
		error("can't open /dev/mouse: %r");

	snprint(obuf, sizeof obuf, "m %d %d",
		screen->r.min.x + Dx(screen->r)/2,
		screen->r.min.y + Dy(screen->r)/2);
	while(read(fd, ibuf, sizeof ibuf) > 0){
		ibuf[12] = 0;
		ibuf[24] = 0;
		x = atoi(ibuf+1);
		y = atoi(ibuf+13);
		if(x != screen->r.min.x + Dx(screen->r)/2 ||
		   y != screen->r.min.y + Dy(screen->r)/2){
			fprint(fd, "%s", obuf);
			doblank = 1;
		}
	}
}

/* lay down text at `p' */
static void
screenstring(Point p, char *s)
{
	string(screen, p, screen->display->white, ZP, font, s);
	flushimage(display, 1);
}

void
lockscreen(void)
{
	enum { Nfld = 5, Fldlen = 12, Cursorlen = 2*4 + 2*2*16, };
	char *s;
	char buf[Nfld*Fldlen], *flds[Nfld], newcmd[128], cbuf[Cursorlen];
	int fd, dx, dy;
	Image *i;
	Point p;
	Rectangle r;
	Tm *tm;

	fd = open("/dev/screen", OREAD);
	if(fd < 0)
		error("can't open /dev/screen: %r");
	if(read(fd, buf, Nfld*Fldlen) != Nfld*Fldlen)
		error("can't read /dev/screen: %r");
	close(fd);
	buf[sizeof buf-1] = 0;
	if(tokenize(buf, flds, Nfld) != Nfld)
		error("can't tokenize /dev/screen header");
	snprint(newcmd, sizeof newcmd, "-r %s %s %d %d",
		flds[1], flds[2], atoi(flds[3]) - 1, atoi(flds[4]) - 1);
	newwindow(newcmd);
	if (initdraw(nil, nil, "screenlock") < 0)
		sysfatal("initdraw failed");
	if(display == nil)
		error("no display");

	/* screen is now open and covered.  grab mouse and hold on tight */
	procrfork(grabmouse, nil, 4096, RFFDG);
	procrfork(blanker, nil, 4096, RFFDG);
	fd = open(pic, OREAD);
	if(fd > 0){
		i = readimage(display, fd, 0);
		if(i){
 			r = screen->r;
			p = Pt(r.max.x / 2, r.max.y * 2 / 3); 
			dx = (Dx(screen->r) - Dx(i->r)) / 2;
			r.min.x += dx;
			r.max.x -= dx;
			dy = (Dy(screen->r) - Dy(i->r)) / 2;
			r.min.y += dy;
			r.max.y -= dy;
			draw(screen, screen->r, display->black, nil, ZP);
			draw(screen, r, i, nil, i->r.min);
			flushimage(display, 1);
		}
		close(fd);

		/* identify the user on screen, centered */
		tm = localtime(time(0));
		s = smprint("user %s at %d:%2d", getuser(), tm->hour, tm->min);
		p = subpt(p, Pt(stringsize(font, "m").x * strlen(s) / 2, 0));
		screenstring(p, s);
	}

	/* clear the cursor */
	fd = open("/dev/cursor", OWRITE);
	if(fd > 0){
		memset(cbuf, 0, sizeof cbuf);
		write(fd, cbuf, sizeof cbuf);
		/* leave it open */
	}
}

void
threadmain(int argc, char *argv[])
{
	readfile("#c/user", user, sizeof user, 1);

	if((vgactl = open("/dev/vgactl", OWRITE)) < 0)
		vgactl = open("#v/vgactl", OWRITE);

	ARGBEGIN{
	case 'd':
		debug++;
		break;
	default:
		usage();
	}ARGEND

	if(argc != 0)
		usage();

	doblank = 1;
	lockscreen();
	checkpassword();
	threadexitsall(nil);
}