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
|
/*
*
* 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",
"Device address is unknown");
}
|
