| /* GDBus - GLib D-Bus Library |
| * |
| * Copyright (C) 2008-2010 Red Hat, Inc. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library 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 |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General |
| * Public License along with this library; if not, see <http://www.gnu.org/licenses/>. |
| * |
| * Author: David Zeuthen <davidz@redhat.com> |
| */ |
| |
| #include "config.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "gdbuserror.h" |
| #include "gioenums.h" |
| #include "gioenumtypes.h" |
| #include "gioerror.h" |
| #include "gdbusprivate.h" |
| |
| #include "glibintl.h" |
| |
| /** |
| * SECTION:gdbuserror |
| * @title: GDBusError |
| * @short_description: Mapping D-Bus errors to and from GError |
| * @include: gio/gio.h |
| * |
| * All facilities that return errors from remote methods (such as |
| * g_dbus_connection_call_sync()) use #GError to represent both D-Bus |
| * errors (e.g. errors returned from the other peer) and locally |
| * in-process generated errors. |
| * |
| * To check if a returned #GError is an error from a remote peer, use |
| * g_dbus_error_is_remote_error(). To get the actual D-Bus error name, |
| * use g_dbus_error_get_remote_error(). Before presenting an error, |
| * always use g_dbus_error_strip_remote_error(). |
| * |
| * In addition, facilities used to return errors to a remote peer also |
| * use #GError. See g_dbus_method_invocation_return_error() for |
| * discussion about how the D-Bus error name is set. |
| * |
| * Applications can associate a #GError error domain with a set of D-Bus errors in order to |
| * automatically map from D-Bus errors to #GError and back. This |
| * is typically done in the function returning the #GQuark for the |
| * error domain: |
| * |[<!-- language="C" --> |
| * // foo-bar-error.h: |
| * |
| * #define FOO_BAR_ERROR (foo_bar_error_quark ()) |
| * GQuark foo_bar_error_quark (void); |
| * |
| * typedef enum |
| * { |
| * FOO_BAR_ERROR_FAILED, |
| * FOO_BAR_ERROR_ANOTHER_ERROR, |
| * FOO_BAR_ERROR_SOME_THIRD_ERROR, |
| * FOO_BAR_N_ERRORS / *< skip >* / |
| * } FooBarError; |
| * |
| * // foo-bar-error.c: |
| * |
| * static const GDBusErrorEntry foo_bar_error_entries[] = |
| * { |
| * {FOO_BAR_ERROR_FAILED, "org.project.Foo.Bar.Error.Failed"}, |
| * {FOO_BAR_ERROR_ANOTHER_ERROR, "org.project.Foo.Bar.Error.AnotherError"}, |
| * {FOO_BAR_ERROR_SOME_THIRD_ERROR, "org.project.Foo.Bar.Error.SomeThirdError"}, |
| * }; |
| * |
| * // Ensure that every error code has an associated D-Bus error name |
| * G_STATIC_ASSERT (G_N_ELEMENTS (foo_bar_error_entries) == FOO_BAR_N_ERRORS); |
| * |
| * GQuark |
| * foo_bar_error_quark (void) |
| * { |
| * static gsize quark = 0; |
| * g_dbus_error_register_error_domain ("foo-bar-error-quark", |
| * &quark, |
| * foo_bar_error_entries, |
| * G_N_ELEMENTS (foo_bar_error_entries)); |
| * return (GQuark) quark; |
| * } |
| * ]| |
| * With this setup, a D-Bus peer can transparently pass e.g. %FOO_BAR_ERROR_ANOTHER_ERROR and |
| * other peers will see the D-Bus error name org.project.Foo.Bar.Error.AnotherError. |
| * |
| * If the other peer is using GDBus, and has registered the association with |
| * g_dbus_error_register_error_domain() in advance (e.g. by invoking the %FOO_BAR_ERROR quark |
| * generation itself in the previous example) the peer will see also %FOO_BAR_ERROR_ANOTHER_ERROR instead |
| * of %G_IO_ERROR_DBUS_ERROR. Note that GDBus clients can still recover |
| * org.project.Foo.Bar.Error.AnotherError using g_dbus_error_get_remote_error(). |
| * |
| * Note that the %G_DBUS_ERROR error domain is intended only |
| * for returning errors from a remote message bus process. Errors |
| * generated locally in-process by e.g. #GDBusConnection should use the |
| * %G_IO_ERROR domain. |
| */ |
| |
| static const GDBusErrorEntry g_dbus_error_entries[] = |
| { |
| {G_DBUS_ERROR_FAILED, "org.freedesktop.DBus.Error.Failed"}, |
| {G_DBUS_ERROR_NO_MEMORY, "org.freedesktop.DBus.Error.NoMemory"}, |
| {G_DBUS_ERROR_SERVICE_UNKNOWN, "org.freedesktop.DBus.Error.ServiceUnknown"}, |
| {G_DBUS_ERROR_NAME_HAS_NO_OWNER, "org.freedesktop.DBus.Error.NameHasNoOwner"}, |
| {G_DBUS_ERROR_NO_REPLY, "org.freedesktop.DBus.Error.NoReply"}, |
| {G_DBUS_ERROR_IO_ERROR, "org.freedesktop.DBus.Error.IOError"}, |
| {G_DBUS_ERROR_BAD_ADDRESS, "org.freedesktop.DBus.Error.BadAddress"}, |
| {G_DBUS_ERROR_NOT_SUPPORTED, "org.freedesktop.DBus.Error.NotSupported"}, |
| {G_DBUS_ERROR_LIMITS_EXCEEDED, "org.freedesktop.DBus.Error.LimitsExceeded"}, |
| {G_DBUS_ERROR_ACCESS_DENIED, "org.freedesktop.DBus.Error.AccessDenied"}, |
| {G_DBUS_ERROR_AUTH_FAILED, "org.freedesktop.DBus.Error.AuthFailed"}, |
| {G_DBUS_ERROR_NO_SERVER, "org.freedesktop.DBus.Error.NoServer"}, |
| {G_DBUS_ERROR_TIMEOUT, "org.freedesktop.DBus.Error.Timeout"}, |
| {G_DBUS_ERROR_NO_NETWORK, "org.freedesktop.DBus.Error.NoNetwork"}, |
| {G_DBUS_ERROR_ADDRESS_IN_USE, "org.freedesktop.DBus.Error.AddressInUse"}, |
| {G_DBUS_ERROR_DISCONNECTED, "org.freedesktop.DBus.Error.Disconnected"}, |
| {G_DBUS_ERROR_INVALID_ARGS, "org.freedesktop.DBus.Error.InvalidArgs"}, |
| {G_DBUS_ERROR_FILE_NOT_FOUND, "org.freedesktop.DBus.Error.FileNotFound"}, |
| {G_DBUS_ERROR_FILE_EXISTS, "org.freedesktop.DBus.Error.FileExists"}, |
| {G_DBUS_ERROR_UNKNOWN_METHOD, "org.freedesktop.DBus.Error.UnknownMethod"}, |
| {G_DBUS_ERROR_TIMED_OUT, "org.freedesktop.DBus.Error.TimedOut"}, |
| {G_DBUS_ERROR_MATCH_RULE_NOT_FOUND, "org.freedesktop.DBus.Error.MatchRuleNotFound"}, |
| {G_DBUS_ERROR_MATCH_RULE_INVALID, "org.freedesktop.DBus.Error.MatchRuleInvalid"}, |
| {G_DBUS_ERROR_SPAWN_EXEC_FAILED, "org.freedesktop.DBus.Error.Spawn.ExecFailed"}, |
| {G_DBUS_ERROR_SPAWN_FORK_FAILED, "org.freedesktop.DBus.Error.Spawn.ForkFailed"}, |
| {G_DBUS_ERROR_SPAWN_CHILD_EXITED, "org.freedesktop.DBus.Error.Spawn.ChildExited"}, |
| {G_DBUS_ERROR_SPAWN_CHILD_SIGNALED, "org.freedesktop.DBus.Error.Spawn.ChildSignaled"}, |
| {G_DBUS_ERROR_SPAWN_FAILED, "org.freedesktop.DBus.Error.Spawn.Failed"}, |
| {G_DBUS_ERROR_SPAWN_SETUP_FAILED, "org.freedesktop.DBus.Error.Spawn.FailedToSetup"}, |
| {G_DBUS_ERROR_SPAWN_CONFIG_INVALID, "org.freedesktop.DBus.Error.Spawn.ConfigInvalid"}, |
| {G_DBUS_ERROR_SPAWN_SERVICE_INVALID, "org.freedesktop.DBus.Error.Spawn.ServiceNotValid"}, |
| {G_DBUS_ERROR_SPAWN_SERVICE_NOT_FOUND, "org.freedesktop.DBus.Error.Spawn.ServiceNotFound"}, |
| {G_DBUS_ERROR_SPAWN_PERMISSIONS_INVALID, "org.freedesktop.DBus.Error.Spawn.PermissionsInvalid"}, |
| {G_DBUS_ERROR_SPAWN_FILE_INVALID, "org.freedesktop.DBus.Error.Spawn.FileInvalid"}, |
| {G_DBUS_ERROR_SPAWN_NO_MEMORY, "org.freedesktop.DBus.Error.Spawn.NoMemory"}, |
| {G_DBUS_ERROR_UNIX_PROCESS_ID_UNKNOWN, "org.freedesktop.DBus.Error.UnixProcessIdUnknown"}, |
| {G_DBUS_ERROR_INVALID_SIGNATURE, "org.freedesktop.DBus.Error.InvalidSignature"}, |
| {G_DBUS_ERROR_INVALID_FILE_CONTENT, "org.freedesktop.DBus.Error.InvalidFileContent"}, |
| {G_DBUS_ERROR_SELINUX_SECURITY_CONTEXT_UNKNOWN, "org.freedesktop.DBus.Error.SELinuxSecurityContextUnknown"}, |
| {G_DBUS_ERROR_ADT_AUDIT_DATA_UNKNOWN, "org.freedesktop.DBus.Error.AdtAuditDataUnknown"}, |
| {G_DBUS_ERROR_OBJECT_PATH_IN_USE, "org.freedesktop.DBus.Error.ObjectPathInUse"}, |
| {G_DBUS_ERROR_UNKNOWN_OBJECT, "org.freedesktop.DBus.Error.UnknownObject"}, |
| {G_DBUS_ERROR_UNKNOWN_INTERFACE, "org.freedesktop.DBus.Error.UnknownInterface"}, |
| {G_DBUS_ERROR_UNKNOWN_PROPERTY, "org.freedesktop.DBus.Error.UnknownProperty"}, |
| {G_DBUS_ERROR_PROPERTY_READ_ONLY, "org.freedesktop.DBus.Error.PropertyReadOnly"}, |
| }; |
| |
| GQuark |
| g_dbus_error_quark (void) |
| { |
| G_STATIC_ASSERT (G_N_ELEMENTS (g_dbus_error_entries) - 1 == G_DBUS_ERROR_PROPERTY_READ_ONLY); |
| static gsize quark = 0; |
| g_dbus_error_register_error_domain ("g-dbus-error-quark", |
| &quark, |
| g_dbus_error_entries, |
| G_N_ELEMENTS (g_dbus_error_entries)); |
| return (GQuark) quark; |
| } |
| |
| /** |
| * g_dbus_error_register_error_domain: |
| * @error_domain_quark_name: The error domain name. |
| * @quark_volatile: A pointer where to store the #GQuark. |
| * @entries: (array length=num_entries): A pointer to @num_entries #GDBusErrorEntry struct items. |
| * @num_entries: Number of items to register. |
| * |
| * Helper function for associating a #GError error domain with D-Bus error names. |
| * |
| * While @quark_volatile has a `volatile` qualifier, this is a historical |
| * artifact and the argument passed to it should not be `volatile`. |
| * |
| * Since: 2.26 |
| */ |
| void |
| g_dbus_error_register_error_domain (const gchar *error_domain_quark_name, |
| volatile gsize *quark_volatile, |
| const GDBusErrorEntry *entries, |
| guint num_entries) |
| { |
| gsize *quark; |
| |
| g_return_if_fail (error_domain_quark_name != NULL); |
| g_return_if_fail (quark_volatile != NULL); |
| g_return_if_fail (entries != NULL); |
| g_return_if_fail (num_entries > 0); |
| |
| /* Drop the volatile qualifier, which should never have been on the argument |
| * in the first place. */ |
| quark = (gsize *) quark_volatile; |
| |
| if (g_once_init_enter (quark)) |
| { |
| guint n; |
| GQuark new_quark; |
| |
| new_quark = g_quark_from_static_string (error_domain_quark_name); |
| |
| for (n = 0; n < num_entries; n++) |
| { |
| g_warn_if_fail (g_dbus_error_register_error (new_quark, |
| entries[n].error_code, |
| entries[n].dbus_error_name)); |
| } |
| g_once_init_leave (quark, new_quark); |
| } |
| } |
| |
| static gboolean |
| _g_dbus_error_decode_gerror (const gchar *dbus_name, |
| GQuark *out_error_domain, |
| gint *out_error_code) |
| { |
| gboolean ret; |
| guint n; |
| GString *s; |
| gchar *domain_quark_string; |
| |
| ret = FALSE; |
| s = NULL; |
| |
| if (g_str_has_prefix (dbus_name, "org.gtk.GDBus.UnmappedGError.Quark._")) |
| { |
| s = g_string_new (NULL); |
| |
| for (n = sizeof "org.gtk.GDBus.UnmappedGError.Quark._" - 1; |
| dbus_name[n] != '.' && dbus_name[n] != '\0'; |
| n++) |
| { |
| if (g_ascii_isalnum (dbus_name[n])) |
| { |
| g_string_append_c (s, dbus_name[n]); |
| } |
| else if (dbus_name[n] == '_') |
| { |
| guint nibble_top; |
| guint nibble_bottom; |
| |
| n++; |
| |
| nibble_top = dbus_name[n]; |
| if (nibble_top >= '0' && nibble_top <= '9') |
| nibble_top -= '0'; |
| else if (nibble_top >= 'a' && nibble_top <= 'f') |
| nibble_top -= ('a' - 10); |
| else |
| goto not_mapped; |
| |
| n++; |
| |
| nibble_bottom = dbus_name[n]; |
| if (nibble_bottom >= '0' && nibble_bottom <= '9') |
| nibble_bottom -= '0'; |
| else if (nibble_bottom >= 'a' && nibble_bottom <= 'f') |
| nibble_bottom -= ('a' - 10); |
| else |
| goto not_mapped; |
| |
| g_string_append_c (s, (nibble_top<<4) | nibble_bottom); |
| } |
| else |
| { |
| goto not_mapped; |
| } |
| } |
| |
| if (!g_str_has_prefix (dbus_name + n, ".Code")) |
| goto not_mapped; |
| |
| domain_quark_string = g_string_free (s, FALSE); |
| s = NULL; |
| |
| if (out_error_domain != NULL) |
| *out_error_domain = g_quark_from_string (domain_quark_string); |
| g_free (domain_quark_string); |
| |
| if (out_error_code != NULL) |
| *out_error_code = atoi (dbus_name + n + sizeof ".Code" - 1); |
| |
| ret = TRUE; |
| } |
| |
| not_mapped: |
| |
| if (s != NULL) |
| g_string_free (s, TRUE); |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------------------------------------- */ |
| |
| typedef struct |
| { |
| GQuark error_domain; |
| gint error_code; |
| } QuarkCodePair; |
| |
| static guint |
| quark_code_pair_hash_func (const QuarkCodePair *pair) |
| { |
| gint val; |
| val = pair->error_domain + pair->error_code; |
| return g_int_hash (&val); |
| } |
| |
| static gboolean |
| quark_code_pair_equal_func (const QuarkCodePair *a, |
| const QuarkCodePair *b) |
| { |
| return (a->error_domain == b->error_domain) && (a->error_code == b->error_code); |
| } |
| |
| typedef struct |
| { |
| QuarkCodePair pair; |
| gchar *dbus_error_name; |
| } RegisteredError; |
| |
| static void |
| registered_error_free (RegisteredError *re) |
| { |
| g_free (re->dbus_error_name); |
| g_free (re); |
| } |
| |
| G_LOCK_DEFINE_STATIC (error_lock); |
| |
| /* maps from QuarkCodePair* -> RegisteredError* */ |
| static GHashTable *quark_code_pair_to_re = NULL; |
| |
| /* maps from gchar* -> RegisteredError* */ |
| static GHashTable *dbus_error_name_to_re = NULL; |
| |
| /** |
| * g_dbus_error_register_error: |
| * @error_domain: A #GQuark for an error domain. |
| * @error_code: An error code. |
| * @dbus_error_name: A D-Bus error name. |
| * |
| * Creates an association to map between @dbus_error_name and |
| * #GErrors specified by @error_domain and @error_code. |
| * |
| * This is typically done in the routine that returns the #GQuark for |
| * an error domain. |
| * |
| * Returns: %TRUE if the association was created, %FALSE if it already |
| * exists. |
| * |
| * Since: 2.26 |
| */ |
| gboolean |
| g_dbus_error_register_error (GQuark error_domain, |
| gint error_code, |
| const gchar *dbus_error_name) |
| { |
| gboolean ret; |
| QuarkCodePair pair; |
| RegisteredError *re; |
| |
| g_return_val_if_fail (dbus_error_name != NULL, FALSE); |
| |
| ret = FALSE; |
| |
| G_LOCK (error_lock); |
| |
| if (quark_code_pair_to_re == NULL) |
| { |
| g_assert (dbus_error_name_to_re == NULL); /* check invariant */ |
| quark_code_pair_to_re = g_hash_table_new ((GHashFunc) quark_code_pair_hash_func, |
| (GEqualFunc) quark_code_pair_equal_func); |
| dbus_error_name_to_re = g_hash_table_new_full (g_str_hash, |
| g_str_equal, |
| NULL, |
| (GDestroyNotify) registered_error_free); |
| } |
| |
| if (g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name) != NULL) |
| goto out; |
| |
| pair.error_domain = error_domain; |
| pair.error_code = error_code; |
| |
| if (g_hash_table_lookup (quark_code_pair_to_re, &pair) != NULL) |
| goto out; |
| |
| re = g_new0 (RegisteredError, 1); |
| re->pair = pair; |
| re->dbus_error_name = g_strdup (dbus_error_name); |
| |
| g_hash_table_insert (quark_code_pair_to_re, &(re->pair), re); |
| g_hash_table_insert (dbus_error_name_to_re, re->dbus_error_name, re); |
| |
| ret = TRUE; |
| |
| out: |
| G_UNLOCK (error_lock); |
| return ret; |
| } |
| |
| /** |
| * g_dbus_error_unregister_error: |
| * @error_domain: A #GQuark for an error domain. |
| * @error_code: An error code. |
| * @dbus_error_name: A D-Bus error name. |
| * |
| * Destroys an association previously set up with g_dbus_error_register_error(). |
| * |
| * Returns: %TRUE if the association was destroyed, %FALSE if it wasn't found. |
| * |
| * Since: 2.26 |
| */ |
| gboolean |
| g_dbus_error_unregister_error (GQuark error_domain, |
| gint error_code, |
| const gchar *dbus_error_name) |
| { |
| gboolean ret; |
| RegisteredError *re; |
| guint hash_size; |
| |
| g_return_val_if_fail (dbus_error_name != NULL, FALSE); |
| |
| ret = FALSE; |
| |
| G_LOCK (error_lock); |
| |
| if (dbus_error_name_to_re == NULL) |
| { |
| g_assert (quark_code_pair_to_re == NULL); /* check invariant */ |
| goto out; |
| } |
| |
| re = g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name); |
| if (re == NULL) |
| { |
| QuarkCodePair pair; |
| pair.error_domain = error_domain; |
| pair.error_code = error_code; |
| g_warn_if_fail (g_hash_table_lookup (quark_code_pair_to_re, &pair) == NULL); /* check invariant */ |
| goto out; |
| } |
| |
| ret = TRUE; |
| |
| g_warn_if_fail (g_hash_table_lookup (quark_code_pair_to_re, &(re->pair)) == re); /* check invariant */ |
| |
| g_warn_if_fail (g_hash_table_remove (quark_code_pair_to_re, &(re->pair))); |
| g_warn_if_fail (g_hash_table_remove (dbus_error_name_to_re, re->dbus_error_name)); |
| |
| /* destroy hashes if empty */ |
| hash_size = g_hash_table_size (dbus_error_name_to_re); |
| if (hash_size == 0) |
| { |
| g_warn_if_fail (g_hash_table_size (quark_code_pair_to_re) == 0); /* check invariant */ |
| |
| g_hash_table_unref (dbus_error_name_to_re); |
| dbus_error_name_to_re = NULL; |
| g_hash_table_unref (quark_code_pair_to_re); |
| quark_code_pair_to_re = NULL; |
| } |
| else |
| { |
| g_warn_if_fail (g_hash_table_size (quark_code_pair_to_re) == hash_size); /* check invariant */ |
| } |
| |
| out: |
| G_UNLOCK (error_lock); |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------------------------------------- */ |
| |
| /** |
| * g_dbus_error_is_remote_error: |
| * @error: A #GError. |
| * |
| * Checks if @error represents an error received via D-Bus from a remote peer. If so, |
| * use g_dbus_error_get_remote_error() to get the name of the error. |
| * |
| * Returns: %TRUE if @error represents an error from a remote peer, |
| * %FALSE otherwise. |
| * |
| * Since: 2.26 |
| */ |
| gboolean |
| g_dbus_error_is_remote_error (const GError *error) |
| { |
| g_return_val_if_fail (error != NULL, FALSE); |
| return g_str_has_prefix (error->message, "GDBus.Error:"); |
| } |
| |
| |
| /** |
| * g_dbus_error_get_remote_error: |
| * @error: a #GError |
| * |
| * Gets the D-Bus error name used for @error, if any. |
| * |
| * This function is guaranteed to return a D-Bus error name for all |
| * #GErrors returned from functions handling remote method calls |
| * (e.g. g_dbus_connection_call_finish()) unless |
| * g_dbus_error_strip_remote_error() has been used on @error. |
| * |
| * Returns: (nullable) (transfer full): an allocated string or %NULL if the |
| * D-Bus error name could not be found. Free with g_free(). |
| * |
| * Since: 2.26 |
| */ |
| gchar * |
| g_dbus_error_get_remote_error (const GError *error) |
| { |
| RegisteredError *re; |
| gchar *ret; |
| |
| g_return_val_if_fail (error != NULL, NULL); |
| |
| /* Ensure that e.g. G_DBUS_ERROR is registered using g_dbus_error_register_error() */ |
| _g_dbus_initialize (); |
| |
| ret = NULL; |
| |
| G_LOCK (error_lock); |
| |
| re = NULL; |
| if (quark_code_pair_to_re != NULL) |
| { |
| QuarkCodePair pair; |
| pair.error_domain = error->domain; |
| pair.error_code = error->code; |
| g_assert (dbus_error_name_to_re != NULL); /* check invariant */ |
| re = g_hash_table_lookup (quark_code_pair_to_re, &pair); |
| } |
| |
| if (re != NULL) |
| { |
| ret = g_strdup (re->dbus_error_name); |
| } |
| else |
| { |
| if (g_str_has_prefix (error->message, "GDBus.Error:")) |
| { |
| const gchar *begin; |
| const gchar *end; |
| begin = error->message + sizeof ("GDBus.Error:") -1; |
| end = strstr (begin, ":"); |
| if (end != NULL && end[1] == ' ') |
| { |
| ret = g_strndup (begin, end - begin); |
| } |
| } |
| } |
| |
| G_UNLOCK (error_lock); |
| |
| return ret; |
| } |
| |
| /* ---------------------------------------------------------------------------------------------------- */ |
| |
| /** |
| * g_dbus_error_new_for_dbus_error: |
| * @dbus_error_name: D-Bus error name. |
| * @dbus_error_message: D-Bus error message. |
| * |
| * Creates a #GError based on the contents of @dbus_error_name and |
| * @dbus_error_message. |
| * |
| * Errors registered with g_dbus_error_register_error() will be looked |
| * up using @dbus_error_name and if a match is found, the error domain |
| * and code is used. Applications can use g_dbus_error_get_remote_error() |
| * to recover @dbus_error_name. |
| * |
| * If a match against a registered error is not found and the D-Bus |
| * error name is in a form as returned by g_dbus_error_encode_gerror() |
| * the error domain and code encoded in the name is used to |
| * create the #GError. Also, @dbus_error_name is added to the error message |
| * such that it can be recovered with g_dbus_error_get_remote_error(). |
| * |
| * Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR |
| * in the #G_IO_ERROR error domain is returned. Also, @dbus_error_name is |
| * added to the error message such that it can be recovered with |
| * g_dbus_error_get_remote_error(). |
| * |
| * In all three cases, @dbus_error_name can always be recovered from the |
| * returned #GError using the g_dbus_error_get_remote_error() function |
| * (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error). |
| * |
| * This function is typically only used in object mappings to prepare |
| * #GError instances for applications. Regular applications should not use |
| * it. |
| * |
| * Returns: (transfer full): An allocated #GError. Free with g_error_free(). |
| * |
| * Since: 2.26 |
| */ |
| GError * |
| g_dbus_error_new_for_dbus_error (const gchar *dbus_error_name, |
| const gchar *dbus_error_message) |
| { |
| GError *error; |
| RegisteredError *re; |
| |
| g_return_val_if_fail (dbus_error_name != NULL, NULL); |
| g_return_val_if_fail (dbus_error_message != NULL, NULL); |
| |
| /* Ensure that e.g. G_DBUS_ERROR is registered using g_dbus_error_register_error() */ |
| _g_dbus_initialize (); |
| |
| G_LOCK (error_lock); |
| |
| re = NULL; |
| if (dbus_error_name_to_re != NULL) |
| { |
| g_assert (quark_code_pair_to_re != NULL); /* check invariant */ |
| re = g_hash_table_lookup (dbus_error_name_to_re, dbus_error_name); |
| } |
| |
| if (re != NULL) |
| { |
| error = g_error_new (re->pair.error_domain, |
| re->pair.error_code, |
| "GDBus.Error:%s: %s", |
| dbus_error_name, |
| dbus_error_message); |
| } |
| else |
| { |
| GQuark error_domain = 0; |
| gint error_code = 0; |
| |
| if (_g_dbus_error_decode_gerror (dbus_error_name, |
| &error_domain, |
| &error_code)) |
| { |
| error = g_error_new (error_domain, |
| error_code, |
| "GDBus.Error:%s: %s", |
| dbus_error_name, |
| dbus_error_message); |
| } |
| else |
| { |
| error = g_error_new (G_IO_ERROR, |
| G_IO_ERROR_DBUS_ERROR, |
| "GDBus.Error:%s: %s", |
| dbus_error_name, |
| dbus_error_message); |
| } |
| } |
| |
| G_UNLOCK (error_lock); |
| return error; |
| } |
| |
| /** |
| * g_dbus_error_set_dbus_error: |
| * @error: A pointer to a #GError or %NULL. |
| * @dbus_error_name: D-Bus error name. |
| * @dbus_error_message: D-Bus error message. |
| * @format: (nullable): printf()-style format to prepend to @dbus_error_message or %NULL. |
| * @...: Arguments for @format. |
| * |
| * Does nothing if @error is %NULL. Otherwise sets *@error to |
| * a new #GError created with g_dbus_error_new_for_dbus_error() |
| * with @dbus_error_message prepend with @format (unless %NULL). |
| * |
| * Since: 2.26 |
| */ |
| void |
| g_dbus_error_set_dbus_error (GError **error, |
| const gchar *dbus_error_name, |
| const gchar *dbus_error_message, |
| const gchar *format, |
| ...) |
| { |
| g_return_if_fail (error == NULL || *error == NULL); |
| g_return_if_fail (dbus_error_name != NULL); |
| g_return_if_fail (dbus_error_message != NULL); |
| |
| if (error == NULL) |
| return; |
| |
| if (format == NULL) |
| { |
| *error = g_dbus_error_new_for_dbus_error (dbus_error_name, dbus_error_message); |
| } |
| else |
| { |
| va_list var_args; |
| va_start (var_args, format); |
| g_dbus_error_set_dbus_error_valist (error, |
| dbus_error_name, |
| dbus_error_message, |
| format, |
| var_args); |
| va_end (var_args); |
| } |
| } |
| |
| /** |
| * g_dbus_error_set_dbus_error_valist: |
| * @error: A pointer to a #GError or %NULL. |
| * @dbus_error_name: D-Bus error name. |
| * @dbus_error_message: D-Bus error message. |
| * @format: (nullable): printf()-style format to prepend to @dbus_error_message or %NULL. |
| * @var_args: Arguments for @format. |
| * |
| * Like g_dbus_error_set_dbus_error() but intended for language bindings. |
| * |
| * Since: 2.26 |
| */ |
| void |
| g_dbus_error_set_dbus_error_valist (GError **error, |
| const gchar *dbus_error_name, |
| const gchar *dbus_error_message, |
| const gchar *format, |
| va_list var_args) |
| { |
| g_return_if_fail (error == NULL || *error == NULL); |
| g_return_if_fail (dbus_error_name != NULL); |
| g_return_if_fail (dbus_error_message != NULL); |
| |
| if (error == NULL) |
| return; |
| |
| if (format != NULL) |
| { |
| gchar *message; |
| gchar *s; |
| message = g_strdup_vprintf (format, var_args); |
| s = g_strdup_printf ("%s: %s", message, dbus_error_message); |
| *error = g_dbus_error_new_for_dbus_error (dbus_error_name, s); |
| g_free (s); |
| g_free (message); |
| } |
| else |
| { |
| *error = g_dbus_error_new_for_dbus_error (dbus_error_name, dbus_error_message); |
| } |
| } |
| |
| /** |
| * g_dbus_error_strip_remote_error: |
| * @error: A #GError. |
| * |
| * Looks for extra information in the error message used to recover |
| * the D-Bus error name and strips it if found. If stripped, the |
| * message field in @error will correspond exactly to what was |
| * received on the wire. |
| * |
| * This is typically used when presenting errors to the end user. |
| * |
| * Returns: %TRUE if information was stripped, %FALSE otherwise. |
| * |
| * Since: 2.26 |
| */ |
| gboolean |
| g_dbus_error_strip_remote_error (GError *error) |
| { |
| gboolean ret; |
| |
| g_return_val_if_fail (error != NULL, FALSE); |
| |
| ret = FALSE; |
| |
| if (g_str_has_prefix (error->message, "GDBus.Error:")) |
| { |
| const gchar *begin; |
| const gchar *end; |
| gchar *new_message; |
| |
| begin = error->message + sizeof ("GDBus.Error:") -1; |
| end = strstr (begin, ":"); |
| if (end != NULL && end[1] == ' ') |
| { |
| new_message = g_strdup (end + 2); |
| g_free (error->message); |
| error->message = new_message; |
| ret = TRUE; |
| } |
| } |
| |
| return ret; |
| } |
| |
| /** |
| * g_dbus_error_encode_gerror: |
| * @error: A #GError. |
| * |
| * Creates a D-Bus error name to use for @error. If @error matches |
| * a registered error (cf. g_dbus_error_register_error()), the corresponding |
| * D-Bus error name will be returned. |
| * |
| * Otherwise the a name of the form |
| * `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE` |
| * will be used. This allows other GDBus applications to map the error |
| * on the wire back to a #GError using g_dbus_error_new_for_dbus_error(). |
| * |
| * This function is typically only used in object mappings to put a |
| * #GError on the wire. Regular applications should not use it. |
| * |
| * Returns: (transfer full) (not nullable): A D-Bus error name (never %NULL). |
| * Free with g_free(). |
| * |
| * Since: 2.26 |
| */ |
| gchar * |
| g_dbus_error_encode_gerror (const GError *error) |
| { |
| RegisteredError *re; |
| gchar *error_name; |
| |
| g_return_val_if_fail (error != NULL, NULL); |
| |
| /* Ensure that e.g. G_DBUS_ERROR is registered using g_dbus_error_register_error() */ |
| _g_dbus_initialize (); |
| |
| error_name = NULL; |
| |
| G_LOCK (error_lock); |
| re = NULL; |
| if (quark_code_pair_to_re != NULL) |
| { |
| QuarkCodePair pair; |
| pair.error_domain = error->domain; |
| pair.error_code = error->code; |
| g_assert (dbus_error_name_to_re != NULL); /* check invariant */ |
| re = g_hash_table_lookup (quark_code_pair_to_re, &pair); |
| } |
| if (re != NULL) |
| { |
| error_name = g_strdup (re->dbus_error_name); |
| G_UNLOCK (error_lock); |
| } |
| else |
| { |
| const gchar *domain_as_string; |
| GString *s; |
| guint n; |
| |
| G_UNLOCK (error_lock); |
| |
| /* We can't make a lot of assumptions about what domain_as_string |
| * looks like and D-Bus is extremely picky about error names so |
| * hex-encode it for transport across the wire. |
| */ |
| domain_as_string = g_quark_to_string (error->domain); |
| |
| /* 0 is not a domain; neither are non-quark integers */ |
| g_return_val_if_fail (domain_as_string != NULL, NULL); |
| |
| s = g_string_new ("org.gtk.GDBus.UnmappedGError.Quark._"); |
| for (n = 0; domain_as_string[n] != 0; n++) |
| { |
| gint c = domain_as_string[n]; |
| if (g_ascii_isalnum (c)) |
| { |
| g_string_append_c (s, c); |
| } |
| else |
| { |
| guint nibble_top; |
| guint nibble_bottom; |
| g_string_append_c (s, '_'); |
| nibble_top = ((int) domain_as_string[n]) >> 4; |
| nibble_bottom = ((int) domain_as_string[n]) & 0x0f; |
| if (nibble_top < 10) |
| nibble_top += '0'; |
| else |
| nibble_top += 'a' - 10; |
| if (nibble_bottom < 10) |
| nibble_bottom += '0'; |
| else |
| nibble_bottom += 'a' - 10; |
| g_string_append_c (s, nibble_top); |
| g_string_append_c (s, nibble_bottom); |
| } |
| } |
| g_string_append_printf (s, ".Code%d", error->code); |
| error_name = g_string_free (s, FALSE); |
| } |
| |
| return error_name; |
| } |
