[BACK]Return to usbhidaction.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / usr.bin / usbhidaction

Annotation of src/usr.bin/usbhidaction/usbhidaction.c, Revision 1.24

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

CVSweb <webmaster@jp.NetBSD.org>