ref: fe1eb39db7ae6904924f3ab1f6f9b34416f2eb1b
dir: /sys/src/cmd/auth/factotum/fgui.c/
#include "dat.h"
#include <draw.h>
#include <mouse.h>
#include <keyboard.h>
#include <control.h>
int ctldeletequits = 1;
typedef struct RequestType RequestType;
typedef struct Request Request;
typedef struct Memory Memory;
struct RequestType
{
char *file; /* file to read requests from */
void (*f)(Request*); /* request handler */
void (*r)(Controlset*); /* resize handler */
int fd; /* fd = open(file, ORDWR) */
Channel *rc; /* channel requests are multiplexed to */
Controlset *cs;
};
struct Request
{
RequestType *rt;
Attr *a;
Attr *tag;
};
struct Memory
{
Memory *next;
Attr *a;
Attr *val;
};
Memory *mem;
static void readreq(void*);
static void hide(void);
static void unhide(void);
static void openkmr(void);
static void closekmr(void);
static Memory* searchmem(Attr*);
static void addmem(Attr*, Attr*);
static void confirm(Request*);
static void resizeconfirm(Controlset*);
static void needkey(Request*);
static void resizeneedkey(Controlset*);
Control *b_remember;
Control *b_accept;
Control *b_refuse;
RequestType rt[] =
{
{ "/mnt/factotum/confirm", confirm, resizeconfirm, },
{ "/mnt/factotum/needkey", needkey, resizeneedkey, },
{ 0 },
};
enum
{
ButtonDim= 15,
};
void
threadmain(int argc, char *argv[])
{
Request r;
Channel *rc;
RequestType *p;
Font *invis;
ARGBEGIN{
}ARGEND;
if(newwindow("-hide") < 0)
sysfatal("newwindow: %r");
fmtinstall('A', _attrfmt);
/* create the proc's that read */
rc = chancreate(sizeof(Request), 0);
for(p = rt; p->file != 0; p++){
p->fd = -1;
p->rc = rc;
proccreate(readreq, p, 16*1024);
}
/* gui initialization */
if(initdraw(0, 0, "auth/fgui") < 0)
sysfatal("initdraw failed: %r");
initcontrols();
hide();
/* get an invisible font for passwords */
invis = openfont(display, "/lib/font/bit/lucm/passwd.9.font");
if (invis == nil)
sysfatal("fgui: %s: %r", "/lib/font/bit/lucm/passwd.9.font");
namectlfont(invis, "invisible");
/* serialize all requests */
for(;;){
if(recv(rc, &r) < 0)
break;
(*r.rt->f)(&r);
_freeattr(r.a);
_freeattr(r.tag);
}
threadexitsall(nil);
}
/*
* read requests and pass them to the main loop
*/
enum
{
Requestlen=4096,
};
static void
readreq(void *a)
{
RequestType *rt = a;
char *buf, *p;
int n;
Request r;
Attr **l;
rt->fd = open(rt->file, ORDWR);
if(rt->fd < 0)
sysfatal("opening %s: %r", rt->file);
rt->cs = nil;
buf = malloc(Requestlen);
if(buf == nil)
sysfatal("allocating read buffer: %r");
r.rt = rt;
for(;;){
n = read(rt->fd, buf, Requestlen-1);
if(n < 0)
break;
buf[n] = 0;
/* skip verb, parse attributes, and remove tag */
p = strchr(buf, ' ');
if(p != nil)
p++;
else
p = buf;
r.a = _parseattr(p);
/* separate out the tag */
r.tag = nil;
for(l = &r.a; *l != nil; l = &(*l)->next)
if(strcmp((*l)->name, "tag") == 0){
r.tag = *l;
*l = r.tag->next;
r.tag->next = nil;
break;
}
/* if no tag, forget it */
if(r.tag == nil){
_freeattr(r.a);
continue;
}
send(rt->rc, &r);
}
}
#ifdef asdf
static void
readreq(void *a)
{
RequestType *rt = a;
char *buf, *p;
int n;
Request r;
rt->fd = -1;
rt->cs = nil;
buf = malloc(Requestlen);
if(buf == nil)
sysfatal("allocating read buffer: %r");
r.rt = rt;
for(;;){
strcpy(buf, "adfasdf=afdasdf asdfasdf=asdfasdf");
r.a = _parseattr(buf);
send(rt->rc, &r);
sleep(5000);
}
}
#endif asdf
/*
* open/close the keyboard, mouse and resize channels
*/
static Channel *kbdc;
static Channel *mousec;
static Channel *resizec;
static Keyboardctl *kctl;
static Mousectl *mctl;
static void
openkmr(void)
{
/* get channels for subsequent newcontrolset calls */
kctl = initkeyboard(nil);
if(kctl == nil)
sysfatal("can't initialize keyboard: %r");
kbdc = kctl->c;
mctl = initmouse(nil, screen);
if(mctl == nil)
sysfatal("can't initialize mouse: %r");
mousec = mctl->c;
resizec = mctl->resizec;
}
static void
closekmr(void)
{
Mouse m;
while(nbrecv(kbdc, &m) > 0)
;
closekeyboard(kctl);
while(nbrecv(mousec, &m) > 0)
;
closemouse(mctl);
}
/*
* called when the window is resized
*/
void
resizecontrolset(Controlset *cs)
{
RequestType *p;
for(p = rt; p->file != 0; p++){
if(p->cs == cs){
(*p->r)(cs);
break;
}
}
}
/*
* hide window when not in use
*/
static void
unhide(void)
{
int wctl;
wctl = open("/dev/wctl", OWRITE);
if(wctl < 0)
return;
fprint(wctl, "unhide");
close(wctl);
}
static void
hide(void)
{
int wctl;
int tries;
wctl = open("/dev/wctl", OWRITE);
if(wctl < 0)
return;
for(tries = 0; tries < 10; tries++){
if(fprint(wctl, "hide") >= 0)
break;
sleep(100);
}
close(wctl);
}
/*
* set up the controls for the confirmation window
*/
static Channel*
setupconfirm(Request *r)
{
Controlset *cs;
Channel *c;
Attr *a;
/* create a new control set for the confirmation */
openkmr();
cs = newcontrolset(screen, kbdc, mousec, resizec);
createtext(cs, "msg");
chanprint(cs->ctl, "msg image paleyellow");
chanprint(cs->ctl, "msg border 1");
chanprint(cs->ctl, "msg add 'The following key is being used:'");
for(a = r->a; a != nil; a = a->next)
chanprint(cs->ctl, "msg add ' %s = %s'", a->name,
a->val);
namectlimage(display->white, "i_white");
namectlimage(display->black, "i_black");
b_remember = createbutton(cs, "b_remember");
chanprint(cs->ctl, "b_remember border 1");
chanprint(cs->ctl, "b_remember mask i_white");
chanprint(cs->ctl, "b_remember image i_white");
chanprint(cs->ctl, "b_remember light i_black");
createtext(cs, "t_remember");
chanprint(cs->ctl, "t_remember image white");
chanprint(cs->ctl, "t_remember bordercolor white");
chanprint(cs->ctl, "t_remember add 'Remember this answer for future confirmations'");
b_accept = createtextbutton(cs, "b_accept");
chanprint(cs->ctl, "b_accept border 1");
chanprint(cs->ctl, "b_accept align center");
chanprint(cs->ctl, "b_accept text Accept");
chanprint(cs->ctl, "b_accept image i_white");
chanprint(cs->ctl, "b_accept light i_black");
b_refuse = createtextbutton(cs, "b_refuse");
chanprint(cs->ctl, "b_refuse border 1");
chanprint(cs->ctl, "b_refuse align center");
chanprint(cs->ctl, "b_refuse text Refuse");
chanprint(cs->ctl, "b_refuse image i_white");
chanprint(cs->ctl, "b_refuse light i_black");
c = chancreate(sizeof(char*), 0);
controlwire(b_remember, "event", c);
controlwire(b_accept, "event", c);
controlwire(b_refuse, "event", c);
/* make the controls interactive */
activate(b_remember);
activate(b_accept);
activate(b_refuse);
r->rt->cs = cs;
unhide();
resizecontrolset(cs);
return c;
}
/*
* resize the controls for the confirmation window
*/
static void
resizeconfirm(Controlset *cs)
{
Rectangle r, mr, nr, ntr, ar, rr;
int fontwidth;
fontwidth = font->height;
/* get usable window rectangle */
if(getwindow(display, Refnone) < 0)
ctlerror("resize failed: %r");
r = insetrect(screen->r, 10);
/* message box fills everything not needed for buttons */
mr = r;
mr.max.y = mr.min.y + font->height*((Dy(mr)-3*ButtonDim-font->height-4)/font->height);
/* remember button */
nr.min = Pt(mr.min.x, mr.max.y+ButtonDim);
nr.max = Pt(mr.max.x, r.max.y);
if(Dx(nr) > ButtonDim)
nr.max.x = nr.min.x+ButtonDim;
if(Dy(nr) > ButtonDim)
nr.max.y = nr.min.y+ButtonDim;
ntr.min = Pt(nr.max.x+ButtonDim, nr.min.y);
ntr.max = Pt(r.max.x, nr.min.y+font->height);
/* accept/refuse buttons */
ar.min = Pt(r.min.x+Dx(r)/2-ButtonDim-6*fontwidth, nr.max.y+ButtonDim);
ar.max = Pt(ar.min.x+6*fontwidth, ar.min.y+font->height+4);
rr.min = Pt(r.min.x+Dx(r)/2+ButtonDim, nr.max.y+ButtonDim);
rr.max = Pt(rr.min.x+6*fontwidth, rr.min.y+font->height+4);
/* make the controls visible */
chanprint(cs->ctl, "msg rect %R\nmsg show", mr);
chanprint(cs->ctl, "b_remember rect %R\nb_remember show", nr);
chanprint(cs->ctl, "t_remember rect %R\nt_remember show", ntr);
chanprint(cs->ctl, "b_accept rect %R\nb_accept show", ar);
chanprint(cs->ctl, "b_refuse rect %R\nb_refuse show", rr);
}
/*
* free the controls for the confirmation window
*/
static void
teardownconfirm(Request *r)
{
Controlset *cs;
cs = r->rt->cs;
r->rt->cs = nil;
hide();
closecontrolset(cs);
closekmr();
}
/*
* get user confirmation of a key
*/
static void
confirm(Request *r)
{
Channel *c;
char *s;
int n;
char *args[3];
int remember;
Attr *val;
Memory *m;
/* if it's something that the user wanted us not to ask again about */
m = searchmem(r->a);
if(m != nil){
fprint(r->rt->fd, "%A %A", r->tag, m->val);
return;
}
/* set up the controls */
c = setupconfirm(r);
/* wait for user to reply */
remember = 0;
for(;;){
s = recvp(c);
n = tokenize(s, args, nelem(args));
if(n==3 && strcmp(args[1], "value")==0){
if(strcmp(args[0], "b_remember:") == 0){
remember = atoi(args[2]);
}
if(strcmp(args[0], "b_accept:") == 0){
val = _mkattr(AttrNameval, "answer", "yes", nil);
free(s);
break;
}
if(strcmp(args[0], "b_refuse:") == 0){
val = _mkattr(AttrNameval, "answer", "no", nil);
free(s);
break;
}
}
free(s);
}
teardownconfirm(r);
fprint(r->rt->fd, "%A %A", r->tag, val);
if(remember)
addmem(_copyattr(r->a), val);
else
_freeattr(val);
}
/*
* confirmations that are remembered
*/
static int
match(Attr *a, Attr *b)
{
Attr *x;
for(; a != nil; a = a->next){
x = _findattr(b, a->name);
if(x == nil || strcmp(a->val, x->val) != 0)
return 0;
}
return 1;
}
static Memory*
searchmem(Attr *a)
{
Memory *m;
for(m = mem; m != nil; m = m->next){
if(match(a, m->a))
break;
}
return m;
}
static void
addmem(Attr *a, Attr *val)
{
Memory *m;
m = malloc(sizeof *m);
if(m == nil)
return;
m->a = a;
m->val = val;
m->next = mem;
mem = m;
}
/* controls for needkey */
Control *msg;
Control *b_done;
Control *b_cancel;
enum {
Pprivate= 1<<0,
Pneed= 1<<1,
};
typedef struct Entry Entry;
struct Entry {
Control *name;
Control *val;
Control *eq;
Attr *a;
};
static Entry *entry;
static int entries;
/*
* set up the controls for the confirmation window
*/
static Channel*
setupneedkey(Request *r)
{
Controlset *cs;
Channel *c;
Attr *a;
Attr **l;
char cn[10];
int i;
/* create a new control set for the confirmation */
openkmr();
cs = newcontrolset(screen, kbdc, mousec, resizec);
/* count attributes and allocate entry controls */
entries = 0;
for(l = &r->a; *l; l = &(*l)->next)
entries++;
if(entries == 0){
closecontrolset(cs);
closekmr();
return nil;
}
*l = a = mallocz(sizeof *a, 1);
a->type = AttrQuery;
entries++;
l = &(*l)->next;
*l = a = mallocz(sizeof *a, 1);
a->type = AttrQuery;
entries++;
entry = malloc(entries*sizeof(Entry));
if(entry == nil){
closecontrolset(cs);
closekmr();
return nil;
}
namectlimage(display->white, "i_white");
namectlimage(display->black, "i_black");
/* create controls */
msg = createtext(cs, "msg");
chanprint(cs->ctl, "msg image white");
chanprint(cs->ctl, "msg bordercolor white");
chanprint(cs->ctl, "msg add 'You need the following key. Fill in the blanks'");
chanprint(cs->ctl, "msg add 'and click on the DONE button.'");
for(i = 0, a = r->a; a != nil; i++, a = a->next){
entry[i].a = a;
snprint(cn, sizeof cn, "name_%d", i);
if(entry[i].a->name == nil){
entry[i].name = createentry(cs, cn);
chanprint(cs->ctl, "%s image paleyellow", cn);
chanprint(cs->ctl, "%s border 1", cn);
} else {
entry[i].name = createtext(cs, cn);
chanprint(cs->ctl, "%s image white", cn);
chanprint(cs->ctl, "%s bordercolor white", cn);
chanprint(cs->ctl, "%s add '%s'", cn, a->name);
}
snprint(cn, sizeof cn, "val_%d", i);
if(a->type == AttrQuery){
entry[i].val = createentry(cs, cn);
chanprint(cs->ctl, "%s image paleyellow", cn);
chanprint(cs->ctl, "%s border 1", cn);
if(a->name != nil){
if(strcmp(a->name, "user") == 0)
chanprint(cs->ctl, "%s value %q", cn, getuser());
if(*a->name == '!')
chanprint(cs->ctl, "%s font invisible", cn);
}
} else {
entry[i].val = createtext(cs, cn);
chanprint(cs->ctl, "%s image white", cn);
chanprint(cs->ctl, "%s add %q", cn, a->val);
}
snprint(cn, sizeof cn, "eq_%d", i);
entry[i].eq = createtext(cs, cn);
chanprint(cs->ctl, "%s image white", cn);
chanprint(cs->ctl, "%s add ' = '", cn);
}
b_done = createtextbutton(cs, "b_done");
chanprint(cs->ctl, "b_done border 1");
chanprint(cs->ctl, "b_done align center");
chanprint(cs->ctl, "b_done text Done");
chanprint(cs->ctl, "b_done image palegreen");
chanprint(cs->ctl, "b_done light palegreen");
b_cancel = createtextbutton(cs, "b_cancel");
chanprint(cs->ctl, "b_cancel border 1");
chanprint(cs->ctl, "b_cancel align center");
chanprint(cs->ctl, "b_cancel text Cancel");
chanprint(cs->ctl, "b_cancel image i_white");
chanprint(cs->ctl, "b_cancel light i_black");
/* wire controls for input */
c = chancreate(sizeof(char*), 0);
controlwire(b_done, "event", c);
controlwire(b_cancel, "event", c);
for(i = 0; i < entries; i++)
if(entry[i].a->type == AttrQuery)
controlwire(entry[i].val, "event", c);
/* make the controls interactive */
activate(msg);
activate(b_done);
activate(b_cancel);
for(i = 0; i < entries; i++){
if(entry[i].a->type != AttrQuery)
continue;
if(entry[i].a->name == nil)
activate(entry[i].name);
activate(entry[i].val);
}
/* change the display */
r->rt->cs = cs;
unhide();
resizecontrolset(cs);
return c;
}
/*
* resize the controls for the confirmation window
*/
static void
resizeneedkey(Controlset *cs)
{
Rectangle r, mr;
int mid, i, n, lasty;
/* get usable window rectangle */
if(getwindow(display, Refnone) < 0)
ctlerror("resize failed: %r");
r = insetrect(screen->r, 10);
/* find largest name */
mid = 0;
for(i = 0; i < entries; i++){
if(entry[i].a->name == nil)
continue;
n = strlen(entry[i].a->name);
if(n > mid)
mid = n;
}
mid = (mid+2) * font->height;
/* top line is the message */
mr = r;
mr.max.y = mr.min.y + 2*font->height + 2;
chanprint(cs->ctl, "msg rect %R\nmsg show", mr);
/* one line per attribute */
mr.min.x += 2*font->height;
lasty = mr.max.y;
for(i = 0; i < entries; i++){
r.min.x = mr.min.x;
r.min.y = lasty+2;
r.max.x = r.min.x + mid - 3*stringwidth(font, "=");
r.max.y = r.min.y + font->height;
chanprint(cs->ctl, "name_%d rect %R\nname_%d show", i, r, i);
r.min.x = r.max.x;
r.max.x = r.min.x + 3*stringwidth(font, "=");
chanprint(cs->ctl, "eq_%d rect %R\neq_%d show", i, r, i);
r.min.x = r.max.x;
r.max.x = mr.max.x;
if(Dx(r) > 32*font->height)
r.max.x = r.min.x + 32*font->height;
chanprint(cs->ctl, "val_%d rect %R\nval_%d show", i, r, i);
lasty = r.max.y;
}
mr.min.x -= 2*font->height;
/* done button */
r.min.x = mr.min.x + mid - 9*font->height;
r.min.y = lasty+10;
r.max.x = r.min.x + 6*font->height;
r.max.y = r.min.y + font->height + 2;
chanprint(cs->ctl, "b_done rect %R\nb_done show", r);
/* cancel button */
r.min.x = mr.min.x + mid + 3*font->height;
r.min.y = lasty+10;
r.max.x = r.min.x + 6*font->height;
r.max.y = r.min.y + font->height + 2;
chanprint(cs->ctl, "b_cancel rect %R\nb_cancel show", r);
}
/*
* free the controls for the confirmation window
*/
static void
teardownneedkey(Request *r)
{
Controlset *cs;
cs = r->rt->cs;
r->rt->cs = nil;
hide();
closecontrolset(cs);
closekmr();
if(entry != nil)
free(entry);
entry = nil;
}
static void
needkey(Request *r)
{
Channel *c;
char *nam, *val;
int i, n;
int fd;
char *args[3];
/* set up the controls */
c = setupneedkey(r);
if(c == nil)
goto out;
/* wait for user to reply */
for(;;){
val = recvp(c);
n = tokenize(val, args, nelem(args));
if(n==3 && strcmp(args[1], "value")==0) /* user hit 'enter' */
break;
free(val);
}
if(strcmp(args[0], "b_cancel:") == 0){
free(val);
teardownneedkey(r);
fprint(r->rt->fd, "%A error='canceled by user'", r->tag);
return;
}
free(val);
/* get entry values */
for(i = 0; i < entries; i++){
if(entry[i].a->type != AttrQuery)
continue;
chanprint(r->rt->cs->ctl, "val_%d data", i);
val = recvp(entry[i].val->data);
if(entry[i].a->name == nil){
chanprint(r->rt->cs->ctl, "name_%d data", i);
nam = recvp(entry[i].name->data);
if(nam == nil || *nam == 0){
free(val);
continue;
}
entry[i].a->val = estrdup(val);
free(val);
entry[i].a->name = estrdup(nam);
free(nam);
} else {
if(val != nil){
entry[i].a->val = estrdup(val);
free(val);
}
}
entry[i].a->type = AttrNameval;
}
/* enter the new key */
fd = open("/mnt/factotum/ctl", OWRITE);
if(fd >= 0){
fprint(fd, "key %A", r->a);
close(fd);
}
teardownneedkey(r);
out:
fprint(r->rt->fd, "%A", r->tag);
}