Lines Matching +full:supported +full:- +full:buses
40 #include "pcap-int.h"
41 #include "pcap-usb-linux.h"
42 #include "pcap-usb-linux-common.h"
74 #include "diag-control.h"
79 #define USBMON_DEV_PREFIX_LEN (sizeof USBMON_DEV_PREFIX - 1)
129 u_char *mmapbuf; /* memory-mapped region pointer */
152 * XXX - is there any notion of "up" and "running"? in usb_dev_add()
156 * As this refers to all buses, there's no notion of in usb_dev_add()
162 "Raw USB traffic, all USB buses", err_str) == NULL) in usb_dev_add()
163 return -1; in usb_dev_add()
166 * XXX - is there a way to determine whether anything's in usb_dev_add()
173 return -1; in usb_dev_add()
189 * We require 2.6.27 or later kernels, so we have binary-mode support. in usb_findalldevs()
196 name = data->d_name; in usb_findalldevs()
231 * 1) a fixed-length header, of size header_size; in usb_set_ring_size()
241 * Therefore, if we subtract the fixed-length size from the in usb_set_ring_size()
243 * don't worry about the descriptors - if we have descriptors, in usb_set_ring_size()
250 if (handle->snapshot < header_size) in usb_set_ring_size()
251 handle->snapshot = header_size; in usb_set_ring_size()
253 ring_size = (handle->snapshot - header_size) * 5; in usb_set_ring_size()
265 * maximum-size ring. in usb_set_ring_size()
268 handle->snapshot = header_size + (MAX_RING_SIZE/5); in usb_set_ring_size()
279 if (ioctl(handle->fd, MON_IOCT_RING_SIZE, ring_size) == -1) { in usb_set_ring_size()
280 pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_set_ring_size()
281 errno, "Can't set ring size from fd %d", handle->fd); in usb_set_ring_size()
282 return -1; in usb_set_ring_size()
290 struct pcap_usb_linux *handlep = handle->priv; in usb_mmap()
299 if (len == -1) { in usb_mmap()
300 /* Failed. Fall back on non-memory-mapped access. */ in usb_mmap()
304 handlep->mmapbuflen = len; in usb_mmap()
305 handlep->mmapbuf = mmap(0, handlep->mmapbuflen, PROT_READ, in usb_mmap()
306 MAP_SHARED, handle->fd, 0); in usb_mmap()
307 if (handlep->mmapbuf == MAP_FAILED) { in usb_mmap()
310 * just try to fall back on non-memory-mapped access. in usb_mmap()
356 char* name = data->d_name; in probe_devices()
361 snprintf(busdevpath, sizeof(busdevpath), "/dev/bus/usb/%03d/%s", bus, data->d_name); in probe_devices()
364 if (fd == -1) in probe_devices()
432 if (strncmp(cp, USB_IFACE, sizeof USB_IFACE - 1) != 0) { in usb_create()
437 /* Yes - is USB_IFACE followed by a number? */ in usb_create()
438 cp += sizeof USB_IFACE - 1; in usb_create()
446 /* Followed by a non-valid number. */ in usb_create()
458 p->activate_op = usb_activate; in usb_create()
465 struct pcap_usb_linux *handlep = handle->priv; in usb_activate()
476 if (handle->snapshot <= 0 || handle->snapshot > MAXIMUM_SNAPLEN) in usb_activate()
477 handle->snapshot = MAXIMUM_SNAPLEN; in usb_activate()
480 handle->bufsize = handle->snapshot; in usb_activate()
481 handle->offset = 0; in usb_activate()
482 handle->linktype = DLT_USB_LINUX; in usb_activate()
484 handle->inject_op = usb_inject_linux; in usb_activate()
485 handle->setfilter_op = install_bpf_program; /* no kernel filtering */ in usb_activate()
486 handle->setdirection_op = usb_setdirection_linux; in usb_activate()
487 handle->set_datalink_op = NULL; /* can't change data link type */ in usb_activate()
488 handle->getnonblock_op = pcap_getnonblock_fd; in usb_activate()
489 handle->setnonblock_op = pcap_setnonblock_fd; in usb_activate()
492 if (sscanf(handle->opt.device, USB_IFACE"%d", &handlep->bus_index) != 1) in usb_activate()
494 snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_activate()
495 "Can't get USB bus index from %s", handle->opt.device); in usb_activate()
500 * We require 2.6.27 or later kernels, so we have binary-mode support. in usb_activate()
504 handlep->bus_index); in usb_activate()
505 handle->fd = open(full_path, O_RDONLY, 0); in usb_activate()
506 if (handle->fd < 0) in usb_activate()
517 * no support for monitoring USB buses in usb_activate()
521 * doesn't exist (no "scan all buses" in usb_activate()
529 handle->errbuf[0] = '\0'; in usb_activate()
537 snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_activate()
538 "Attempt to open %s failed with EACCES - root privileges may be required", in usb_activate()
547 pcap_fmt_errmsg_for_errno(handle->errbuf, in usb_activate()
554 if (handle->opt.rfmon) in usb_activate()
559 close(handle->fd); in usb_activate()
567 handle->linktype = DLT_USB_LINUX_MMAPPED; in usb_activate()
568 handle->stats_op = usb_stats_linux_bin; in usb_activate()
569 handle->read_op = usb_read_linux_mmap; in usb_activate()
570 handle->cleanup_op = usb_cleanup_linux_mmap; in usb_activate()
572 probe_devices(handlep->bus_index); in usb_activate()
576 * "handle->fd" is a real file, so in usb_activate()
579 handle->selectable_fd = handle->fd; in usb_activate()
591 if (usb_set_ring_size(handle, (int)sizeof(pcap_usb_header)) == -1) { in usb_activate()
593 close(handle->fd); in usb_activate()
596 handle->stats_op = usb_stats_linux_bin; in usb_activate()
597 handle->read_op = usb_read_linux_bin; in usb_activate()
599 probe_devices(handlep->bus_index); in usb_activate()
603 * "handle->fd" is a real file, so "select()" and "poll()" in usb_activate()
606 handle->selectable_fd = handle->fd; in usb_activate()
610 handle->buffer = malloc(handle->bufsize); in usb_activate()
611 if (!handle->buffer) { in usb_activate()
612 pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_activate()
614 close(handle->fd); in usb_activate()
623 snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_inject_linux()
624 "Packet injection is not supported on USB devices"); in usb_inject_linux()
625 return (-1); in usb_inject_linux()
635 p->direction = d; in usb_setdirection_linux()
642 struct pcap_usb_linux *handlep = handle->priv; in usb_stats_linux_bin()
645 ret = ioctl(handle->fd, MON_IOCG_STATS, &st); in usb_stats_linux_bin()
648 pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_stats_linux_bin()
649 errno, "Can't read stats from fd %d", handle->fd); in usb_stats_linux_bin()
650 return -1; in usb_stats_linux_bin()
653 stats->ps_recv = handlep->packets_read + st.queued; in usb_stats_linux_bin()
654 stats->ps_drop = st.dropped; in usb_stats_linux_bin()
655 stats->ps_ifdrop = 0; in usb_stats_linux_bin()
660 * see <linux-kernel-source>/Documentation/usb/usbmon.txt and
661 * <linux-kernel-source>/drivers/usb/mon/mon_bin.c binary ABI
666 struct pcap_usb_linux *handlep = handle->priv; in usb_read_linux_bin()
670 u_int clen = handle->snapshot - sizeof(pcap_usb_header); in usb_read_linux_bin()
673 info.hdr = (pcap_usb_header*) handle->buffer; in usb_read_linux_bin()
674 info.data = (u_char *)handle->buffer + sizeof(pcap_usb_header); in usb_read_linux_bin()
679 ret = ioctl(handle->fd, MON_IOCX_GET, &info); in usb_read_linux_bin()
680 if (handle->break_loop) in usb_read_linux_bin()
682 handle->break_loop = 0; in usb_read_linux_bin()
683 return -2; in usb_read_linux_bin()
685 } while ((ret == -1) && (errno == EINTR)); in usb_read_linux_bin()
691 pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_read_linux_bin()
692 errno, "Can't read from fd %d", handle->fd); in usb_read_linux_bin()
693 return -1; in usb_read_linux_bin()
697 * info.hdr->data_len is the number of bytes of isochronous in usb_read_linux_bin()
700 * because we're using the old 48-byte header. in usb_read_linux_bin()
702 * If info.hdr->data_flag is non-zero, there's no URB data; in usb_read_linux_bin()
703 * info.hdr->urb_len is the size of the buffer into which in usb_read_linux_bin()
705 * of data transferred. If info.hdr->data_flag is zero, in usb_read_linux_bin()
706 * there is URB data, and info.hdr->urb_len is the number in usb_read_linux_bin()
714 if (info.hdr->data_len < clen) in usb_read_linux_bin()
715 clen = info.hdr->data_len; in usb_read_linux_bin()
716 info.hdr->data_len = clen; in usb_read_linux_bin()
718 if (info.hdr->data_flag) { in usb_read_linux_bin()
720 * No data; just base the on-the-wire length on in usb_read_linux_bin()
721 * info.hdr->data_len (so that it's >= the captured in usb_read_linux_bin()
724 pkth.len = sizeof(pcap_usb_header) + info.hdr->data_len; in usb_read_linux_bin()
727 * We got data; base the on-the-wire length on in usb_read_linux_bin()
728 * info.hdr->urb_len, so that it includes data in usb_read_linux_bin()
732 pkth.len = sizeof(pcap_usb_header) + info.hdr->urb_len; in usb_read_linux_bin()
734 pkth.ts.tv_sec = (time_t)info.hdr->ts_sec; in usb_read_linux_bin()
735 pkth.ts.tv_usec = info.hdr->ts_usec; in usb_read_linux_bin()
737 if (handle->fcode.bf_insns == NULL || in usb_read_linux_bin()
738 pcap_filter(handle->fcode.bf_insns, handle->buffer, in usb_read_linux_bin()
740 handlep->packets_read++; in usb_read_linux_bin()
741 callback(user, &pkth, handle->buffer); in usb_read_linux_bin()
749 * see <linux-kernel-source>/Documentation/usb/usbmon.txt and
750 * <linux-kernel-source>/drivers/usb/mon/mon_bin.c binary ABI
756 struct pcap_usb_linux *handlep = handle->priv; in usb_read_linux_mmap()
766 max_clen = handle->snapshot - sizeof(pcap_usb_header_mmapped); in usb_read_linux_mmap()
792 limit = max_packets - packets; in usb_read_linux_mmap()
800 * earlier (nflush) - MON_IOCX_MFETCH does both in usb_read_linux_mmap()
809 ret = ioctl(handle->fd, MON_IOCX_MFETCH, &fetch); in usb_read_linux_mmap()
810 if (handle->break_loop) in usb_read_linux_mmap()
812 handle->break_loop = 0; in usb_read_linux_mmap()
813 return -2; in usb_read_linux_mmap()
815 } while ((ret == -1) && (errno == EINTR)); in usb_read_linux_mmap()
821 pcap_fmt_errmsg_for_errno(handle->errbuf, in usb_read_linux_mmap()
823 handle->fd); in usb_read_linux_mmap()
824 return -1; in usb_read_linux_mmap()
831 * XXX - we can't check break_loop here, as in usb_read_linux_mmap()
835 * not be seen - and won't be flushed, either. in usb_read_linux_mmap()
839 * with the count of packets to flush - or in usb_read_linux_mmap()
840 * would have to flush the already-processed in usb_read_linux_mmap()
845 bp = &handlep->mmapbuf[vec[i]]; in usb_read_linux_mmap()
851 if (hdr->event_type == '@') in usb_read_linux_mmap()
855 * hdr->data_len is the number of bytes of in usb_read_linux_mmap()
859 * If hdr->data_flag is non-zero, there's no in usb_read_linux_mmap()
860 * URB data; hdr->urb_len is the size of the in usb_read_linux_mmap()
863 * If hdr->data_flag is zero, there is URB data, in usb_read_linux_mmap()
864 * and hdr->urb_len is the number of bytes in usb_read_linux_mmap()
875 if (hdr->data_len < clen) in usb_read_linux_mmap()
876 clen = hdr->data_len; in usb_read_linux_mmap()
878 if (hdr->data_flag) { in usb_read_linux_mmap()
880 * No data; just base the on-the-wire length in usb_read_linux_mmap()
881 * on hdr->data_len (so that it's >= the in usb_read_linux_mmap()
885 hdr->data_len; in usb_read_linux_mmap()
888 * We got data; base the on-the-wire length in usb_read_linux_mmap()
889 * on hdr->urb_len, so that it includes in usb_read_linux_mmap()
894 (hdr->ndesc * sizeof (usb_isodesc)) + hdr->urb_len; in usb_read_linux_mmap()
903 pkth.ts.tv_sec = (time_t)hdr->ts_sec; in usb_read_linux_mmap()
904 pkth.ts.tv_usec = hdr->ts_usec; in usb_read_linux_mmap()
906 if (handle->fcode.bf_insns == NULL || in usb_read_linux_mmap()
907 pcap_filter(handle->fcode.bf_insns, (u_char*) hdr, in usb_read_linux_mmap()
909 handlep->packets_read++; in usb_read_linux_mmap()
925 if (ioctl(handle->fd, MON_IOCH_MFLUSH, nflush) == -1) { in usb_read_linux_mmap()
926 pcap_fmt_errmsg_for_errno(handle->errbuf, PCAP_ERRBUF_SIZE, in usb_read_linux_mmap()
927 errno, "Can't mflush fd %d", handle->fd); in usb_read_linux_mmap()
928 return -1; in usb_read_linux_mmap()
936 struct pcap_usb_linux *handlep = handle->priv; in usb_cleanup_linux_mmap()
938 /* if we have a memory-mapped buffer, unmap it */ in usb_cleanup_linux_mmap()
939 if (handlep->mmapbuf != NULL) { in usb_cleanup_linux_mmap()
940 munmap(handlep->mmapbuf, handlep->mmapbuflen); in usb_cleanup_linux_mmap()
941 handlep->mmapbuf = NULL; in usb_cleanup_linux_mmap()