1/*
2 * Copyright (c) 2009 Felix Obenhuber
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
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
16 * permission.
17 *
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.
29 *
30 * Sockettrace sniffing API implementation for Linux platform
31 * By Felix Obenhuber <felix@obenhuber.de>
32 *
33 */
34
35#ifdef HAVE_CONFIG_H
36#include "config.h"
37#endif
38
39#include <libusb-1.0/libusb.h>
40
41#include "pcap-int.h"
42#include <stdlib.h>
43#include <unistd.h>
44#include <fcntl.h>
45#include <string.h>
46
47
48#define CANUSB_IFACE "canusb"
49
50#define CANUSB_VID 0x0403
51#define CANUSB_PID 0x8990
52
53#define USE_THREAD 1
54
55#if USE_THREAD == 0
56#include <signal.h>
57#endif
58
59
60/* forward declaration */
61static int canusb_activate(pcap_t *);
62static int canusb_read_linux(pcap_t *, int , pcap_handler , u_char *);
63static int canusb_inject_linux(pcap_t *, const void *, size_t);
64static int canusb_setfilter_linux(pcap_t *, struct bpf_program *);
65static int canusb_setdirection_linux(pcap_t *, pcap_direction_t);
66static int canusb_stats_linux(pcap_t *, struct pcap_stat *);
67
68struct CAN_Msg
69{
70    uint32_t timestamp;
71    uint32_t id;
72    uint32_t length;
73    uint8_t data[8];
74};
75
76struct canusb_t
77{
78    libusb_context *ctx;
79    libusb_device_handle *dev;
80    char *serial;
81    pthread_t worker;
82    int rdpipe, wrpipe;
83    volatile int* loop;
84};
85
86static struct canusb_t canusb;
87static volatile int loop;
88
89int canusb_findalldevs(pcap_if_t **alldevsp, char *err_str)
90{
91    libusb_context *fdctx;
92    libusb_device** devs;
93    unsigned char sernum[65];
94    unsigned char buf[96];
95    int cnt, i;
96
97    if (libusb_init(&fdctx) != 0) {
98        /*
99         * XXX - if this doesn't just mean "no USB file system mounted",
100         * perhaps we should report a real error rather than just
101         * saying "no CANUSB devices".
102         */
103        return 0;
104    }
105
106    cnt = libusb_get_device_list(fdctx,&devs);
107
108    for(i=0;i<cnt;i++)
109    {
110        int ret;
111        // Check if this device is interesting.
112        struct libusb_device_descriptor desc;
113        libusb_get_device_descriptor(devs[i],&desc);
114
115        if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
116            continue; //It is not, check next device
117
118        //It is!
119        libusb_device_handle *dh = NULL;
120
121        if (ret = libusb_open(devs[i],&dh) == 0)
122        {
123            char dev_name[30];
124            char dev_descr[50];
125            int n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,sernum,64);
126            sernum[n] = 0;
127
128            snprintf(dev_name, 30, CANUSB_IFACE"%s", sernum);
129            snprintf(dev_descr, 50, "CanUSB [%s]", sernum);
130
131            libusb_close(dh);
132
133            if (pcap_add_if(alldevsp, dev_name, 0, dev_descr, err_str) < 0)
134            {
135                libusb_free_device_list(devs,1);
136                return -1;
137            }
138        }
139    }
140
141    libusb_free_device_list(devs,1);
142    libusb_exit(fdctx);
143    return 0;
144}
145
146static libusb_device_handle* canusb_opendevice(struct libusb_context *ctx, char* devserial)
147{
148    libusb_device_handle* dh;
149    libusb_device** devs;
150    unsigned char serial[65];
151    int cnt,i,n;
152
153    cnt = libusb_get_device_list(ctx,&devs);
154
155    for(i=0;i<cnt;i++)
156    {
157        // Check if this device is interesting.
158        struct libusb_device_descriptor desc;
159        libusb_get_device_descriptor(devs[i],&desc);
160
161        if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
162          continue;
163
164        //Found one!
165        libusb_device_handle *dh = NULL;
166
167        if (libusb_open(devs[i],&dh) != 0) continue;
168
169        n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,serial,64);
170        serial[n] = 0;
171
172        if ((devserial) && (strcmp(serial,devserial) != 0))
173        {
174            libusb_close(dh);
175            continue;
176        }
177
178        if ((libusb_kernel_driver_active(dh,0)) && (libusb_detach_kernel_driver(dh,0) != 0))
179        {
180            libusb_close(dh);
181            continue;
182        }
183
184        if (libusb_set_configuration(dh,1) != 0)
185        {
186            libusb_close(dh);
187            continue;
188        }
189
190        if (libusb_claim_interface(dh,0) != 0)
191        {
192            libusb_close(dh);
193            continue;
194        }
195
196        //Fount it!
197        libusb_free_device_list(devs,1);
198        return dh;
199    }
200
201    libusb_free_device_list(devs,1);
202    return NULL;
203}
204
205
206pcap_t *
207canusb_create(const char *device, char *ebuf, int *is_ours)
208{
209    const char *cp;
210    char *cpend;
211    long devnum;
212    pcap_t* p;
213
214    libusb_init(&canusb.ctx);
215
216    /* Does this look like a DAG device? */
217    cp = strrchr(device, '/');
218    if (cp == NULL)
219        cp = device;
220    /* Does it begin with "canusb"? */
221    if (strncmp(cp, "canusb", 6) != 0) {
222        /* Nope, doesn't begin with "canusb" */
223        *is_ours = 0;
224        return NULL;
225    }
226    /* Yes - is "canusb" followed by a number? */
227    cp += 6;
228    devnum = strtol(cp, &cpend, 10);
229    if (cpend == cp || *cpend != '\0') {
230        /* Not followed by a number. */
231        *is_ours = 0;
232        return NULL;
233    }
234    if (devnum < 0) {
235        /* Followed by a non-valid number. */
236        *is_ours = 0;
237        return NULL;
238    }
239
240    /* OK, it's probably ours. */
241    *is_ours = 1;
242
243    p = pcap_create_common(device, ebuf);
244    if (p == NULL)
245        return (NULL);
246
247    memset(&canusb, 0x00, sizeof(canusb));
248
249    p->activate_op = canusb_activate;
250
251    return (p);
252}
253
254
255static void* canusb_capture_thread(struct canusb_t *canusb)
256{
257    struct libusb_context *ctx;
258    libusb_device_handle *dev;
259    int i, n;
260    struct
261    {
262      uint8_t rxsz, txsz;
263    } status;
264    char *serial;
265
266    libusb_init(&ctx);
267
268    serial = canusb->serial;
269    dev = canusb_opendevice(ctx, serial);
270
271    fcntl(canusb->wrpipe, F_SETFL, O_NONBLOCK);
272
273    while(*canusb->loop)
274    {
275        int sz, ret;
276        struct CAN_Msg msg;
277
278        libusb_interrupt_transfer(dev, 0x81, (unsigned char*)&status, sizeof(status), &sz, 100);
279        //HACK!!!!! -> drop buffered data, read new one by reading twice.
280        ret = libusb_interrupt_transfer(dev, 0x81, (unsigned char*)&status, sizeof(status), &sz, 100);
281
282        for(i = 0; i<status.rxsz; i++)
283        {
284            libusb_bulk_transfer(dev, 0x85, (unsigned char*)&msg, sizeof(msg), &sz, 100);
285            n = write(canusb->wrpipe, &msg, sizeof(msg));
286        }
287
288    }
289
290    libusb_close(dev);
291    libusb_exit(ctx);
292
293    return NULL;
294}
295
296static int canusb_startcapture(struct canusb_t* this)
297{
298    int pipefd[2];
299
300    if (pipe(pipefd) == -1)
301        return -1;
302
303    canusb.rdpipe = pipefd[0];
304    canusb.wrpipe = pipefd[1];
305    canusb.loop = &loop;
306
307    loop = 1;
308    pthread_create(&this->worker, NULL, canusb_capture_thread, &canusb);
309
310    return canusb.rdpipe;
311}
312
313static void canusb_clearbufs(struct canusb_t* this)
314{
315    unsigned char cmd[16];
316    int al;
317
318    cmd[0] = 1;  //Empty incoming buffer
319    cmd[1] = 1;  //Empty outgoing buffer
320    cmd[3] = 0;  //Not a write to serial number
321    memset(&cmd[4],0,16-4);
322
323    libusb_interrupt_transfer(this->dev, 0x1,cmd,16,&al,100);
324}
325
326
327static void canusb_close(pcap_t* handle)
328{
329    loop = 0;
330    pthread_join(canusb.worker, NULL);
331
332    if (canusb.dev)
333    {
334        libusb_close(canusb.dev);
335        canusb.dev = NULL;
336    }
337}
338
339
340
341static int canusb_activate(pcap_t* handle)
342{
343    char *serial;
344
345    handle->read_op = canusb_read_linux;
346
347    handle->inject_op = canusb_inject_linux;
348    handle->setfilter_op = canusb_setfilter_linux;
349    handle->setdirection_op = canusb_setdirection_linux;
350    handle->getnonblock_op = pcap_getnonblock_fd;
351    handle->setnonblock_op = pcap_setnonblock_fd;
352    handle->stats_op = canusb_stats_linux;
353    handle->cleanup_op = canusb_close;
354
355    /* Initialize some components of the pcap structure. */
356    handle->bufsize = 32;
357    handle->offset = 8;
358    handle->linktype = DLT_CAN_SOCKETCAN;
359    handle->set_datalink_op = NULL;
360
361    serial = handle->opt.source + strlen(CANUSB_IFACE);
362    canusb.serial = strdup(serial);
363
364    canusb.dev = canusb_opendevice(canusb.ctx,serial);
365    if (!canusb.dev)
366    {
367        snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "Can't open USB Device:");
368        return PCAP_ERROR;
369    }
370
371    canusb_clearbufs(&canusb);
372
373    handle->fd = canusb_startcapture(&canusb);
374    handle->selectable_fd = handle->fd;
375
376    return 0;
377}
378
379
380
381
382static int
383canusb_read_linux(pcap_t *handle, int max_packets, pcap_handler callback, u_char *user)
384{
385    static struct timeval firstpacket = { -1, -1};
386
387    int msgsent = 0;
388    int i = 0;
389    struct CAN_Msg msg;
390    struct pcap_pkthdr pkth;
391
392    while(i < max_packets)
393    {
394        int n;
395        usleep(10 * 1000);
396        n = read(handle->fd, &msg, sizeof(msg));
397        if (n <= 0)
398            break;
399        pkth.caplen = pkth.len = n;
400        pkth.caplen -= 4;
401        pkth.caplen -= 8 - msg.length;
402
403        if ((firstpacket.tv_sec == -1) && (firstpacket.tv_usec == -1))
404            gettimeofday(&firstpacket, NULL);
405
406        pkth.ts.tv_usec = firstpacket.tv_usec + (msg.timestamp % 100) * 10000;
407        pkth.ts.tv_sec = firstpacket.tv_usec + (msg.timestamp / 100);
408        if (pkth.ts.tv_usec > 1000000)
409        {
410            pkth.ts.tv_usec -= 1000000;
411            pkth.ts.tv_sec++;
412        }
413
414        callback(user, &pkth, (void*)&msg.id);
415        i++;
416    }
417
418    return i;
419}
420
421
422static int
423canusb_inject_linux(pcap_t *handle, const void *buf, size_t size)
424{
425    /* not yet implemented */
426    snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "inject not supported on canusb devices");
427    return (-1);
428}
429
430
431static int
432canusb_stats_linux(pcap_t *handle, struct pcap_stat *stats)
433{
434    /* not yet implemented */
435    stats->ps_recv = 0;     /* number of packets received */
436    stats->ps_drop = 0;     /* number of packets dropped */
437    stats->ps_ifdrop = 0;   /* drops by interface -- only supported on some platforms */
438    return 0;
439}
440
441
442static int
443canusb_setfilter_linux(pcap_t *p, struct bpf_program *fp)
444{
445    /* not yet implemented */
446    return 0;
447}
448
449
450static int
451canusb_setdirection_linux(pcap_t *p, pcap_direction_t d)
452{
453    /* no support for PCAP_D_OUT */
454    if (d == PCAP_D_OUT)
455    {
456        snprintf(p->errbuf, sizeof(p->errbuf),
457            "Setting direction to PCAP_D_OUT is not supported on this interface");
458        return -1;
459    }
460
461    p->direction = d;
462
463    return 0;
464}
465
466
467/* eof */
468