2 * Copyright (c) 2009 Felix Obenhuber
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. The name of the author may not be used to endorse or promote
15 * products derived from this software without specific prior written
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 * Sockettrace sniffing API implementation for Linux platform
31 * By Felix Obenhuber <felix@obenhuber.de>
39 #include <libusb-1.0/libusb.h>
48 #include "pcap-canusb-linux.h"
50 #define CANUSB_IFACE "canusb"
52 #define CANUSB_VID 0x0403
53 #define CANUSB_PID 0x8990
62 /* forward declaration */
63 static int canusb_activate(pcap_t *);
64 static int canusb_read_linux(pcap_t *, int , pcap_handler , u_char *);
65 static int canusb_inject_linux(pcap_t *, const void *, size_t);
66 static int canusb_setfilter_linux(pcap_t *, struct bpf_program *);
67 static int canusb_setdirection_linux(pcap_t *, pcap_direction_t);
68 static int canusb_stats_linux(pcap_t *, struct pcap_stat *);
79 * Private data for capturing on Linux CANbus USB devices.
83 libusb_device_handle *dev;
89 int canusb_findalldevs(pcap_if_t **alldevsp, char *err_str)
91 libusb_context *fdctx;
93 unsigned char sernum[65];
96 if (libusb_init(&fdctx) != 0) {
98 * XXX - if this doesn't just mean "no USB file system mounted",
99 * perhaps we should report a real error rather than just
100 * saying "no CANUSB devices".
105 cnt = libusb_get_device_list(fdctx,&devs);
110 // Check if this device is interesting.
111 struct libusb_device_descriptor desc;
112 libusb_get_device_descriptor(devs[i],&desc);
114 if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
115 continue; //It is not, check next device
118 libusb_device_handle *dh = NULL;
120 if ((ret = libusb_open(devs[i],&dh)) == 0)
124 int n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,sernum,64);
127 snprintf(dev_name, 30, CANUSB_IFACE"%s", sernum);
128 snprintf(dev_descr, 50, "CanUSB [%s]", sernum);
132 if (pcap_add_if(alldevsp, dev_name, 0, dev_descr, err_str) < 0)
134 libusb_free_device_list(devs,1);
141 libusb_free_device_list(devs,1);
146 static libusb_device_handle* canusb_opendevice(struct libusb_context *ctx, char* devserial)
148 libusb_device** devs;
149 unsigned char serial[65];
152 cnt = libusb_get_device_list(ctx,&devs);
156 // Check if this device is interesting.
157 struct libusb_device_descriptor desc;
158 libusb_get_device_descriptor(devs[i],&desc);
160 if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
164 libusb_device_handle *dh = NULL;
166 if (libusb_open(devs[i],&dh) != 0) continue;
168 n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,serial,64);
171 if ((devserial) && (strcmp((char *)serial,devserial) != 0))
177 if ((libusb_kernel_driver_active(dh,0)) && (libusb_detach_kernel_driver(dh,0) != 0))
183 if (libusb_set_configuration(dh,1) != 0)
189 if (libusb_claim_interface(dh,0) != 0)
196 libusb_free_device_list(devs,1);
200 libusb_free_device_list(devs,1);
206 canusb_create(const char *device, char *ebuf, int *is_ours)
212 struct pcap_canusb *canusb;
214 /* Does this look like a DAG device? */
215 cp = strrchr(device, '/');
218 /* Does it begin with "canusb"? */
219 if (strncmp(cp, "canusb", 6) != 0) {
220 /* Nope, doesn't begin with "canusb" */
224 /* Yes - is "canusb" followed by a number? */
226 devnum = strtol(cp, &cpend, 10);
227 if (cpend == cp || *cpend != '\0') {
228 /* Not followed by a number. */
233 /* Followed by a non-valid number. */
238 /* OK, it's probably ours. */
241 p = pcap_create_common(device, ebuf, sizeof (struct pcap_canusb));
251 p->activate_op = canusb_activate;
257 static void* canusb_capture_thread(void *arg)
259 struct pcap_canusb *canusb = arg;
266 fcntl(canusb->wrpipe, F_SETFL, O_NONBLOCK);
273 libusb_interrupt_transfer(canusb->dev, 0x81, (unsigned char*)&status, sizeof(status), &sz, 100);
274 //HACK!!!!! -> drop buffered data, read new one by reading twice.
275 libusb_interrupt_transfer(canusb->dev, 0x81, (unsigned char*)&status, sizeof(status), &sz, 100);
277 for(i = 0; i<status.rxsz; i++)
279 libusb_bulk_transfer(canusb->dev, 0x85, (unsigned char*)&msg, sizeof(msg), &sz, 100);
280 write(canusb->wrpipe, &msg, sizeof(msg));
288 static int canusb_startcapture(struct pcap_canusb* this)
292 if (pipe(pipefd) == -1)
295 this->rdpipe = pipefd[0];
296 this->wrpipe = pipefd[1];
299 pthread_create(&this->worker, NULL, canusb_capture_thread, this);
304 static void canusb_clearbufs(struct pcap_canusb* this)
306 unsigned char cmd[16];
309 cmd[0] = 1; //Empty incoming buffer
310 cmd[1] = 1; //Empty outgoing buffer
311 cmd[3] = 0; //Not a write to serial number
312 memset(&cmd[4],0,16-4);
314 libusb_interrupt_transfer(this->dev, 0x1,cmd,16,&al,100);
318 static void canusb_close(pcap_t* handle)
320 struct pcap_canusb *canusb = handle->priv;
323 pthread_join(canusb->worker, NULL);
327 libusb_close(canusb->dev);
332 libusb_exit(canusb->ctx);
339 static int canusb_activate(pcap_t* handle)
341 struct pcap_canusb *canusb = handle->priv;
344 if (libusb_init(&canusb->ctx) != 0) {
346 * XXX - what causes this to fail?
348 snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "libusb_init() failed");
352 handle->read_op = canusb_read_linux;
354 handle->inject_op = canusb_inject_linux;
355 handle->setfilter_op = canusb_setfilter_linux;
356 handle->setdirection_op = canusb_setdirection_linux;
357 handle->getnonblock_op = pcap_getnonblock_fd;
358 handle->setnonblock_op = pcap_setnonblock_fd;
359 handle->stats_op = canusb_stats_linux;
360 handle->cleanup_op = canusb_close;
362 /* Initialize some components of the pcap structure. */
363 handle->bufsize = 32;
365 handle->linktype = DLT_CAN_SOCKETCAN;
366 handle->set_datalink_op = NULL;
368 serial = handle->opt.source + strlen(CANUSB_IFACE);
370 canusb->dev = canusb_opendevice(canusb->ctx, serial);
373 libusb_exit(canusb->ctx);
374 snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't open USB Device");
378 canusb_clearbufs(canusb);
380 handle->fd = canusb_startcapture(canusb);
381 handle->selectable_fd = handle->fd;
390 canusb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
392 static struct timeval firstpacket = { -1, -1};
395 struct pcap_pkthdr pkth;
397 while(i < max_packets)
401 n = read(handle->fd, &msg, sizeof(msg));
404 pkth.caplen = pkth.len = n;
406 pkth.caplen -= 8 - msg.length;
408 if ((firstpacket.tv_sec == -1) && (firstpacket.tv_usec == -1))
409 gettimeofday(&firstpacket, NULL);
411 pkth.ts.tv_usec = firstpacket.tv_usec + (msg.timestamp % 100) * 10000;
412 pkth.ts.tv_sec = firstpacket.tv_usec + (msg.timestamp / 100);
413 if (pkth.ts.tv_usec > 1000000)
415 pkth.ts.tv_usec -= 1000000;
419 callback(user, &pkth, (void*)&msg.id);
428 canusb_inject_linux(pcap_t *handle, const void *buf, size_t size)
430 /* not yet implemented */
431 snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on canusb devices");
437 canusb_stats_linux(pcap_t *handle, struct pcap_stat *stats)
439 /* not yet implemented */
440 stats->ps_recv = 0; /* number of packets received */
441 stats->ps_drop = 0; /* number of packets dropped */
442 stats->ps_ifdrop = 0; /* drops by interface -- only supported on some platforms */
448 canusb_setfilter_linux(pcap_t *p, struct bpf_program *fp)
450 /* not yet implemented */
456 canusb_setdirection_linux(pcap_t *p, pcap_direction_t d)
458 /* no support for PCAP_D_OUT */
461 snprintf(p->errbuf, sizeof(p->errbuf),
462 "Setting direction to PCAP_D_OUT is not supported on this interface");