libpcap  1.10.1
About: libpcap is a packet filter library used by tools like tcpdump.
  Fossies Dox: libpcap-1.10.1.tar.gz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

pcap-bt-linux.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2006 Paolo Abeni (Italy)
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  * Bluetooth sniffing API implementation for Linux platform
31  * By Paolo Abeni <paolo.abeni@email.it>
32  *
33  */
34 
35 #ifdef HAVE_CONFIG_H
36 #include <config.h>
37 #endif
38 
39 #include "pcap-int.h"
40 #include "pcap-bt-linux.h"
41 #include "pcap/bluetooth.h"
42 
43 #include <errno.h>
44 #include <stdlib.h>
45 #include <unistd.h>
46 #include <fcntl.h>
47 #include <string.h>
48 #include <sys/ioctl.h>
49 #include <sys/socket.h>
50 #include <arpa/inet.h>
51 
52 #include <bluetooth/bluetooth.h>
53 #include <bluetooth/hci.h>
54 
55 #define BT_IFACE "bluetooth"
56 #define BT_CTRL_SIZE 128
57 
58 /* forward declaration */
59 static int bt_activate(pcap_t *);
60 static int bt_read_linux(pcap_t *, int , pcap_handler , u_char *);
61 static int bt_inject_linux(pcap_t *, const void *, int);
63 static int bt_stats_linux(pcap_t *, struct pcap_stat *);
64 
65 /*
66  * Private data for capturing on Linux Bluetooth devices.
67  */
68 struct pcap_bt {
69  int dev_id; /* device ID of device we're bound to */
70 };
71 
72 int
73 bt_findalldevs(pcap_if_list_t *devlistp, char *err_str)
74 {
75  struct hci_dev_list_req *dev_list;
76  struct hci_dev_req *dev_req;
77  int sock;
78  unsigned i;
79  int ret = 0;
80 
81  sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
82  if (sock < 0)
83  {
84  /* if bluetooth is not supported this is not fatal*/
85  if (errno == EAFNOSUPPORT)
86  return 0;
88  errno, "Can't open raw Bluetooth socket");
89  return -1;
90  }
91 
92  dev_list = malloc(HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
93  if (!dev_list)
94  {
95  snprintf(err_str, PCAP_ERRBUF_SIZE, "Can't allocate %zu bytes for Bluetooth device list",
96  HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
97  ret = -1;
98  goto done;
99  }
100 
101  dev_list->dev_num = HCI_MAX_DEV;
102 
103  if (ioctl(sock, HCIGETDEVLIST, (void *) dev_list) < 0)
104  {
106  errno, "Can't get Bluetooth device list via ioctl");
107  ret = -1;
108  goto free;
109  }
110 
111  dev_req = dev_list->dev_req;
112  for (i = 0; i < dev_list->dev_num; i++, dev_req++) {
113  char dev_name[20], dev_descr[40];
114 
115  snprintf(dev_name, sizeof(dev_name), BT_IFACE"%u", dev_req->dev_id);
116  snprintf(dev_descr, sizeof(dev_descr), "Bluetooth adapter number %u", i);
117 
118  /*
119  * Bluetooth is a wireless technology.
120  * XXX - if there's the notion of associating with a
121  * network, and we can determine whether the interface
122  * is associated with a network, check that and set
123  * the status to PCAP_IF_CONNECTION_STATUS_CONNECTED
124  * or PCAP_IF_CONNECTION_STATUS_DISCONNECTED.
125  */
126  if (add_dev(devlistp, dev_name, PCAP_IF_WIRELESS, dev_descr, err_str) == NULL)
127  {
128  ret = -1;
129  break;
130  }
131  }
132 
133 free:
134  free(dev_list);
135 
136 done:
137  close(sock);
138  return ret;
139 }
140 
141 pcap_t *
142 bt_create(const char *device, char *ebuf, int *is_ours)
143 {
144  const char *cp;
145  char *cpend;
146  long devnum;
147  pcap_t *p;
148 
149  /* Does this look like a Bluetooth device? */
150  cp = strrchr(device, '/');
151  if (cp == NULL)
152  cp = device;
153  /* Does it begin with BT_IFACE? */
154  if (strncmp(cp, BT_IFACE, sizeof BT_IFACE - 1) != 0) {
155  /* Nope, doesn't begin with BT_IFACE */
156  *is_ours = 0;
157  return NULL;
158  }
159  /* Yes - is BT_IFACE followed by a number? */
160  cp += sizeof BT_IFACE - 1;
161  devnum = strtol(cp, &cpend, 10);
162  if (cpend == cp || *cpend != '\0') {
163  /* Not followed by a number. */
164  *is_ours = 0;
165  return NULL;
166  }
167  if (devnum < 0) {
168  /* Followed by a non-valid number. */
169  *is_ours = 0;
170  return NULL;
171  }
172 
173  /* OK, it's probably ours. */
174  *is_ours = 1;
175 
176  p = PCAP_CREATE_COMMON(ebuf, struct pcap_bt);
177  if (p == NULL)
178  return (NULL);
179 
181  return (p);
182 }
183 
184 static int
186 {
187  struct pcap_bt *handlep = handle->priv;
188  struct sockaddr_hci addr;
189  int opt;
190  int dev_id;
191  struct hci_filter flt;
192  int err = PCAP_ERROR;
193 
194  /* get bt interface id */
195  if (sscanf(handle->opt.device, BT_IFACE"%d", &dev_id) != 1)
196  {
198  "Can't get Bluetooth device index from %s",
199  handle->opt.device);
200  return PCAP_ERROR;
201  }
202 
203  /*
204  * Turn a negative snapshot value (invalid), a snapshot value of
205  * 0 (unspecified), or a value bigger than the normal maximum
206  * value, into the maximum allowed value.
207  *
208  * If some application really *needs* a bigger snapshot
209  * length, we should just increase MAXIMUM_SNAPLEN.
210  */
211  if (handle->snapshot <= 0 || handle->snapshot > MAXIMUM_SNAPLEN)
212  handle->snapshot = MAXIMUM_SNAPLEN;
213 
214  /* Initialize some components of the pcap structure. */
215  handle->bufsize = BT_CTRL_SIZE+sizeof(pcap_bluetooth_h4_header)+handle->snapshot;
217 
218  handle->read_op = bt_read_linux;
219  handle->inject_op = bt_inject_linux;
220  handle->setfilter_op = install_bpf_program; /* no kernel filtering */
222  handle->set_datalink_op = NULL; /* can't change data link type */
225  handle->stats_op = bt_stats_linux;
226  handlep->dev_id = dev_id;
227 
228  /* Create HCI socket */
229  handle->fd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
230  if (handle->fd < 0) {
232  errno, "Can't create raw socket");
233  return PCAP_ERROR;
234  }
235 
236  handle->buffer = malloc(handle->bufsize);
237  if (!handle->buffer) {
239  errno, "Can't allocate dump buffer");
240  goto close_fail;
241  }
242 
243  opt = 1;
244  if (setsockopt(handle->fd, SOL_HCI, HCI_DATA_DIR, &opt, sizeof(opt)) < 0) {
246  errno, "Can't enable data direction info");
247  goto close_fail;
248  }
249 
250  opt = 1;
251  if (setsockopt(handle->fd, SOL_HCI, HCI_TIME_STAMP, &opt, sizeof(opt)) < 0) {
253  errno, "Can't enable time stamp");
254  goto close_fail;
255  }
256 
257  /* Setup filter, do not call hci function to avoid dependence on
258  * external libs */
259  memset(&flt, 0, sizeof(flt));
260  memset((void *) &flt.type_mask, 0xff, sizeof(flt.type_mask));
261  memset((void *) &flt.event_mask, 0xff, sizeof(flt.event_mask));
262  if (setsockopt(handle->fd, SOL_HCI, HCI_FILTER, &flt, sizeof(flt)) < 0) {
264  errno, "Can't set filter");
265  goto close_fail;
266  }
267 
268 
269  /* Bind socket to the HCI device */
270  addr.hci_family = AF_BLUETOOTH;
271  addr.hci_dev = handlep->dev_id;
272 #ifdef HAVE_STRUCT_SOCKADDR_HCI_HCI_CHANNEL
273  addr.hci_channel = HCI_CHANNEL_RAW;
274 #endif
275  if (bind(handle->fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
277  errno, "Can't attach to device %d", handlep->dev_id);
278  goto close_fail;
279  }
280 
281  if (handle->opt.rfmon) {
282  /*
283  * Monitor mode doesn't apply to Bluetooth devices.
284  */
286  goto close_fail;
287  }
288 
289  if (handle->opt.buffer_size != 0) {
290  /*
291  * Set the socket buffer size to the specified value.
292  */
293  if (setsockopt(handle->fd, SOL_SOCKET, SO_RCVBUF,
294  &handle->opt.buffer_size,
295  sizeof(handle->opt.buffer_size)) == -1) {
297  errno, PCAP_ERRBUF_SIZE, "SO_RCVBUF");
298  goto close_fail;
299  }
300  }
301 
302  handle->selectable_fd = handle->fd;
303  return 0;
304 
305 close_fail:
306  pcap_cleanup_live_common(handle);
307  return err;
308 }
309 
310 static int
311 bt_read_linux(pcap_t *handle, int max_packets _U_, pcap_handler callback, u_char *user)
312 {
313  struct cmsghdr *cmsg;
314  struct msghdr msg;
315  struct iovec iv;
316  ssize_t ret;
317  struct pcap_pkthdr pkth;
319  u_char *pktd;
320  int in = 0;
321 
322  pktd = (u_char *)handle->buffer + BT_CTRL_SIZE;
323  bthdr = (pcap_bluetooth_h4_header*)(void *)pktd;
324  iv.iov_base = pktd + sizeof(pcap_bluetooth_h4_header);
325  iv.iov_len = handle->snapshot;
326 
327  memset(&msg, 0, sizeof(msg));
328  msg.msg_iov = &iv;
329  msg.msg_iovlen = 1;
330  msg.msg_control = handle->buffer;
331  msg.msg_controllen = BT_CTRL_SIZE;
332 
333  /* ignore interrupt system call error */
334  do {
335  ret = recvmsg(handle->fd, &msg, 0);
336  if (handle->break_loop)
337  {
338  handle->break_loop = 0;
339  return -2;
340  }
341  } while ((ret == -1) && (errno == EINTR));
342 
343  if (ret < 0) {
344  if (errno == EAGAIN || errno == EWOULDBLOCK) {
345  /* Nonblocking mode, no data */
346  return 0;
347  }
349  errno, "Can't receive packet");
350  return -1;
351  }
352 
353  pkth.caplen = (bpf_u_int32)ret;
354 
355  /* get direction and timestamp*/
356  cmsg = CMSG_FIRSTHDR(&msg);
357  while (cmsg) {
358  switch (cmsg->cmsg_type) {
359  case HCI_CMSG_DIR:
360  memcpy(&in, CMSG_DATA(cmsg), sizeof in);
361  break;
362  case HCI_CMSG_TSTAMP:
363  memcpy(&pkth.ts, CMSG_DATA(cmsg),
364  sizeof pkth.ts);
365  break;
366  }
367  cmsg = CMSG_NXTHDR(&msg, cmsg);
368  }
369  switch (handle->direction) {
370 
371  case PCAP_D_IN:
372  if (!in)
373  return 0;
374  break;
375 
376  case PCAP_D_OUT:
377  if (in)
378  return 0;
379  break;
380 
381  default:
382  break;
383  }
384 
385  bthdr->direction = htonl(in != 0);
386  pkth.caplen+=sizeof(pcap_bluetooth_h4_header);
387  pkth.len = pkth.caplen;
388  if (handle->fcode.bf_insns == NULL ||
389  pcap_filter(handle->fcode.bf_insns, pktd, pkth.len, pkth.caplen)) {
390  callback(user, &pkth, pktd);
391  return 1;
392  }
393  return 0; /* didn't pass filter */
394 }
395 
396 static int
397 bt_inject_linux(pcap_t *handle, const void *buf _U_, int size _U_)
398 {
400  "Packet injection is not supported on Bluetooth devices");
401  return (-1);
402 }
403 
404 
405 static int
406 bt_stats_linux(pcap_t *handle, struct pcap_stat *stats)
407 {
408  struct pcap_bt *handlep = handle->priv;
409  int ret;
410  struct hci_dev_info dev_info;
411  struct hci_dev_stats * s = &dev_info.stat;
412  dev_info.dev_id = handlep->dev_id;
413 
414  /* ignore eintr */
415  do {
416  ret = ioctl(handle->fd, HCIGETDEVINFO, (void *)&dev_info);
417  } while ((ret == -1) && (errno == EINTR));
418 
419  if (ret < 0) {
421  errno, "Can't get stats via ioctl");
422  return (-1);
423 
424  }
425 
426  /* we receive both rx and tx frames, so comulate all stats */
427  stats->ps_recv = s->evt_rx + s->acl_rx + s->sco_rx + s->cmd_tx +
428  s->acl_tx +s->sco_tx;
429  stats->ps_drop = s->err_rx + s->err_tx;
430  stats->ps_ifdrop = 0;
431  return 0;
432 }
433 
434 static int
436 {
437  /*
438  * It's guaranteed, at this point, that d is a valid
439  * direction value.
440  */
441  p->direction = d;
442  return 0;
443 }
struct _pcap_bluetooth_h4_header pcap_bluetooth_h4_header
u_int bpf_u_int32
Definition: bpf.h:98
u_int pcap_filter(const struct bpf_insn *pc, const u_char *p, u_int wirelen, u_int buflen)
Definition: bpf_filter.c:391
#define DLT_BLUETOOTH_HCI_H4_WITH_PHDR
Definition: dlt.h:798
void pcap_fmt_errmsg_for_errno(char *errbuf, size_t errbuflen, int errnum, const char *fmt,...)
Definition: fmtutils.c:269
int install_bpf_program(pcap_t *p, struct bpf_program *fp)
Definition: optimize.c:2939
int snprintf(char *, size_t, const char *,...)
int ioctl(int, int, caddr_t)
long strtol(const char *, char **, int)
int setsockopt(int, int, int, char *, int)
int sscanf(char *, const char *,...)
int socket(int, int, int)
int close(int)
int bind(int, struct sockaddr *, int)
pcap_t * bt_create(const char *device, char *ebuf, int *is_ours)
static int bt_activate(pcap_t *)
static int bt_inject_linux(pcap_t *, const void *, int)
static int bt_stats_linux(pcap_t *, struct pcap_stat *)
static int bt_read_linux(pcap_t *, int, pcap_handler, u_char *)
static int bt_setdirection_linux(pcap_t *, pcap_direction_t)
#define BT_CTRL_SIZE
Definition: pcap-bt-linux.c:56
#define BT_IFACE
Definition: pcap-bt-linux.c:55
int bt_findalldevs(pcap_if_list_t *devlistp, char *err_str)
Definition: pcap-bt-linux.c:73
#define _U_
Definition: pcap-dos.h:93
int errno
#define MAXIMUM_SNAPLEN
Definition: pcap-int.h:131
pcap_if_t * add_dev(pcap_if_list_t *, const char *, bpf_u_int32, const char *, char *)
Definition: pcap.c:1308
void pcap_cleanup_live_common(pcap_t *)
Definition: pcap.c:3987
int pcap_getnonblock_fd(pcap_t *)
Definition: pcap.c:3537
int pcap_setnonblock_fd(pcap_t *p, int)
Definition: pcap.c:3583
#define PCAP_CREATE_COMMON(ebuf, type)
Definition: pcap-int.h:474
#define PCAP_ERROR_RFMON_NOTSUP
Definition: pcap.h:344
void(* pcap_handler)(u_char *, const struct pcap_pkthdr *, const u_char *)
Definition: pcap.h:330
#define PCAP_IF_WIRELESS
Definition: pcap.h:312
pcap_direction_t
Definition: pcap.h:227
@ PCAP_D_IN
Definition: pcap.h:229
@ PCAP_D_OUT
Definition: pcap.h:230
#define PCAP_ERRBUF_SIZE
Definition: pcap.h:152
#define PCAP_ERROR
Definition: pcap.h:339
struct bpf_insn * bf_insns
Definition: bpf.h:119
int dev_id
Definition: pcap-bt-linux.c:69
char * device
Definition: pcap-int.h:146
int rfmon
Definition: pcap-int.h:150
u_int buffer_size
Definition: pcap-int.h:148
bpf_u_int32 caplen
Definition: pcap.h:247
struct timeval ts
Definition: pcap.h:246
bpf_u_int32 len
Definition: pcap.h:248
u_int ps_drop
Definition: pcap.h:256
u_int ps_recv
Definition: pcap.h:255
u_int ps_ifdrop
Definition: pcap.h:257
Definition: pcap-int.h:200
stats_op_t stats_op
Definition: pcap-int.h:320
activate_op_t activate_op
Definition: pcap-int.h:311
setnonblock_op_t setnonblock_op
Definition: pcap-int.h:319
setfilter_op_t setfilter_op
Definition: pcap-int.h:315
sig_atomic_t break_loop
Definition: pcap-int.h:225
u_int bufsize
Definition: pcap-int.h:220
void * priv
Definition: pcap-int.h:227
getnonblock_op_t getnonblock_op
Definition: pcap-int.h:318
read_op_t read_op
Definition: pcap-int.h:204
void * buffer
Definition: pcap-int.h:221
pcap_direction_t direction
Definition: pcap-int.h:266
int snapshot
Definition: pcap-int.h:247
setdirection_op_t setdirection_op
Definition: pcap-int.h:316
inject_op_t inject_op
Definition: pcap-int.h:313
struct bpf_program fcode
Definition: pcap-int.h:293
set_datalink_op_t set_datalink_op
Definition: pcap-int.h:317
char errbuf[256+1]
Definition: pcap-int.h:295
int linktype
Definition: pcap-int.h:248
int selectable_fd
Definition: pcap-int.h:274
int fd
Definition: pcap-int.h:214
struct pcap_opt opt
Definition: pcap-int.h:254