Branch data Line data Source code
1 : : /* GDBus - GLib D-Bus Library
2 : : *
3 : : * Copyright (C) 2008-2010 Red Hat, Inc.
4 : : *
5 : : * SPDX-License-Identifier: LGPL-2.1-or-later
6 : : *
7 : : * This library is free software; you can redistribute it and/or
8 : : * modify it under the terms of the GNU Lesser General Public
9 : : * License as published by the Free Software Foundation; either
10 : : * version 2.1 of the License, or (at your option) any later version.
11 : : *
12 : : * This library is distributed in the hope that it will be useful,
13 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : : * Lesser General Public License for more details.
16 : : *
17 : : * You should have received a copy of the GNU Lesser General
18 : : * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
19 : : *
20 : : * Author: David Zeuthen <davidz@redhat.com>
21 : : */
22 : :
23 : : #include "config.h"
24 : :
25 : : #include <stdlib.h>
26 : : #include <string.h>
27 : :
28 : : #include "gdbuserror.h"
29 : : #include "gioenums.h"
30 : : #include "gioenumtypes.h"
31 : : #include "gioerror.h"
32 : : #include "gdbusprivate.h"
33 : :
34 : : #include "glibintl.h"
35 : :
36 : : static const GDBusErrorEntry g_dbus_error_entries[] =
37 : : {
38 : : {G_DBUS_ERROR_FAILED, "org.freedesktop.DBus.Error.Failed"},
39 : : {G_DBUS_ERROR_NO_MEMORY, "org.freedesktop.DBus.Error.NoMemory"},
40 : : {G_DBUS_ERROR_SERVICE_UNKNOWN, "org.freedesktop.DBus.Error.ServiceUnknown"},
41 : : {G_DBUS_ERROR_NAME_HAS_NO_OWNER, "org.freedesktop.DBus.Error.NameHasNoOwner"},
42 : : {G_DBUS_ERROR_NO_REPLY, "org.freedesktop.DBus.Error.NoReply"},
43 : : {G_DBUS_ERROR_IO_ERROR, "org.freedesktop.DBus.Error.IOError"},
44 : : {G_DBUS_ERROR_BAD_ADDRESS, "org.freedesktop.DBus.Error.BadAddress"},
45 : : {G_DBUS_ERROR_NOT_SUPPORTED, "org.freedesktop.DBus.Error.NotSupported"},
46 : : {G_DBUS_ERROR_LIMITS_EXCEEDED, "org.freedesktop.DBus.Error.LimitsExceeded"},
47 : : {G_DBUS_ERROR_ACCESS_DENIED, "org.freedesktop.DBus.Error.AccessDenied"},
48 : : {G_DBUS_ERROR_AUTH_FAILED, "org.freedesktop.DBus.Error.AuthFailed"},
49 : : {G_DBUS_ERROR_NO_SERVER, "org.freedesktop.DBus.Error.NoServer"},
50 : : {G_DBUS_ERROR_TIMEOUT, "org.freedesktop.DBus.Error.Timeout"},
51 : : {G_DBUS_ERROR_NO_NETWORK, "org.freedesktop.DBus.Error.NoNetwork"},
52 : : {G_DBUS_ERROR_ADDRESS_IN_USE, "org.freedesktop.DBus.Error.AddressInUse"},
53 : : {G_DBUS_ERROR_DISCONNECTED, "org.freedesktop.DBus.Error.Disconnected"},
54 : : {G_DBUS_ERROR_INVALID_ARGS, "org.freedesktop.DBus.Error.InvalidArgs"},
55 : : {G_DBUS_ERROR_FILE_NOT_FOUND, "org.freedesktop.DBus.Error.FileNotFound"},
56 : : {G_DBUS_ERROR_FILE_EXISTS, "org.freedesktop.DBus.Error.FileExists"},
57 : : {G_DBUS_ERROR_UNKNOWN_METHOD, "org.freedesktop.DBus.Error.UnknownMethod"},
58 : : {G_DBUS_ERROR_TIMED_OUT, "org.freedesktop.DBus.Error.TimedOut"},
59 : : {G_DBUS_ERROR_MATCH_RULE_NOT_FOUND, "org.freedesktop.DBus.Error.MatchRuleNotFound"},
60 : : {G_DBUS_ERROR_MATCH_RULE_INVALID, "org.freedesktop.DBus.Error.MatchRuleInvalid"},
61 : : {G_DBUS_ERROR_SPAWN_EXEC_FAILED, "org.freedesktop.DBus.Error.Spawn.ExecFailed"},
62 : : {G_DBUS_ERROR_SPAWN_FORK_FAILED, "org.freedesktop.DBus.Error.Spawn.ForkFailed"},
63 : : {G_DBUS_ERROR_SPAWN_CHILD_EXITED, "org.freedesktop.DBus.Error.Spawn.ChildExited"},
64 : : {G_DBUS_ERROR_SPAWN_CHILD_SIGNALED, "org.freedesktop.DBus.Error.Spawn.ChildSignaled"},
65 : : {G_DBUS_ERROR_SPAWN_FAILED, "org.freedesktop.DBus.Error.Spawn.Failed"},
66 : : {G_DBUS_ERROR_SPAWN_SETUP_FAILED, "org.freedesktop.DBus.Error.Spawn.FailedToSetup"},
67 : : {G_DBUS_ERROR_SPAWN_CONFIG_INVALID, "org.freedesktop.DBus.Error.Spawn.ConfigInvalid"},
68 : : {G_DBUS_ERROR_SPAWN_SERVICE_INVALID, "org.freedesktop.DBus.Error.Spawn.ServiceNotValid"},
69 : : {G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND, "org.freedesktop.DBus.Error.Spawn.ServiceNotFound"},
70 : : {G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID, "org.freedesktop.DBus.Error.Spawn.PermissionsInvalid"},
71 : : {G_DBUS_ERROR_SPAWN_FILE_INVALID, "org.freedesktop.DBus.Error.Spawn.FileInvalid"},
72 : : {G_DBUS_ERROR_SPAWN_NO_MEMORY, "org.freedesktop.DBus.Error.Spawn.NoMemory"},
73 : : {G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, "org.freedesktop.DBus.Error.UnixProcessIdUnknown"},
74 : : {G_DBUS_ERROR_INVALID_SIGNATURE, "org.freedesktop.DBus.Error.InvalidSignature"},
75 : : {G_DBUS_ERROR_INVALID_FILE_CONTENT, "org.freedesktop.DBus.Error.InvalidFileContent"},
76 : : {G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown"},
77 : : {G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN, "org.freedesktop.DBus.Error.AdtAuditDataUnknown"},
78 : : {G_DBUS_ERROR_OBJECT_PATH_IN_USE, "org.freedesktop.DBus.Error.ObjectPathInUse"},
79 : : {G_DBUS_ERROR_UNKNOWN_OBJECT, "org.freedesktop.DBus.Error.UnknownObject"},
80 : : {G_DBUS_ERROR_UNKNOWN_INTERFACE, "org.freedesktop.DBus.Error.UnknownInterface"},
81 : : {G_DBUS_ERROR_UNKNOWN_PROPERTY, "org.freedesktop.DBus.Error.UnknownProperty"},
82 : : {G_DBUS_ERROR_PROPERTY_READ_ONLY, "org.freedesktop.DBus.Error.PropertyReadOnly"},
83 : : };
84 : :
85 : : GQuark
86 : 680 : g_dbus_error_quark (void)
87 : : {
88 : : G_STATIC_ASSERT (G_N_ELEMENTS (g_dbus_error_entries) - 1 == G_DBUS_ERROR_PROPERTY_READ_ONLY);
89 : : static gsize quark = 0;
90 : 680 : g_dbus_error_register_error_domain ("g-dbus-error-quark",
91 : : &quark,
92 : : g_dbus_error_entries,
93 : : G_N_ELEMENTS (g_dbus_error_entries));
94 : 680 : return (GQuark) quark;
95 : : }
96 : :
97 : : /**
98 : : * g_dbus_error_register_error_domain:
99 : : * @error_domain_quark_name: The error domain name.
100 : : * @quark_volatile: A pointer where to store the #GQuark.
101 : : * @entries: (array length=num_entries): A pointer to @num_entries #GDBusErrorEntry struct items.
102 : : * @num_entries: Number of items to register.
103 : : *
104 : : * Helper function for associating a #GError error domain with D-Bus error names.
105 : : *
106 : : * While @quark_volatile has a `volatile` qualifier, this is a historical
107 : : * artifact and the argument passed to it should not be `volatile`.
108 : : *
109 : : * Since: 2.26
110 : : */
111 : : void
112 : 681 : g_dbus_error_register_error_domain (const gchar *error_domain_quark_name,
113 : : volatile gsize *quark_volatile,
114 : : const GDBusErrorEntry *entries,
115 : : guint num_entries)
116 : : {
117 : : gsize *quark;
118 : :
119 : 681 : g_return_if_fail (error_domain_quark_name != NULL);
120 : 681 : g_return_if_fail (quark_volatile != NULL);
121 : 681 : g_return_if_fail (entries != NULL);
122 : 681 : g_return_if_fail (num_entries > 0);
123 : :
124 : : /* Drop the volatile qualifier, which should never have been on the argument
125 : : * in the first place. */
126 : 681 : quark = (gsize *) quark_volatile;
127 : :
128 [ + + + - : 681 : if (g_once_init_enter (quark))
+ + ]
129 : : {
130 : : guint n;
131 : : GQuark new_quark;
132 : :
133 : 124 : new_quark = g_quark_from_static_string (error_domain_quark_name);
134 : :
135 [ + + ]: 5661 : for (n = 0; n < num_entries; n++)
136 : : {
137 [ - + ]: 5537 : g_warn_if_fail (g_dbus_error_register_error (new_quark,
138 : : entries[n].error_code,
139 : : entries[n].dbus_error_name));
140 : : }
141 : 124 : g_once_init_leave (quark, new_quark);
142 : : }
143 : : }
144 : :
145 : : static gboolean
146 : 20 : _g_dbus_error_decode_gerror (const gchar *dbus_name,
147 : : GQuark *out_error_domain,
148 : : gint *out_error_code)
149 : : {
150 : : gboolean ret;
151 : : guint n;
152 : : GString *s;
153 : : gchar *domain_quark_string;
154 : :
155 : 20 : ret = FALSE;
156 : 20 : s = NULL;
157 : :
158 [ + - - + : 20 : if (g_str_has_prefix (dbus_name, "org.gtk.GDBus.UnmappedGError.Quark._"))
+ + + + ]
159 : : {
160 : 8 : s = g_string_new (NULL);
161 : :
162 : 8 : for (n = sizeof "org.gtk.GDBus.UnmappedGError.Quark._" - 1;
163 [ + + + - ]: 142 : dbus_name[n] != '.' && dbus_name[n] != '\0';
164 : 134 : n++)
165 : : {
166 [ + + ]: 134 : if (g_ascii_isalnum (dbus_name[n]))
167 : : {
168 [ + - ]: 109 : g_string_append_c (s, dbus_name[n]);
169 : : }
170 [ + - ]: 25 : else if (dbus_name[n] == '_')
171 : : {
172 : : guint nibble_top;
173 : : guint nibble_bottom;
174 : :
175 : 25 : n++;
176 : :
177 : 25 : nibble_top = dbus_name[n];
178 [ + - + - ]: 25 : if (nibble_top >= '0' && nibble_top <= '9')
179 : 25 : nibble_top -= '0';
180 [ # # # # ]: 0 : else if (nibble_top >= 'a' && nibble_top <= 'f')
181 : 0 : nibble_top -= ('a' - 10);
182 : : else
183 : 0 : goto not_mapped;
184 : :
185 : 25 : n++;
186 : :
187 : 25 : nibble_bottom = dbus_name[n];
188 [ + - - + ]: 25 : if (nibble_bottom >= '0' && nibble_bottom <= '9')
189 : 0 : nibble_bottom -= '0';
190 [ + - + - ]: 25 : else if (nibble_bottom >= 'a' && nibble_bottom <= 'f')
191 : 25 : nibble_bottom -= ('a' - 10);
192 : : else
193 : 0 : goto not_mapped;
194 : :
195 [ + - ]: 25 : g_string_append_c (s, (nibble_top<<4) | nibble_bottom);
196 : : }
197 : : else
198 : : {
199 : 0 : goto not_mapped;
200 : : }
201 : : }
202 : :
203 [ + - - + : 8 : if (!g_str_has_prefix (dbus_name + n, ".Code"))
+ - - + ]
204 : 0 : goto not_mapped;
205 : :
206 : 8 : domain_quark_string = g_string_free (s, FALSE);
207 : 8 : s = NULL;
208 : :
209 [ + - ]: 8 : if (out_error_domain != NULL)
210 : 8 : *out_error_domain = g_quark_from_string (domain_quark_string);
211 : 8 : g_free (domain_quark_string);
212 : :
213 [ + - ]: 8 : if (out_error_code != NULL)
214 : 8 : *out_error_code = atoi (dbus_name + n + sizeof ".Code" - 1);
215 : :
216 : 8 : ret = TRUE;
217 : : }
218 : :
219 : 12 : not_mapped:
220 : :
221 [ - + ]: 20 : if (s != NULL)
222 : 0 : g_string_free (s, TRUE);
223 : :
224 : 20 : return ret;
225 : : }
226 : :
227 : : /* ---------------------------------------------------------------------------------------------------- */
228 : :
229 : : typedef struct
230 : : {
231 : : GQuark error_domain;
232 : : gint error_code;
233 : : } QuarkCodePair;
234 : :
235 : : static guint
236 : 11125 : quark_code_pair_hash_func (const QuarkCodePair *pair)
237 : : {
238 : : gint val;
239 : 11125 : val = pair->error_domain + pair->error_code;
240 : 11125 : return g_int_hash (&val);
241 : : }
242 : :
243 : : static gboolean
244 : 28 : quark_code_pair_equal_func (const QuarkCodePair *a,
245 : : const QuarkCodePair *b)
246 : : {
247 [ + - + - ]: 28 : return (a->error_domain == b->error_domain) && (a->error_code == b->error_code);
248 : : }
249 : :
250 : : typedef struct
251 : : {
252 : : QuarkCodePair pair;
253 : : gchar *dbus_error_name;
254 : : } RegisteredError;
255 : :
256 : : static void
257 : 1 : registered_error_free (RegisteredError *re)
258 : : {
259 : 1 : g_free (re->dbus_error_name);
260 : 1 : g_free (re);
261 : 1 : }
262 : :
263 : : G_LOCK_DEFINE_STATIC (error_lock);
264 : :
265 : : /* maps from QuarkCodePair* -> RegisteredError* */
266 : : static GHashTable *quark_code_pair_to_re = NULL;
267 : :
268 : : /* maps from gchar* -> RegisteredError* */
269 : : static GHashTable *dbus_error_name_to_re = NULL;
270 : :
271 : : /**
272 : : * g_dbus_error_register_error:
273 : : * @error_domain: A #GQuark for an error domain.
274 : : * @error_code: An error code.
275 : : * @dbus_error_name: A D-Bus error name.
276 : : *
277 : : * Creates an association to map between @dbus_error_name and
278 : : * #GErrors specified by @error_domain and @error_code.
279 : : *
280 : : * This is typically done in the routine that returns the #GQuark for
281 : : * an error domain.
282 : : *
283 : : * Returns: %TRUE if the association was created, %FALSE if it already
284 : : * exists.
285 : : *
286 : : * Since: 2.26
287 : : */
288 : : gboolean
289 : 5537 : g_dbus_error_register_error (GQuark error_domain,
290 : : gint error_code,
291 : : const gchar *dbus_error_name)
292 : : {
293 : : gboolean ret;
294 : : QuarkCodePair pair;
295 : : RegisteredError *re;
296 : :
297 : 5537 : g_return_val_if_fail (dbus_error_name != NULL, FALSE);
298 : :
299 : 5537 : ret = FALSE;
300 : :
301 : 5537 : G_LOCK (error_lock);
302 : :
303 [ + + ]: 5537 : if (quark_code_pair_to_re == NULL)
304 : : {
305 : 123 : g_assert (dbus_error_name_to_re == NULL); /* check invariant */
306 : 123 : quark_code_pair_to_re = g_hash_table_new ((GHashFunc) quark_code_pair_hash_func,
307 : : (GEqualFunc) quark_code_pair_equal_func);
308 : 123 : dbus_error_name_to_re = g_hash_table_new_full (g_str_hash,
309 : : g_str_equal,
310 : : NULL,
311 : : (GDestroyNotify) registered_error_free);
312 : : }
313 : :
314 [ - + ]: 5537 : if (g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name) != NULL)
315 : 0 : goto out;
316 : :
317 : 5537 : pair.error_domain = error_domain;
318 : 5537 : pair.error_code = error_code;
319 : :
320 [ - + ]: 5537 : if (g_hash_table_lookup (quark_code_pair_to_re, &pair) != NULL)
321 : 0 : goto out;
322 : :
323 : 5537 : re = g_new0 (RegisteredError, 1);
324 : 5537 : re->pair = pair;
325 : 5537 : re->dbus_error_name = g_strdup (dbus_error_name);
326 : :
327 : 5537 : g_hash_table_insert (quark_code_pair_to_re, &(re->pair), re);
328 : 5537 : g_hash_table_insert (dbus_error_name_to_re, re->dbus_error_name, re);
329 : :
330 : 5537 : ret = TRUE;
331 : :
332 : 5537 : out:
333 : 5537 : G_UNLOCK (error_lock);
334 : 5537 : return ret;
335 : : }
336 : :
337 : : /**
338 : : * g_dbus_error_unregister_error:
339 : : * @error_domain: A #GQuark for an error domain.
340 : : * @error_code: An error code.
341 : : * @dbus_error_name: A D-Bus error name.
342 : : *
343 : : * Destroys an association previously set up with g_dbus_error_register_error().
344 : : *
345 : : * Returns: %TRUE if the association was destroyed, %FALSE if it wasn't found.
346 : : *
347 : : * Since: 2.26
348 : : */
349 : : gboolean
350 : 1 : g_dbus_error_unregister_error (GQuark error_domain,
351 : : gint error_code,
352 : : const gchar *dbus_error_name)
353 : : {
354 : : gboolean ret;
355 : : RegisteredError *re;
356 : : guint hash_size;
357 : :
358 : 1 : g_return_val_if_fail (dbus_error_name != NULL, FALSE);
359 : :
360 : 1 : ret = FALSE;
361 : :
362 : 1 : G_LOCK (error_lock);
363 : :
364 [ - + ]: 1 : if (dbus_error_name_to_re == NULL)
365 : : {
366 : 0 : g_assert (quark_code_pair_to_re == NULL); /* check invariant */
367 : 0 : goto out;
368 : : }
369 : :
370 : 1 : re = g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name);
371 [ - + ]: 1 : if (re == NULL)
372 : : {
373 : : QuarkCodePair pair;
374 : 0 : pair.error_domain = error_domain;
375 : 0 : pair.error_code = error_code;
376 [ # # ]: 0 : g_warn_if_fail (g_hash_table_lookup (quark_code_pair_to_re, &pair) == NULL); /* check invariant */
377 : 0 : goto out;
378 : : }
379 : :
380 : 1 : ret = TRUE;
381 : :
382 [ - + ]: 1 : g_warn_if_fail (g_hash_table_lookup (quark_code_pair_to_re, &(re->pair)) == re); /* check invariant */
383 : :
384 [ - + ]: 1 : g_warn_if_fail (g_hash_table_remove (quark_code_pair_to_re, &(re->pair)));
385 [ - + ]: 1 : g_warn_if_fail (g_hash_table_remove (dbus_error_name_to_re, re->dbus_error_name));
386 : :
387 : : /* destroy hashes if empty */
388 : 1 : hash_size = g_hash_table_size (dbus_error_name_to_re);
389 [ - + ]: 1 : if (hash_size == 0)
390 : : {
391 [ # # ]: 0 : g_warn_if_fail (g_hash_table_size (quark_code_pair_to_re) == 0); /* check invariant */
392 : :
393 : 0 : g_hash_table_unref (dbus_error_name_to_re);
394 : 0 : dbus_error_name_to_re = NULL;
395 : 0 : g_hash_table_unref (quark_code_pair_to_re);
396 : 0 : quark_code_pair_to_re = NULL;
397 : : }
398 : : else
399 : : {
400 [ - + ]: 1 : g_warn_if_fail (g_hash_table_size (quark_code_pair_to_re) == hash_size); /* check invariant */
401 : : }
402 : :
403 : 1 : out:
404 : 1 : G_UNLOCK (error_lock);
405 : 1 : return ret;
406 : : }
407 : :
408 : : /* ---------------------------------------------------------------------------------------------------- */
409 : :
410 : : /**
411 : : * g_dbus_error_is_remote_error:
412 : : * @error: A #GError.
413 : : *
414 : : * Checks if @error represents an error received via D-Bus from a remote peer. If so,
415 : : * use g_dbus_error_get_remote_error() to get the name of the error.
416 : : *
417 : : * Returns: %TRUE if @error represents an error from a remote peer,
418 : : * %FALSE otherwise.
419 : : *
420 : : * Since: 2.26
421 : : */
422 : : gboolean
423 : 48 : g_dbus_error_is_remote_error (const GError *error)
424 : : {
425 : 48 : g_return_val_if_fail (error != NULL, FALSE);
426 [ + - - + : 48 : return g_str_has_prefix (error->message, "GDBus.Error:");
+ + ]
427 : : }
428 : :
429 : :
430 : : /**
431 : : * g_dbus_error_get_remote_error:
432 : : * @error: a #GError
433 : : *
434 : : * Gets the D-Bus error name used for @error, if any.
435 : : *
436 : : * This function is guaranteed to return a D-Bus error name for all
437 : : * #GErrors returned from functions handling remote method calls
438 : : * (e.g. g_dbus_connection_call_finish()) unless
439 : : * g_dbus_error_strip_remote_error() has been used on @error.
440 : : *
441 : : * Returns: (nullable) (transfer full): an allocated string or %NULL if the
442 : : * D-Bus error name could not be found. Free with g_free().
443 : : *
444 : : * Since: 2.26
445 : : */
446 : : gchar *
447 : 21 : g_dbus_error_get_remote_error (const GError *error)
448 : : {
449 : : RegisteredError *re;
450 : : gchar *ret;
451 : :
452 : 21 : g_return_val_if_fail (error != NULL, NULL);
453 : :
454 : : /* Ensure that e.g. G_DBUS_ERROR is registered using g_dbus_error_register_error() */
455 : 21 : _g_dbus_initialize ();
456 : :
457 : 21 : ret = NULL;
458 : :
459 : 21 : G_LOCK (error_lock);
460 : :
461 : 21 : re = NULL;
462 [ + - ]: 21 : if (quark_code_pair_to_re != NULL)
463 : : {
464 : : QuarkCodePair pair;
465 : 21 : pair.error_domain = error->domain;
466 : 21 : pair.error_code = error->code;
467 : 21 : g_assert (dbus_error_name_to_re != NULL); /* check invariant */
468 : 21 : re = g_hash_table_lookup (quark_code_pair_to_re, &pair);
469 : : }
470 : :
471 [ + + ]: 21 : if (re != NULL)
472 : : {
473 : 12 : ret = g_strdup (re->dbus_error_name);
474 : : }
475 : : else
476 : : {
477 [ + - - + : 15 : if (g_str_has_prefix (error->message, "GDBus.Error:"))
+ + + + ]
478 : : {
479 : : const gchar *begin;
480 : : const gchar *end;
481 : 10 : begin = error->message + sizeof ("GDBus.Error:") -1;
482 : 10 : end = strstr (begin, ":");
483 [ + - + - ]: 10 : if (end != NULL && end[1] == ' ')
484 : : {
485 : 10 : ret = g_strndup (begin, end - begin);
486 : : }
487 : : }
488 : : }
489 : :
490 : 21 : G_UNLOCK (error_lock);
491 : :
492 : 21 : return ret;
493 : : }
494 : :
495 : : /* ---------------------------------------------------------------------------------------------------- */
496 : :
497 : : /**
498 : : * g_dbus_error_new_for_dbus_error:
499 : : * @dbus_error_name: D-Bus error name.
500 : : * @dbus_error_message: D-Bus error message.
501 : : *
502 : : * Creates a #GError based on the contents of @dbus_error_name and
503 : : * @dbus_error_message.
504 : : *
505 : : * Errors registered with g_dbus_error_register_error() will be looked
506 : : * up using @dbus_error_name and if a match is found, the error domain
507 : : * and code is used. Applications can use g_dbus_error_get_remote_error()
508 : : * to recover @dbus_error_name.
509 : : *
510 : : * If a match against a registered error is not found and the D-Bus
511 : : * error name is in a form as returned by g_dbus_error_encode_gerror()
512 : : * the error domain and code encoded in the name is used to
513 : : * create the #GError. Also, @dbus_error_name is added to the error message
514 : : * such that it can be recovered with g_dbus_error_get_remote_error().
515 : : *
516 : : * Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR
517 : : * in the %G_IO_ERROR error domain is returned. Also, @dbus_error_name is
518 : : * added to the error message such that it can be recovered with
519 : : * g_dbus_error_get_remote_error().
520 : : *
521 : : * In all three cases, @dbus_error_name can always be recovered from the
522 : : * returned #GError using the g_dbus_error_get_remote_error() function
523 : : * (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error).
524 : : *
525 : : * This function is typically only used in object mappings to prepare
526 : : * #GError instances for applications. Regular applications should not use
527 : : * it.
528 : : *
529 : : * Returns: (transfer full): An allocated #GError. Free with g_error_free().
530 : : *
531 : : * Since: 2.26
532 : : */
533 : : GError *
534 : 583 : g_dbus_error_new_for_dbus_error (const gchar *dbus_error_name,
535 : : const gchar *dbus_error_message)
536 : : {
537 : : GError *error;
538 : : RegisteredError *re;
539 : :
540 : 583 : g_return_val_if_fail (dbus_error_name != NULL, NULL);
541 : 583 : g_return_val_if_fail (dbus_error_message != NULL, NULL);
542 : :
543 : : /* Ensure that e.g. G_DBUS_ERROR is registered using g_dbus_error_register_error() */
544 : 583 : _g_dbus_initialize ();
545 : :
546 : 583 : G_LOCK (error_lock);
547 : :
548 : 583 : re = NULL;
549 [ + - ]: 583 : if (dbus_error_name_to_re != NULL)
550 : : {
551 : 583 : g_assert (quark_code_pair_to_re != NULL); /* check invariant */
552 : 583 : re = g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name);
553 : : }
554 : :
555 [ + + ]: 583 : if (re != NULL)
556 : : {
557 : 563 : error = g_error_new (re->pair.error_domain,
558 : : re->pair.error_code,
559 : : "GDBus.Error:%s: %s",
560 : : dbus_error_name,
561 : : dbus_error_message);
562 : : }
563 : : else
564 : : {
565 : 20 : GQuark error_domain = 0;
566 : 20 : gint error_code = 0;
567 : :
568 [ + + ]: 20 : if (_g_dbus_error_decode_gerror (dbus_error_name,
569 : : &error_domain,
570 : : &error_code))
571 : : {
572 : 8 : error = g_error_new (error_domain,
573 : : error_code,
574 : : "GDBus.Error:%s: %s",
575 : : dbus_error_name,
576 : : dbus_error_message);
577 : : }
578 : : else
579 : : {
580 : 12 : error = g_error_new (G_IO_ERROR,
581 : : G_IO_ERROR_DBUS_ERROR,
582 : : "GDBus.Error:%s: %s",
583 : : dbus_error_name,
584 : : dbus_error_message);
585 : : }
586 : : }
587 : :
588 : 583 : G_UNLOCK (error_lock);
589 : 583 : return error;
590 : : }
591 : :
592 : : /**
593 : : * g_dbus_error_set_dbus_error:
594 : : * @error: A pointer to a #GError or %NULL.
595 : : * @dbus_error_name: D-Bus error name.
596 : : * @dbus_error_message: D-Bus error message.
597 : : * @format: (nullable): printf()-style format to prepend to @dbus_error_message or %NULL.
598 : : * @...: Arguments for @format.
599 : : *
600 : : * Does nothing if @error is %NULL. Otherwise sets *@error to
601 : : * a new #GError created with g_dbus_error_new_for_dbus_error()
602 : : * with @dbus_error_message prepend with @format (unless %NULL).
603 : : *
604 : : * Since: 2.26
605 : : */
606 : : void
607 : 713 : g_dbus_error_set_dbus_error (GError **error,
608 : : const gchar *dbus_error_name,
609 : : const gchar *dbus_error_message,
610 : : const gchar *format,
611 : : ...)
612 : : {
613 : 713 : g_return_if_fail (error == NULL || *error == NULL);
614 : 713 : g_return_if_fail (dbus_error_name != NULL);
615 : 713 : g_return_if_fail (dbus_error_message != NULL);
616 : :
617 [ + + ]: 713 : if (error == NULL)
618 : 139 : return;
619 : :
620 [ + + ]: 574 : if (format == NULL)
621 : : {
622 : 573 : *error = g_dbus_error_new_for_dbus_error (dbus_error_name, dbus_error_message);
623 : : }
624 : : else
625 : : {
626 : : va_list var_args;
627 : 1 : va_start (var_args, format);
628 : 1 : g_dbus_error_set_dbus_error_valist (error,
629 : : dbus_error_name,
630 : : dbus_error_message,
631 : : format,
632 : : var_args);
633 : 1 : va_end (var_args);
634 : : }
635 : : }
636 : :
637 : : /**
638 : : * g_dbus_error_set_dbus_error_valist:
639 : : * @error: A pointer to a #GError or %NULL.
640 : : * @dbus_error_name: D-Bus error name.
641 : : * @dbus_error_message: D-Bus error message.
642 : : * @format: (nullable): printf()-style format to prepend to @dbus_error_message or %NULL.
643 : : * @var_args: Arguments for @format.
644 : : *
645 : : * Like g_dbus_error_set_dbus_error() but intended for language bindings.
646 : : *
647 : : * Since: 2.26
648 : : */
649 : : void
650 : 1 : g_dbus_error_set_dbus_error_valist (GError **error,
651 : : const gchar *dbus_error_name,
652 : : const gchar *dbus_error_message,
653 : : const gchar *format,
654 : : va_list var_args)
655 : : {
656 : 1 : g_return_if_fail (error == NULL || *error == NULL);
657 : 1 : g_return_if_fail (dbus_error_name != NULL);
658 : 1 : g_return_if_fail (dbus_error_message != NULL);
659 : :
660 [ - + ]: 1 : if (error == NULL)
661 : 0 : return;
662 : :
663 [ + - ]: 1 : if (format != NULL)
664 : : {
665 : : gchar *message;
666 : : gchar *s;
667 : 1 : message = g_strdup_vprintf (format, var_args);
668 : 1 : s = g_strdup_printf ("%s: %s", message, dbus_error_message);
669 : 1 : *error = g_dbus_error_new_for_dbus_error (dbus_error_name, s);
670 : 1 : g_free (s);
671 : 1 : g_free (message);
672 : : }
673 : : else
674 : : {
675 : 0 : *error = g_dbus_error_new_for_dbus_error (dbus_error_name, dbus_error_message);
676 : : }
677 : : }
678 : :
679 : : /**
680 : : * g_dbus_error_strip_remote_error:
681 : : * @error: A #GError.
682 : : *
683 : : * Looks for extra information in the error message used to recover
684 : : * the D-Bus error name and strips it if found. If stripped, the
685 : : * message field in @error will correspond exactly to what was
686 : : * received on the wire.
687 : : *
688 : : * This is typically used when presenting errors to the end user.
689 : : *
690 : : * Returns: %TRUE if information was stripped, %FALSE otherwise.
691 : : *
692 : : * Since: 2.26
693 : : */
694 : : gboolean
695 : 18 : g_dbus_error_strip_remote_error (GError *error)
696 : : {
697 : : gboolean ret;
698 : :
699 : 18 : g_return_val_if_fail (error != NULL, FALSE);
700 : :
701 : 18 : ret = FALSE;
702 : :
703 [ + - - + : 18 : if (g_str_has_prefix (error->message, "GDBus.Error:"))
+ + + + ]
704 : : {
705 : : const gchar *begin;
706 : : const gchar *end;
707 : : gchar *new_message;
708 : :
709 : 17 : begin = error->message + sizeof ("GDBus.Error:") -1;
710 : 17 : end = strstr (begin, ":");
711 [ + - + - ]: 17 : if (end != NULL && end[1] == ' ')
712 : : {
713 : 17 : new_message = g_strdup (end + 2);
714 : 17 : g_free (error->message);
715 : 17 : error->message = new_message;
716 : 17 : ret = TRUE;
717 : : }
718 : : }
719 : :
720 : 18 : return ret;
721 : : }
722 : :
723 : : /**
724 : : * g_dbus_error_encode_gerror:
725 : : * @error: A #GError.
726 : : *
727 : : * Creates a D-Bus error name to use for @error. If @error matches
728 : : * a registered error (cf. g_dbus_error_register_error()), the corresponding
729 : : * D-Bus error name will be returned.
730 : : *
731 : : * Otherwise the a name of the form
732 : : * `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE`
733 : : * will be used. This allows other GDBus applications to map the error
734 : : * on the wire back to a #GError using g_dbus_error_new_for_dbus_error().
735 : : *
736 : : * This function is typically only used in object mappings to put a
737 : : * #GError on the wire. Regular applications should not use it.
738 : : *
739 : : * Returns: (transfer full) (not nullable): A D-Bus error name (never %NULL).
740 : : * Free with g_free().
741 : : *
742 : : * Since: 2.26
743 : : */
744 : : gchar *
745 : 28 : g_dbus_error_encode_gerror (const GError *error)
746 : : {
747 : : RegisteredError *re;
748 : : gchar *error_name;
749 : :
750 : 28 : g_return_val_if_fail (error != NULL, NULL);
751 : :
752 : : /* Ensure that e.g. G_DBUS_ERROR is registered using g_dbus_error_register_error() */
753 : 28 : _g_dbus_initialize ();
754 : :
755 : 28 : error_name = NULL;
756 : :
757 : 28 : G_LOCK (error_lock);
758 : 28 : re = NULL;
759 [ + - ]: 28 : if (quark_code_pair_to_re != NULL)
760 : : {
761 : : QuarkCodePair pair;
762 : 28 : pair.error_domain = error->domain;
763 : 28 : pair.error_code = error->code;
764 : 28 : g_assert (dbus_error_name_to_re != NULL); /* check invariant */
765 : 28 : re = g_hash_table_lookup (quark_code_pair_to_re, &pair);
766 : : }
767 [ + + ]: 28 : if (re != NULL)
768 : : {
769 : 20 : error_name = g_strdup (re->dbus_error_name);
770 : 20 : G_UNLOCK (error_lock);
771 : : }
772 : : else
773 : : {
774 : : const gchar *domain_as_string;
775 : : GString *s;
776 : : guint n;
777 : :
778 : 8 : G_UNLOCK (error_lock);
779 : :
780 : : /* We can't make a lot of assumptions about what domain_as_string
781 : : * looks like and D-Bus is extremely picky about error names so
782 : : * hex-encode it for transport across the wire.
783 : : */
784 : 8 : domain_as_string = g_quark_to_string (error->domain);
785 : :
786 : : /* 0 is not a domain; neither are non-quark integers */
787 : 8 : g_return_val_if_fail (domain_as_string != NULL, NULL);
788 : :
789 : 8 : s = g_string_new ("org.gtk.GDBus.UnmappedGError.Quark._");
790 [ + + ]: 142 : for (n = 0; domain_as_string[n] != 0; n++)
791 : : {
792 : 134 : gint c = domain_as_string[n];
793 [ + + ]: 134 : if (g_ascii_isalnum (c))
794 : : {
795 [ + - ]: 109 : g_string_append_c (s, c);
796 : : }
797 : : else
798 : : {
799 : : guint nibble_top;
800 : : guint nibble_bottom;
801 : : g_string_append_c (s, '_');
802 : 25 : nibble_top = ((int) domain_as_string[n]) >> 4;
803 : 25 : nibble_bottom = ((int) domain_as_string[n]) & 0x0f;
804 [ + - ]: 25 : if (nibble_top < 10)
805 : 25 : nibble_top += '0';
806 : : else
807 : 0 : nibble_top += 'a' - 10;
808 [ - + ]: 25 : if (nibble_bottom < 10)
809 : 0 : nibble_bottom += '0';
810 : : else
811 : 25 : nibble_bottom += 'a' - 10;
812 [ + - ]: 25 : g_string_append_c (s, nibble_top);
813 [ + - ]: 25 : g_string_append_c (s, nibble_bottom);
814 : : }
815 : : }
816 : 8 : g_string_append_printf (s, ".Code%d", error->code);
817 : 8 : error_name = g_string_free (s, FALSE);
818 : : }
819 : :
820 : 28 : return error_name;
821 : : }
|
