3 * BlueZ - Bluetooth protocol stack for Linux
5 * Copyright (C) 2011-2012 Intel Corporation
6 * Copyright (C) 2004-2010 Marcel Holtmann <marcel@holtmann.org>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
36 #include <bluetooth/bluetooth.h>
37 #include <bluetooth/hci.h>
38 #include <bluetooth/mgmt.h>
49 static void free_data(void *user_data)
51 struct control_data *data = user_data;
58 static void mgmt_index_added(uint16_t len, const void *buf)
60 printf("@ Index Added\n");
62 packet_hexdump(buf, len);
65 static void mgmt_index_removed(uint16_t len, const void *buf)
67 printf("@ Index Removed\n");
69 packet_hexdump(buf, len);
72 static void mgmt_controller_error(uint16_t len, const void *buf)
74 const struct mgmt_ev_controller_error *ev = buf;
76 if (len < sizeof(*ev)) {
77 printf("* Malformed Controller Error control\n");
81 printf("@ Controller Error: 0x%2.2x\n", ev->error_code);
86 packet_hexdump(buf, len);
90 #define NELEM(x) (sizeof(x) / sizeof((x)[0]))
93 static const char *settings_str[] = {
94 "powered", "connectable", "fast-connectable", "discoverable",
95 "pairable", "link-security", "ssp", "br/edr", "hs", "le"
98 static void mgmt_new_settings(uint16_t len, const void *buf)
104 printf("* Malformed New Settings control\n");
108 settings = bt_get_le32(buf);
110 printf("@ New Settings: 0x%4.4x\n", settings);
112 printf("%-12c", ' ');
113 for (i = 0; i < NELEM(settings_str); i++) {
114 if (settings & (1 << i))
115 printf("%s ", settings_str[i]);
122 packet_hexdump(buf, len);
125 static void mgmt_class_of_dev_changed(uint16_t len, const void *buf)
127 const struct mgmt_ev_class_of_dev_changed *ev = buf;
129 if (len < sizeof(*ev)) {
130 printf("* Malformed Class of Device Changed control\n");
134 printf("@ Class of Device Changed: 0x%2.2x%2.2x%2.2x\n",
137 ev->class_of_dev[0]);
142 packet_hexdump(buf, len);
145 static void mgmt_local_name_changed(uint16_t len, const void *buf)
147 const struct mgmt_ev_local_name_changed *ev = buf;
149 if (len < sizeof(*ev)) {
150 printf("* Malformed Local Name Changed control\n");
154 printf("@ Local Name Changed: %s (%s)\n", ev->name, ev->short_name);
159 packet_hexdump(buf, len);
162 static void mgmt_new_link_key(uint16_t len, const void *buf)
164 const struct mgmt_ev_new_link_key *ev = buf;
167 if (len < sizeof(*ev)) {
168 printf("* Malformed New Link Key control\n");
172 ba2str(&ev->key.addr.bdaddr, str);
174 printf("@ New Link Key: %s (%d)\n", str, ev->key.addr.type);
179 packet_hexdump(buf, len);
182 static void mgmt_new_long_term_key(uint16_t len, const void *buf)
184 const struct mgmt_ev_new_long_term_key *ev = buf;
187 if (len < sizeof(*ev)) {
188 printf("* Malformed New Long Term Key control\n");
192 ba2str(&ev->key.addr.bdaddr, str);
194 printf("@ New Long Term Key: %s (%d)\n", str, ev->key.addr.type);
199 packet_hexdump(buf, len);
202 static void mgmt_device_connected(uint16_t len, const void *buf)
204 const struct mgmt_ev_device_connected *ev = buf;
208 if (len < sizeof(*ev)) {
209 printf("* Malformed Device Connected control\n");
213 flags = btohs(ev->flags);
214 ba2str(&ev->addr.bdaddr, str);
216 printf("@ Device Connected: %s (%d) flags 0x%4.4x\n",
217 str, ev->addr.type, flags);
222 packet_hexdump(buf, len);
225 static void mgmt_device_disconnected(uint16_t len, const void *buf)
227 const struct mgmt_ev_device_disconnected *ev = buf;
230 if (len < sizeof(*ev)) {
231 printf("* Malformed Device Disconnected control\n");
235 ba2str(&ev->addr.bdaddr, str);
237 printf("@ Device Disconnected: %s (%d)\n", str, ev->addr.type);
242 packet_hexdump(buf, len);
245 static void mgmt_connect_failed(uint16_t len, const void *buf)
247 const struct mgmt_ev_connect_failed *ev = buf;
250 if (len < sizeof(*ev)) {
251 printf("* Malformed Connect Failed control\n");
255 ba2str(&ev->addr.bdaddr, str);
257 printf("@ Connect Failed: %s (%d) status 0x%2.2x\n",
258 str, ev->addr.type, ev->status);
263 packet_hexdump(buf, len);
266 static void mgmt_pin_code_request(uint16_t len, const void *buf)
268 const struct mgmt_ev_pin_code_request *ev = buf;
271 if (len < sizeof(*ev)) {
272 printf("* Malformed PIN Code Request control\n");
276 ba2str(&ev->addr.bdaddr, str);
278 printf("@ PIN Code Request: %s (%d) secure 0x%2.2x\n",
279 str, ev->addr.type, ev->secure);
284 packet_hexdump(buf, len);
287 static void mgmt_user_confirm_request(uint16_t len, const void *buf)
289 const struct mgmt_ev_user_confirm_request *ev = buf;
292 if (len < sizeof(*ev)) {
293 printf("* Malformed User Confirmation Request control\n");
297 ba2str(&ev->addr.bdaddr, str);
299 printf("@ User Confirmation Request: %s (%d) hint %d value %d\n",
300 str, ev->addr.type, ev->confirm_hint, ev->value);
305 packet_hexdump(buf, len);
308 static void mgmt_user_passkey_request(uint16_t len, const void *buf)
310 const struct mgmt_ev_user_passkey_request *ev = buf;
313 if (len < sizeof(*ev)) {
314 printf("* Malformed User Passkey Request control\n");
318 ba2str(&ev->addr.bdaddr, str);
320 printf("@ PIN User Passkey Request: %s (%d)\n", str, ev->addr.type);
325 packet_hexdump(buf, len);
328 static void mgmt_auth_failed(uint16_t len, const void *buf)
330 const struct mgmt_ev_auth_failed *ev = buf;
333 if (len < sizeof(*ev)) {
334 printf("* Malformed Authentication Failed control\n");
338 ba2str(&ev->addr.bdaddr, str);
340 printf("@ Authentication Failed: %s (%d) status 0x%2.2x\n",
341 str, ev->addr.type, ev->status);
346 packet_hexdump(buf, len);
349 static void mgmt_device_found(uint16_t len, const void *buf)
351 const struct mgmt_ev_device_found *ev = buf;
355 if (len < sizeof(*ev)) {
356 printf("* Malformed Device Found control\n");
360 flags = btohs(ev->flags);
361 ba2str(&ev->addr.bdaddr, str);
363 printf("@ Device Found: %s (%d) rssi %d flags 0x%4.4x\n",
364 str, ev->addr.type, ev->rssi, flags);
369 packet_hexdump(buf, len);
372 static void mgmt_discovering(uint16_t len, const void *buf)
374 const struct mgmt_ev_discovering *ev = buf;
376 if (len < sizeof(*ev)) {
377 printf("* Malformed Discovering control\n");
381 printf("@ Discovering: 0x%2.2x (%d)\n", ev->discovering, ev->type);
386 packet_hexdump(buf, len);
389 static void mgmt_device_blocked(uint16_t len, const void *buf)
391 const struct mgmt_ev_device_blocked *ev = buf;
394 if (len < sizeof(*ev)) {
395 printf("* Malformed Device Blocked control\n");
399 ba2str(&ev->addr.bdaddr, str);
401 printf("@ Device Blocked: %s (%d)\n", str, ev->addr.type);
406 packet_hexdump(buf, len);
409 static void mgmt_device_unblocked(uint16_t len, const void *buf)
411 const struct mgmt_ev_device_unblocked *ev = buf;
414 if (len < sizeof(*ev)) {
415 printf("* Malformed Device Unblocked control\n");
419 ba2str(&ev->addr.bdaddr, str);
421 printf("@ Device Unblocked: %s (%d)\n", str, ev->addr.type);
426 packet_hexdump(buf, len);
429 static void mgmt_device_unpaired(uint16_t len, const void *buf)
431 const struct mgmt_ev_device_unpaired *ev = buf;
434 if (len < sizeof(*ev)) {
435 printf("* Malformed Device Unpaired control\n");
439 ba2str(&ev->addr.bdaddr, str);
441 printf("@ Device Unpaired: %s (%d)\n", str, ev->addr.type);
446 packet_hexdump(buf, len);
449 void control_message(uint16_t opcode, const void *data, uint16_t size)
452 case MGMT_EV_INDEX_ADDED:
453 mgmt_index_added(size, data);
455 case MGMT_EV_INDEX_REMOVED:
456 mgmt_index_removed(size, data);
458 case MGMT_EV_CONTROLLER_ERROR:
459 mgmt_controller_error(size, data);
461 case MGMT_EV_NEW_SETTINGS:
462 mgmt_new_settings(size, data);
464 case MGMT_EV_CLASS_OF_DEV_CHANGED:
465 mgmt_class_of_dev_changed(size, data);
467 case MGMT_EV_LOCAL_NAME_CHANGED:
468 mgmt_local_name_changed(size, data);
470 case MGMT_EV_NEW_LINK_KEY:
471 mgmt_new_link_key(size, data);
473 case MGMT_EV_NEW_LONG_TERM_KEY:
474 mgmt_new_long_term_key(size, data);
476 case MGMT_EV_DEVICE_CONNECTED:
477 mgmt_device_connected(size, data);
479 case MGMT_EV_DEVICE_DISCONNECTED:
480 mgmt_device_disconnected(size, data);
482 case MGMT_EV_CONNECT_FAILED:
483 mgmt_connect_failed(size, data);
485 case MGMT_EV_PIN_CODE_REQUEST:
486 mgmt_pin_code_request(size, data);
488 case MGMT_EV_USER_CONFIRM_REQUEST:
489 mgmt_user_confirm_request(size, data);
491 case MGMT_EV_USER_PASSKEY_REQUEST:
492 mgmt_user_passkey_request(size, data);
494 case MGMT_EV_AUTH_FAILED:
495 mgmt_auth_failed(size, data);
497 case MGMT_EV_DEVICE_FOUND:
498 mgmt_device_found(size, data);
500 case MGMT_EV_DISCOVERING:
501 mgmt_discovering(size, data);
503 case MGMT_EV_DEVICE_BLOCKED:
504 mgmt_device_blocked(size, data);
506 case MGMT_EV_DEVICE_UNBLOCKED:
507 mgmt_device_unblocked(size, data);
509 case MGMT_EV_DEVICE_UNPAIRED:
510 mgmt_device_unpaired(size, data);
513 printf("* Unknown control (code %d len %d)\n", opcode, size);
514 packet_hexdump(data, size);
519 static void data_callback(int fd, uint32_t events, void *user_data)
521 struct control_data *data = user_data;
522 unsigned char buf[HCI_MAX_FRAME_SIZE];
523 unsigned char control[32];
528 if (events & (EPOLLERR | EPOLLHUP)) {
529 mainloop_remove_fd(fd);
533 iov[0].iov_base = &hdr;
534 iov[0].iov_len = MGMT_HDR_SIZE;
535 iov[1].iov_base = buf;
536 iov[1].iov_len = sizeof(buf);
538 memset(&msg, 0, sizeof(msg));
541 msg.msg_control = control;
542 msg.msg_controllen = sizeof(control);
545 struct cmsghdr *cmsg;
546 struct timeval *tv = NULL;
547 uint16_t opcode, index, pktlen;
550 len = recvmsg(fd, &msg, MSG_DONTWAIT);
554 if (len < MGMT_HDR_SIZE)
557 for (cmsg = CMSG_FIRSTHDR(&msg); cmsg != NULL;
558 cmsg = CMSG_NXTHDR(&msg, cmsg)) {
559 if (cmsg->cmsg_level != SOL_SOCKET)
562 if (cmsg->cmsg_type == SCM_TIMESTAMP)
563 tv = (struct timeval *) CMSG_DATA(cmsg);
566 opcode = btohs(hdr.opcode);
567 index = btohs(hdr.index);
568 pktlen = btohs(hdr.len);
570 switch (data->channel) {
571 case HCI_CHANNEL_CONTROL:
572 packet_control(tv, index, opcode, buf, pktlen);
574 case HCI_CHANNEL_MONITOR:
575 packet_monitor(tv, index, opcode, buf, pktlen);
581 static int open_socket(uint16_t channel)
583 struct sockaddr_hci addr;
586 fd = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
588 perror("Failed to open channel");
592 memset(&addr, 0, sizeof(addr));
593 addr.hci_family = AF_BLUETOOTH;
594 addr.hci_dev = HCI_DEV_NONE;
595 addr.hci_channel = channel;
597 if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
598 if (errno == EINVAL) {
599 /* Fallback to hcidump support */
603 perror("Failed to bind channel");
608 if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMP, &opt, sizeof(opt)) < 0) {
609 perror("Failed to enable timestamps");
617 static int open_channel(uint16_t channel)
619 struct control_data *data;
621 data = malloc(sizeof(*data));
625 memset(data, 0, sizeof(*data));
626 data->channel = channel;
628 data->fd = open_socket(channel);
634 mainloop_add_fd(data->fd, EPOLLIN, data_callback, data, free_data);
639 int control_tracing(void)
641 if (open_channel(HCI_CHANNEL_MONITOR) < 0)
644 open_channel(HCI_CHANNEL_CONTROL);