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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
|
/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2004-2006 Marcel Holtmann <marcel@holtmann.org>
*
*
* 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
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h>
#include <errno.h>
#include <sys/socket.h>
#include <bluetooth/bluetooth.h>
#include <bluetooth/hci.h>
#include <dbus/dbus.h>
#include "hcid.h"
#include "dbus.h"
typedef struct {
uint32_t code;
const char *str;
} bluez_error_t;
static const bluez_error_t dbus_error_array[] = {
{ BLUEZ_EDBUS_UNKNOWN_METHOD, "Method not found" },
{ BLUEZ_EDBUS_WRONG_SIGNATURE, "Wrong method signature" },
{ BLUEZ_EDBUS_WRONG_PARAM, "Invalid parameters" },
{ BLUEZ_EDBUS_RECORD_NOT_FOUND, "No record found" },
{ BLUEZ_EDBUS_NO_MEM, "No memory" },
{ BLUEZ_EDBUS_CONN_NOT_FOUND, "Connection not found" },
{ BLUEZ_EDBUS_UNKNOWN_PATH, "Unknown D-BUS path" },
{ BLUEZ_EDBUS_NOT_IMPLEMENTED, "Method not implemented" },
{ 0, NULL }
};
static const bluez_error_t hci_error_array[] = {
{ HCI_UNKNOWN_COMMAND, "Unknown HCI Command" },
{ HCI_NO_CONNECTION, "Unknown Connection Identifier" },
{ HCI_HARDWARE_FAILURE, "Hardware Failure" },
{ HCI_PAGE_TIMEOUT, "Page Timeout" },
{ HCI_AUTHENTICATION_FAILURE, "Authentication Failure" },
{ HCI_PIN_OR_KEY_MISSING, "PIN Missing" },
{ HCI_MEMORY_FULL, "Memory Capacity Exceeded" },
{ HCI_CONNECTION_TIMEOUT, "Connection Timeout" },
{ HCI_MAX_NUMBER_OF_CONNECTIONS, "Connection Limit Exceeded" },
{ HCI_MAX_NUMBER_OF_SCO_CONNECTIONS, "Synchronous Connection Limit To A Device Exceeded" },
{ HCI_ACL_CONNECTION_EXISTS, "ACL Connection Already Exists" },
{ HCI_COMMAND_DISALLOWED, "Command Disallowed" },
{ HCI_REJECTED_LIMITED_RESOURCES, "Connection Rejected due to Limited Resources" },
{ HCI_REJECTED_SECURITY, "Connection Rejected Due To Security Reasons" },
{ HCI_REJECTED_PERSONAL, "Connection Rejected due to Unacceptable BD_ADDR" },
{ HCI_HOST_TIMEOUT, "Connection Accept Timeout Exceeded" },
{ HCI_UNSUPPORTED_FEATURE, "Unsupported Feature or Parameter Value" },
{ HCI_INVALID_PARAMETERS, "Invalid HCI Command Parameters" },
{ HCI_OE_USER_ENDED_CONNECTION, "Remote User Terminated Connection" },
{ HCI_OE_LOW_RESOURCES, "Remote Device Terminated Connection due to Low Resources" },
{ HCI_OE_POWER_OFF, "Remote Device Terminated Connection due to Power Off" },
{ HCI_CONNECTION_TERMINATED, "Connection Terminated By Local Host" },
{ HCI_REPEATED_ATTEMPTS, "Repeated Attempts" },
{ HCI_PAIRING_NOT_ALLOWED, "Pairing Not Allowed" },
{ HCI_UNKNOWN_LMP_PDU, "Unknown LMP PDU" },
{ HCI_UNSUPPORTED_REMOTE_FEATURE, "Unsupported Remote Feature" },
{ HCI_SCO_OFFSET_REJECTED, "SCO Offset Rejected" },
{ HCI_SCO_INTERVAL_REJECTED, "SCO Interval Rejected" },
{ HCI_AIR_MODE_REJECTED, "SCO Air Mode Rejected" },
{ HCI_INVALID_LMP_PARAMETERS, "Invalid LMP Parameters" },
{ HCI_UNSPECIFIED_ERROR, "Unspecified Error" },
{ HCI_UNSUPPORTED_LMP_PARAMETER_VALUE, "Unsupported LMP Parameter Value" },
{ HCI_ROLE_CHANGE_NOT_ALLOWED, "Role Change Not Allowed" },
{ HCI_LMP_RESPONSE_TIMEOUT, "LMP Response Timeout" },
{ HCI_LMP_ERROR_TRANSACTION_COLLISION, "LMP Error Transaction Collision" },
{ HCI_LMP_PDU_NOT_ALLOWED, "LMP PDU Not Allowed" },
{ HCI_ENCRYPTION_MODE_NOT_ACCEPTED, "Encryption Mode Not Acceptable" },
{ HCI_UNIT_LINK_KEY_USED, "Link Key Can Not be Changed" },
{ HCI_QOS_NOT_SUPPORTED, "Requested QoS Not Supported" },
{ HCI_INSTANT_PASSED, "Instant Passed" },
{ HCI_PAIRING_NOT_SUPPORTED, "Pairing With Unit Key Not Supported" },
{ HCI_TRANSACTION_COLLISION, "Different Transaction Collision" },
{ HCI_QOS_UNACCEPTABLE_PARAMETER, "QoS Unacceptable Parameter" },
{ HCI_QOS_REJECTED, "QoS Rejected" },
{ HCI_CLASSIFICATION_NOT_SUPPORTED, "Channel Classification Not Supported" },
{ HCI_INSUFFICIENT_SECURITY, "Insufficient Security" },
{ HCI_PARAMETER_OUT_OF_RANGE, "Parameter Out Of Mandatory Range" },
{ HCI_ROLE_SWITCH_PENDING, "Role Switch Pending" },
{ HCI_SLOT_VIOLATION, "Reserved Slot Violation" },
{ HCI_ROLE_SWITCH_FAILED, "Role Switch Failed" },
{ 0, NULL },
};
static const char *bluez_dbus_error_to_str(const uint32_t ecode)
{
const bluez_error_t *ptr;
uint32_t raw_code = 0;
if (ecode & BLUEZ_ESYSTEM_OFFSET) {
/* System error */
raw_code = (~BLUEZ_ESYSTEM_OFFSET) & ecode;
syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, strerror(raw_code));
return strerror(raw_code);
} else if (ecode & BLUEZ_EDBUS_OFFSET) {
/* D-Bus error */
for (ptr = dbus_error_array; ptr->code; ptr++) {
if (ptr->code == ecode) {
syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, ptr->str);
return ptr->str;
}
}
} else {
/* BLUEZ_EBT_OFFSET - Bluetooth HCI errors */
for (ptr = hci_error_array; ptr->code; ptr++) {
if (ptr->code == ecode) {
syslog(LOG_INFO, "%s - msg:%s", __PRETTY_FUNCTION__, ptr->str);
return ptr->str;
}
}
}
return NULL;
}
DBusMessage *bluez_new_failure_msg(DBusMessage *msg, const uint32_t ecode)
{
DBusMessageIter iter;
DBusMessage *reply;
const char *error_msg;
error_msg = bluez_dbus_error_to_str(ecode);
if (!error_msg)
return NULL;
reply = dbus_message_new_error(msg, ERROR_INTERFACE, error_msg);
dbus_message_iter_init_append(reply, &iter);
dbus_message_iter_append_basic(&iter, DBUS_TYPE_UINT32 ,&ecode);
return reply;
}
DBusMessage *error_failed(DBusMessage *msg, int err)
{
const char *str = strerror(err);
return dbus_message_new_error(msg, ERROR_INTERFACE ".Failed", str);
}
DBusMessage *error_invalid_arguments(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".InvalidArguments",
"Invalid arguments");
}
DBusMessage *error_not_authorized(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".NotAuthorized",
"Not authorized");
}
DBusMessage *error_out_of_memory(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".OutOfMemory",
"Out of memory");
}
DBusMessage *error_no_such_adapter(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".NoSuchAdapter",
"No such adapter");
}
DBusMessage *error_unknown_address(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".UnknownAddress",
"Unknown address");
}
DBusMessage *error_not_available(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".NotAvailable",
"Not available");
}
DBusMessage *error_not_connected(DBusMessage *msg)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".NotConnected",
"Not connected");
}
static DBusMessage *error_already_exists(DBusMessage *msg, const char *str)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".AlreadyExists", str);
}
static DBusMessage *error_does_not_exists(DBusMessage *msg, const char *str)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".DoesNotExists", str);
}
static DBusMessage *error_in_progress(DBusMessage *msg, const char *str)
{
return dbus_message_new_error(msg, ERROR_INTERFACE ".InProgress", str);
}
DBusMessage *error_bonding_already_exists(DBusMessage *msg)
{
return error_already_exists(msg, "Bonding already exists");
}
DBusMessage *error_bonding_does_not_exists(DBusMessage *msg)
{
return error_does_not_exists(msg, "Bonding does not exists");
}
DBusMessage *error_bonding_in_progress(DBusMessage *msg)
{
return error_in_progress(msg, "Bonding in progress");
}
|
