1 /*      $NetBSD: usbhidaction.c,v 1.8 2002/06/11 06:06:21 itojun Exp $ */
2 
3 /*-
4  * SPDX-License-Identifier: BSD-2-Clause
5  *
6  * Copyright (c) 2000, 2002 The NetBSD Foundation, Inc.
7  * All rights reserved.
8  *
9  * This code is derived from software contributed to The NetBSD Foundation
10  * by Lennart Augustsson <lennart@augustsson.net>.
11  *
12  * Redistribution and use in source and binary forms, with or without
13  * modification, are permitted provided that the following conditions
14  * are met:
15  * 1. Redistributions of source code must retain the above copyright
16  *    notice, this list of conditions and the following disclaimer.
17  * 2. Redistributions in binary form must reproduce the above copyright
18  *    notice, this list of conditions and the following disclaimer in the
19  *    documentation and/or other materials provided with the distribution.
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
23  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31  * POSSIBILITY OF SUCH DAMAGE.
32  */
33 
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <ctype.h>
38 #include <err.h>
39 #include <fcntl.h>
40 #include <limits.h>
41 #include <unistd.h>
42 #include <sys/types.h>
43 #include <dev/usb/usbhid.h>
44 #include <usbhid.h>
45 #include <syslog.h>
46 #include <signal.h>
47 #include <errno.h>
48 #include <sys/stat.h>
49 
50 static int	verbose = 0;
51 static int	isdemon = 0;
52 static int	reparse = 1;
53 static const char *	pidfile = "/var/run/usbaction.pid";
54 
55 struct command {
56 	struct command *next;
57 	int line;
58 
59 	struct hid_item item;
60 	int value;
61 	int lastseen;
62 	int lastused;
63 	int debounce;
64 	char anyvalue;
65 	char *name;
66 	char *action;
67 };
68 static struct command *commands;
69 
70 #define SIZE 4000
71 
72 void usage(void);
73 struct command *parse_conf(const char *, report_desc_t, int, int);
74 void docmd(struct command *, int, const char *, int, char **);
75 void freecommands(struct command *);
76 
77 static void
78 sighup(int sig __unused)
79 {
80 	reparse = 1;
81 }
82 
83 int
84 main(int argc, char **argv)
85 {
86 	const char *conf = NULL;
87 	const char *dev = NULL;
88 	const char *table = NULL;
89 	int fd, fp, ch, n, val, i;
90 	size_t sz, sz1;
91 	int demon, ignore, dieearly;
92 	report_desc_t repd;
93 	char buf[100];
94 	char devnamebuf[PATH_MAX];
95 	struct command *cmd;
96 	int reportid = -1;
97 
98 	demon = 1;
99 	ignore = 0;
100 	dieearly = 0;
101 	while ((ch = getopt(argc, argv, "c:def:ip:r:t:v")) != -1) {
102 		switch(ch) {
103 		case 'c':
104 			conf = optarg;
105 			break;
106 		case 'd':
107 			demon ^= 1;
108 			break;
109 		case 'e':
110 			dieearly = 1;
111 			break;
112 		case 'i':
113 			ignore++;
114 			break;
115 		case 'f':
116 			dev = optarg;
117 			break;
118 		case 'p':
119 			pidfile = optarg;
120 			break;
121 		case 'r':
122 			reportid = atoi(optarg);
123 			break;
124 		case 't':
125 			table = optarg;
126 			break;
127 		case 'v':
128 			demon = 0;
129 			verbose++;
130 			break;
131 		case '?':
132 		default:
133 			usage();
134 		}
135 	}
136 	argc -= optind;
137 	argv += optind;
138 
139 	if (conf == NULL || dev == NULL)
140 		usage();
141 
142 	hid_init(table);
143 
144 	if (dev[0] != '/') {
145 		snprintf(devnamebuf, sizeof(devnamebuf), "/dev/%s%s",
146 			 isdigit(dev[0]) ? "uhid" : "", dev);
147 		dev = devnamebuf;
148 	}
149 
150 	fd = open(dev, O_RDWR);
151 	if (fd < 0)
152 		err(1, "%s", dev);
153 	repd = hid_get_report_desc(fd);
154 	if (repd == NULL)
155 		err(1, "hid_get_report_desc() failed");
156 
157 	commands = parse_conf(conf, repd, reportid, ignore);
158 
159 	sz = (size_t)hid_report_size(repd, hid_input, -1);
160 
161 	if (verbose)
162 		printf("report size %zu\n", sz);
163 	if (sz > sizeof buf)
164 		errx(1, "report too large");
165 
166 	(void)signal(SIGHUP, sighup);
167 
168 	if (demon) {
169 		fp = open(pidfile, O_WRONLY|O_CREAT, S_IRUSR|S_IRGRP|S_IROTH);
170 		if (fp < 0)
171 			err(1, "%s", pidfile);
172 		if (daemon(0, 0) < 0)
173 			err(1, "daemon()");
174 		snprintf(buf, sizeof(buf), "%ld\n", (long)getpid());
175 		sz1 = strlen(buf);
176 		if (write(fp, buf, sz1) < 0)
177 			err(1, "%s", pidfile);
178 		close(fp);
179 		isdemon = 1;
180 	}
181 
182 	for(;;) {
183 		n = read(fd, buf, sz);
184 		if (verbose > 2) {
185 			printf("read %d bytes:", n);
186 			for (i = 0; i < n; i++)
187 				printf(" %02x", buf[i]);
188 			printf("\n");
189 		}
190 		if (n < 0) {
191 			if (verbose)
192 				err(1, "read");
193 			else
194 				exit(1);
195 		}
196 #if 0
197 		if (n != sz) {
198 			err(2, "read size");
199 		}
200 #endif
201 		for (cmd = commands; cmd; cmd = cmd->next) {
202 			if (cmd->item.report_ID != 0 &&
203 			    buf[0] != cmd->item.report_ID)
204 				continue;
205 			if (cmd->item.flags & HIO_VARIABLE)
206 				val = hid_get_data(buf, &cmd->item);
207 			else {
208 				uint32_t pos = cmd->item.pos;
209 				for (i = 0; i < cmd->item.report_count; i++) {
210 					val = hid_get_data(buf, &cmd->item);
211 					if (val == cmd->value)
212 						break;
213 					cmd->item.pos += cmd->item.report_size;
214 				}
215 				cmd->item.pos = pos;
216 				val = (i < cmd->item.report_count) ?
217 				    cmd->value : -1;
218 			}
219 			if (cmd->value != val && cmd->anyvalue == 0)
220 				goto next;
221 			if ((cmd->debounce == 0) ||
222 			    ((cmd->debounce == 1) && ((cmd->lastseen == -1) ||
223 					       (cmd->lastseen != val)))) {
224 				docmd(cmd, val, dev, argc, argv);
225 				goto next;
226 			}
227 			if ((cmd->debounce > 1) &&
228 			    ((cmd->lastused == -1) ||
229 			     (abs(cmd->lastused - val) >= cmd->debounce))) {
230 				docmd(cmd, val, dev, argc, argv);
231 				cmd->lastused = val;
232 				goto next;
233 			}
234 next:
235 			cmd->lastseen = val;
236 		}
237 
238 		if (dieearly)
239 			exit(0);
240 
241 		if (reparse) {
242 			struct command *cmds =
243 			    parse_conf(conf, repd, reportid, ignore);
244 			if (cmds) {
245 				freecommands(commands);
246 				commands = cmds;
247 			}
248 			reparse = 0;
249 		}
250 	}
251 
252 	exit(0);
253 }
254 
255 void
256 usage(void)
257 {
258 
259 	fprintf(stderr, "Usage: %s [-deiv] -c config_file -f hid_dev "
260 		"[-p pidfile] [-t tablefile]\n", getprogname());
261 	exit(1);
262 }
263 
264 static int
265 peek(FILE *f)
266 {
267 	int c;
268 
269 	c = getc(f);
270 	if (c != EOF)
271 		ungetc(c, f);
272 	return c;
273 }
274 
275 struct command *
276 parse_conf(const char *conf, report_desc_t repd, int reportid, int ignore)
277 {
278 	FILE *f;
279 	char *p;
280 	int line;
281 	char buf[SIZE], name[SIZE], value[SIZE], debounce[SIZE], action[SIZE];
282 	char usbuf[SIZE], coll[SIZE], *tmp;
283 	struct command *cmd, *cmds;
284 	struct hid_data *d;
285 	struct hid_item h;
286 	int inst, cinst, u, lo, hi, range, t;
287 
288 	f = fopen(conf, "r");
289 	if (f == NULL)
290 		err(1, "%s", conf);
291 
292 	cmds = NULL;
293 	for (line = 1; ; line++) {
294 		if (fgets(buf, sizeof buf, f) == NULL)
295 			break;
296 		if (buf[0] == '#' || buf[0] == '\n')
297 			continue;
298 		p = strchr(buf, '\n');
299 		while (p && isspace(peek(f))) {
300 			if (fgets(p, sizeof buf - strlen(buf), f) == NULL)
301 				break;
302 			p = strchr(buf, '\n');
303 		}
304 		if (p)
305 			*p = 0;
306 		if (sscanf(buf, "%s %s %s %[^\n]",
307 			   name, value, debounce, action) != 4) {
308 			if (isdemon) {
309 				syslog(LOG_WARNING, "config file `%s', line %d"
310 				       ", syntax error: %s", conf, line, buf);
311 				freecommands(cmds);
312 				return (NULL);
313 			} else {
314 				errx(1, "config file `%s', line %d,"
315 				     ", syntax error: %s", conf, line, buf);
316 			}
317 		}
318 		tmp = strchr(name, '#');
319 		if (tmp != NULL) {
320 			*tmp = 0;
321 			inst = atoi(tmp + 1);
322 		} else
323 			inst = 0;
324 
325 		cmd = malloc(sizeof *cmd);
326 		if (cmd == NULL)
327 			err(1, "malloc failed");
328 		cmd->next = cmds;
329 		cmds = cmd;
330 		cmd->line = line;
331 
332 		if (strcmp(value, "*") == 0) {
333 			cmd->anyvalue = 1;
334 		} else {
335 			cmd->anyvalue = 0;
336 			if (sscanf(value, "%d", &cmd->value) != 1) {
337 				if (isdemon) {
338 					syslog(LOG_WARNING,
339 					       "config file `%s', line %d, "
340 					       "bad value: %s (should be * or a number)\n",
341 					       conf, line, value);
342 					freecommands(cmds);
343 					return (NULL);
344 				} else {
345 					errx(1, "config file `%s', line %d, "
346 					     "bad value: %s (should be * or a number)\n",
347 					     conf, line, value);
348 				}
349 			}
350 		}
351 
352 		if (sscanf(debounce, "%d", &cmd->debounce) != 1) {
353 			if (isdemon) {
354 				syslog(LOG_WARNING,
355 				       "config file `%s', line %d, "
356 				       "bad value: %s (should be a number >= 0)\n",
357 				       conf, line, debounce);
358 				freecommands(cmds);
359 				return (NULL);
360 			} else {
361 				errx(1, "config file `%s', line %d, "
362 				     "bad value: %s (should be a number >= 0)\n",
363 				     conf, line, debounce);
364 			}
365 		}
366 
367 		coll[0] = 0;
368 		cinst = 0;
369 		for (d = hid_start_parse(repd, 1 << hid_input, reportid);
370 		     hid_get_item(d, &h); ) {
371 			if (verbose > 2)
372 				printf("kind=%d usage=%x\n", h.kind, h.usage);
373 			if (h.flags & HIO_CONST)
374 				continue;
375 			switch (h.kind) {
376 			case hid_input:
377 				if (h.usage_minimum != 0 ||
378 				    h.usage_maximum != 0) {
379 					lo = h.usage_minimum;
380 					hi = h.usage_maximum;
381 					range = 1;
382 				} else {
383 					lo = h.usage;
384 					hi = h.usage;
385 					range = 0;
386 				}
387 				for (u = lo; u <= hi; u++) {
388 					if (coll[0]) {
389 						snprintf(usbuf, sizeof usbuf,
390 						  "%s.%s:%s", coll+1,
391 						  hid_usage_page(HID_PAGE(u)),
392 						  hid_usage_in_page(u));
393 					} else {
394 						snprintf(usbuf, sizeof usbuf,
395 						  "%s:%s",
396 						  hid_usage_page(HID_PAGE(u)),
397 						  hid_usage_in_page(u));
398 					}
399 					if (verbose > 2)
400 						printf("usage %s\n", usbuf);
401 					t = strlen(usbuf) - strlen(name);
402 					if (t > 0) {
403 						if (strcmp(usbuf + t, name))
404 							continue;
405 						if (usbuf[t - 1] != '.')
406 							continue;
407 					} else if (strcmp(usbuf, name))
408 						continue;
409 					if (inst == cinst++)
410 						goto foundhid;
411 				}
412 				break;
413 			case hid_collection:
414 				snprintf(coll + strlen(coll),
415 				    sizeof coll - strlen(coll),  ".%s:%s",
416 				    hid_usage_page(HID_PAGE(h.usage)),
417 				    hid_usage_in_page(h.usage));
418 				break;
419 			case hid_endcollection:
420 				if (coll[0])
421 					*strrchr(coll, '.') = 0;
422 				break;
423 			default:
424 				break;
425 			}
426 		}
427 		if (ignore) {
428 			if (verbose)
429 				warnx("ignore item '%s'", name);
430 			continue;
431 		}
432 		if (isdemon) {
433 			syslog(LOG_WARNING, "config file `%s', line %d, HID "
434 			       "item not found: `%s'\n", conf, line, name);
435 			freecommands(cmds);
436 			return (NULL);
437 		} else {
438 			errx(1, "config file `%s', line %d, HID item "
439 			     "not found: `%s'\n", conf, line, name);
440 		}
441 
442 	foundhid:
443 		hid_end_parse(d);
444 		cmd->lastseen = -1;
445 		cmd->lastused = -1;
446 		cmd->item = h;
447 		cmd->name = strdup(name);
448 		cmd->action = strdup(action);
449 		if (range) {
450 			if (cmd->value == 1)
451 				cmd->value = u - lo;
452 			else
453 				cmd->value = -1;
454 		}
455 
456 		if (verbose)
457 			printf("PARSE:%d %s, %d, '%s'\n", cmd->line, name,
458 			       cmd->value, cmd->action);
459 	}
460 	fclose(f);
461 	return (cmds);
462 }
463 
464 void
465 docmd(struct command *cmd, int value, const char *hid, int argc, char **argv)
466 {
467 	char cmdbuf[SIZE], *p, *q;
468 	size_t len;
469 	int n, r;
470 
471 	for (p = cmd->action, q = cmdbuf; *p && q < &cmdbuf[SIZE-1]; ) {
472 		if (*p == '$') {
473 			p++;
474 			len = &cmdbuf[SIZE-1] - q;
475 			if (isdigit(*p)) {
476 				n = strtol(p, &p, 10) - 1;
477 				if (n >= 0 && n < argc) {
478 					strncpy(q, argv[n], len);
479 					q += strlen(q);
480 				}
481 			} else if (*p == 'V') {
482 				p++;
483 				snprintf(q, len, "%d", value);
484 				q += strlen(q);
485 			} else if (*p == 'N') {
486 				p++;
487 				strncpy(q, cmd->name, len);
488 				q += strlen(q);
489 			} else if (*p == 'H') {
490 				p++;
491 				strncpy(q, hid, len);
492 				q += strlen(q);
493 			} else if (*p) {
494 				*q++ = *p++;
495 			}
496 		} else {
497 			*q++ = *p++;
498 		}
499 	}
500 	*q = 0;
501 
502 	if (verbose)
503 		printf("system '%s'\n", cmdbuf);
504 	r = system(cmdbuf);
505 	if (verbose > 1 && r)
506 		printf("return code = 0x%x\n", r);
507 }
508 
509 void
510 freecommands(struct command *cmd)
511 {
512 	struct command *next;
513 
514 	while (cmd) {
515 		next = cmd->next;
516 		free(cmd);
517 		cmd = next;
518 	}
519 }
520