[Midnightbsd-cvs] src [8336] trunk/contrib/libpcap: add missing files
laffer1 at midnightbsd.org
laffer1 at midnightbsd.org
Sat Sep 17 18:57:38 EDT 2016
Revision: 8336
http://svnweb.midnightbsd.org/src/?rev=8336
Author: laffer1
Date: 2016-09-17 18:57:37 -0400 (Sat, 17 Sep 2016)
Log Message:
-----------
add missing files
Added Paths:
-----------
trunk/contrib/libpcap/pcap-canusb-linux.c
trunk/contrib/libpcap/pcap-canusb-linux.h
Added: trunk/contrib/libpcap/pcap-canusb-linux.c
===================================================================
--- trunk/contrib/libpcap/pcap-canusb-linux.c (rev 0)
+++ trunk/contrib/libpcap/pcap-canusb-linux.c 2016-09-17 22:57:37 UTC (rev 8336)
@@ -0,0 +1,428 @@
+/*
+ * Copyright (c) 2009 Felix Obenhuber
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Sockettrace sniffing API implementation for Linux platform
+ * By Felix Obenhuber <felix at obenhuber.de>
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <libusb-1.0/libusb.h>
+
+#include "pcap-int.h"
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <string.h>
+
+
+#define CANUSB_IFACE "canusb"
+
+#define CANUSB_VID 0x0403
+#define CANUSB_PID 0x8990
+
+#define USE_THREAD 1
+
+#if USE_THREAD == 0
+#include <signal.h>
+#endif
+
+
+/* forward declaration */
+static int canusb_activate(pcap_t *);
+static int canusb_read_linux(pcap_t *, int , pcap_handler , u_char *);
+static int canusb_inject_linux(pcap_t *, const void *, size_t);
+static int canusb_setfilter_linux(pcap_t *, struct bpf_program *);
+static int canusb_setdirection_linux(pcap_t *, pcap_direction_t);
+static int canusb_stats_linux(pcap_t *, struct pcap_stat *);
+
+struct CAN_Msg
+{
+ uint32_t timestamp;
+ uint32_t id;
+ uint32_t length;
+ uint8_t data[8];
+};
+
+struct canusb_t
+{
+ libusb_context *ctx;
+ libusb_device_handle *dev;
+ char* src;
+ pthread_t worker;
+ int rdpipe, wrpipe;
+ volatile int* loop;
+};
+
+static struct canusb_t canusb;
+static volatile int loop;
+
+
+
+int canusb_platform_finddevs(pcap_if_t **alldevsp, char *err_str)
+{
+ libusb_context *fdctx;
+ libusb_device** devs;
+ unsigned char sernum[65];
+ unsigned char buf[96];
+ int cnt, i;
+
+ libusb_init(&fdctx);
+
+ cnt = libusb_get_device_list(fdctx,&devs);
+
+ for(i=0;i<cnt;i++)
+ {
+ int ret;
+ // Check if this device is interesting.
+ struct libusb_device_descriptor desc;
+ libusb_get_device_descriptor(devs[i],&desc);
+
+ if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
+ continue; //It is not, check next device
+
+ //It is!
+ libusb_device_handle *dh = NULL;
+
+ if (ret = libusb_open(devs[i],&dh) == 0)
+ {
+ char dev_name[30];
+ char dev_descr[50];
+ int n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,sernum,64);
+ sernum[n] = 0;
+
+ snprintf(dev_name, 30, CANUSB_IFACE"%s", sernum);
+ snprintf(dev_descr, 50, "CanUSB [%s]", sernum);
+
+ libusb_close(dh);
+
+ if (pcap_add_if(alldevsp, dev_name, 0, dev_descr, err_str) < 0)
+ {
+ libusb_free_device_list(devs,1);
+ return -1;
+ }
+ }
+ }
+
+ libusb_free_device_list(devs,1);
+ libusb_exit(fdctx);
+ return 0;
+}
+
+static libusb_device_handle* canusb_opendevice(struct libusb_context *ctx, char* devserial)
+{
+ libusb_device_handle* dh;
+ libusb_device** devs;
+ unsigned char serial[65];
+ int cnt,i,n;
+
+ cnt = libusb_get_device_list(ctx,&devs);
+
+ for(i=0;i<cnt;i++)
+ {
+ // Check if this device is interesting.
+ struct libusb_device_descriptor desc;
+ libusb_get_device_descriptor(devs[i],&desc);
+
+ if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
+ continue;
+
+ //Found one!
+ libusb_device_handle *dh = NULL;
+
+ if (libusb_open(devs[i],&dh) != 0) continue;
+
+ n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,serial,64);
+ serial[n] = 0;
+
+ if ((devserial) && (strcmp(serial,devserial) != 0))
+ {
+ libusb_close(dh);
+ continue;
+ }
+
+ if ((libusb_kernel_driver_active(dh,0)) && (libusb_detach_kernel_driver(dh,0) != 0))
+ {
+ libusb_close(dh);
+ continue;
+ }
+
+ if (libusb_set_configuration(dh,1) != 0)
+ {
+ libusb_close(dh);
+ continue;
+ }
+
+ if (libusb_claim_interface(dh,0) != 0)
+ {
+ libusb_close(dh);
+ continue;
+ }
+
+ //Fount it!
+ libusb_free_device_list(devs,1);
+ return dh;
+ }
+
+ libusb_free_device_list(devs,1);
+ return NULL;
+}
+
+
+pcap_t *
+canusb_create(const char *device, char *ebuf)
+{
+ pcap_t* p;
+
+ libusb_init(&canusb.ctx);
+
+ p = pcap_create_common(device, ebuf);
+ if (p == NULL)
+ return (NULL);
+
+ memset(&canusb, 0x00, sizeof(canusb));
+
+
+ p->activate_op = canusb_activate;
+
+ canusb.src = strdup(p->opt.source);
+ return (p);
+}
+
+
+static void* canusb_capture_thread(struct canusb_t *canusb)
+{
+ struct libusb_context *ctx;
+ libusb_device_handle *dev;
+
+ int i, n;
+ struct
+ {
+ uint8_t rxsz, txsz;
+ } status;
+
+ libusb_init(&ctx);
+
+ char *serial = canusb->src + strlen(CANUSB_IFACE);
+ dev = canusb_opendevice(ctx, serial);
+
+ fcntl(canusb->wrpipe, F_SETFL, O_NONBLOCK);
+
+ while(*canusb->loop)
+ {
+ int sz, ret;
+ struct CAN_Msg msg;
+
+ libusb_interrupt_transfer(dev, 0x81, (unsigned char*)&status, sizeof(status), &sz, 100);
+ //HACK!!!!! -> drop buffered data, read new one by reading twice.
+ ret = libusb_interrupt_transfer(dev, 0x81, (unsigned char*)&status, sizeof(status), &sz, 100);
+
+ for(i = 0; i<status.rxsz; i++)
+ {
+ libusb_bulk_transfer(dev, 0x85, (unsigned char*)&msg, sizeof(msg), &sz, 100);
+ n = write(canusb->wrpipe, &msg, sizeof(msg));
+ }
+
+ }
+
+ libusb_close(dev);
+ libusb_exit(ctx);
+
+ return NULL;
+}
+
+static int canusb_startcapture(struct canusb_t* this)
+{
+ int pipefd[2];
+
+ if (pipe(pipefd) == -1) return -1;
+
+ canusb.rdpipe = pipefd[0];
+ canusb.wrpipe = pipefd[1];
+ canusb.loop = &loop;
+
+ loop = 1;
+ pthread_create(&this->worker, NULL, canusb_capture_thread, &canusb);
+
+ return canusb.rdpipe;
+}
+
+static void canusb_clearbufs(struct canusb_t* this)
+{
+ unsigned char cmd[16];
+ int al;
+
+ cmd[0] = 1; //Empty incoming buffer
+ cmd[1] = 1; //Empty outgoing buffer
+ cmd[3] = 0; //Not a write to serial number
+ memset(&cmd[4],0,16-4);
+
+ libusb_interrupt_transfer(this->dev, 0x1,cmd,16,&al,100);
+}
+
+
+static void canusb_close(pcap_t* handle)
+{
+ loop = 0;
+ pthread_join(canusb.worker, NULL);
+
+ if (canusb.dev)
+ {
+ libusb_close(canusb.dev);
+ canusb.dev = NULL;
+ }
+}
+
+
+
+static int canusb_activate(pcap_t* handle)
+{
+ handle->read_op = canusb_read_linux;
+
+ handle->inject_op = canusb_inject_linux;
+ handle->setfilter_op = canusb_setfilter_linux;
+ handle->setdirection_op = canusb_setdirection_linux;
+ handle->getnonblock_op = pcap_getnonblock_fd;
+ handle->setnonblock_op = pcap_setnonblock_fd;
+ handle->stats_op = canusb_stats_linux;
+ handle->cleanup_op = canusb_close;
+
+ /* Initialize some components of the pcap structure. */
+ handle->bufsize = 32;
+ handle->offset = 8;
+ handle->linktype = DLT_CAN_SOCKETCAN;
+ handle->set_datalink_op = NULL;
+
+ char* serial = handle->opt.source + strlen("canusb");
+
+ canusb.dev = canusb_opendevice(canusb.ctx,serial);
+ if (!canusb.dev)
+ {
+ snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't open USB Device:");
+ return PCAP_ERROR;
+ }
+
+ canusb_clearbufs(&canusb);
+
+ handle->fd = canusb_startcapture(&canusb);
+ handle->selectable_fd = handle->fd;
+
+ return 0;
+}
+
+
+
+
+static int
+canusb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
+{
+ static struct timeval firstpacket = { -1, -1};
+
+ int msgsent = 0;
+ int i = 0;
+ struct CAN_Msg msg;
+ struct pcap_pkthdr pkth;
+
+ while(i < max_packets)
+ {
+ usleep(10 * 1000);
+ int n = read(handle->fd, &msg, sizeof(msg));
+ if (n <= 0) break;
+ pkth.caplen = pkth.len = n;
+ pkth.caplen -= 4;
+ pkth.caplen -= 8 - msg.length;
+
+ if ((firstpacket.tv_sec == -1) && (firstpacket.tv_usec == -1))
+ gettimeofday(&firstpacket, NULL);
+
+ pkth.ts.tv_usec = firstpacket.tv_usec + (msg.timestamp % 100) * 10000;
+ pkth.ts.tv_sec = firstpacket.tv_usec + (msg.timestamp / 100);
+ if (pkth.ts.tv_usec > 1000000)
+ {
+ pkth.ts.tv_usec -= 1000000;
+ pkth.ts.tv_sec++;
+ }
+
+ callback(user, &pkth, (void*)&msg.id);
+ i++;
+ }
+
+ return i;
+}
+
+
+static int
+canusb_inject_linux(pcap_t *handle, const void *buf, size_t size)
+{
+ /* not yet implemented */
+ snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on canusb devices");
+ return (-1);
+}
+
+
+static int
+canusb_stats_linux(pcap_t *handle, struct pcap_stat *stats)
+{
+ /* not yet implemented */
+ stats->ps_recv = 0; /* number of packets received */
+ stats->ps_drop = 0; /* number of packets dropped */
+ stats->ps_ifdrop = 0; /* drops by interface -- only supported on some platforms */
+ return 0;
+}
+
+
+static int
+canusb_setfilter_linux(pcap_t *p, struct bpf_program *fp)
+{
+ /* not yet implemented */
+ return 0;
+}
+
+
+static int
+canusb_setdirection_linux(pcap_t *p, pcap_direction_t d)
+{
+ /* no support for PCAP_D_OUT */
+ if (d == PCAP_D_OUT)
+ {
+ snprintf(p->errbuf, sizeof(p->errbuf),
+ "Setting direction to PCAP_D_OUT is not supported on this interface");
+ return -1;
+ }
+
+ p->direction = d;
+
+ return 0;
+}
+
+
+/* eof */
Property changes on: trunk/contrib/libpcap/pcap-canusb-linux.c
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+MidnightBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
Added: trunk/contrib/libpcap/pcap-canusb-linux.h
===================================================================
--- trunk/contrib/libpcap/pcap-canusb-linux.h (rev 0)
+++ trunk/contrib/libpcap/pcap-canusb-linux.h 2016-09-17 22:57:37 UTC (rev 8336)
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2009 Felix Obenhuber
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote
+ * products derived from this software without specific prior written
+ * permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ */
+
+/*
+ * Prototypes for SocketCAN related functions
+ */
+pcap_t* canusb_create(const char *device, char *ebuf);
+int canusb_listdevices(pcap_if_t **pdevlist, char* errbuf);
+
Property changes on: trunk/contrib/libpcap/pcap-canusb-linux.h
___________________________________________________________________
Added: svn:eol-style
## -0,0 +1 ##
+native
\ No newline at end of property
Added: svn:keywords
## -0,0 +1 ##
+MidnightBSD=%H
\ No newline at end of property
Added: svn:mime-type
## -0,0 +1 ##
+text/plain
\ No newline at end of property
More information about the Midnightbsd-cvs
mailing list