1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2004-2009 Marcel Holtmann <marcel@holtmann.org>
* Copyright (C) 2009 The Android Open Source Project
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <unistd.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <private/android_filesystem_config.h>
#include <sys/prctl.h>
#include <linux/capability.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
/* Set UID to bluetooth w/ CAP_NET_RAW, CAP_NET_ADMIN and CAP_NET_BIND_SERVICE
* (Android's init.rc does not yet support applying linux capabilities) */
void android_set_aid_and_cap() {
prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0);
setuid(AID_BLUETOOTH);
struct __user_cap_header_struct header;
struct __user_cap_data_struct cap;
header.version = _LINUX_CAPABILITY_VERSION;
header.pid = 0;
cap.effective = cap.permitted = 1 << CAP_NET_RAW |
1 << CAP_NET_ADMIN |
1 << CAP_NET_BIND_SERVICE;
cap.inheritable = 0;
capset(&header, &cap);
}
static int write_flush_timeout(int fd, uint16_t handle,
unsigned int timeout_ms) {
uint16_t timeout = (timeout_ms * 1000) / 625; // timeout units of 0.625ms
unsigned char hci_write_flush_cmd[] = {
0x01, // HCI command packet
0x28, 0x0C, // HCI_Write_Automatic_Flush_Timeout
0x04, // Length
0x00, 0x00, // Handle
0x00, 0x00, // Timeout
};
hci_write_flush_cmd[4] = (uint8_t)handle;
hci_write_flush_cmd[5] = (uint8_t)(handle >> 8);
hci_write_flush_cmd[6] = (uint8_t)timeout;
hci_write_flush_cmd[7] = (uint8_t)(timeout >> 8);
int ret = write(fd, hci_write_flush_cmd, sizeof(hci_write_flush_cmd));
if (ret < 0) {
error("write(): %s (%d)]", strerror(errno), errno);
return -1;
} else if (ret != sizeof(hci_write_flush_cmd)) {
error("write(): unexpected length %d", ret);
return -1;
}
return 0;
}
#ifdef BOARD_HAVE_BLUETOOTH_BCM
static int vendor_high_priority(int fd, uint16_t handle) {
unsigned char hci_sleep_cmd[] = {
0x01, // HCI command packet
0x57, 0xfc, // HCI_Write_High_Priority_Connection
0x02, // Length
0x00, 0x00 // Handle
};
hci_sleep_cmd[4] = (uint8_t)handle;
hci_sleep_cmd[5] = (uint8_t)(handle >> 8);
int ret = write(fd, hci_sleep_cmd, sizeof(hci_sleep_cmd));
if (ret < 0) {
error("write(): %s (%d)]", strerror(errno), errno);
return -1;
} else if (ret != sizeof(hci_sleep_cmd)) {
error("write(): unexpected length %d", ret);
return -1;
}
return 0;
}
static int get_hci_sock() {
int sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
struct sockaddr_hci addr;
int opt;
if(sock < 0) {
error("Can't create raw HCI socket!");
return -1;
}
opt = 1;
if (setsockopt(sock, SOL_HCI, HCI_DATA_DIR, &opt, sizeof(opt)) < 0) {
error("Error setting data direction\n");
return -1;
}
/* Bind socket to the HCI device */
memset(&addr, 0, sizeof(addr));
addr.hci_family = AF_BLUETOOTH;
addr.hci_dev = 0; // hci0
if(bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
error("Can't attach to device hci0. %s(%d)\n",
strerror(errno),
errno);
return -1;
}
return sock;
}
static int get_acl_handle(int fd, bdaddr_t *bdaddr) {
int i;
int ret = -1;
struct hci_conn_list_req *conn_list;
struct hci_conn_info *conn_info;
int max_conn = 10;
conn_list = malloc(max_conn * (
sizeof(struct hci_conn_list_req) + sizeof(struct hci_conn_info)));
if (!conn_list) {
error("Out of memory in %s\n", __FUNCTION__);
return -1;
}
conn_list->dev_id = 0; /* hardcoded to HCI device 0 */
conn_list->conn_num = max_conn;
if (ioctl(fd, HCIGETCONNLIST, (void *)conn_list)) {
error("Failed to get connection list\n");
goto out;
}
for (i=0; i < conn_list->conn_num; i++) {
conn_info = &conn_list->conn_info[i];
if (conn_info->type == ACL_LINK &&
!memcmp((void *)&conn_info->bdaddr, (void *)bdaddr,
sizeof(bdaddr_t))) {
ret = conn_info->handle;
goto out;
}
}
ret = 0;
out:
free(conn_list);
return ret;
}
/* Request that the ACL link to a given Bluetooth connection be high priority,
* for improved coexistance support
*/
int android_set_high_priority(bdaddr_t *ba) {
int ret;
int fd = get_hci_sock();
int acl_handle;
if (fd < 0)
return fd;
acl_handle = get_acl_handle(fd, ba);
if (acl_handle < 0) {
ret = acl_handle;
goto out;
}
ret = vendor_high_priority(fd, acl_handle);
if (ret < 0)
goto out;
ret = write_flush_timeout(fd, acl_handle, 200);
out:
close(fd);
return ret;
}
#else
int android_set_high_priority(bdaddr_t *ba) {
return 0;
}
#endif
|
