2 * $NetBSD: usbd.c,v 1.4 1998/12/09 00:57:19 augustss Exp $
3 * $FreeBSD: src/usr.sbin/usbd/usbd.c,v 1.29 2003/10/25 22:03:10 jmg Exp $
4 * $DragonFly: src/usr.sbin/usbd/usbd.c,v 1.6 2004/12/18 22:48:14 swildner Exp $
8 * Copyright (c) 1998 The NetBSD Foundation, Inc.
11 * This code is derived from software contributed to The NetBSD Foundation
12 * by Lennart Augustsson (augustss@netbsd.org).
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions
17 * 1. Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
19 * 2. Redistributions in binary form must reproduce the above copyright
20 * notice, this list of conditions and the following disclaimer in the
21 * documentation and/or other materials provided with the distribution.
22 * 3. All advertising materials mentioning features or use of this software
23 * must display the following acknowledgement:
24 * This product includes software developed by the NetBSD
25 * Foundation, Inc. and its contributors.
26 * 4. Neither the name of The NetBSD Foundation nor the names of its
27 * contributors may be used to endorse or promote products derived
28 * from this software without specific prior written permission.
30 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
31 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
32 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
33 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
34 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
35 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
36 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
37 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
38 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
39 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
40 * POSSIBILITY OF SUCH DAMAGE.
43 /* USBD creates 'threads' in the kernel, used for doing discovery when a
44 * device has attached or detached. This functionality should be removed
45 * once kernel threads have been added to the kernel.
46 * It also handles the event queue, and executing commands based on those
60 #include <sys/param.h>
61 #include <sys/types.h>
62 #include <sys/errno.h>
63 #include <sys/ioctl.h>
64 #include <sys/linker.h>
65 #include <sys/module.h>
66 #include <sys/queue.h>
71 #include <bus/usb/usb.h>
73 /* default name of configuration file
76 #define CONFIGFILE "/etc/usbd.conf"
78 /* the name of the device spitting out usb attach/detach events as well as
79 * the prefix for the individual busses (used as a semi kernel thread).
81 #define USBDEV "/dev/usb"
83 /* Maximum number of USB busses expected to be in a system
84 * XXX should be replaced by dynamic allocation.
88 /* Sometimes a device does not respond in time for interrupt
89 * driven explore to find it. Therefore we run an exploration
90 * at regular intervals to catch those.
94 /* The wildcard used in actions for strings and integers
96 #define WILDCARD_STRING NULL
97 #define WILDCARD_INT -1
100 extern char *__progname; /* name of program */
102 char *configfile = CONFIGFILE; /* name of configuration file */
104 char *devs[MAXUSBDEV]; /* device names */
105 int fds[MAXUSBDEV]; /* file descriptors for USBDEV\d+ */
106 int ndevs = 0; /* number of entries in fds / devs */
107 int fd = -1; /* file descriptor for USBDEV */
110 int verbose = 0; /* print message on what it is doing */
112 typedef struct event_name_s {
113 int type; /* event number (from usb.h) */
117 event_name_t event_names[] = {
118 {USB_EVENT_CTRLR_ATTACH, "ctrlr-attach"},
119 {USB_EVENT_CTRLR_DETACH, "ctrlr-detach"},
120 {USB_EVENT_DRIVER_ATTACH, "driver-attach"},
121 {USB_EVENT_DRIVER_DETACH, "driver-detach"},
122 {USB_EVENT_DEVICE_ATTACH, "device-attach"},
123 {USB_EVENT_DEVICE_DETACH, "device-detach"},
124 {0, NULL} /* NULL indicates end of list, not 0 */
127 #define DEVICE_FIELD 0 /* descriptive field */
129 #define VENDOR_FIELD 1 /* selective fields */
130 #define PRODUCT_FIELD 2
131 #define RELEASE_FIELD 3
132 #define CLASS_FIELD 4
133 #define SUBCLASS_FIELD 5
134 #define PROTOCOL_FIELD 6
135 #define DEVNAME_FIELD 7
137 #define ATTACH_FIELD 8 /* command fields */
138 #define DETACH_FIELD 9
141 typedef struct action_s {
142 char *name; /* descriptive string */
144 int vendor; /* selection criteria */
151 regex_t devname_regex;
153 char *attach; /* commands to execute */
156 STAILQ_ENTRY(action_s) next;
159 STAILQ_HEAD(action_list, action_s) actions = STAILQ_HEAD_INITIALIZER(actions);
161 typedef struct action_match_s {
167 /* the function returns 0 for failure, 1 for all arguments found and 2 for
168 * arguments left over in trail.
170 typedef int (*config_field_fn) __P((action_t *action, char *args,
173 int set_device_field(action_t *action, char *args, char **trail);
174 int set_vendor_field(action_t *action, char *args, char **trail);
175 int set_product_field(action_t *action, char *args, char **trail);
176 int set_release_field(action_t *action, char *args, char **trail);
177 int set_class_field(action_t *action, char *args, char **trail);
178 int set_subclass_field(action_t *action, char *args, char **trail);
179 int set_protocol_field(action_t *action, char *args, char **trail);
180 int set_devname_field(action_t *action, char *args, char **trail);
181 int set_attach_field(action_t *action, char *args, char **trail);
182 int set_detach_field(action_t *action, char *args, char **trail);
184 /* the list of fields supported in an entry */
185 typedef struct config_field_s {
188 config_field_fn function;
191 config_field_t config_fields[] = {
192 {DEVICE_FIELD, "device", set_device_field},
194 {VENDOR_FIELD, "vendor", set_vendor_field},
195 {PRODUCT_FIELD, "product", set_product_field},
196 {RELEASE_FIELD, "release", set_release_field},
197 {CLASS_FIELD, "class", set_class_field},
198 {SUBCLASS_FIELD, "subclass", set_subclass_field},
199 {PROTOCOL_FIELD, "protocol", set_protocol_field},
200 {DEVNAME_FIELD, "devname", set_devname_field},
202 {ATTACH_FIELD, "attach", set_attach_field},
203 {DETACH_FIELD, "detach", set_detach_field},
205 {0, NULL, NULL} /* NULL is EOL marker, not the 0 */
209 /* prototypes for some functions */
210 void print_event __P((struct usb_event *event));
211 void print_action __P((action_t *action, int i));
212 void print_actions __P((void));
213 int find_action __P((struct usb_device_info *devinfo,
214 action_match_t *action_match));
220 fprintf(stderr, "usage: %s [-d] [-v] [-t timeout] [-e] [-f dev]\n"
221 " [-n] [-c config]\n",
227 /* generic helper functions for the functions to set the fields of actions */
229 get_string(char *src, char **rdst, char **rsrc)
231 /* Takes the first string from src, taking quoting into account.
232 * rsrc (if not NULL) is set to the first byte not included in the
233 * string returned in rdst.
236 * src = 'fir"st \'par"t second part';
238 * *dst = 'hello \'world';
240 * *rsrc = 'second part';
242 * Notice the fact that the single quote enclosed in double quotes is
243 * returned. Also notice that before second part there is more than
244 * one space, which is removed in rsrc.
246 * The string in src is not modified.
249 char *dst; /* destination string */
250 int i; /* index into src */
251 int j; /* index into dst */
252 int quoted = 0; /* 1 for single, 2 for double quoted */
254 dst = malloc(strlen(src)+1); /* XXX allocation is too big, realloc?*/
255 if (dst == NULL) { /* should not happen, really */
256 fprintf(stderr, "%s:%d: Out of memory\n", configfile, lineno);
260 /* find the end of the current string. If quotes are found the search
261 * continues until the corresponding quote is found.
264 * represents the string
266 * and not (hello world).
268 for (i = 0, j = 0; i < strlen(src); i++) {
269 if (src[i] == '\'' && (quoted == 0 || quoted == 1)) {
270 quoted = (quoted? 0:1);
271 } else if (src[i] == '"' && (quoted == 0 || quoted == 2)) {
272 quoted = (quoted? 0:2);
273 } else if (isspace(src[i]) && !quoted) {
274 /* found a space outside quotes -> terminates src */
277 dst[j++] = src[i]; /* copy character */
281 /* quotes being left open? */
283 fprintf(stderr, "%s:%d: Missing %s quote at end of '%s'\n",
285 (quoted == 1? "single":"double"), src);
289 /* skip whitespace for second part */
290 for (/*i is set*/; i < strlen(src) && isspace(src[i]); i++)
293 dst[j] = '\0'; /* make sure it's NULL terminated */
295 *rdst = dst; /* and return the pointers */
296 if (rsrc != NULL) /* if info wanted */
299 if (*dst == '\0') { /* empty string */
301 } else if (src[i] == '\0') { /* completely used (1 argument) */
303 } else { /* 2 or more args, *rsrc is rest */
309 get_integer(char *src, int *dst, char **rsrc)
313 /* Converts str to a number. If one argument was found in
314 * str, 1 is returned and *dst is set to the value of the integer.
315 * If 2 or more arguments were presented, 2 is returned,
316 * *dst is set to the converted value and rsrc, if not null, points
317 * at the start of the next argument (whitespace skipped).
318 * Else 0 is returned and nothing else is valid.
321 if (src == NULL || *src == '\0') /* empty src */
324 *dst = (int) strtol(src, &endptr, 0);
326 /* skip over whitespace of second argument */
327 while (isspace(*endptr))
333 if (isspace(*endptr)) { /* partial match, 2 or more arguments */
335 } else if (*endptr == '\0') { /* full match, 1 argument */
337 } else { /* invalid src, no match */
342 /* functions to set the fields of the actions appropriately */
344 set_device_field(action_t *action, char *args, char **trail)
346 return(get_string(args, &action->name, trail));
349 set_vendor_field(action_t *action, char *args, char **trail)
351 return(get_integer(args, &action->vendor, trail));
354 set_product_field(action_t *action, char *args, char **trail)
356 return(get_integer(args, &action->product, trail));
359 set_release_field(action_t *action, char *args, char **trail)
361 return(get_integer(args, &action->release, trail));
364 set_class_field(action_t *action, char *args, char **trail)
366 return(get_integer(args, &action->class, trail));
369 set_subclass_field(action_t *action, char *args, char **trail)
371 return(get_integer(args, &action->subclass, trail));
374 set_protocol_field(action_t *action, char *args, char **trail)
376 return(get_integer(args, &action->protocol, trail));
379 set_devname_field(action_t *action, char *args, char **trail)
381 int match = get_string(args, &action->devname, trail);
385 # define ERRSTR_SIZE 100
386 char errstr[ERRSTR_SIZE];
391 len = strlen(action->devname);
392 string = malloc(len + 15);
396 bcopy(action->devname, string+7, len); /* make some space for */
397 bcopy("[[:<:]]", string, 7); /* beginning of word */
398 bcopy("[[:>:]]", string+7+len, 7); /* and end of word */
399 string[len + 14] = '\0';
401 error = regcomp(&action->devname_regex, string, REG_NOSUB|REG_EXTENDED);
404 regerror(error, &action->devname_regex, errstr, ERRSTR_SIZE);
405 fprintf(stderr, "%s:%d: %s\n", configfile, lineno, errstr);
412 set_attach_field(action_t *action, char *args, char **trail)
414 return(get_string(args, &action->attach, trail));
417 set_detach_field(action_t *action, char *args, char **trail)
419 return(get_string(args, &action->detach, trail));
424 read_configuration(void)
426 FILE *file; /* file descriptor */
427 char *line; /* current line */
428 char *linez; /* current line, NULL terminated */
429 char *field; /* first part, the field name */
430 char *args; /* second part, arguments */
431 char *trail; /* remaining part after parsing, should be '' */
432 size_t len; /* length of current line */
433 int i,j; /* loop counters */
434 action_t *action = NULL; /* current action */
436 file = fopen(configfile, "r");
438 fprintf(stderr, "%s: Could not open for reading, %s\n",
439 configfile, strerror(errno));
443 for (lineno = 1; /* nop */;lineno++) {
445 line = fgetln(file, &len);
447 if (feof(file)) /* EOF */
450 fprintf(stderr, "%s:%d: Could not read, %s\n",
451 configfile, lineno, strerror(errno));
456 /* skip initial spaces */
457 while (len > 0 && isspace(*line)) {
462 if (len == 0) /* empty line */
464 if (line[0] == '#') /* comment line */
467 /* make a NULL terminated copy of the string */
468 linez = malloc(len+1);
470 fprintf(stderr, "%s:%d: Out of memory\n",
474 strncpy(linez, line, len);
477 /* find the end of the current word (is field), that's the
478 * start of the arguments
482 while (*args != '\0' && !isspace(*args))
485 /* If arguments is not the empty string, NULL terminate the
486 * field and move the argument pointer to the first character
488 * If arguments is the empty string field and arguments both
489 * are terminated (strlen(field) >= 0, strlen(arguments) == 0).
496 /* Skip initial spaces */
497 while (*args != '\0' && isspace(*args))
500 /* Cut off trailing whitespace */
501 for (i = 0, j = 0; args[i] != '\0'; i++)
502 if (!isspace(args[i]))
506 /* We now have the field and the argument separated into
507 * two strings that are NULL terminated
510 /* If the field is 'device' we have to start a new action. */
511 if (strcmp(field, "device") == 0) {
512 /* Allocate a new action and set defaults */
513 action = malloc(sizeof(*action));
514 if (action == NULL) {
515 fprintf(stderr, "%s:%d: Out of memory\n",
519 memset(action, 0, sizeof(*action));
520 action->product = WILDCARD_INT;
521 action->vendor = WILDCARD_INT;
522 action->release = WILDCARD_INT;
523 action->class = WILDCARD_INT;
524 action->subclass = WILDCARD_INT;
525 action->protocol = WILDCARD_INT;
526 action->devname = WILDCARD_STRING;
528 /* Add it to the end of the list to preserve order */
529 STAILQ_INSERT_TAIL(&actions, action, next);
532 if (action == NULL) {
533 line[len] = '\0'; /* XXX zero terminate */
534 fprintf(stderr, "%s:%d: Doesn't start with 'device' "
535 "but '%s'\n", configfile, lineno, field);
539 for (i = 0; config_fields[i].name ; i++) {
540 /* does the field name match? */
541 if (strcmp(config_fields[i].name, field) == 0) {
542 /* execute corresponding set-field function */
543 if ((config_fields[i].function)(action, args,
546 fprintf(stderr,"%s:%d: "
547 "Syntax error in '%s'\n",
548 configfile, lineno, linez);
554 if (config_fields[i].name == NULL) { /* Reached end of list*/
555 fprintf(stderr, "%s:%d: Unknown field '%s'\n",
556 configfile, lineno, field);
569 print_event(struct usb_event *event)
572 struct timespec *timespec = &event->ue_time;
573 struct usb_device_info *devinfo = &event->u.ue_device;
575 printf("%s: ", __progname);
576 for (i = 0; event_names[i].name != NULL; i++) {
577 if (event->ue_type == event_names[i].type) {
578 printf("%s event", event_names[i].name);
582 if (event_names[i].name == NULL)
583 printf("unknown event %d", event->ue_type);
585 if (event->ue_type == USB_EVENT_DEVICE_ATTACH ||
586 event->ue_type == USB_EVENT_DEVICE_DETACH) {
587 devinfo = &event->u.ue_device;
589 printf(" at %ld.%09ld, %s, %s:\n",
590 timespec->tv_sec, timespec->tv_nsec,
591 devinfo->udi_product, devinfo->udi_vendor);
593 printf(" vndr=0x%04x prdct=0x%04x rlse=0x%04x "
594 "clss=0x%04x subclss=0x%04x prtcl=0x%04x\n",
595 devinfo->udi_vendorNo, devinfo->udi_productNo,
596 devinfo->udi_releaseNo,
597 devinfo->udi_class, devinfo->udi_subclass, devinfo->udi_protocol);
599 if (devinfo->udi_devnames[0][0] != '\0') {
602 printf(" device names:");
603 for (i = 0; i < USB_MAX_DEVNAMES; i++) {
604 if (devinfo->udi_devnames[i][0] == '\0')
607 printf("%c%s", c, devinfo->udi_devnames[i]);
611 } else if (event->ue_type == USB_EVENT_CTRLR_ATTACH ||
612 event->ue_type == USB_EVENT_CTRLR_DETACH) {
613 printf(" bus=%d", &event->u.ue_ctrlr.ue_bus);
614 } else if (event->ue_type == USB_EVENT_DRIVER_ATTACH ||
615 event->ue_type == USB_EVENT_DRIVER_DETACH) {
616 printf(" cookie=%u devname=%s",
617 &event->u.ue_driver.ue_cookie.cookie,
618 &event->u.ue_driver.ue_devname);
624 print_action(action_t *action, int i)
629 printf("%s: action %d: %s\n",
631 (action->name? action->name:""));
632 if (action->product != WILDCARD_INT ||
633 action->vendor != WILDCARD_INT ||
634 action->release != WILDCARD_INT ||
635 action->class != WILDCARD_INT ||
636 action->subclass != WILDCARD_INT ||
637 action->protocol != WILDCARD_INT)
639 if (action->vendor != WILDCARD_INT)
640 printf(" vndr=0x%04x", action->vendor);
641 if (action->product != WILDCARD_INT)
642 printf(" prdct=0x%04x", action->product);
643 if (action->release != WILDCARD_INT)
644 printf(" rlse=0x%04x", action->release);
645 if (action->class != WILDCARD_INT)
646 printf(" clss=0x%04x", action->class);
647 if (action->subclass != WILDCARD_INT)
648 printf(" subclss=0x%04x", action->subclass);
649 if (action->protocol != WILDCARD_INT)
650 printf(" prtcl=0x%04x", action->protocol);
651 if (action->vendor != WILDCARD_INT ||
652 action->product != WILDCARD_INT ||
653 action->release != WILDCARD_INT ||
654 action->class != WILDCARD_INT ||
655 action->subclass != WILDCARD_INT ||
656 action->protocol != WILDCARD_INT)
658 if (action->devname != WILDCARD_STRING)
659 printf(" devname: %s\n", action->devname);
661 if (action->attach != NULL)
662 printf(" attach='%s'\n",
664 if (action->detach != NULL)
665 printf(" detach='%s'\n",
675 STAILQ_FOREACH(action, &actions, next)
676 print_action(action, ++i);
678 printf("%s: %d action%s\n", __progname, i, (i == 1? "":"s"));
683 match_devname(action_t *action, struct usb_device_info *devinfo)
689 for (i = 0; i < USB_MAX_DEVNAMES; i++) {
690 if (devinfo->udi_devnames[i][0] == '\0')
693 error = regexec(&action->devname_regex, devinfo->udi_devnames[i],
697 printf("%s: %s matches %s\n", __progname,
698 devinfo->udi_devnames[i], action->devname);
708 find_action(struct usb_device_info *devinfo, action_match_t *action_match)
711 char *devname = NULL;
714 STAILQ_FOREACH(action, &actions, next) {
715 if ((action->vendor == WILDCARD_INT ||
716 action->vendor == devinfo->udi_vendorNo) &&
717 (action->product == WILDCARD_INT ||
718 action->product == devinfo->udi_productNo) &&
719 (action->release == WILDCARD_INT ||
720 action->release == devinfo->udi_releaseNo) &&
721 (action->class == WILDCARD_INT ||
722 action->class == devinfo->udi_class) &&
723 (action->subclass == WILDCARD_INT ||
724 action->subclass == devinfo->udi_subclass) &&
725 (action->protocol == WILDCARD_INT ||
726 action->protocol == devinfo->udi_protocol) &&
727 (action->devname == WILDCARD_STRING ||
728 (match = match_devname(action, devinfo)) != -1)) {
731 /* Find a devname for pretty printing. Either
732 * the matched one or otherwise, if there is only
733 * one devname for that device, use that.
736 devname = devinfo->udi_devnames[match];
737 else if (devinfo->udi_devnames[0][0] != '\0' &&
738 devinfo->udi_devnames[1][0] == '\0')
739 /* if we have exactly 1 device name */
740 devname = devinfo->udi_devnames[0];
743 printf("%s: Found action '%s' for %s, %s",
744 __progname, action->name,
745 devinfo->udi_product, devinfo->udi_vendor);
747 printf(" at %s", devname);
751 action_match->action = action;
752 action_match->devname = devname;
762 execute_command(char *cmd)
765 struct sigaction ign, intact, quitact;
766 sigset_t newsigblock, oldsigblock;
771 printf("%s: Executing '%s'\n", __progname, cmd);
775 /* The code below is directly taken from the system(3) call.
776 * Added to it is the closing of open file descriptors.
779 * Ignore SIGINT and SIGQUIT, block SIGCHLD. Remember to save
780 * existing signal dispositions.
782 ign.sa_handler = SIG_IGN;
783 sigemptyset(&ign.sa_mask);
785 sigaction(SIGINT, &ign, &intact);
786 sigaction(SIGQUIT, &ign, &quitact);
787 sigemptyset(&newsigblock);
788 sigaddset(&newsigblock, SIGCHLD);
789 sigprocmask(SIG_BLOCK, &newsigblock, &oldsigblock);
792 fprintf(stderr, "%s: fork failed, %s\n",
793 __progname, strerror(errno));
794 } else if (pid == 0) {
797 /* close all open file handles for USBDEV\d* devices */
798 for (i = 0; i < ndevs; i++)
799 close(fds[i]); /* USBDEV\d+ */
800 close(fd); /* USBDEV */
802 /* Restore original signal dispositions and exec the command. */
803 sigaction(SIGINT, &intact, NULL);
804 sigaction(SIGQUIT, &quitact, NULL);
805 sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
807 execl(_PATH_BSHELL, "sh", "-c", cmd, (char *)NULL);
809 /* should only be reached in case of error */
814 pid = waitpid(pid, &status, 0);
815 } while (pid == -1 && errno == EINTR);
817 sigaction(SIGINT, &intact, NULL);
818 sigaction(SIGQUIT, &quitact, NULL);
819 sigprocmask(SIG_SETMASK, &oldsigblock, NULL);
822 fprintf(stderr, "%s: waitpid returned: %s\n",
823 __progname, strerror(errno));
824 } else if (pid == 0) {
825 fprintf(stderr, "%s: waitpid returned 0 ?!\n",
829 fprintf(stderr, "%s: Could not start '%s'\n",
831 } else if (status == 127) {
832 fprintf(stderr, "%s: Shell failed for '%s'\n",
834 } else if (WIFEXITED(status) && WEXITSTATUS(status)) {
835 fprintf(stderr, "%s: '%s' returned %d\n",
836 __progname, cmd, WEXITSTATUS(status));
837 } else if (WIFSIGNALED(status)) {
838 fprintf(stderr, "%s: '%s' caught signal %d\n",
839 __progname, cmd, WTERMSIG(status));
840 } else if (verbose >= 2) {
841 printf("%s: '%s' is ok\n", __progname, cmd);
847 process_event_queue(int fd)
849 struct usb_event event;
852 action_match_t action_match;
855 len = read(fd, &event, sizeof(event));
857 if (errno == EWOULDBLOCK) {
861 fprintf(stderr,"%s: Could not read event, %s\n",
862 __progname, strerror(errno));
868 if (len != sizeof(event)) {
869 fprintf(stderr, "partial read on %s\n", USBDEV);
873 /* we seem to have gotten a valid event */
878 /* handle the event appropriately */
879 switch (event.ue_type) {
880 case USB_EVENT_CTRLR_ATTACH:
882 printf("USB_EVENT_CTRLR_ATTACH\n");
884 case USB_EVENT_CTRLR_DETACH:
886 printf("USB_EVENT_CTRLR_DETACH\n");
888 case USB_EVENT_DEVICE_ATTACH:
889 case USB_EVENT_DEVICE_DETACH:
890 if (find_action(&event.u.ue_device, &action_match) == 0)
895 print_action(action_match.action, 0);
897 if (action_match.devname) {
899 printf("%s: Setting DEVNAME='%s'\n",
900 __progname, action_match.devname);
902 error = setenv("DEVNAME", action_match.devname, 1);
904 fprintf(stderr, "%s: setenv(\"DEVNAME\", \"%s\",1) failed, %s\n",
905 __progname, action_match.devname, strerror(errno));
908 if (USB_EVENT_IS_ATTACH(event.ue_type) &&
909 action_match.action->attach)
910 execute_command(action_match.action->attach);
911 if (USB_EVENT_IS_DETACH(event.ue_type) &&
912 action_match.action->detach)
913 execute_command(action_match.action->detach);
915 case USB_EVENT_DRIVER_ATTACH:
917 printf("USB_EVENT_DRIVER_ATTACH\n");
919 case USB_EVENT_DRIVER_DETACH:
921 printf("USB_EVENT_DRIVER_DETACH\n");
924 printf("Unknown USB event %d\n", event.ue_type);
931 main(int argc, char **argv)
934 int ch; /* getopt option */
935 int debug = 0; /* print debugging output */
936 int explore_once = 0; /* don't do only explore */
937 int handle_events = 1; /* do handle the event queue */
938 int maxfd; /* maximum fd in use */
939 char buf[50]; /* for creation of the filename */
941 int itimeout = TIMEOUT; /* timeout for select */
944 if (modfind(USB_UHUB) < 0) {
945 if (kldload(USB_KLD) < 0 || modfind(USB_UHUB) < 0) {
946 perror(USB_KLD ": Kernel module not available");
951 while ((ch = getopt(argc, argv, "c:def:nt:v")) != -1) {
954 configfile = strdup(optarg);
955 if (configfile == NULL) {
956 fprintf(stderr, "strdup returned NULL\n");
967 if (ndevs < MAXUSBDEV)
968 devs[ndevs++] = optarg;
974 itimeout = atoi(optarg);
989 /* open all the USBDEVS\d+ devices */
990 for (i = 0; i < MAXUSBDEV; i++) {
991 sprintf(buf, "%s%d", USBDEV, i);
992 fds[ndevs] = open(buf, O_RDWR);
993 if (fds[ndevs] >= 0) {
994 devs[ndevs] = strdup(buf);
995 if (devs[ndevs] == NULL) {
996 fprintf(stderr, "strdup returned NULL\n");
1000 printf("%s: opened %s\n",
1001 __progname, devs[ndevs]);
1002 if (fds[ndevs] > maxfd)
1005 } else if (errno != ENXIO && errno != ENOENT) {
1006 /* there was an error, on a device that does
1007 * exist (device is configured)
1009 fprintf(stderr, "%s: Could not open %s, %s\n",
1010 __progname, buf, strerror(errno));
1015 /* open all the files specified with -f */
1016 for (i = 0; i < ndevs; i++) {
1017 fds[i] = open(devs[i], O_RDWR);
1019 fprintf(stderr, "%s: Could not open %s, %s\n",
1020 __progname, devs[i], strerror(errno));
1024 printf("%s: opened %s\n",
1025 __progname, devs[i]);
1033 fprintf(stderr, "No USB host controllers found\n");
1038 /* Do the explore once and exit */
1040 for (i = 0; i < ndevs; i++) {
1041 error = ioctl(fds[i], USB_DISCOVER);
1043 fprintf(stderr, "%s: ioctl(%s, USB_DISCOVER) "
1045 __progname, devs[i], strerror(errno));
1052 if (handle_events) {
1054 printf("%s: reading configuration file %s\n",
1055 __progname, configfile);
1056 read_configuration();
1058 fd = open(USBDEV, O_RDONLY | O_NONBLOCK);
1060 fprintf(stderr, "%s: Could not open %s, %s\n",
1061 __progname, USBDEV, strerror(errno));
1065 printf("%s: opened %s\n", __progname, USBDEV);
1069 process_event_queue(fd); /* dequeue the initial events */
1072 /* move to the background */
1076 /* start select on all the open file descriptors */
1081 FD_SET(fd, &r); /* device USBDEV */
1082 for (i = 0; i < ndevs; i++)
1083 FD_SET(fds[i], &w); /* device USBDEV\d+ */
1085 tv.tv_sec = itimeout;
1086 error = select(maxfd+1, &r, &w, 0, itimeout ? &tv : 0);
1088 fprintf(stderr, "%s: Select failed, %s\n",
1089 __progname, strerror(errno));
1093 /* USBDEV\d+ devices have signaled change, do a usb_discover */
1094 for (i = 0; i < ndevs; i++) {
1095 if (error == 0 || FD_ISSET(fds[i], &w)) {
1097 printf("%s: doing %sdiscovery on %s\n",
1099 (error? "":"timeout "), devs[i]);
1100 if (ioctl(fds[i], USB_DISCOVER) < 0) {
1101 fprintf(stderr, "%s: ioctl(%s, "
1102 "USB_DISCOVER) failed, %s\n",
1103 __progname, devs[i],
1110 /* check the event queue */
1111 if (handle_events && (FD_ISSET(fd, &r) || error == 0)) {
1113 printf("%s: processing event queue %son %s\n",
1115 (error? "":"due to timeout "), USBDEV);
1116 process_event_queue(fd);