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 #define CANUSB_IFACE "canusb"
50 #define CANUSB_VID 0x0403
51 #define CANUSB_PID 0x8990
60 /* forward declaration */
61 static int canusb_activate(pcap_t
*);
62 static int canusb_read_linux(pcap_t
*, int , pcap_handler
, u_char
*);
63 static int canusb_inject_linux(pcap_t
*, const void *, size_t);
64 static int canusb_setfilter_linux(pcap_t
*, struct bpf_program
*);
65 static int canusb_setdirection_linux(pcap_t
*, pcap_direction_t
);
66 static int canusb_stats_linux(pcap_t
*, struct pcap_stat
*);
79 libusb_device_handle
*dev
;
86 static struct canusb_t canusb
;
87 static volatile int loop
;
91 int canusb_platform_finddevs(pcap_if_t
**alldevsp
, char *err_str
)
93 libusb_context
*fdctx
;
95 unsigned char sernum
[65];
96 unsigned char buf
[96];
101 cnt
= libusb_get_device_list(fdctx
,&devs
);
106 // Check if this device is interesting.
107 struct libusb_device_descriptor desc
;
108 libusb_get_device_descriptor(devs
[i
],&desc
);
110 if ((desc
.idVendor
!= CANUSB_VID
) || (desc
.idProduct
!= CANUSB_PID
))
111 continue; //It is not, check next device
114 libusb_device_handle
*dh
= NULL
;
116 if (ret
= libusb_open(devs
[i
],&dh
) == 0)
120 int n
= libusb_get_string_descriptor_ascii(dh
,desc
.iSerialNumber
,sernum
,64);
123 snprintf(dev_name
, 30, CANUSB_IFACE
"%s", sernum
);
124 snprintf(dev_descr
, 50, "CanUSB [%s]", sernum
);
128 if (pcap_add_if(alldevsp
, dev_name
, 0, dev_descr
, err_str
) < 0)
130 libusb_free_device_list(devs
,1);
136 libusb_free_device_list(devs
,1);
141 static libusb_device_handle
* canusb_opendevice(struct libusb_context
*ctx
, char* devserial
)
143 libusb_device_handle
* dh
;
144 libusb_device
** devs
;
145 unsigned char serial
[65];
148 cnt
= libusb_get_device_list(ctx
,&devs
);
152 // Check if this device is interesting.
153 struct libusb_device_descriptor desc
;
154 libusb_get_device_descriptor(devs
[i
],&desc
);
156 if ((desc
.idVendor
!= CANUSB_VID
) || (desc
.idProduct
!= CANUSB_PID
))
160 libusb_device_handle
*dh
= NULL
;
162 if (libusb_open(devs
[i
],&dh
) != 0) continue;
164 n
= libusb_get_string_descriptor_ascii(dh
,desc
.iSerialNumber
,serial
,64);
167 if ((devserial
) && (strcmp(serial
,devserial
) != 0))
173 if ((libusb_kernel_driver_active(dh
,0)) && (libusb_detach_kernel_driver(dh
,0) != 0))
179 if (libusb_set_configuration(dh
,1) != 0)
185 if (libusb_claim_interface(dh
,0) != 0)
192 libusb_free_device_list(devs
,1);
196 libusb_free_device_list(devs
,1);
202 canusb_create(const char *device
, char *ebuf
)
206 libusb_init(&canusb
.ctx
);
208 p
= pcap_create_common(device
, ebuf
);
212 memset(&canusb
, 0x00, sizeof(canusb
));
215 p
->activate_op
= canusb_activate
;
217 canusb
.src
= strdup(p
->opt
.source
);
222 static void* canusb_capture_thread(struct canusb_t
*canusb
)
224 struct libusb_context
*ctx
;
225 libusb_device_handle
*dev
;
235 char *serial
= canusb
->src
+ strlen(CANUSB_IFACE
);
236 dev
= canusb_opendevice(ctx
, serial
);
238 fcntl(canusb
->wrpipe
, F_SETFL
, O_NONBLOCK
);
245 libusb_interrupt_transfer(dev
, 0x81, (unsigned char*)&status
, sizeof(status
), &sz
, 100);
246 //HACK!!!!! -> drop buffered data, read new one by reading twice.
247 ret
= libusb_interrupt_transfer(dev
, 0x81, (unsigned char*)&status
, sizeof(status
), &sz
, 100);
249 for(i
= 0; i
<status
.rxsz
; i
++)
251 libusb_bulk_transfer(dev
, 0x85, (unsigned char*)&msg
, sizeof(msg
), &sz
, 100);
252 n
= write(canusb
->wrpipe
, &msg
, sizeof(msg
));
263 static int canusb_startcapture(struct canusb_t
* this)
267 if (pipe(pipefd
) == -1) return -1;
269 canusb
.rdpipe
= pipefd
[0];
270 canusb
.wrpipe
= pipefd
[1];
274 pthread_create(&this->worker
, NULL
, canusb_capture_thread
, &canusb
);
276 return canusb
.rdpipe
;
279 static void canusb_clearbufs(struct canusb_t
* this)
281 unsigned char cmd
[16];
284 cmd
[0] = 1; //Empty incoming buffer
285 cmd
[1] = 1; //Empty outgoing buffer
286 cmd
[3] = 0; //Not a write to serial number
287 memset(&cmd
[4],0,16-4);
289 libusb_interrupt_transfer(this->dev
, 0x1,cmd
,16,&al
,100);
293 static void canusb_close(pcap_t
* handle
)
296 pthread_join(canusb
.worker
, NULL
);
300 libusb_close(canusb
.dev
);
307 static int canusb_activate(pcap_t
* handle
)
309 handle
->read_op
= canusb_read_linux
;
311 handle
->inject_op
= canusb_inject_linux
;
312 handle
->setfilter_op
= canusb_setfilter_linux
;
313 handle
->setdirection_op
= canusb_setdirection_linux
;
314 handle
->getnonblock_op
= pcap_getnonblock_fd
;
315 handle
->setnonblock_op
= pcap_setnonblock_fd
;
316 handle
->stats_op
= canusb_stats_linux
;
317 handle
->cleanup_op
= canusb_close
;
319 /* Initialize some components of the pcap structure. */
320 handle
->bufsize
= 32;
322 handle
->linktype
= DLT_CAN_SOCKETCAN
;
323 handle
->set_datalink_op
= NULL
;
325 char* serial
= handle
->opt
.source
+ strlen("canusb");
327 canusb
.dev
= canusb_opendevice(canusb
.ctx
,serial
);
330 snprintf(handle
->errbuf
, PCAP_ERRBUF_SIZE
, "Can't open USB Device:");
334 canusb_clearbufs(&canusb
);
336 handle
->fd
= canusb_startcapture(&canusb
);
337 handle
->selectable_fd
= handle
->fd
;
346 canusb_read_linux(pcap_t
*handle
, int max_packets
, pcap_handler callback
, u_char
*user
)
348 static struct timeval firstpacket
= { -1, -1};
353 struct pcap_pkthdr pkth
;
355 while(i
< max_packets
)
358 int n
= read(handle
->fd
, &msg
, sizeof(msg
));
360 pkth
.caplen
= pkth
.len
= n
;
362 pkth
.caplen
-= 8 - msg
.length
;
364 if ((firstpacket
.tv_sec
== -1) && (firstpacket
.tv_usec
== -1))
365 gettimeofday(&firstpacket
, NULL
);
367 pkth
.ts
.tv_usec
= firstpacket
.tv_usec
+ (msg
.timestamp
% 100) * 10000;
368 pkth
.ts
.tv_sec
= firstpacket
.tv_usec
+ (msg
.timestamp
/ 100);
369 if (pkth
.ts
.tv_usec
> 1000000)
371 pkth
.ts
.tv_usec
-= 1000000;
375 callback(user
, &pkth
, (void*)&msg
.id
);
384 canusb_inject_linux(pcap_t
*handle
, const void *buf
, size_t size
)
386 /* not yet implemented */
387 snprintf(handle
->errbuf
, PCAP_ERRBUF_SIZE
, "inject not supported on canusb devices");
393 canusb_stats_linux(pcap_t
*handle
, struct pcap_stat
*stats
)
395 /* not yet implemented */
396 stats
->ps_recv
= 0; /* number of packets received */
397 stats
->ps_drop
= 0; /* number of packets dropped */
398 stats
->ps_ifdrop
= 0; /* drops by interface -- only supported on some platforms */
404 canusb_setfilter_linux(pcap_t
*p
, struct bpf_program
*fp
)
406 /* not yet implemented */
412 canusb_setdirection_linux(pcap_t
*p
, pcap_direction_t d
)
414 /* no support for PCAP_D_OUT */
417 snprintf(p
->errbuf
, sizeof(p
->errbuf
),
418 "Setting direction to PCAP_D_OUT is not supported on this interface");