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
238
239
240
241
242
|
/*
*
* BlueZ - Bluetooth protocol stack for Linux
*
* Copyright (C) 2006-2007 Nokia Corporation
* Copyright (C) 2004-2007 Marcel Holtmann <marcel@holtmann.org>
* Copyright (C) 2007 Fabien Chevalier <fabchevalier@free.fr>
*
*
* 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 <string.h>
#include <errno.h>
#include "dbus-helper.h"
#include "error.h"
/**
org.bluez.Error.DeviceUnreachable:
The remote device is either powered down or out of range.
*/
DBusHandlerResult error_device_unreachable(DBusConnection *conn, DBusMessage *msg)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".DeviceUnreachable",
"Device Unreachable");
}
/**
org.bluez.Error.ConnectionAttemptFailed:
An unexpected error (other than DeviceUnreachable) error has occured while
attempting a connection to a device
*/
DBusHandlerResult error_connection_attempt_failed(DBusConnection *conn, DBusMessage *msg, int err)
{
return error_common_reply(conn, msg,
ERROR_INTERFACE ".ConnectionAttemptFailed",
err ? strerror(err) : "Connection attempt failed");
}
/**
org.bluez.Error.AlreadyConnected:
A connection request has been received on an already connected device.
*/
DBusHandlerResult error_already_connected(DBusConnection *conn, DBusMessage *msg)
{
return error_common_reply(conn, msg,
ERROR_INTERFACE ".AlreadyConnected",
"Already connected to a device");
}
/**
org.bluez.Error.InProgress:
Error returned if an operation is in progress. Since
this is a generic error that can be used in various
situations, the error message should be more clear
about what is in progress. For example "Bonding in
progress".
*/
DBusHandlerResult error_in_progress(DBusConnection *conn, DBusMessage *msg,
const char *str)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".InProgress", str);
}
/**
org.bluez.Error.InvalidArguments:
The DBUS request does not contain the right number of
arguments with the right type, or the arguments are there but
their value is wrong, or does not makes sense in the current context.
*/
DBusHandlerResult error_invalid_arguments(DBusConnection *conn, DBusMessage *msg,
const char *descr)
{
return error_common_reply(conn, msg,
ERROR_INTERFACE ".InvalidArguments",
descr ? descr : "Invalid arguments in method call");
}
/**
org.bluez.Error.OutOfMemory:
Not enough memory to execute the request.
Error returned when a memory allocation via malloc()
fails. This error is similar to ENOMEM.
*/
DBusHandlerResult error_out_of_memory(DBusConnection *conn, DBusMessage *msg)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".OutOfMemory",
"Out of memory");
}
/**
org.bluez.Error.NotAvailable:
The requested information is not there.
Examples of use: Adapter object when remote info is not available, or Database
object record is not found
*/
DBusHandlerResult error_not_available(DBusConnection *conn, DBusMessage *msg)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".NotAvailable",
"Not available");
}
/**
org.bluez.Error.NotSupported:
The remote device does not support the expected feature.
Examples of use: trying to connect to audio device while audio is not
declared in device sdp record.
*/
DBusHandlerResult error_not_supported(DBusConnection *conn, DBusMessage *msg)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".NotSupported",
"Not supported");
}
/**
org.bluez.Error.NotConnected:
The remote device is not connected, while the method call
would expect it to be, or is not in the expected state to
perform the action
*/
DBusHandlerResult error_not_connected(DBusConnection *conn, DBusMessage *msg)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".NotConnected",
"Not connected");
}
/**
org.bluez.Error.AlreadyExists:
One of the requested elements already exists
Examples of use: Bonding, record, passkey agent, auth agent,
hid device ... already exists
*/
DBusHandlerResult error_already_exists(DBusConnection *conn, DBusMessage *msg,
const char *str)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".AlreadyExists", str);
}
/**
org.bluez.Error.DoesNotExist:
One of the requested elements does not exist
Examples of use: Bonding, record, passkey agent, auth agent, bluetooth device
... does not exist.
*/
DBusHandlerResult error_does_not_exist(DBusConnection *conn, DBusMessage *msg,
const char *str)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".DoesNotExist", str);
}
/**
org.bluez.Error.DoesNotExist:
Same as error_does_not_exist, but with device error message
*/
DBusHandlerResult error_device_does_not_exist(DBusConnection *conn,
DBusMessage *msg)
{
return error_does_not_exist(conn, msg, "Device does not exist");
}
/**
org.bluez.Error.Canceled:
The operation was canceled.
Examples of use : autorization process canceled, connection canceled
*/
DBusHandlerResult error_canceled(DBusConnection *conn, DBusMessage *msg,
const char *str)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".Canceled", str);
}
/**
org.bluez.Error.Failed:
This is a the most generic error.
desc filed is MANDATORY
*/
DBusHandlerResult error_failed(DBusConnection *conn, DBusMessage *msg,
const char * desc)
{
return error_common_reply(conn, msg, ERROR_INTERFACE ".Failed", desc);
}
/**
org.bluez.Error.Failed:
This is a the most generic error, instantiated form a UNIX errno number.
*/
DBusHandlerResult error_failed_errno(DBusConnection *conn, DBusMessage *msg,
int err)
{
const char *desc = strerror(err);
return error_failed(conn, msg, desc);
}
/* Helper function - internal use only */
DBusHandlerResult error_common_reply(DBusConnection *conn, DBusMessage *msg,
const char *name, const char *descr)
{
DBusMessage *derr;
if (!conn || !msg)
return DBUS_HANDLER_RESULT_HANDLED;
derr = dbus_message_new_error(msg, name, descr);
if (!derr)
return DBUS_HANDLER_RESULT_NEED_MEMORY;
return dbus_connection_send_and_unref(conn, derr);
}
|
