1 /*
2  * Copyright (c) 2020 Omar Polo <op@omarpolo.com>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16 
17 #include "star-platinum.h"
18 
19 #include <err.h>
20 #include <stdio.h>
21 #include <string.h>
22 #include <unistd.h>
23 
24 #include <X11/XKBlib.h>
25 #include <X11/Xutil.h>
26 
27 #ifndef __OpenBSD__
28 # define pledge(a, b) 0
29 #endif
30 
31 extern FILE *yyin;
32 char *fname;
33 
34 extern int yylineno;
35 int yyparse(void);
36 
37 struct group *config;
38 int goterror = 0;
39 
40 Display *d;
41 
42 int ignored_modifiers[] = {
43 	0, 			/* no modifiers */
44 	LockMask,		/* caps lock */
45 	Mod2Mask,		/* num lock */
46 	Mod3Mask,		/* scroll lock */
47 	Mod5Mask,		/* ? */
48 };
49 
50 #define IGNORE_MODIFIERS (LockMask | Mod2Mask | Mod3Mask | Mod5Mask)
51 
52 void
53 yyerror(const char *e)
54 {
55 	goterror = 1;
56 	fprintf(stderr, "%s:%d %s\n", fname, yylineno, e);
57 }
58 
59 char *
60 find_config()
61 {
62 	char *home, *xdg, *t;
63 	int free_xdg = 0;
64 
65 	home = getenv("HOME");
66 	xdg = getenv("XDG_CONFIG_HOME");
67 
68 	if (home == NULL && xdg == NULL)
69 		return NULL;
70 
71 	/* file in home directory >>>>>> XDG shit */
72 	if (home != NULL) {
73 		if (asprintf(&t, "%s/.star-platinum.conf", home) == -1)
74 			return NULL;
75 		if (access(t, R_OK) == 0)
76 			return t;
77 
78 		free(t);
79 		/* continue to search */
80 	}
81 
82 	/* sanitize XDG_CONFIG_HOME */
83 	if (xdg == NULL) {
84 		free_xdg = 1;
85 		if (asprintf(&xdg, "%s/.config", home) == -1)
86 			return NULL;
87 	}
88 
89 	if (asprintf(&t, "%s/star-platinum.conf", xdg) == -1)
90 		goto err;
91 
92 	if (access(t, R_OK) == 0)
93 		return t;
94 	free(t);
95 
96 err:
97 	if (free_xdg)
98 		free(xdg);
99 
100 	return NULL;
101 }
102 
103 int
104 main(int argc, char **argv)
105 {
106 	int status = 0, dump_config = 0, conftest = 0, ch;
107 	struct group *g;
108 	struct rule *r;
109 	XEvent e;
110 	Window root;
111 
112 	fname = NULL;
113 	while ((ch = getopt(argc, argv, "c:dn")) != -1) {
114 		switch (ch) {
115 		case 'c':
116 			free(fname);
117 			if ((fname = strdup(optarg)) == NULL)
118 				err(1, "strdup");
119 			break;
120 
121 		case 'd':
122 			dump_config = 1;
123 			break;
124 
125 		case 'n':
126 			conftest = 1;
127 			break;
128 
129 		default:
130 			fprintf(stderr, "USAGE: %s [-dn] [-c conf]\n", *argv);
131 			return 1;
132 		}
133 	}
134 
135 	if (fname == NULL) {
136 		if ((fname = find_config()) == NULL)
137 			errx(1, "can't find a configuration file");
138 	}
139 
140 	if ((yyin = fopen(fname, "r")) == NULL)
141 		err(1, "cannot open %s", fname);
142 	yyparse();
143 	fclose(yyin);
144 
145 	free(fname);
146 	fname = NULL;
147 
148 	if (goterror)
149                 return 1;
150 
151 	if (dump_config)
152 		printgroup(config);
153 
154 	if (conftest) {
155 		recfree_group(config);
156 		return 0;
157 	}
158 
159 	if ((d = XOpenDisplay(NULL)) == NULL) {
160 		recfree_group(config);
161 		return 1;
162 	}
163 
164 	XSetErrorHandler(&error_handler);
165 
166 	root = DefaultRootWindow(d);
167 
168 	/* grab all the keys */
169 	for (g = config; g != NULL; g = g->next)
170 		for (r = g->rules; r != NULL; r = r->next)
171 			grabkey(r->key);
172 
173 	XSelectInput(d, root, KeyPressMask);
174 	XFlush(d);
175 
176 	pledge("stdio", "");
177 
178 	while (1) {
179 		XNextEvent(d, &e);
180 		switch (e.type) {
181 		case KeyRelease:
182 		case KeyPress:
183 			process_event(config, (XKeyEvent*)&e);
184 			break;
185 
186 		default:
187 			printf("Unknown event %d\n", e.type);
188 			break;
189 		}
190 	}
191 
192 	XCloseDisplay(d);
193 	recfree_group(config);
194 	return status;
195 }
196 
197 
198 /* xlib */
199 
200 int
201 error_handler(Display *d, XErrorEvent *e)
202 {
203 	fprintf(stderr, "Xlib error %d\n", e->type);
204 	return 1;
205 }
206 
207 /* TODO: it should grab ALL POSSIBLE COMBINATIONS of `ignored_modifiers`! */
208 void
209 grabkey(struct key k)
210 {
211 	static size_t len = sizeof(ignored_modifiers)/sizeof(int);
212 	size_t i;
213 	Window root;
214 
215 	root = DefaultRootWindow(d);
216 
217 	/* printf("Grabbing "); printkey(k); printf("\n"); */
218 	for (i = 0; i < len; ++i) {
219                 XGrabKey(d, XKeysymToKeycode(d, k.key),
220 		    k.modifier | ignored_modifiers[i],
221 		    root, False, GrabModeAsync, GrabModeAsync);
222 	}
223 }
224 
225 KeySym
226 keycode_to_keysym(unsigned int kc)
227 {
228 	/* group 0 (?). shift level is 0 because we don't want it*/
229 	return XkbKeycodeToKeysym(d, kc, 0, 0);
230 }
231 
232 Window
233 focused_window()
234 {
235 	Window w;
236 	int revert_to;
237 
238 	/* one can use (at least) three way to obtain the current
239 	 * focused window using xlib:
240 	 *
241 	 * - XQueryTree : you traverse tre tree until you find the
242 	 *     window
243 	 *
244 	 * - looking at _NET_ACTIVE_WINDOW in the root window, but
245 	 *    depedns on the window manager to set it
246 	 *
247 	 * - using XGetInputFocus
248 	 *
249 	 * I don't know the pro/cons of these, but XGetInputFocus
250 	 * seems the easiest.
251 	 */
252 	XGetInputFocus(d, &w, &revert_to);
253 	return w;
254 }
255 
256 void
257 send_fake(Window w, struct key k, int pressed)
258 {
259 	XKeyEvent e;
260 
261 	e.type = pressed ? KeyPress : KeyRelease;
262 
263 	e.display = d;
264 	e.window = w;
265 	e.root = DefaultRootWindow(d);
266 	e.subwindow = None;
267 	e.time = CurrentTime;
268 
269 	/* TODO: fix these */
270 	e.x = 1;
271 	e.y = 1;
272 	e.x_root = 1;
273 	e.y_root = 1;
274 
275 	e.same_screen = True;
276 	e.keycode = XKeysymToKeycode(d, k.key);
277 	e.state = k.modifier;
278 
279 	XSendEvent(d, w, True, KeyPressMask, (XEvent*)&e);
280 	XFlush(d);
281 }
282 
283 int
284 window_match_class(Window w, const char *class)
285 {
286 	XClassHint ch;
287 	int matched;
288 
289         if (!XGetClassHint(d, w, &ch)) {
290 		fprintf(stderr, "XGetClassHint failed\n");
291 		return 0;
292 	}
293 
294 	matched = !strcmp(ch.res_class, class);
295 
296 	XFree(ch.res_name);
297 	XFree(ch.res_class);
298 
299 	return matched;
300 }
301 
302 
303 /* action */
304 
305 void
306 do_action(struct action a, Window focused, int pressed)
307 {
308 	switch (a.type) {
309 	case AFAKE:
310 		send_fake(focused, a.send_key, pressed);
311 		break;
312 
313 	case ASPECIAL:
314 		switch (a.special) {
315 		case ATOGGLE:
316 		case AACTIVATE:
317 		case ADEACTIVATE:
318 			printf("TODO\n");
319 			break;
320 
321 		case AIGNORE:
322 			break;
323 
324 		default:
325 			/* unreachable */
326 			abort();
327 		}
328                 break;
329 
330 	default:
331 		/* unreachable */
332 		abort();
333 	}
334 }
335 
336 
337 /* match */
338 
339 struct match *
340 new_match(int prop, char *s)
341 {
342 	struct match *m;
343 
344 	if ((m = calloc(1, sizeof(*m))) == NULL)
345 		err(1, "calloc");
346 	m->prop = prop;
347 	m->str = s;
348 	return m;
349 }
350 
351 void
352 recfree_match(struct match *m)
353 {
354 	struct match *mt;
355 
356 	if (m == NULL)
357 		return;
358 
359 	mt = m->next;
360 	free(m->str);
361 	free(m);
362 	recfree_match(mt);
363 }
364 
365 int
366 match_window(struct match *m, Window w)
367 {
368         switch (m->prop) {
369 	case MANY:
370 		return 1;
371 
372 	case MCLASS:
373 		return window_match_class(w, m->str);
374 		break;
375 
376 	default:
377 		/* unreachable */
378 		abort();
379 	}
380 }
381 
382 
383 /* rule */
384 
385 struct rule *
386 new_rule(struct key k, struct action a)
387 {
388 	struct rule *r;
389 
390 	if ((r = calloc(1, sizeof(*r))) == NULL)
391 		err(1, "calloc");
392 	memcpy(&r->key, &k, sizeof(k));
393 	memcpy(&r->action, &a, sizeof(a));
394 	return r;
395 }
396 
397 void
398 recfree_rule(struct rule *r)
399 {
400 	struct rule *rt;
401 
402 	if (r == NULL)
403 		return;
404 
405 	rt = r->next;
406 	free(r);
407 	recfree_rule(rt);
408 }
409 
410 int
411 rule_matched(struct rule *r, struct key k)
412 {
413 	unsigned int m;
414 
415 	m = k.modifier;
416 	m &= ~IGNORE_MODIFIERS; /* clear ignored modifiers */
417 
418 	return r->key.modifier == m
419 		&& r->key.key == k.key;
420 }
421 
422 
423 /* group */
424 
425 struct group *
426 new_group(struct match *matches, struct rule *rules)
427 {
428 	struct group *g;
429 
430 	if ((g = calloc(1, sizeof(*g))) == NULL)
431 		err(1, "calloc");
432 	g->matches = matches;
433 	g->rules = rules;
434 	return g;
435 }
436 
437 void
438 recfree_group(struct group *g)
439 {
440 	struct group *gt;
441 
442 	if (g == NULL)
443 		return;
444 
445 	gt = g->next;
446 	recfree_match(g->matches);
447 	recfree_rule(g->rules);
448 	free(g);
449 	recfree_group(gt);
450 }
451 
452 void
453 process_event(struct group *g, XKeyEvent *e)
454 {
455 	Window focused;
456 	struct rule *r;
457 	struct key pressed = {
458 		.modifier = e->state,
459 		.key = keycode_to_keysym(e->keycode),
460 	};
461 
462 	focused = focused_window();
463 
464 	for (; g != NULL; g = g->next) {
465 		if (!group_match(g, focused))
466 			continue;
467 
468 		for (r = g->rules; r != NULL; r = r->next) {
469 			if (rule_matched(r, pressed)) {
470                                 do_action(r->action, focused, e->type == KeyPress);
471 				return;
472 			}
473 		}
474 	}
475 
476 	send_fake(focused, pressed, e->type == KeyPress);
477 }
478 
479 int
480 group_match(struct group *g, Window w)
481 {
482 	struct match *m;
483 
484 	for (m = g->matches; m != NULL; m = m->next)
485 		if (match_window(m, w))
486 			return 1;
487 	return 0;
488 }
489 
490 
491 /* debug/dump stuff */
492 
493 void
494 printkey(struct key k)
495 {
496 	if (k.modifier & ControlMask)
497 		printf("C-");
498 	if (k.modifier & ShiftMask)
499 		printf("S-");
500 	if (k.modifier & Mod1Mask)
501 		printf("M-");
502 	if (k.modifier & Mod4Mask)
503 		printf("s-");
504 
505 	printf("%s", XKeysymToString(k.key));
506 }
507 
508 void
509 printaction(struct action a)
510 {
511 	if (a.type == ASPECIAL) {
512 		switch (a.special) {
513 		case ATOGGLE: printf("toggle"); break;
514 		case AACTIVATE: printf("activate"); break;
515 		case ADEACTIVATE: printf("deactivate"); break;
516 		case AIGNORE: printf("ignore"); break;
517 		}
518 	} else {
519 		printf("send key ");
520 		printkey(a.send_key);
521 	}
522 }
523 
524 void
525 printmatch(struct match *m)
526 {
527 	if (m == NULL) {
528 		printf("(null)");
529 		return;
530 	}
531 	printf("match ");
532 	switch (m->prop) {
533 	case MCLASS:
534 		printf("class");
535 		break;
536 	default:
537 		abort();
538 	}
539 	printf(" %s", m->str);
540 
541 	if (m->next == NULL)
542 		printf("\n");
543 	else {
544 		printf(" ; ");
545 		printmatch(m->next);
546 	}
547 }
548 
549 void
550 printrule(struct rule *r)
551 {
552 	if (r == NULL) {
553 		printf("(null)");
554 		return;
555 	}
556 	printf("on ");
557 	printkey(r->key);
558 	printf(" do ");
559 	printaction(r->action);
560 	printf("\n");
561 
562 	if (r->next != NULL)
563 		printrule(r->next);
564 }
565 
566 void
567 printgroup(struct group *g)
568 {
569 	if (g == NULL) {
570 		printf("(null)");
571 		return;
572 	}
573 	printmatch(g->matches);
574 	printf("\n");
575 	printrule(g->rules);
576 	printf("\n\n");
577 
578 	if (g->next != NULL)
579 		printgroup(g->next);
580 }