diff options
48 files changed, 2605 insertions, 939 deletions
@@ -1,3 +1,65 @@ +2003-03-12 Havoc Pennington <hp@redhat.com> + + Mega-patch that gets the message bus daemon initially handling + out-of-memory. Work still needed. Also lots of random + moving stuff to DBusError instead of ResultCode. + + * dbus/dbus-list.c (_dbus_list_length_is_one): new function + + * dbus/dbus-connection.c + (dbus_connection_send_with_reply_and_block): use DBusError + + * dbus/dbus-bus.c: adapt to API changes, make it use DBusError not + DBusResultCode + + * dbus/dbus-connection.c (dbus_connection_send): drop the result + code here, as the only failure possible is OOM. + + * bus/connection.c (bus_connection_disconnect): + rename bus_connection_disconnected as it's a notification only + + * bus/driver.c (bus_driver_handle_acquire_service): don't free + "name" on get_args failure, should be done by get_args; + don't disconnect client for bad args, just return an error. + (bus_driver_handle_service_exists): ditto + + * bus/services.c (bus_services_list): NULL-terminate returned array + + * bus/driver.c (bus_driver_send_service_lost) + (bus_driver_send_service_acquired): send messages from driver to a + specific client to the client's unique name, not to the broadcast + service. + + * dbus/dbus-message.c (decode_header_data): reject messages that + contain no name field + (_dbus_message_get_client_serial): rename to + dbus_message_get_serial and make public + (_dbus_message_set_serial): rename from set_client_serial + (_dbus_message_set_reply_serial): make public + (_dbus_message_get_reply_serial): make public + + * bus/connection.c (bus_connection_foreach): allow stopping + iteration by returning FALSE from foreach function. + + * dbus/dbus-connection.c (dbus_connection_send_preallocated) + (dbus_connection_free_preallocated_send) + (dbus_connection_preallocate_send): new API for sending a message + without possibility of malloc failure. + (dbus_connection_send_message): rename to just + dbus_connection_send (and same for whole function family) + + * dbus/dbus-errors.c (dbus_error_free): make this reinit the error + + * dbus/dbus-sysdeps.c (_dbus_exit): new function + + * bus/activation.c: handle/return errors + + * dbus/dbus-errors.h: add more DBUS_ERROR #define + + * dbus/dbus-sysdeps.c (_dbus_directory_open) (_dbus_file_get_contents) + (_dbus_directory_get_next_file): use DBusError instead of DBusResultCode + (_dbus_result_from_errno): move to this file + 2003-03-10 Anders Carlsson <andersca@codefactory.se> * dbus/dbus-marshal.c: diff --git a/bus/activation.c b/bus/activation.c index b5cec44a..4e428bde 100644 --- a/bus/activation.c +++ b/bus/activation.c @@ -59,18 +59,24 @@ bus_activation_entry_free (BusActivationEntry *entry) } static dbus_bool_t -add_desktop_file_entry (BusDesktopFile *desktop_file) +add_desktop_file_entry (BusDesktopFile *desktop_file, + DBusError *error) { char *name, *exec; BusActivationEntry *entry; + + name = NULL; + exec = NULL; + entry = NULL; if (!bus_desktop_file_get_string (desktop_file, DBUS_SERVICE_SECTION, DBUS_SERVICE_NAME, &name)) { - _dbus_verbose ("No \""DBUS_SERVICE_NAME"\" key in .service file\n"); - return FALSE; + dbus_set_error (error, DBUS_ERROR_FAILED, + "No \""DBUS_SERVICE_NAME"\" key in .service file\n"); + goto failed; } if (!bus_desktop_file_get_string (desktop_file, @@ -78,57 +84,104 @@ add_desktop_file_entry (BusDesktopFile *desktop_file) DBUS_SERVICE_EXEC, &exec)) { - _dbus_verbose ("No \""DBUS_SERVICE_EXEC"\" key in .service file\n"); - - dbus_free (name); - return FALSE; + dbus_set_error (error, DBUS_ERROR_FAILED, + "No \""DBUS_SERVICE_EXEC"\" key in .service file\n"); + goto failed; } + /* FIXME we need a better-defined algorithm for which service file to + * pick than "whichever one is first in the directory listing" + */ if (_dbus_hash_table_lookup_string (activation_entries, name)) { - _dbus_verbose ("Service %s already exists in activation entry list\n", name); - dbus_free (name); - dbus_free (exec); - - return FALSE; + dbus_set_error (error, DBUS_ERROR_FAILED, + "Service %s already exists in activation entry list\n", name); + goto failed; + } + + entry = dbus_new0 (BusActivationEntry, 1); + if (entry == NULL) + { + BUS_SET_OOM (error); + goto failed; } - BUS_HANDLE_OOM (entry = dbus_malloc0 (sizeof (BusActivationEntry))); entry->name = name; entry->exec = exec; - BUS_HANDLE_OOM (_dbus_hash_table_insert_string (activation_entries, entry->name, entry)); + if (!_dbus_hash_table_insert_string (activation_entries, entry->name, entry)) + { + BUS_SET_OOM (error); + goto failed; + } _dbus_verbose ("Added \"%s\" to list of services\n", entry->name); return TRUE; + + failed: + dbus_free (name); + dbus_free (exec); + dbus_free (entry); + + return FALSE; } -static void -load_directory (const char *directory) +/* warning: this doesn't fully "undo" itself on failure, i.e. doesn't strip + * hash entries it already added. + */ +static dbus_bool_t +load_directory (const char *directory, + DBusError *error) { DBusDirIter *iter; DBusString dir, filename; - DBusResultCode result; - + DBusString full_path; + BusDesktopFile *desktop_file; + DBusError tmp_error; + _dbus_string_init_const (&dir, directory); + + iter = NULL; + desktop_file = NULL; - iter = _dbus_directory_open (&dir, &result); - if (iter == NULL) + if (!_dbus_string_init (&filename, _DBUS_INT_MAX)) { - _dbus_verbose ("Failed to open directory %s: &s\n", directory, - result); - return; + BUS_SET_OOM (error); + return FALSE; } - BUS_HANDLE_OOM (_dbus_string_init (&filename, _DBUS_INT_MAX)); + if (!_dbus_string_init (&full_path, _DBUS_INT_MAX)) + { + BUS_SET_OOM (error); + _dbus_string_free (&filename); + return FALSE; + } + + /* from this point it's safe to "goto failed" */ + + iter = _dbus_directory_open (&dir, error); + if (iter == NULL) + { + _dbus_verbose ("Failed to open directory %s: %s\n", + directory, error ? error->message : "unknown"); + goto failed; + } /* Now read the files */ - while (_dbus_directory_get_next_file (iter, &filename, &result)) + dbus_error_init (&tmp_error); + while (_dbus_directory_get_next_file (iter, &filename, &tmp_error)) { - DBusString full_path; - BusDesktopFile *desktop_file; - DBusError error; + _dbus_assert (!dbus_error_is_set (&tmp_error)); + + _dbus_string_set_length (&full_path, 0); + + if (!_dbus_string_append (&full_path, directory) || + !_dbus_concat_dir_and_file (&full_path, &filename)) + { + BUS_SET_OOM (error); + goto failed; + } if (!_dbus_string_ends_with_c_str (&filename, ".service")) { @@ -136,71 +189,133 @@ load_directory (const char *directory) _dbus_string_get_const_data (&filename, &filename_c); _dbus_verbose ("Skipping non-.service file %s\n", filename_c); - continue; + continue; } - BUS_HANDLE_OOM (_dbus_string_init (&full_path, _DBUS_INT_MAX)); - BUS_HANDLE_OOM (_dbus_string_append (&full_path, directory)); - - BUS_HANDLE_OOM (_dbus_concat_dir_and_file (&full_path, &filename)); + desktop_file = bus_desktop_file_load (&full_path, &tmp_error); - desktop_file = bus_desktop_file_load (&full_path, &error); - - if (!desktop_file) + if (desktop_file == NULL) { const char *full_path_c; _dbus_string_get_const_data (&full_path, &full_path_c); _dbus_verbose ("Could not load %s: %s\n", full_path_c, - error.message); - dbus_error_free (&error); - _dbus_string_free (&full_path); + tmp_error.message); + + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) + { + dbus_move_error (&tmp_error, error); + goto failed; + } + + dbus_error_free (&tmp_error); continue; } - if (!add_desktop_file_entry (desktop_file)) + if (!add_desktop_file_entry (desktop_file, &tmp_error)) { const char *full_path_c; + bus_desktop_file_free (desktop_file); + desktop_file = NULL; + _dbus_string_get_const_data (&full_path, &full_path_c); - _dbus_verbose ("Could not add %s to activation entry list.\n", full_path_c); + _dbus_verbose ("Could not add %s to activation entry list: %s\n", + full_path_c, tmp_error.message); + + if (dbus_error_has_name (&tmp_error, DBUS_ERROR_NO_MEMORY)) + { + dbus_move_error (&tmp_error, error); + goto failed; + } + + dbus_error_free (&tmp_error); + continue; } + else + { + bus_desktop_file_free (desktop_file); + desktop_file = NULL; + continue; + } + } - bus_desktop_file_free (desktop_file); - _dbus_string_free (&full_path); + if (dbus_error_is_set (&tmp_error)) + { + dbus_move_error (&tmp_error, error); + goto failed; } + + return TRUE; + + failed: + _DBUS_ASSERT_ERROR_IS_SET (error); + + if (iter != NULL) + _dbus_directory_close (iter); + if (desktop_file) + bus_desktop_file_free (desktop_file); + _dbus_string_free (&filename); + _dbus_string_free (&full_path); + + return FALSE; } - -void -bus_activation_init (const char *address, - const char **directories) +dbus_bool_t +bus_activation_init (const char *address, + const char **directories, + DBusError *error) { int i; + _dbus_assert (server_address == NULL); + _dbus_assert (activation_entries == NULL); + /* FIXME: We should split up the server addresses. */ - BUS_HANDLE_OOM (server_address = _dbus_strdup (address)); + server_address = _dbus_strdup (address); + if (server_address == NULL) + { + BUS_SET_OOM (error); + goto failed; + } - BUS_HANDLE_OOM (activation_entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, - (DBusFreeFunction)bus_activation_entry_free)); - - i = 0; + activation_entries = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, + (DBusFreeFunction)bus_activation_entry_free); + if (activation_entries == NULL) + { + BUS_SET_OOM (error); + goto failed; + } /* Load service files */ + i = 0; while (directories[i] != NULL) { - load_directory (directories[i]); - i++; + if (!load_directory (directories[i], error)) + goto failed; + ++i; } + + return TRUE; + + failed: + dbus_free (server_address); + if (activation_entries) + _dbus_hash_table_unref (activation_entries); + + return FALSE; } static void child_setup (void *data) { - /* FIXME: Check return value in case of OOM */ - _dbus_setenv ("DBUS_ADDRESS", server_address); + /* If no memory, we simply have the child exit, so it won't try + * to connect to the wrong thing. + */ + if (!_dbus_setenv ("DBUS_ADDRESS", server_address)) + _dbus_exit (1); } dbus_bool_t @@ -220,6 +335,10 @@ bus_activation_activate_service (const char *service_name, return FALSE; } + /* FIXME we need to support a full command line, not just a single + * argv[0] + */ + /* Now try to spawn the process */ argv[0] = entry->exec; argv[1] = NULL; diff --git a/bus/activation.h b/bus/activation.h index 5f29871e..e7a9cdfc 100644 --- a/bus/activation.h +++ b/bus/activation.h @@ -26,8 +26,9 @@ #include <dbus/dbus.h> -void bus_activation_init (const char *address, - const char **paths); +dbus_bool_t bus_activation_init (const char *address, + const char **paths, + DBusError *error); dbus_bool_t bus_activation_activate_service (const char *service_name, DBusError *error); diff --git a/bus/connection.c b/bus/connection.c index 40bbc325..ff671c58 100644 --- a/bus/connection.c +++ b/bus/connection.c @@ -24,34 +24,79 @@ #include "dispatch.h" #include "loop.h" #include "services.h" +#include "utils.h" #include <dbus/dbus-list.h> +static void bus_connection_remove_transactions (DBusConnection *connection); + static int connection_data_slot; static DBusList *connections = NULL; typedef struct { + DBusConnection *connection; DBusList *services_owned; - char *name; + DBusList *transaction_messages; /**< Stuff we need to send as part of a transaction */ + DBusMessage *oom_message; + DBusPreallocatedSend *oom_preallocated; } BusConnectionData; #define BUS_CONNECTION_DATA(connection) (dbus_connection_get_data ((connection), connection_data_slot)) void -bus_connection_disconnect (DBusConnection *connection) +bus_connection_disconnected (DBusConnection *connection) { BusConnectionData *d; BusService *service; - + _dbus_warn ("Disconnected\n"); d = BUS_CONNECTION_DATA (connection); _dbus_assert (d != NULL); - /* Drop any service ownership */ - while ((service = _dbus_list_get_last (&d->services_owned))) - bus_service_remove_owner (service, connection); + /* Drop any service ownership. FIXME Unfortunately, this requires + * memory allocation and there doesn't seem to be a good way to + * handle it other than sleeping; we can't "fail" the operation of + * disconnecting a client, and preallocating a broadcast "service is + * now gone" message for every client-service pair seems kind of + * involved. Probably we need to do that though, and also + * extend BusTransaction to be able to revert generic + * stuff, not just sending a message (so we can e.g. revert + * removal of service owners). + */ + { + BusTransaction *transaction; + DBusError error; + + dbus_error_init (&error); + + transaction = NULL; + while (transaction == NULL) + { + transaction = bus_transaction_new (); + bus_wait_for_memory (); + } + + while ((service = _dbus_list_get_last (&d->services_owned))) + { + retry: + if (!bus_service_remove_owner (service, connection, + transaction, &error)) + { + if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) + { + dbus_error_free (&error); + bus_wait_for_memory (); + goto retry; + } + else + _dbus_assert_not_reached ("Removing service owner failed for non-memory-related reason"); + } + } + + bus_transaction_execute_and_free (transaction); + } bus_dispatch_remove_connection (connection); @@ -60,12 +105,14 @@ bus_connection_disconnect (DBusConnection *connection) NULL, NULL, connection, NULL); + + bus_connection_remove_transactions (connection); dbus_connection_set_data (connection, connection_data_slot, NULL, NULL); - _dbus_list_remove (&connections, connection); + _dbus_list_remove (&connections, connection); dbus_connection_unref (connection); } @@ -106,7 +153,14 @@ free_connection_data (void *data) /* services_owned should be NULL since we should be disconnected */ _dbus_assert (d->services_owned == NULL); + /* similarly */ + _dbus_assert (d->transaction_messages == NULL); + if (d->oom_preallocated) + dbus_connection_free_preallocated_send (d->connection, d->oom_preallocated); + if (d->oom_message) + dbus_message_unref (d->oom_message); + dbus_free (d->name); dbus_free (d); @@ -132,6 +186,8 @@ bus_connection_setup (DBusConnection *connection) if (d == NULL) return FALSE; + + d->connection = connection; if (!dbus_connection_set_data (connection, connection_data_slot, @@ -163,6 +219,88 @@ bus_connection_setup (DBusConnection *connection) return TRUE; } +/** + * Checks whether the connection is registered with the message bus. + * + * @param connection the connection + * @returns #TRUE if we're an active message bus participant + */ +dbus_bool_t +bus_connection_is_active (DBusConnection *connection) +{ + BusConnectionData *d; + + d = BUS_CONNECTION_DATA (connection); + + return d != NULL && d->name != NULL; +} + +dbus_bool_t +bus_connection_preallocate_oom_error (DBusConnection *connection) +{ + DBusMessage *message; + DBusPreallocatedSend *preallocated; + BusConnectionData *d; + + d = BUS_CONNECTION_DATA (connection); + + _dbus_assert (d != NULL); + + if (d->oom_preallocated != NULL) + return TRUE; + + preallocated = dbus_connection_preallocate_send (connection); + if (preallocated == NULL) + return FALSE; + + message = dbus_message_new (DBUS_SERVICE_DBUS, + DBUS_ERROR_NO_MEMORY); + if (message == NULL) + { + dbus_connection_free_preallocated_send (connection, preallocated); + return FALSE; + } + + /* set reply serial to placeholder value just so space is already allocated + * for it. + */ + if (!dbus_message_set_reply_serial (message, 14)) + { + dbus_connection_free_preallocated_send (connection, preallocated); + dbus_message_unref (message); + return FALSE; + } + + d->oom_message = message; + d->oom_preallocated = preallocated; + + return TRUE; +} + +void +bus_connection_send_oom_error (DBusConnection *connection, + DBusMessage *in_reply_to) +{ + BusConnectionData *d; + + d = BUS_CONNECTION_DATA (connection); + + _dbus_assert (d != NULL); + _dbus_assert (d->oom_message != NULL); + + /* should always succeed since we set it to a placeholder earlier */ + if (!dbus_message_set_reply_serial (d->oom_message, + dbus_message_get_serial (in_reply_to))) + _dbus_assert_not_reached ("Failed to set reply serial for preallocated oom message"); + + dbus_connection_send_preallocated (connection, d->oom_preallocated, + d->oom_message, NULL); + + dbus_message_unref (d->oom_message); + d->oom_message = NULL; + d->oom_preallocated = NULL; +} + dbus_bool_t bus_connection_add_owned_service (DBusConnection *connection, BusService *service) @@ -223,9 +361,277 @@ bus_connection_get_name (DBusConnection *connection) return d->name; } +/** + * Calls function on each connection; if the function returns + * #FALSE, stops iterating. + * + * @param function the function + * @param data data to pass to it as a second arg + */ void bus_connection_foreach (BusConnectionForeachFunction function, void *data) { - _dbus_list_foreach (&connections, (DBusForeachFunction)function, data); + DBusList *link; + + link = _dbus_list_get_first_link (&connections); + while (link != NULL) + { + DBusConnection *connection = link->data; + DBusList *next = _dbus_list_get_next_link (&connections, link); + + if (!(* function) (connection, data)) + break; + + link = next; + } +} + +typedef struct +{ + BusTransaction *transaction; + DBusMessage *message; + DBusPreallocatedSend *preallocated; +} MessageToSend; + +struct BusTransaction +{ + DBusList *connections; + +}; + +static void +message_to_send_free (DBusConnection *connection, + MessageToSend *to_send) +{ + if (to_send->message) + dbus_message_unref (to_send->message); + + if (to_send->preallocated) + dbus_connection_free_preallocated_send (connection, to_send->preallocated); + + dbus_free (to_send); +} + +BusTransaction* +bus_transaction_new (void) +{ + BusTransaction *transaction; + + transaction = dbus_new0 (BusTransaction, 1); + if (transaction == NULL) + return NULL; + + return transaction; +} + +dbus_bool_t +bus_transaction_send_message (BusTransaction *transaction, + DBusConnection *connection, + DBusMessage *message) +{ + MessageToSend *to_send; + BusConnectionData *d; + DBusList *link; + + if (!dbus_connection_get_is_connected (connection)) + return TRUE; /* silently ignore disconnected connections */ + + d = BUS_CONNECTION_DATA (connection); + _dbus_assert (d != NULL); + + to_send = dbus_new (MessageToSend, 1); + if (to_send == NULL) + { + return FALSE; + } + + to_send->preallocated = dbus_connection_preallocate_send (connection); + if (to_send->preallocated == NULL) + { + dbus_free (to_send); + return FALSE; + } + + dbus_message_ref (message); + to_send->message = message; + to_send->transaction = transaction; + + if (!_dbus_list_prepend (&d->transaction_messages, to_send)) + { + message_to_send_free (connection, to_send); + return FALSE; + } + + /* See if we already had this connection in the list + * for this transaction. If we have a pending message, + * then we should already be in transaction->connections + */ + link = _dbus_list_get_first_link (&d->transaction_messages); + _dbus_assert (link->data == to_send); + link = _dbus_list_get_next_link (&d->transaction_messages, link); + while (link != NULL) + { + MessageToSend *m = link->data; + DBusList *next = _dbus_list_get_next_link (&d->transaction_messages, link); + + if (m->transaction == transaction) + break; + + link = next; + } + + if (link == NULL) + { + if (!_dbus_list_prepend (&transaction->connections, connection)) + { + _dbus_list_remove (&d->transaction_messages, to_send); + message_to_send_free (connection, to_send); + return FALSE; + } + } + + return TRUE; +} + +static void +connection_cancel_transaction (DBusConnection *connection, + BusTransaction *transaction) +{ + DBusList *link; + BusConnectionData *d; + + d = BUS_CONNECTION_DATA (connection); + _dbus_assert (d != NULL); + + link = _dbus_list_get_first_link (&d->transaction_messages); + while (link != NULL) + { + MessageToSend *m = link->data; + DBusList *next = _dbus_list_get_next_link (&d->transaction_messages, link); + + if (m->transaction == transaction) + { + _dbus_list_remove_link (&d->transaction_messages, + link); + + message_to_send_free (connection, m); + } + + link = next; + } +} + +void +bus_transaction_cancel_and_free (BusTransaction *transaction) +{ + DBusConnection *connection; + + while ((connection = _dbus_list_pop_first (&transaction->connections))) + connection_cancel_transaction (connection, transaction); + + _dbus_assert (transaction->connections == NULL); + + dbus_free (transaction); +} + +static void +connection_execute_transaction (DBusConnection *connection, + BusTransaction *transaction) +{ + DBusList *link; + BusConnectionData *d; + + d = BUS_CONNECTION_DATA (connection); + _dbus_assert (d != NULL); + + /* Send the queue in order (FIFO) */ + link = _dbus_list_get_last_link (&d->transaction_messages); + while (link != NULL) + { + MessageToSend *m = link->data; + DBusList *prev = _dbus_list_get_prev_link (&d->transaction_messages, link); + + if (m->transaction == transaction) + { + _dbus_list_remove_link (&d->transaction_messages, + link); + + dbus_connection_send_preallocated (connection, + m->preallocated, + m->message, + NULL); + + m->preallocated = NULL; /* so we don't double-free it */ + + message_to_send_free (connection, m); + } + + link = prev; + } +} + +void +bus_transaction_execute_and_free (BusTransaction *transaction) +{ + /* For each connection in transaction->connections + * send the messages + */ + DBusConnection *connection; + + while ((connection = _dbus_list_pop_first (&transaction->connections))) + connection_execute_transaction (connection, transaction); + + _dbus_assert (transaction->connections == NULL); + + dbus_free (transaction); +} + +static void +bus_connection_remove_transactions (DBusConnection *connection) +{ + MessageToSend *to_send; + BusConnectionData *d; + + d = BUS_CONNECTION_DATA (connection); + _dbus_assert (d != NULL); + + while ((to_send = _dbus_list_get_first (&d->transaction_messages))) + { + /* only has an effect for the first MessageToSend listing this transaction */ + _dbus_list_remove (&to_send->transaction->connections, + connection); + + _dbus_list_remove (&d->transaction_messages, to_send); + message_to_send_free (connection, to_send); + } +} + +/** + * Converts the DBusError to a message reply + */ +dbus_bool_t +bus_transaction_send_error_reply (BusTransaction *transaction, + DBusConnection *connection, + const DBusError *error, + DBusMessage *in_reply_to) +{ + DBusMessage *reply; + + _dbus_assert (error != NULL); + _DBUS_ASSERT_ERROR_IS_SET (error); + + reply = dbus_message_new_error_reply (in_reply_to, + error->name, + error->message); + if (reply == NULL) + return FALSE; + + if (!bus_transaction_send_message (transaction, connection, reply)) + { + dbus_message_unref (reply); + return FALSE; + } + + return TRUE; } diff --git a/bus/connection.h b/bus/connection.h index 04ab1f08..a7a448a1 100644 --- a/bus/connection.h +++ b/bus/connection.h @@ -27,13 +27,19 @@ #include <dbus/dbus.h> #include "services.h" -typedef void (* BusConnectionForeachFunction) (DBusConnection *connection, - void *data); +typedef dbus_bool_t (* BusConnectionForeachFunction) (DBusConnection *connection, + void *data); dbus_bool_t bus_connection_init (void); dbus_bool_t bus_connection_setup (DBusConnection *connection); +dbus_bool_t bus_connection_is_active (DBusConnection *connection); + +dbus_bool_t bus_connection_preallocate_oom_error (DBusConnection *connection); +void bus_connection_send_oom_error (DBusConnection *connection, + DBusMessage *in_reply_to); + /* called by services.c */ dbus_bool_t bus_connection_add_owned_service (DBusConnection *connection, BusService *service); @@ -47,8 +53,20 @@ const char *bus_connection_get_name (DBusConnection *connection); void bus_connection_foreach (BusConnectionForeachFunction function, void *data); -/* called by dispatch.c */ -void bus_connection_disconnect (DBusConnection *connection); +/* called by dispatch.c when the connection is dropped */ +void bus_connection_disconnected (DBusConnection *connection); + +/* transaction API so we can send or not send a block of messages as a whole */ +BusTransaction* bus_transaction_new (void); +dbus_bool_t bus_transaction_send_message (BusTransaction *transaction, + DBusConnection *connection, + DBusMessage *message); +dbus_bool_t bus_transaction_send_error_reply (BusTransaction *transaction, + DBusConnection *connection, + const DBusError *error, + DBusMessage *in_reply_to); +void bus_transaction_cancel_and_free (BusTransaction *transaction); +void bus_transaction_execute_and_free (BusTransaction *transaction); #endif /* BUS_CONNECTION_H */ diff --git a/bus/desktop-file.c b/bus/desktop-file.c index 0ab6afc8..65a0d76f 100644 --- a/bus/desktop-file.c +++ b/bus/desktop-file.c @@ -125,7 +125,7 @@ bus_desktop_file_free (BusDesktopFile *desktop_file) dbus_free (desktop_file); } -static void +static dbus_bool_t grow_lines_in_section (BusDesktopFileSection *section) { BusDesktopFileLine *lines; @@ -137,14 +137,19 @@ grow_lines_in_section (BusDesktopFileSection *section) else new_n_lines = section->n_allocated_lines*2; - BUS_HANDLE_OOM (lines = dbus_realloc (section->lines, - sizeof (BusDesktopFileLine) * new_n_lines)); - section->lines = lines; + lines = dbus_realloc (section->lines, + sizeof (BusDesktopFileLine) * new_n_lines); + + if (lines == NULL) + return FALSE; + section->lines = lines; section->n_allocated_lines = new_n_lines; + + return TRUE; } -static void +static dbus_bool_t grow_sections (BusDesktopFile *desktop_file) { int new_n_sections; @@ -155,21 +160,36 @@ grow_sections (BusDesktopFile *desktop_file) else new_n_sections = desktop_file->n_allocated_sections*2; - BUS_HANDLE_OOM (sections = dbus_realloc (desktop_file->sections, - sizeof (BusDesktopFileSection) * new_n_sections)); + sections = dbus_realloc (desktop_file->sections, + sizeof (BusDesktopFileSection) * new_n_sections); + if (sections == NULL) + return FALSE; + desktop_file->sections = sections; desktop_file->n_allocated_sections = new_n_sections; + + return TRUE; } static char * -unescape_string (const DBusString *str, int pos, int end_pos) +unescape_string (BusDesktopFileParser *parser, + const DBusString *str, + int pos, + int end_pos, + DBusError *error) { char *retval, *q; /* len + 1 is enough, because unescaping never makes the - * string longer */ - BUS_HANDLE_OOM (retval = dbus_malloc (end_pos - pos + 1)); + * string longer + */ + retval = dbus_malloc (end_pos - pos + 1); + if (retval == NULL) + { + BUS_SET_OOM (error); + return NULL; + } q = retval; @@ -179,6 +199,8 @@ unescape_string (const DBusString *str, int pos, int end_pos) { /* Found an embedded null */ dbus_free (retval); + report_error (parser, "Text to be unescaped contains embedded nul", + BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error); return NULL; } @@ -190,6 +212,8 @@ unescape_string (const DBusString *str, int pos, int end_pos) { /* Escape at end of string */ dbus_free (retval); + report_error (parser, "Text to be unescaped ended in \\", + BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error); return NULL; } @@ -213,7 +237,9 @@ unescape_string (const DBusString *str, int pos, int end_pos) default: /* Invalid escape code */ dbus_free (retval); - return NULL; + report_error (parser, "Text to be unescaped had invalid escape sequence", + BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error); + return NULL; } pos++; } @@ -235,20 +261,34 @@ new_section (BusDesktopFile *desktop_file, const char *name) { int n; + char *name_copy; if (desktop_file->n_allocated_sections == desktop_file->n_sections) - grow_sections (desktop_file); - - n = desktop_file->n_sections++; + { + if (!grow_sections (desktop_file)) + return NULL; + } - BUS_HANDLE_OOM (desktop_file->sections[n].section_name = _dbus_strdup (name)); + name_copy = _dbus_strdup (name); + if (name_copy == NULL) + return NULL; + + n = desktop_file->n_sections + 1; + desktop_file->sections[n].section_name = name_copy; desktop_file->sections[n].n_lines = 0; desktop_file->sections[n].lines = NULL; desktop_file->sections[n].n_allocated_lines = 0; - grow_lines_in_section (&desktop_file->sections[n]); + if (!grow_lines_in_section (&desktop_file->sections[n])) + { + dbus_free (desktop_file->sections[n].section_name); + desktop_file->sections[n].section_name = NULL; + return NULL; + } + desktop_file->n_sections = n; + return &desktop_file->sections[n]; } @@ -277,7 +317,10 @@ new_line (BusDesktopFileParser *parser) section = &parser->desktop_file->sections[parser->current_section]; if (section->n_allocated_lines == section->n_lines) - grow_lines_in_section (section); + { + if (!grow_lines_in_section (section)) + return NULL; + } line = §ion->lines[section->n_lines++]; @@ -358,11 +401,12 @@ parse_section_start (BusDesktopFileParser *parser, DBusError *error) return FALSE; } - section_name = unescape_string (&parser->data, parser->pos + 1, line_end - 1); + section_name = unescape_string (parser, + &parser->data, parser->pos + 1, line_end - 1, + error); if (section_name == NULL) { - report_error (parser, "Invalid escaping in section name", BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error); parser_free (parser); return FALSE; } @@ -450,20 +494,39 @@ parse_key_value (BusDesktopFileParser *parser, DBusError *error) value_start = p; - value = unescape_string (&parser->data, value_start, line_end); + value = unescape_string (parser, &parser->data, value_start, line_end, error); if (value == NULL) { - report_error (parser, "Invalid escaping in value", BUS_DESKTOP_PARSE_ERROR_INVALID_ESCAPES, error); parser_free (parser); return FALSE; } line = new_line (parser); - - BUS_HANDLE_OOM (_dbus_string_init (&key, key_end - key_start)); - BUS_HANDLE_OOM (_dbus_string_copy_len (&parser->data, key_start, key_end - key_start, - &key, 0)); - BUS_HANDLE_OOM (_dbus_string_steal_data (&key, &tmp)); + if (line == NULL) + { + parser_free (parser); + return FALSE; + } + + if (!_dbus_string_init (&key, key_end - key_start)) + { + parser_free (parser); + return FALSE; + } + + if (!_dbus_string_copy_len (&parser->data, key_start, key_end - key_start, + &key, 0)) + { + parser_free (parser); + return FALSE; + } + + if (!_dbus_string_steal_data (&key, &tmp)) + { + parser_free (parser); + return FALSE; + } + _dbus_string_free (&key); line->key = tmp; @@ -491,11 +554,11 @@ report_error (BusDesktopFileParser *parser, section_name = parser->desktop_file->sections[parser->current_section].section_name; if (section_name) - BUS_HANDLE_OOM (dbus_set_error (error, error_name, - "Error in section %s at line %d: %s\n", section_name, parser->line_num, message)); + dbus_set_error (error, error_name, + "Error in section %s at line %d: %s\n", section_name, parser->line_num, message); else - BUS_HANDLE_OOM (dbus_set_error (error, error_name, - "Error at line %d: %s\n", parser->line_num, message)); + dbus_set_error (error, error_name, + "Error at line %d: %s\n", parser->line_num, message); } #if 0 @@ -519,39 +582,52 @@ dump_desktop_file (BusDesktopFile *file) } #endif -BusDesktopFile * +BusDesktopFile* bus_desktop_file_load (DBusString *filename, DBusError *error) { DBusString str; - DBusResultCode result_code; BusDesktopFileParser parser; + DBusStat sb; - /* FIXME: Check file size so we don't try to load a ridicously large file. */ + /* Clearly there's a race here, but it's just to make it unlikely + * that we do something silly, we still handle doing it below. + */ + if (!_dbus_stat (filename, &sb, error)) + return NULL; - BUS_HANDLE_OOM (_dbus_string_init (&str, _DBUS_INT_MAX)); + if (sb.size > _DBUS_ONE_KILOBYTE * 128) + { + dbus_set_error (error, DBUS_ERROR_FAILED, + "Desktop file size (%ld bytes) is too large", (long) sb.size); + return NULL; + } - BUS_HANDLE_OOM ((result_code = _dbus_file_get_contents (&str, filename)) != - DBUS_RESULT_NO_MEMORY); + if (!_dbus_string_init (&str, _DBUS_INT_MAX)) + return NULL; - if (result_code != DBUS_RESULT_SUCCESS) + if (!_dbus_file_get_contents (&str, filename, error)) { _dbus_string_free (&str); - - /* FIXME: Set error */ return NULL; } if (!_dbus_string_validate_utf8 (&str, 0, _dbus_string_get_length (&str))) { _dbus_string_free (&str); - - /* FIXME: Set error */ + dbus_set_error (error, DBUS_ERROR_FAILED, + "invalid UTF-8"); + return NULL; + } + + parser.desktop_file = dbus_new0 (BusDesktopFile, 1); + if (parser.desktop_file == NULL) + { + _dbus_string_free (&str); + BUS_SET_OOM (error); return NULL; } - BUS_HANDLE_OOM (parser.desktop_file = dbus_malloc0 (sizeof (BusDesktopFile))); - parser.data = str; parser.line_num = 1; parser.pos = 0; @@ -563,7 +639,10 @@ bus_desktop_file_load (DBusString *filename, if (_dbus_string_get_byte (&parser.data, parser.pos) == '[') { if (!parse_section_start (&parser, error)) - return NULL; + { + _dbus_string_free (&parser.data); + return NULL; + } } else if (is_blank_line (&parser) || _dbus_string_get_byte (&parser.data, parser.pos) == '#') @@ -571,7 +650,10 @@ bus_desktop_file_load (DBusString *filename, else { if (!parse_key_value (&parser, error)) - return NULL; + { + _dbus_string_free (&parser.data); + return NULL; + } } } @@ -661,7 +743,13 @@ bus_desktop_file_get_string (BusDesktopFile *desktop_file, if (!bus_desktop_file_get_raw (desktop_file, section, keyname, &raw)) return FALSE; - BUS_HANDLE_OOM (*val = _dbus_strdup (raw)); + *val = _dbus_strdup (raw); + + /* FIXME we don't distinguish "key not found" from "out of memory" here, + * which is broken. + */ + if (*val == NULL) + return FALSE; return TRUE; } diff --git a/bus/dispatch.c b/bus/dispatch.c index 76e10a9f..d9fe81ac 100644 --- a/bus/dispatch.c +++ b/bus/dispatch.c @@ -30,23 +30,110 @@ static int message_handler_slot; -static void +typedef struct +{ + DBusMessage *message; + BusTransaction *transaction; + DBusError *error; +} SendMessageData; + +static dbus_bool_t send_one_message (DBusConnection *connection, void *data) { - /* Only send messages to registered connections */ - if (bus_connection_get_name (connection) == NULL) - return; + SendMessageData *d = data; - BUS_HANDLE_OOM (dbus_connection_send_message (connection, data, NULL, NULL)); + if (!bus_connection_is_active (connection)) + return TRUE; + + if (!bus_transaction_send_message (d->transaction, + connection, + d->message)) + { + BUS_SET_OOM (d->error); + return FALSE; + } + + return TRUE; } -void -bus_dispatch_broadcast_message (DBusMessage *message) +dbus_bool_t +bus_dispatch_broadcast_message (BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { - _dbus_assert (dbus_message_get_sender (message) != NULL); - - bus_connection_foreach (send_one_message, message); + DBusError tmp_error; + SendMessageData d; + _dbus_assert (dbus_message_get_sender (message) != NULL); + + dbus_error_init (&tmp_error); + d.message = message; + d.transaction = transaction; + d.error = &tmp_error; + bus_connection_foreach (send_one_message, &d); + + if (dbus_error_is_set (&tmp_error)) + { + dbus_move_error (&tmp_error, error); + return FALSE; + } + else + return TRUE; +} + +static dbus_bool_t +send_service_nonexistent_error (BusTransaction *transaction, + DBusConnection *connection, + const char *service_name, + DBusMessage *in_reply_to, + DBusError *error) +{ + DBusMessage *error_reply; + DBusString error_message; + const char *error_str; + + /* Trying to send a message to a non-existant service, + * bounce back an error message. + */ + + if (!_dbus_string_init (&error_message, _DBUS_INT_MAX)) + { + BUS_SET_OOM (error); + return FALSE; + } + + if (!_dbus_string_append (&error_message, "Service \"") || + !_dbus_string_append (&error_message, service_name) || + !_dbus_string_append (&error_message, "does not exist")) + { + _dbus_string_free (&error_message); + BUS_SET_OOM (error); + return FALSE; + } + + _dbus_string_get_const_data (&error_message, &error_str); + error_reply = dbus_message_new_error_reply (in_reply_to, + DBUS_ERROR_SERVICE_DOES_NOT_EXIST, + error_str); + + _dbus_string_free (&error_message); + + if (error_reply == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } + + if (!bus_transaction_send_message (transaction, connection, error_reply)) + { + dbus_message_unref (error_reply); + BUS_SET_OOM (error); + return FALSE; + } + + dbus_message_unref (error_reply); + + return TRUE; } static DBusHandlerResult @@ -56,76 +143,164 @@ bus_dispatch_message_handler (DBusMessageHandler *handler, void *user_data) { const char *sender, *service_name, *message_name; + DBusError error; + BusTransaction *transaction; + + transaction = NULL; + dbus_error_init (&error); - /* Assign a sender to the message */ - sender = bus_connection_get_name (connection); - BUS_HANDLE_OOM (dbus_message_set_sender (message, sender)); + /* If we can't even allocate an OOM error, we just go to sleep + * until we can. + */ + while (!bus_connection_preallocate_oom_error (connection)) + bus_wait_for_memory (); + + /* Ref connection in case we disconnect it at some point in here */ + dbus_connection_ref (connection); service_name = dbus_message_get_service (message); message_name = dbus_message_get_name (message); + + _dbus_assert (message_name != NULL); /* DBusMessageLoader is supposed to check this */ + + /* If service_name is NULL, this is a message to the bus daemon, not intended + * to actually go "on the bus"; e.g. a peer-to-peer ping. Handle these + * immediately, especially disconnection messages. + */ + if (service_name == NULL) + { + if (strcmp (message_name, DBUS_MESSAGE_LOCAL_DISCONNECT) == 0) + bus_connection_disconnected (connection); + + /* DBusConnection also handles some of these automatically, we leave + * it to do so. + */ + goto out; + } + + _dbus_assert (service_name != NULL); /* this message is intended for bus routing */ - /* TODO: Crashes if service_name == NULL */ + /* Create our transaction */ + transaction = bus_transaction_new (); + if (transaction == NULL) + { + BUS_SET_OOM (&error); + goto out; + } - /* See if the message is to the driver */ - if (message_name && strcmp (message_name, DBUS_MESSAGE_LOCAL_DISCONNECT) == 0) + /* Assign a sender to the message */ + if (bus_connection_is_active (connection)) { - bus_connection_disconnect (connection); + sender = bus_connection_get_name (connection); + _dbus_assert (sender != NULL); + + if (!dbus_message_set_sender (message, sender)) + { + BUS_SET_OOM (&error); + goto out; + } } - else if (strcmp (service_name, DBUS_SERVICE_DBUS) == 0) + + if (strcmp (service_name, DBUS_SERVICE_DBUS) == 0) /* to bus driver */ { - bus_driver_handle_message (connection, message); + if (!bus_driver_handle_message (connection, transaction, message, &error)) + goto out; } - else if (sender == NULL) + else if (!bus_connection_is_active (connection)) /* clients must talk to bus driver first */ { _dbus_verbose ("Received message from non-registered client. Disconnecting.\n"); dbus_connection_disconnect (connection); } - else if (strcmp (service_name, DBUS_SERVICE_BROADCAST) == 0) + /* FIXME what if we un-special-case this service and just have a flag + * on services that all service owners will get messages to it, not just + * the primary owner. + */ + else if (strcmp (service_name, DBUS_SERVICE_BROADCAST) == 0) /* spam! */ { - bus_dispatch_broadcast_message (message); + if (!bus_dispatch_broadcast_message (transaction, message, &error)) + goto out; } - else + else /* route to named service */ { DBusString service_string; BusService *service; _dbus_string_init_const (&service_string, service_name); - service = bus_service_lookup (&service_string, FALSE); - - if (!service) - { - DBusMessage *error_reply; - DBusString error_message; - const char *error_str; - - /* Trying to send a message to a non-existant service, - bounce back an error message. */ - - BUS_HANDLE_OOM (_dbus_string_init (&error_message, _DBUS_INT_MAX)); - - BUS_HANDLE_OOM (_dbus_string_append (&error_message, "Service \"")); - BUS_HANDLE_OOM (_dbus_string_append (&error_message, service_name)); - BUS_HANDLE_OOM (_dbus_string_append (&error_message, "does not exist")); + service = bus_service_lookup (&service_string); - _dbus_string_get_const_data (&error_message, &error_str); - BUS_HANDLE_OOM (error_reply = dbus_message_new_error_reply (message, DBUS_ERROR_SERVICE_DOES_NOT_EXIST, - error_str)); - _dbus_string_free (&error_message); + if (service == NULL) + { + if (!send_service_nonexistent_error (transaction, connection, + service_name, + message, &error)) + goto out; + } + else + { + _dbus_assert (bus_service_get_primary_owner (service) != NULL); + + /* Dispatch the message */ + if (!bus_transaction_send_message (transaction, + bus_service_get_primary_owner (service), + message)) + { + BUS_SET_OOM (&error); + goto out; + } + } + } + + out: + if (dbus_error_is_set (&error)) + { + if (!dbus_connection_get_is_connected (connection)) + { + /* If we disconnected it, we won't bother to send it any error + * messages. + */ + } + else if (dbus_error_has_name (&error, DBUS_ERROR_NO_MEMORY)) + { + bus_connection_send_oom_error (connection, message); - /* Dispatch the message */ - BUS_HANDLE_OOM (dbus_connection_send_message (connection, error_reply, NULL, NULL)); - dbus_message_unref (error_reply); - } + /* cancel transaction due to OOM */ + if (transaction != NULL) + { + bus_transaction_cancel_and_free (transaction); + transaction = NULL; + } + } else - { - _dbus_assert (bus_service_get_primary_owner (service) != NULL); + { + /* Try to send the real error, if no mem to do that, send + * the OOM error + */ + _dbus_assert (transaction != NULL); + + if (!bus_transaction_send_error_reply (transaction, connection, + &error, message)) + { + bus_connection_send_oom_error (connection, message); + + /* cancel transaction due to OOM */ + if (transaction != NULL) + { + bus_transaction_cancel_and_free (transaction); + transaction = NULL; + } + } + } - /* Dispatch the message */ - BUS_HANDLE_OOM (dbus_connection_send_message (bus_service_get_primary_owner (service), - message, NULL, NULL)); - } + dbus_error_free (&error); } + if (transaction != NULL) + { + bus_transaction_execute_and_free (transaction); + } + + dbus_connection_unref (connection); + return DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS; } diff --git a/bus/dispatch.h b/bus/dispatch.h index 2fe3479c..c24170dc 100644 --- a/bus/dispatch.h +++ b/bus/dispatch.h @@ -25,10 +25,12 @@ #define BUS_DISPATCH_H #include <dbus/dbus.h> +#include "connection.h" dbus_bool_t bus_dispatch_add_connection (DBusConnection *connection); void bus_dispatch_remove_connection (DBusConnection *connection); -void bus_dispatch_broadcast_message (DBusMessage *message); - +dbus_bool_t bus_dispatch_broadcast_message (BusTransaction *transaction, + DBusMessage *message, + DBusError *error); #endif /* BUS_DISPATCH_H */ diff --git a/bus/driver.c b/bus/driver.c index 80478e45..46985594 100644 --- a/bus/driver.c +++ b/bus/driver.c @@ -31,79 +31,171 @@ #include <dbus/dbus-internals.h> #include <string.h> -static void bus_driver_send_welcome_message (DBusConnection *connection, - DBusMessage *hello_message); - -void -bus_driver_send_service_deleted (const char *service_name) +static dbus_bool_t bus_driver_send_welcome_message (DBusConnection *connection, + DBusMessage *hello_message, + BusTransaction *transaction, + DBusError *error); + +dbus_bool_t +bus_driver_send_service_deleted (const char *service_name, + BusTransaction *transaction, + DBusError *error) { DBusMessage *message; - + dbus_bool_t retval; + _dbus_verbose ("sending service deleted: %s\n", service_name); - BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST, - DBUS_MESSAGE_SERVICE_DELETED)); + message = dbus_message_new (DBUS_SERVICE_BROADCAST, + DBUS_MESSAGE_SERVICE_DELETED); + if (message == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS)); + if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS) || + !dbus_message_append_args (message, + DBUS_TYPE_STRING, service_name, + 0)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_message_append_args (message, - DBUS_TYPE_STRING, service_name, - 0)); - bus_dispatch_broadcast_message (message); - dbus_message_unref (message); + retval = bus_dispatch_broadcast_message (transaction, message, error); + dbus_message_unref (message); + + return retval; } -void -bus_driver_send_service_created (const char *service_name) +dbus_bool_t +bus_driver_send_service_created (const char *service_name, + BusTransaction *transaction, + DBusError *error) { DBusMessage *message; - - BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST, - DBUS_MESSAGE_SERVICE_CREATED)); + dbus_bool_t retval; + + message = dbus_message_new (DBUS_SERVICE_BROADCAST, + DBUS_MESSAGE_SERVICE_CREATED); + if (message == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS)); + if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_message_append_args (message, - DBUS_TYPE_STRING, service_name, - 0)); - bus_dispatch_broadcast_message (message); + if (!dbus_message_append_args (message, + DBUS_TYPE_STRING, service_name, + 0)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } + + retval = bus_dispatch_broadcast_message (transaction, message, error); dbus_message_unref (message); + + return retval; } -void +dbus_bool_t bus_driver_send_service_lost (DBusConnection *connection, - const char *service_name) + const char *service_name, + BusTransaction *transaction, + DBusError *error) { DBusMessage *message; - BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST, - DBUS_MESSAGE_SERVICE_LOST)); + message = dbus_message_new (bus_connection_get_name (connection), + DBUS_MESSAGE_SERVICE_LOST); + if (message == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS)); - BUS_HANDLE_OOM (dbus_message_append_args (message, - DBUS_TYPE_STRING, service_name, - 0)); - BUS_HANDLE_OOM (dbus_connection_send_message (connection, message, NULL, NULL)); + if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } - dbus_message_unref (message); + if (!dbus_message_append_args (message, + DBUS_TYPE_STRING, service_name, + 0)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } + + if (!bus_transaction_send_message (transaction, connection, message)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } + else + { + dbus_message_unref (message); + return TRUE; + } } -void +dbus_bool_t bus_driver_send_service_acquired (DBusConnection *connection, - const char *service_name) + const char *service_name, + BusTransaction *transaction, + DBusError *error) { DBusMessage *message; - BUS_HANDLE_OOM (message = dbus_message_new (DBUS_SERVICE_BROADCAST, - DBUS_MESSAGE_SERVICE_ACQUIRED)); + message = dbus_message_new (bus_connection_get_name (connection), + DBUS_MESSAGE_SERVICE_ACQUIRED); + if (message == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_message_set_sender (message, DBUS_SERVICE_DBUS)); - BUS_HANDLE_OOM (dbus_message_append_args (message, - DBUS_TYPE_STRING, service_name, - 0)); - BUS_HANDLE_OOM (dbus_connection_send_message (connection, message, NULL, NULL)); + if (!dbus_message_set_sender (message, DBUS_SERVICE_DBUS)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } - dbus_message_unref (message); + if (!dbus_message_append_args (message, + DBUS_TYPE_STRING, service_name, + 0)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } + + if (!bus_transaction_send_message (transaction, connection, message)) + { + dbus_message_unref (message); + BUS_SET_OOM (error); + return FALSE; + } + else + { + dbus_message_unref (message); + return TRUE; + } } static dbus_bool_t @@ -154,7 +246,7 @@ create_unique_client_name (DBusString *str) next_minor_number += 1; /* Check if a client with the name exists */ - if (bus_service_lookup (str, FALSE) == NULL) + if (bus_service_lookup (str) == NULL) break; /* drop the number again, try the next one. */ @@ -164,35 +256,65 @@ create_unique_client_name (DBusString *str) return TRUE; } -static void +static dbus_bool_t bus_driver_handle_hello (DBusConnection *connection, - DBusMessage *message) + BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { DBusString unique_name; BusService *service; + dbus_bool_t retval; + + if (!_dbus_string_init (&unique_name, _DBUS_INT_MAX)) + { + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (_dbus_string_init (&unique_name, _DBUS_INT_MAX)); - BUS_HANDLE_OOM (create_unique_client_name (&unique_name)); + retval = FALSE; + + if (!create_unique_client_name (&unique_name)) + { + BUS_SET_OOM (error); + goto out_0; + } - BUS_HANDLE_OOM (bus_connection_set_name (connection, &unique_name)); - BUS_HANDLE_OOM (dbus_message_set_sender (message, - bus_connection_get_name (connection))); + if (!bus_connection_set_name (connection, &unique_name)) + { + BUS_SET_OOM (error); + goto out_0; + } + + if (!dbus_message_set_sender (message, + bus_connection_get_name (connection))) + { + BUS_SET_OOM (error); + goto out_0; + } - BUS_HANDLE_OOM (bus_driver_send_welcome_message (connection, message)); + if (!bus_driver_send_welcome_message (connection, message, transaction, error)) + goto out_0; /* Create the service */ - BUS_HANDLE_OOM (service = bus_service_lookup (&unique_name, TRUE)); - bus_service_set_prohibit_replacement (service, TRUE); + service = bus_service_ensure (&unique_name, connection, transaction, error); + if (service == NULL) + goto out_0; - /* Add the connection as the owner */ - BUS_HANDLE_OOM (bus_service_add_owner (service, connection)); + bus_service_set_prohibit_replacement (service, TRUE); + retval = TRUE; + + out_0: _dbus_string_free (&unique_name); + return retval; } -static void +static dbus_bool_t bus_driver_send_welcome_message (DBusConnection *connection, - DBusMessage *hello_message) + DBusMessage *hello_message, + BusTransaction *transaction, + DBusError *error) { DBusMessage *welcome; const char *name; @@ -200,209 +322,330 @@ bus_driver_send_welcome_message (DBusConnection *connection, name = bus_connection_get_name (connection); _dbus_assert (name != NULL); - BUS_HANDLE_OOM (welcome = dbus_message_new_reply (hello_message)); - - BUS_HANDLE_OOM (dbus_message_set_sender (welcome, DBUS_SERVICE_DBUS)); - - BUS_HANDLE_OOM (dbus_message_append_args (welcome, - DBUS_TYPE_STRING, name, - NULL)); + welcome = dbus_message_new_reply (hello_message); + if (welcome == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } - BUS_HANDLE_OOM (dbus_connection_send_message (connection, welcome, NULL, NULL)); + if (!dbus_message_set_sender (welcome, DBUS_SERVICE_DBUS)) + { + dbus_message_unref (welcome); + BUS_SET_OOM (error); + return FALSE; + } - dbus_message_unref (welcome); + if (!dbus_message_append_args (welcome, + DBUS_TYPE_STRING, name, + NULL)) + { + dbus_message_unref (welcome); + BUS_SET_OOM (error); + return FALSE; + } + + if (!bus_transaction_send_message (transaction, connection, welcome)) + { + dbus_message_unref (welcome); + BUS_SET_OOM (error); + return FALSE; + } + else + { + dbus_message_unref (welcome); + return TRUE; + } } -static void +static dbus_bool_t bus_driver_handle_list_services (DBusConnection *connection, - DBusMessage *message) + BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { DBusMessage *reply; - int len, i; + int len; char **services; - BUS_HANDLE_OOM (reply = dbus_message_new_reply (message)); - - BUS_HANDLE_OOM (services = bus_services_list (&len)); - - BUS_HANDLE_OOM (dbus_message_append_args (reply, - DBUS_TYPE_STRING_ARRAY, services, len, - 0)); - - BUS_HANDLE_OOM (dbus_connection_send_message (connection, reply, NULL, NULL)); + reply = dbus_message_new_reply (message); + if (reply == NULL) + { + BUS_SET_OOM (error); + return FALSE; + } - dbus_message_unref (reply); + services = bus_services_list (&len); + if (services == NULL) + { + dbus_message_unref (reply); + BUS_SET_OOM (error); + return FALSE; + } + + if (!dbus_message_append_args (reply, + DBUS_TYPE_STRING_ARRAY, services, len, + 0)) + { + dbus_free_string_array (services); + dbus_message_unref (reply); + BUS_SET_OOM (error); + return FALSE; + } - if (services != NULL) + dbus_free_string_array (services); + + if (!bus_transaction_send_message (transaction, connection, reply)) { - for (i = 0; i < len; i++) - dbus_free (services[i]); - dbus_free (services); + dbus_message_unref (reply); + BUS_SET_OOM (error); + return FALSE; + } + else + { + dbus_message_unref (reply); + return TRUE; } } -static void +static dbus_bool_t bus_driver_handle_acquire_service (DBusConnection *connection, - DBusMessage *message) + BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { DBusMessage *reply; - DBusResultCode result; DBusString service_name; BusService *service; char *name; int service_reply; int flags; + dbus_bool_t retval; + DBusConnection *old_owner; + DBusConnection *current_owner; - BUS_HANDLE_OOM ((result = dbus_message_get_args (message, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_UINT32, &flags, - 0)) != DBUS_RESULT_NO_MEMORY); + if (!dbus_message_get_args (message, + error, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_UINT32, &flags, + 0)) + return FALSE; - if (result != DBUS_RESULT_SUCCESS) - { - dbus_free (name); - dbus_connection_disconnect (connection); - return; - } + _dbus_verbose ("Trying to own service %s with flags 0x%x\n", name, flags); - _dbus_verbose ("Trying to own service %s with flags %d\n", name, flags); + retval = FALSE; + reply = NULL; _dbus_string_init_const (&service_name, name); - service = bus_service_lookup (&service_name, TRUE); + + service = bus_service_lookup (&service_name); - BUS_HANDLE_OOM ((reply = dbus_message_new_reply (message))); + if (service != NULL) + old_owner = bus_service_get_primary_owner (service); + else + old_owner = NULL; - /* - * Check if the service already has an owner - */ - if (bus_service_get_primary_owner (service) != NULL) - { - if (bus_service_has_owner (service, connection)) - service_reply = DBUS_SERVICE_REPLY_ALREADY_OWNER; - else if (!(flags & DBUS_SERVICE_FLAG_REPLACE_EXISTING)) - service_reply = DBUS_SERVICE_REPLY_SERVICE_EXISTS; - else - { - if (bus_service_get_prohibit_replacement (service)) - { - - /* Queue the connection */ - BUS_HANDLE_OOM (bus_service_add_owner (service, connection)); - - service_reply = DBUS_SERVICE_REPLY_IN_QUEUE; - } - else - { - DBusConnection *owner; - - /* We can replace the primary owner */ - owner = bus_service_get_primary_owner (service); - - /* We enqueue the new owner and remove the first one because - * that will cause ServiceAcquired and ServiceLost messages to - * be sent. - */ - BUS_HANDLE_OOM (bus_service_add_owner (service, connection)); - bus_service_remove_owner (service, owner); - _dbus_assert (connection == bus_service_get_primary_owner (service)); - service_reply = DBUS_SERVICE_REPLY_PRIMARY_OWNER; - } - } + reply = dbus_message_new_reply (message); + if (reply == NULL) + { + BUS_SET_OOM (error); + goto out; } - else + + if (service == NULL) { + service = bus_service_ensure (&service_name, connection, transaction, error); + if (service == NULL) + goto out; + } + + current_owner = bus_service_get_primary_owner (service); + + if (old_owner == NULL) + { + _dbus_assert (current_owner == connection); + bus_service_set_prohibit_replacement (service, - (flags & DBUS_SERVICE_FLAG_PROHIBIT_REPLACEMENT)); + (flags & DBUS_SERVICE_FLAG_PROHIBIT_REPLACEMENT)); + + service_reply = DBUS_SERVICE_REPLY_PRIMARY_OWNER; + } + else if (old_owner == connection) + service_reply = DBUS_SERVICE_REPLY_ALREADY_OWNER; + else if (!((flags & DBUS_SERVICE_FLAG_REPLACE_EXISTING))) + service_reply = DBUS_SERVICE_REPLY_SERVICE_EXISTS; + else if (bus_service_get_prohibit_replacement (service)) + { + /* Queue the connection */ + if (!bus_service_add_owner (service, connection, + transaction, error)) + goto out; - /* Broadcast service created message */ - bus_driver_send_service_created (bus_service_get_name (service)); + service_reply = DBUS_SERVICE_REPLY_IN_QUEUE; + } + else + { + /* Replace the current owner */ + + /* We enqueue the new owner and remove the first one because + * that will cause ServiceAcquired and ServiceLost messages to + * be sent. + */ - BUS_HANDLE_OOM (bus_service_add_owner (service, connection)); - + /* FIXME this is broken, if the remove_owner fails + * we don't undo the add_owner + * (easiest fix is probably to move all this to + * services.c and have a single routine for it) + */ + + if (!bus_service_add_owner (service, connection, + transaction, error)) + goto out; + + if (!bus_service_remove_owner (service, old_owner, + transaction, error)) + goto out; + + _dbus_assert (connection == bus_service_get_primary_owner (service)); service_reply = DBUS_SERVICE_REPLY_PRIMARY_OWNER; } - BUS_HANDLE_OOM (dbus_message_append_args (reply, DBUS_TYPE_UINT32, service_reply, 0)); + if (!dbus_message_append_args (reply, DBUS_TYPE_UINT32, service_reply, 0)) + { + BUS_SET_OOM (error); + goto out; + } - /* Send service reply */ - BUS_HANDLE_OOM (dbus_connection_send_message (connection, reply, NULL, NULL)); + if (!bus_transaction_send_message (transaction, connection, reply)) + { + BUS_SET_OOM (error); + goto out; + } + + retval = TRUE; + + out: dbus_free (name); - dbus_message_unref (reply); -} + if (reply) + dbus_message_unref (reply); + return retval; +} -static void +static dbus_bool_t bus_driver_handle_service_exists (DBusConnection *connection, - DBusMessage *message) + BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { DBusMessage *reply; - DBusResultCode result; DBusString service_name; BusService *service; char *name; + dbus_bool_t retval; - BUS_HANDLE_OOM ((result = dbus_message_get_args (message, - DBUS_TYPE_STRING, &name, - 0)) != DBUS_RESULT_NO_MEMORY); - if (result != DBUS_RESULT_SUCCESS) - { - dbus_free (name); - dbus_connection_disconnect (connection); - return; - } + if (!dbus_message_get_args (message, error, + DBUS_TYPE_STRING, &name, + 0)) + return FALSE; + retval = FALSE; + _dbus_string_init_const (&service_name, name); - service = bus_service_lookup (&service_name, FALSE); + service = bus_service_lookup (&service_name); - BUS_HANDLE_OOM ((reply = dbus_message_new_reply (message))); - BUS_HANDLE_OOM (dbus_message_set_sender (reply, DBUS_SERVICE_DBUS)); - - BUS_HANDLE_OOM (dbus_message_append_args (reply, - DBUS_TYPE_UINT32, service != NULL, - 0)); - BUS_HANDLE_OOM (dbus_connection_send_message (connection, reply, NULL, NULL)); - dbus_message_unref (reply); + reply = dbus_message_new_reply (message); + if (reply == NULL) + { + BUS_SET_OOM (error); + goto out; + } + + if (!dbus_message_set_sender (reply, DBUS_SERVICE_DBUS)) + { + BUS_SET_OOM (error); + goto out; + } + + if (!dbus_message_append_args (reply, + DBUS_TYPE_UINT32, service != NULL, + 0)) + { + BUS_SET_OOM (error); + goto out; + } + + if (!bus_transaction_send_message (transaction, connection, reply)) + { + BUS_SET_OOM (error); + goto out; + } + + retval = TRUE; + + out: + if (reply) + dbus_message_unref (reply); dbus_free (name); + + return retval; } -static void +static dbus_bool_t bus_driver_handle_activate_service (DBusConnection *connection, - DBusMessage *message) + BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { - DBusResultCode result; dbus_uint32_t flags; char *name; - DBusError error; + dbus_bool_t retval; - BUS_HANDLE_OOM ((result = dbus_message_get_args (message, - DBUS_TYPE_STRING, &name, - DBUS_TYPE_UINT32, &flags, - 0)) != DBUS_RESULT_NO_MEMORY); - if (result != DBUS_RESULT_SUCCESS) - { - dbus_free (name); - dbus_connection_disconnect (connection); - return; - } + if (!dbus_message_get_args (message, error, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_UINT32, &flags, + 0)) + return FALSE; - if (!bus_activation_activate_service (name, &error)) - { - DBusMessage *error_reply; - - BUS_HANDLE_OOM (error_reply = dbus_message_new_error_reply (message, - error.name, error.message)); - dbus_error_free (&error); + retval = FALSE; - BUS_HANDLE_OOM (dbus_connection_send_message (connection, error_reply, NULL, NULL)); - dbus_message_unref (error_reply); - } + if (!bus_activation_activate_service (name, error)) + goto out; + + retval = TRUE; + + out: + dbus_free (name); + return retval; } -void +/* For speed it might be useful to sort this in order of + * frequency of use (but doesn't matter with only a few items + * anyhow) + */ +struct +{ + const char *name; + dbus_bool_t (* handler) (DBusConnection *connection, + BusTransaction *transaction, + DBusMessage *message, + DBusError *error); +} message_handlers[] = { + { DBUS_MESSAGE_ACQUIRE_SERVICE, bus_driver_handle_acquire_service }, + { DBUS_MESSAGE_ACTIVATE_SERVICE, bus_driver_handle_activate_service }, + { DBUS_MESSAGE_HELLO, bus_driver_handle_hello }, + { DBUS_MESSAGE_SERVICE_EXISTS, bus_driver_handle_service_exists }, + { DBUS_MESSAGE_LIST_SERVICES, bus_driver_handle_list_services } +}; + +dbus_bool_t bus_driver_handle_message (DBusConnection *connection, - DBusMessage *message) + BusTransaction *transaction, + DBusMessage *message, + DBusError *error) { const char *name, *sender; - + int i; + _dbus_verbose ("Driver got a message: %s\n", dbus_message_get_name (message)); @@ -411,26 +654,39 @@ bus_driver_handle_message (DBusConnection *connection, if (sender == NULL && (strcmp (name, DBUS_MESSAGE_HELLO) != 0)) { - _dbus_verbose ("Trying to send a message without being registered. Disconnecting.\n"); + dbus_set_error (error, DBUS_ERROR_ACCESS_DENIED, + "Client tried to send a message other than %s without being registered", + DBUS_MESSAGE_HELLO); + dbus_connection_disconnect (connection); - return; - } - - /* Now check names. */ - if (strcmp (name, DBUS_MESSAGE_HELLO) == 0) - bus_driver_handle_hello (connection, message); - else if (strcmp (name, DBUS_MESSAGE_LIST_SERVICES) == 0) - bus_driver_handle_list_services (connection, message); - else if (strcmp (name, DBUS_MESSAGE_ACQUIRE_SERVICE) == 0) - bus_driver_handle_acquire_service (connection, message); - else if (strcmp (name, DBUS_MESSAGE_SERVICE_EXISTS) == 0) - bus_driver_handle_service_exists (connection, message); - else if (strcmp (name, DBUS_MESSAGE_ACTIVATE_SERVICE) == 0) - bus_driver_handle_activate_service (connection, message); + return FALSE; + } + + i = 0; + while (i < _DBUS_N_ELEMENTS (message_handlers)) + { + if (strcmp (message_handlers[i].name, name) == 0) + { + if ((* message_handlers[i].handler) (connection, transaction, message, error)) + return TRUE; + else + return FALSE; + } + + ++i; + } + + dbus_set_error (error, DBUS_ERROR_UNKNOWN_MESSAGE, + "%s does not understand message %s", + DBUS_SERVICE_DBUS, name); + + return FALSE; } void bus_driver_remove_connection (DBusConnection *connection) { - /* Does nothing for now */ + /* FIXME Does nothing for now, should unregister the connection + * with the bus driver. + */ } diff --git a/bus/driver.h b/bus/driver.h index 3019fe43..ac80c15f 100644 --- a/bus/driver.h +++ b/bus/driver.h @@ -25,17 +25,26 @@ #define BUS_DRIVER_H #include <dbus/dbus.h> +#include "connection.h" -void bus_driver_remove_connection (DBusConnection *connection); -void bus_driver_handle_message (DBusConnection *connection, - DBusMessage *message); -void bus_driver_send_service_deleted (const char *service_name); -void bus_driver_send_service_lost (DBusConnection *connection, - const char *service_name); -void bus_driver_send_service_acquired (DBusConnection *connection, - const char *service_name); -void bus_driver_send_service_created (const char *service_name); - - +void bus_driver_remove_connection (DBusConnection *connection); +dbus_bool_t bus_driver_handle_message (DBusConnection *connection, + BusTransaction *transaction, + DBusMessage *message, + DBusError *error); +dbus_bool_t bus_driver_send_service_deleted (const char *service_name, + BusTransaction *transaction, + DBusError *error); +dbus_bool_t bus_driver_send_service_lost (DBusConnection *connection, + const char *service_name, + BusTransaction *transaction, + DBusError *error); +dbus_bool_t bus_driver_send_service_acquired (DBusConnection *connection, + const char *service_name, + BusTransaction *transaction, + DBusError *error); +dbus_bool_t bus_driver_send_service_created (const char *service_name, + BusTransaction *transaction, + DBusError *error); #endif /* BUS_DRIVER_H */ @@ -97,9 +97,18 @@ main (int argc, char **argv) } else { - char *paths[] = { argv[2], NULL }; + const char *paths[] = { argv[2], NULL }; + DBusError error; - bus_activation_init (argv[1], paths); + dbus_error_init (&error); + if (!bus_activation_init (argv[1], paths, + &error)) + { + _dbus_warn ("Could not initialize service activation: %s\n", + error.message); + dbus_error_free (&error); + return 1; + } } setup_server (server); diff --git a/bus/services.c b/bus/services.c index 497978d0..22302af4 100644 --- a/bus/services.c +++ b/bus/services.c @@ -21,31 +21,29 @@ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * */ -#include "driver.h" -#include "services.h" -#include "connection.h" #include <dbus/dbus-hash.h> #include <dbus/dbus-list.h> #include <dbus/dbus-mempool.h> +#include "driver.h" +#include "services.h" +#include "connection.h" +#include "utils.h" + struct BusService { char *name; DBusList *owners; - - unsigned int prohibit_replacement:1; + + unsigned int prohibit_replacement : 1; }; static DBusHashTable *service_hash = NULL; static DBusMemPool *service_pool = NULL; -BusService* -bus_service_lookup (const DBusString *service_name, - dbus_bool_t create_if_not_found) +static dbus_bool_t +init_hash (void) { - const char *c_name; - BusService *service; - if (service_hash == NULL) { service_hash = _dbus_hash_table_new (DBUS_HASH_STRING, @@ -65,93 +63,182 @@ bus_service_lookup (const DBusString *service_name, _dbus_mem_pool_free (service_pool); service_pool = NULL; } - return NULL; + return FALSE; } } + return TRUE; +} + +BusService* +bus_service_lookup (const DBusString *service_name) +{ + const char *c_name; + BusService *service; + + if (!init_hash ()) + return NULL; _dbus_string_get_const_data (service_name, &c_name); service = _dbus_hash_table_lookup_string (service_hash, c_name); - if (service != NULL) - return service; - if (!create_if_not_found) + return service; +} + +BusService* +bus_service_ensure (const DBusString *service_name, + DBusConnection *owner_if_created, + BusTransaction *transaction, + DBusError *error) +{ + const char *c_name; + BusService *service; + + _dbus_assert (owner_if_created != NULL); + _dbus_assert (transaction != NULL); + + if (!init_hash ()) return NULL; + _dbus_string_get_const_data (service_name, &c_name); + + service = _dbus_hash_table_lookup_string (service_hash, + c_name); + if (service != NULL) + return service; + service = _dbus_mem_pool_alloc (service_pool); if (service == NULL) - return NULL; + { + BUS_SET_OOM (error); + return NULL; + } service->name = _dbus_strdup (c_name); if (service->name == NULL) { _dbus_mem_pool_dealloc (service_pool, service); + BUS_SET_OOM (error); return NULL; } + if (!bus_driver_send_service_created (service->name, transaction, error)) + { + dbus_free (service->name); + _dbus_mem_pool_dealloc (service_pool, service); + return NULL; + } + + if (!bus_service_add_owner (service, owner_if_created, + transaction, error)) + { + dbus_free (service->name); + _dbus_mem_pool_dealloc (service_pool, service); + return NULL; + } + if (!_dbus_hash_table_insert_string (service_hash, service->name, service)) { + _dbus_list_clear (&service->owners); dbus_free (service->name); _dbus_mem_pool_dealloc (service_pool, service); + BUS_SET_OOM (error); return NULL; } - - bus_driver_send_service_created (service->name); return service; } dbus_bool_t bus_service_add_owner (BusService *service, - DBusConnection *owner) + DBusConnection *owner, + BusTransaction *transaction, + DBusError *error) { + /* Send service acquired message first, OOM will result + * in cancelling the transaction + */ + if (service->owners == NULL) + { + if (!bus_driver_send_service_acquired (owner, service->name, transaction, error)) + return FALSE; + } + if (!_dbus_list_append (&service->owners, owner)) - return FALSE; + { + BUS_SET_OOM (error); + return FALSE; + } if (!bus_connection_add_owned_service (owner, service)) { _dbus_list_remove_last (&service->owners, owner); + BUS_SET_OOM (error); return FALSE; } - - /* Send service acquired message */ - if (bus_service_get_primary_owner (service) == owner) - bus_driver_send_service_acquired (owner, service->name); return TRUE; } -void +dbus_bool_t bus_service_remove_owner (BusService *service, - DBusConnection *owner) + DBusConnection *owner, + BusTransaction *transaction, + DBusError *error) { + /* We send out notifications before we do any work we + * might have to undo if the notification-sending failed + */ + /* Send service lost message */ if (bus_service_get_primary_owner (service) == owner) - bus_driver_send_service_lost (owner, service->name); + { + if (!bus_driver_send_service_lost (owner, service->name, + transaction, error)) + return FALSE; + } + + if (_dbus_list_length_is_one (&service->owners)) + { + /* We are the only owner - send service deleted */ + if (!bus_driver_send_service_deleted (service->name, + transaction, error)) + return FALSE; + } + else + { + DBusList *link; + link = _dbus_list_get_first (&service->owners); + link = _dbus_list_get_next_link (&service->owners, link); + + if (link != NULL) + { + /* This will be our new owner */ + if (!bus_driver_send_service_acquired (link->data, + service->name, + transaction, + error)) + return FALSE; + } + } _dbus_list_remove_last (&service->owners, owner); bus_connection_remove_owned_service (owner, service); if (service->owners == NULL) { - /* Delete service */ - bus_driver_send_service_deleted (service->name); - + /* Delete service (already sent message that it was deleted above) */ _dbus_hash_table_remove_string (service_hash, service->name); dbus_free (service->name); _dbus_mem_pool_dealloc (service_pool, service); } - else - { - /* Send service acquired to the new owner */ - bus_driver_send_service_acquired (bus_service_get_primary_owner (service), - service->name); - } + + return TRUE; } DBusConnection* @@ -192,7 +279,7 @@ bus_services_list (int *array_len) DBusHashIter iter; len = _dbus_hash_table_get_n_entries (service_hash); - retval = dbus_new (char *, len); + retval = dbus_new (char *, len + 1); if (retval == NULL) return NULL; @@ -210,6 +297,8 @@ bus_services_list (int *array_len) i++; } + retval[i] = NULL; + if (array_len) *array_len = len; @@ -227,8 +316,6 @@ void bus_service_set_prohibit_replacement (BusService *service, dbus_bool_t prohibit_replacement) { - _dbus_assert (service->owners == NULL); - service->prohibit_replacement = prohibit_replacement != FALSE; } diff --git a/bus/services.h b/bus/services.h index 3f6b31a9..97583582 100644 --- a/bus/services.h +++ b/bus/services.h @@ -26,6 +26,10 @@ #include <dbus/dbus.h> #include <dbus/dbus-string.h> +#include "connection.h" + +/* forward decl that probably shouldn't be in this file */ +typedef struct BusTransaction BusTransaction; /* Each service can have multiple owners; one owner is the "real * owner" and the others are queued up. For example, if I have @@ -38,12 +42,19 @@ typedef struct BusService BusService; typedef void (* BusServiceForeachFunction) (BusService *service, void *data); -BusService* bus_service_lookup (const DBusString *service_name, - dbus_bool_t create_if_not_found); +BusService* bus_service_lookup (const DBusString *service_name); +BusService* bus_service_ensure (const DBusString *service_name, + DBusConnection *owner_if_created, + BusTransaction *transaction, + DBusError *error); dbus_bool_t bus_service_add_owner (BusService *service, - DBusConnection *owner); -void bus_service_remove_owner (BusService *service, - DBusConnection *owner); + DBusConnection *owner, + BusTransaction *transaction, + DBusError *error); +dbus_bool_t bus_service_remove_owner (BusService *service, + DBusConnection *owner, + BusTransaction *transaction, + DBusError *error); dbus_bool_t bus_service_has_owner (BusService *service, DBusConnection *owner); DBusConnection* bus_service_get_primary_owner (BusService *service); diff --git a/bus/utils.c b/bus/utils.c index 8663b1e5..8b964cc4 100644 --- a/bus/utils.c +++ b/bus/utils.c @@ -25,6 +25,8 @@ #include "utils.h" #include <dbus/dbus-sysdeps.h> +const char bus_no_memory_message[] = "Memory allocation failure in message bus"; + void bus_wait_for_memory (void) { diff --git a/bus/utils.h b/bus/utils.h index 5cbe2849..41eb5557 100644 --- a/bus/utils.h +++ b/bus/utils.h @@ -25,8 +25,9 @@ #ifndef BUS_UTILS_H #define BUS_UTILS_H -#define BUS_HANDLE_OOM(stat) (stat) - void bus_wait_for_memory (void); +extern const char bus_no_memory_message[]; +#define BUS_SET_OOM(error) dbus_set_error ((error), DBUS_ERROR_NO_MEMORY, bus_no_memory_message) + #endif /* BUS_ACTIVATION_H */ diff --git a/dbus/dbus-address.c b/dbus/dbus-address.c index fb8952b5..25179cea 100644 --- a/dbus/dbus-address.c +++ b/dbus/dbus-address.c @@ -27,9 +27,9 @@ #include "dbus-list.h" /** - * @defgroup DBusAddress address parsing + * @defgroup DBusAddress Address parsing * @ingroup DBus - * @brief Parsing addresses to DBus servers. + * @brief Parsing addresses of D-BUS servers. * * @{ */ diff --git a/dbus/dbus-auth-script.c b/dbus/dbus-auth-script.c index 732b4515..336d63e1 100644 --- a/dbus/dbus-auth-script.c +++ b/dbus/dbus-auth-script.c @@ -184,7 +184,7 @@ dbus_bool_t _dbus_auth_script_run (const DBusString *filename) { DBusString file; - DBusResultCode result; + DBusError error; DBusString line; dbus_bool_t retval; int line_no; @@ -213,14 +213,14 @@ _dbus_auth_script_run (const DBusString *filename) _dbus_string_free (&line); return FALSE; } - - if ((result = _dbus_file_get_contents (&file, filename)) != DBUS_RESULT_SUCCESS) - { + + dbus_error_init (&error); + if (!_dbus_file_get_contents (&file, filename, &error)) { const char *s; _dbus_string_get_const_data (filename, &s); _dbus_warn ("Getting contents of %s failed: %s\n", - s, dbus_result_to_string (result)); - + s, error.message); + dbus_error_free (&error); goto out; } diff --git a/dbus/dbus-auth.c b/dbus/dbus-auth.c index 516a51ae..8dfdc766 100644 --- a/dbus/dbus-auth.c +++ b/dbus/dbus-auth.c @@ -514,7 +514,7 @@ sha1_handle_first_client_response (DBusAuth *auth, } else { - _dbus_assert (dbus_error_is_set (&error)); + _DBUS_ASSERT_ERROR_IS_SET (&error); _dbus_verbose ("Error loading keyring: %s\n", error.message); if (send_rejected (auth)) @@ -535,7 +535,7 @@ sha1_handle_first_client_response (DBusAuth *auth, auth->cookie_id = _dbus_keyring_get_best_key (auth->keyring, &error); if (auth->cookie_id < 0) { - _dbus_assert (dbus_error_is_set (&error)); + _DBUS_ASSERT_ERROR_IS_SET (&error); _dbus_verbose ("Could not get a cookie ID to send to client: %s\n", error.message); if (send_rejected (auth)) @@ -844,7 +844,8 @@ handle_client_data_cookie_sha1_mech (DBusAuth *auth, } else { - _dbus_assert (dbus_error_is_set (&error)); + _DBUS_ASSERT_ERROR_IS_SET (&error); + _dbus_verbose ("Error loading keyring: %s\n", error.message); @@ -2238,7 +2239,7 @@ process_test_subdir (const DBusString *test_base_dir, DBusString filename; DBusDirIter *dir; dbus_bool_t retval; - DBusResultCode result; + DBusError error; retval = FALSE; dir = NULL; @@ -2258,22 +2259,23 @@ process_test_subdir (const DBusString *test_base_dir, _dbus_string_free (&filename); if (!_dbus_string_init (&filename, _DBUS_INT_MAX)) _dbus_assert_not_reached ("didn't allocate filename string\n"); - - dir = _dbus_directory_open (&test_directory, &result); + + dbus_error_init (&error); + dir = _dbus_directory_open (&test_directory, &error); if (dir == NULL) { const char *s; _dbus_string_get_const_data (&test_directory, &s); _dbus_warn ("Could not open %s: %s\n", s, - dbus_result_to_string (result)); + error.message); + dbus_error_free (&error); goto failed; } printf ("Testing:\n"); - result = DBUS_RESULT_SUCCESS; next: - while (_dbus_directory_get_next_file (dir, &filename, &result)) + while (_dbus_directory_get_next_file (dir, &filename, &error)) { DBusString full_path; @@ -2311,12 +2313,13 @@ process_test_subdir (const DBusString *test_base_dir, _dbus_string_free (&full_path); } - if (result != DBUS_RESULT_SUCCESS) + if (dbus_error_is_set (&error)) { const char *s; _dbus_string_get_const_data (&test_directory, &s); _dbus_warn ("Could not get next file in %s: %s\n", - s, dbus_result_to_string (result)); + s, error.message); + dbus_error_free (&error); goto failed; } diff --git a/dbus/dbus-bus.c b/dbus/dbus-bus.c index 99ef5ade..cc612a78 100644 --- a/dbus/dbus-bus.c +++ b/dbus/dbus-bus.c @@ -2,6 +2,7 @@ /* dbus-bus.c Convenience functions for communicating with the bus. * * Copyright (C) 2003 CodeFactory AB + * Copyright (C) 2003 Red Hat, Inc. * * Licensed under the Academic Free License version 1.2 * @@ -23,29 +24,32 @@ #include "dbus-bus.h" #include "dbus-protocol.h" +#include "dbus-internals.h" /** - * @defgroup DBusBus Convenience functinos for communicating with the bus. + * @defgroup DBusBus Message bus APIs * @ingroup DBus - * @brief Convenience functinos for communicating with the bus. + * @brief Functions for communicating with the message bus * * @{ */ /** - * Registers a connection with the bus. This is needed to send messages - * to other clients. + * Registers a connection with the bus. This must be the first + * thing an application does when connecting to the message bus. * - * @param connection The connection - * @param result address where a result code can be returned. - * @returns the service name of which the client is known as. + * @todo if we get an error reply, it has to be converted into + * DBusError and returned + * + * @param connection the connection + * @param error place to store errors + * @returns the client's unique service name, #NULL on error */ -char * +char* dbus_bus_register_client (DBusConnection *connection, - DBusResultCode *result) + DBusError *error) { DBusMessage *message, *reply; - DBusResultCode code; char *name; message = dbus_message_new (DBUS_SERVICE_DBUS, @@ -53,56 +57,61 @@ dbus_bus_register_client (DBusConnection *connection, if (!message) { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + _DBUS_SET_OOM (error); return NULL; } - reply = dbus_connection_send_message_with_reply_and_block (connection, message, -1, result); + reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error); dbus_message_unref (message); - if (!reply) - return NULL; - - code = dbus_message_get_args (reply, - DBUS_TYPE_STRING, &name, - 0); - if (code != DBUS_RESULT_SUCCESS) + if (reply == NULL) { - dbus_set_result (result, code); + _DBUS_ASSERT_ERROR_IS_SET (error); return NULL; } - dbus_set_result (result, DBUS_RESULT_SUCCESS); - + if (!dbus_message_get_args (reply, error, + DBUS_TYPE_STRING, &name, + 0)) + { + _DBUS_ASSERT_ERROR_IS_SET (error); + return NULL; + } + return name; } /** * Asks the bus to try to acquire a certain service. * + * @todo these docs are not complete, need to document the + * return value and flags + * + * @todo if we get an error reply, it has to be converted into + * DBusError and returned + * * @param connection the connection * @param service_name the service name * @param flags flags - * @param result address where a result code can be returned. - * @returns a result code. + * @param error location to store the error + * @returns a result code, -1 if error is set */ int dbus_bus_acquire_service (DBusConnection *connection, const char *service_name, unsigned int flags, - DBusResultCode *result) + DBusError *error) { DBusMessage *message, *reply; int service_result; - DBusResultCode code; message = dbus_message_new (DBUS_SERVICE_DBUS, DBUS_MESSAGE_ACQUIRE_SERVICE); - if (!message) + if (message == NULL) { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + _DBUS_SET_OOM (error); return -1; } @@ -112,26 +121,28 @@ dbus_bus_acquire_service (DBusConnection *connection, 0)) { dbus_message_unref (message); - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + _DBUS_SET_OOM (error); return -1; } - reply = dbus_connection_send_message_with_reply_and_block (connection, message, -1, result); + reply = dbus_connection_send_with_reply_and_block (connection, message, -1, + error); + dbus_message_unref (message); - if (!reply) - return -1; - - code = dbus_message_get_args (reply, - DBUS_TYPE_UINT32, &service_result, - 0); - if (code != DBUS_RESULT_SUCCESS) + if (reply == NULL) { - dbus_set_result (result, code); + _DBUS_ASSERT_ERROR_IS_SET (error); return -1; } - dbus_set_result (result, DBUS_RESULT_SUCCESS); + if (!dbus_message_get_args (reply, error, + DBUS_TYPE_UINT32, &service_result, + 0)) + { + _DBUS_ASSERT_ERROR_IS_SET (error); + return -1; + } return service_result; } @@ -139,25 +150,26 @@ dbus_bus_acquire_service (DBusConnection *connection, /** * Checks whether a certain service exists. * + * @todo the SERVICE_EXISTS message should use BOOLEAN not UINT32 + * * @param connection the connection * @param service_name the service name - * @param result address where a result code can be returned. - * @returns #TRUE if the service exists, #FALSE otherwise. + * @param error location to store any errors + * @returns #TRUE if the service exists, #FALSE if not or on error */ dbus_bool_t dbus_bus_service_exists (DBusConnection *connection, const char *service_name, - DBusResultCode *result) + DBusError *error) { DBusMessage *message, *reply; unsigned int exists; - DBusResultCode code; message = dbus_message_new (DBUS_SERVICE_DBUS, DBUS_MESSAGE_SERVICE_EXISTS); - if (!message) + if (message == NULL) { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + _DBUS_SET_OOM (error); return FALSE; } @@ -166,27 +178,27 @@ dbus_bus_service_exists (DBusConnection *connection, 0)) { dbus_message_unref (message); - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + _DBUS_SET_OOM (error); return FALSE; } - reply = dbus_connection_send_message_with_reply_and_block (connection, message, -1, result); + reply = dbus_connection_send_with_reply_and_block (connection, message, -1, error); dbus_message_unref (message); - if (!reply) - return FALSE; + if (reply == NULL) + { + _DBUS_ASSERT_ERROR_IS_SET (error); + return FALSE; + } - code = dbus_message_get_args (reply, - DBUS_TYPE_UINT32, &exists, - 0); - if (code != DBUS_RESULT_SUCCESS) + if (!dbus_message_get_args (reply, error, + DBUS_TYPE_UINT32, &exists, + 0)) { - dbus_set_result (result, code); + _DBUS_ASSERT_ERROR_IS_SET (error); return FALSE; } - dbus_set_result (result, DBUS_RESULT_SUCCESS); - return (exists != FALSE); } diff --git a/dbus/dbus-bus.h b/dbus/dbus-bus.h index 0bd8dec8..d1c2bfd7 100644 --- a/dbus/dbus-bus.h +++ b/dbus/dbus-bus.h @@ -29,15 +29,15 @@ #include <dbus/dbus-connection.h> -char * dbus_bus_register_client (DBusConnection *connection, - DBusResultCode *result); +char* dbus_bus_register_client (DBusConnection *connection, + DBusError *error); int dbus_bus_acquire_service (DBusConnection *connection, const char *service_name, unsigned int flags, - DBusResultCode *result); + DBusError *error); dbus_bool_t dbus_bus_service_exists (DBusConnection *connection, const char *service_name, - DBusResultCode *result); + DBusError *error); #endif /* DBUS_BUS_H */ diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c index 3611b871..bfc27e2a 100644 --- a/dbus/dbus-connection.c +++ b/dbus/dbus-connection.c @@ -187,7 +187,7 @@ _dbus_connection_queue_received_message (DBusConnection *connection, return FALSE; /* If this is a reply we're waiting on, remove timeout for it */ - reply_serial = _dbus_message_get_reply_serial (message); + reply_serial = dbus_message_get_reply_serial (message); if (reply_serial != -1) { reply_handler_data = _dbus_hash_table_lookup_int (connection->pending_replies, @@ -205,9 +205,11 @@ _dbus_connection_queue_received_message (DBusConnection *connection, connection->n_incoming += 1; _dbus_connection_wakeup_mainloop (connection); - - _dbus_verbose ("Incoming message %p added to queue, %d incoming\n", - message, connection->n_incoming); + + _dbus_assert (dbus_message_get_name (message) != NULL); + _dbus_verbose ("Incoming message %p (%s) added to queue, %d incoming\n", + message, dbus_message_get_name (message), + connection->n_incoming); return TRUE; } @@ -963,54 +965,88 @@ dbus_connection_get_is_authenticated (DBusConnection *connection) } /** - * Adds a message to the outgoing message queue. Does not block to - * write the message to the network; that happens asynchronously. to - * force the message to be written, call dbus_connection_flush(). + * Preallocates resources needed to send a message, allowing the message + * to be sent without the possibility of memory allocation failure. + * Allows apps to create a future guarantee that they can send + * a message regardless of memory shortages. * - * If the function fails, it returns #FALSE and returns the - * reason for failure via the result parameter. - * The result parameter can be #NULL if you aren't interested - * in the reason for the failure. - * - * @param connection the connection. - * @param message the message to write. - * @param client_serial return location for client serial. - * @param result address where result code can be placed. - * @returns #TRUE on success. + * @param connection the connection we're preallocating for. + * @returns the preallocated resources, or #NULL */ -dbus_bool_t -dbus_connection_send_message (DBusConnection *connection, - DBusMessage *message, - dbus_int32_t *client_serial, - DBusResultCode *result) +DBusPreallocatedSend* +dbus_connection_preallocate_send (DBusConnection *connection) +{ + /* we store "connection" in the link just to enforce via + * assertion that preallocated links are only used + * with the connection they were created for. + */ + return (DBusPreallocatedSend*) _dbus_list_alloc_link (connection); +} +/** + * Frees preallocated message-sending resources from + * dbus_connection_preallocate_send(). Should only + * be called if the preallocated resources are not used + * to send a message. + * + * @param connection the connection + * @param preallocated the resources + */ +void +dbus_connection_free_preallocated_send (DBusConnection *connection, + DBusPreallocatedSend *preallocated) { - dbus_int32_t serial; + DBusList *link = (DBusList*) preallocated; + _dbus_assert (link->data == connection); + _dbus_list_free_link (link); +} +/** + * Sends a message using preallocated resources. This function cannot fail. + * It works identically to dbus_connection_send() in other respects. + * Preallocated resources comes from dbus_connection_preallocate_send(). + * This function "consumes" the preallocated resources, they need not + * be freed separately. + * + * @param connection the connection + * @param preallocated the preallocated resources + * @param message the message to send + * @param client_serial return location for client serial assigned to the message + */ +void +dbus_connection_send_preallocated (DBusConnection *connection, + DBusPreallocatedSend *preallocated, + DBusMessage *message, + dbus_int32_t *client_serial) +{ + DBusList *link = (DBusList*) preallocated; + dbus_int32_t serial; + + _dbus_assert (link->data == connection); + _dbus_assert (dbus_message_get_name (message) != NULL); + dbus_mutex_lock (connection->mutex); - if (!_dbus_list_prepend (&connection->outgoing_messages, - message)) - { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); - dbus_mutex_unlock (connection->mutex); - return FALSE; - } + link->data = message; + _dbus_list_prepend_link (&connection->outgoing_messages, + link); dbus_message_ref (message); connection->n_outgoing += 1; - _dbus_verbose ("Message %p added to outgoing queue, %d pending to send\n", - message, connection->n_outgoing); + _dbus_verbose ("Message %p (%s) added to outgoing queue, %d pending to send\n", + message, + dbus_message_get_name (message), + connection->n_outgoing); - if (_dbus_message_get_client_serial (message) == -1) + if (dbus_message_get_serial (message) == -1) { serial = _dbus_connection_get_next_client_serial (connection); - _dbus_message_set_client_serial (message, serial); + _dbus_message_set_serial (message, serial); } if (client_serial) - *client_serial = _dbus_message_get_client_serial (message); + *client_serial = dbus_message_get_serial (message); _dbus_message_lock (message); @@ -1021,8 +1057,43 @@ dbus_connection_send_message (DBusConnection *connection, _dbus_connection_wakeup_mainloop (connection); dbus_mutex_unlock (connection->mutex); - - return TRUE; +} + +/** + * Adds a message to the outgoing message queue. Does not block to + * write the message to the network; that happens asynchronously. To + * force the message to be written, call dbus_connection_flush(). + * Because this only queues the message, the only reason it can + * fail is lack of memory. Even if the connection is disconnected, + * no error will be returned. + * + * If the function fails, it returns #FALSE and returns the + * reason for failure via the result parameter. + * The result parameter can be #NULL if you aren't interested + * in the reason for the failure. + * + * @param connection the connection. + * @param message the message to write. + * @param client_serial return location for client serial. + * @returns #TRUE on success. + */ +dbus_bool_t +dbus_connection_send (DBusConnection *connection, + DBusMessage *message, + dbus_int32_t *client_serial) +{ + DBusPreallocatedSend *preallocated; + + preallocated = dbus_connection_preallocate_send (connection); + if (preallocated == NULL) + { + return FALSE; + } + else + { + dbus_connection_send_preallocated (connection, preallocated, message, client_serial); + return TRUE; + } } static void @@ -1100,25 +1171,19 @@ reply_handler_data_free (ReplyHandlerData *data) * you want a very short or very long timeout. There is no way to * avoid a timeout entirely, other than passing INT_MAX for the * timeout to postpone it indefinitely. - * - * @todo I think we should rename this function family - * dbus_connection_send(), send_with_reply(), etc. (i.e. - * drop the "message" part), the names are too long. * * @param connection the connection * @param message the message to send * @param reply_handler message handler expecting the reply, or #NULL * @param timeout_milliseconds timeout in milliseconds or -1 for default - * @param result return location for result code * @returns #TRUE if the message is successfully queued, #FALSE if no memory. * */ dbus_bool_t -dbus_connection_send_message_with_reply (DBusConnection *connection, - DBusMessage *message, - DBusMessageHandler *reply_handler, - int timeout_milliseconds, - DBusResultCode *result) +dbus_connection_send_with_reply (DBusConnection *connection, + DBusMessage *message, + DBusMessageHandler *reply_handler, + int timeout_milliseconds) { DBusTimeout *timeout; ReplyHandlerData *data; @@ -1132,10 +1197,7 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, data = dbus_new0 (ReplyHandlerData, 1); if (!data) - { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); - return FALSE; - } + return FALSE; timeout = _dbus_timeout_new (timeout_milliseconds, reply_handler_timeout, data, NULL); @@ -1143,7 +1205,6 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, if (!timeout) { reply_handler_data_free (data); - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); return FALSE; } @@ -1155,8 +1216,6 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, reply_handler_data_free (data); _dbus_timeout_unref (timeout); dbus_mutex_unlock (connection->mutex); - - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); return FALSE; } @@ -1171,17 +1230,15 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, { dbus_mutex_unlock (connection->mutex); reply_handler_data_free (data); - - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); return FALSE; } data->connection_added = TRUE; /* Assign a serial to the message */ - if (_dbus_message_get_client_serial (message) == -1) + if (dbus_message_get_serial (message) == -1) { serial = _dbus_connection_get_next_client_serial (connection); - _dbus_message_set_client_serial (message, serial); + _dbus_message_set_serial (message, serial); } data->handler = reply_handler; @@ -1195,8 +1252,6 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, { dbus_mutex_unlock (connection->mutex); reply_handler_data_free (data); - - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); return FALSE; } @@ -1206,8 +1261,6 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, dbus_mutex_unlock (connection->mutex); dbus_message_unref (reply); reply_handler_data_free (data); - - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); return FALSE; } @@ -1216,23 +1269,20 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, /* Insert the serial in the pending replies hash. */ if (!_dbus_hash_table_insert_int (connection->pending_replies, serial, data)) { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); dbus_mutex_unlock (connection->mutex); - reply_handler_data_free (data); - + reply_handler_data_free (data); return FALSE; } dbus_mutex_unlock (connection->mutex); - if (!dbus_connection_send_message (connection, message, NULL, result)) + if (!dbus_connection_send (connection, message, NULL)) { /* This will free the handler data too */ _dbus_hash_table_remove_int (connection->pending_replies, serial); return FALSE; } - dbus_set_result (result, DBUS_RESULT_SUCCESS); return TRUE; } @@ -1242,9 +1292,9 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, * has been reached. This function is used to do non-reentrant "method calls." * If a reply is received, it is returned, and removed from the incoming * message queue. If it is not received, #NULL is returned and the - * result is set to #DBUS_RESULT_NO_REPLY. If something else goes + * error is set to #DBUS_ERROR_NO_REPLY. If something else goes * wrong, result is set to whatever is appropriate, such as - * #DBUS_RESULT_NO_MEMORY. + * #DBUS_ERROR_NO_MEMORY or #DBUS_ERROR_DISCONNECTED. * * @todo could use performance improvements (it keeps scanning * the whole message queue for example) and has thread issues, @@ -1253,15 +1303,15 @@ dbus_connection_send_message_with_reply (DBusConnection *connection, * @param connection the connection * @param message the message to send * @param timeout_milliseconds timeout in milliseconds or -1 for default - * @param result return location for result code + * @param error return location for error message * @returns the message that is the reply or #NULL with an error code if the * function fails. */ DBusMessage * -dbus_connection_send_message_with_reply_and_block (DBusConnection *connection, - DBusMessage *message, - int timeout_milliseconds, - DBusResultCode *result) +dbus_connection_send_with_reply_and_block (DBusConnection *connection, + DBusMessage *message, + int timeout_milliseconds, + DBusError *error) { dbus_int32_t client_serial; DBusList *link; @@ -1279,8 +1329,11 @@ dbus_connection_send_message_with_reply_and_block (DBusConnection *connectio if (timeout_milliseconds > _DBUS_ONE_HOUR_IN_MILLISECONDS * 6) timeout_milliseconds = _DBUS_ONE_HOUR_IN_MILLISECONDS * 6; - if (!dbus_connection_send_message (connection, message, &client_serial, result)) - return NULL; + if (!dbus_connection_send (connection, message, &client_serial)) + { + _DBUS_SET_OOM (error); + return NULL; + } message = NULL; @@ -1318,13 +1371,10 @@ dbus_connection_send_message_with_reply_and_block (DBusConnection *connectio { DBusMessage *reply = link->data; - if (_dbus_message_get_reply_serial (reply) == client_serial) + if (dbus_message_get_reply_serial (reply) == client_serial) { _dbus_list_remove_link (&connection->incoming_messages, link); dbus_message_ref (reply); - - if (result) - *result = DBUS_RESULT_SUCCESS; dbus_mutex_unlock (connection->mutex); return reply; @@ -1345,14 +1395,14 @@ dbus_connection_send_message_with_reply_and_block (DBusConnection *connectio (end_tv_usec - tv_usec) / 1000; _dbus_verbose ("%d milliseconds remain\n", timeout_milliseconds); _dbus_assert (timeout_milliseconds > 0); - + goto block_again; /* not expired yet */ } - + if (dbus_connection_get_is_connected (connection)) - dbus_set_result (result, DBUS_RESULT_NO_REPLY); + dbus_set_error (error, DBUS_ERROR_NO_REPLY, "Message did not receive a reply"); else - dbus_set_result (result, DBUS_RESULT_DISCONNECTED); + dbus_set_error (error, DBUS_ERROR_DISCONNECTED, "Disconnected prior to receiving a reply"); dbus_mutex_unlock (connection->mutex); @@ -1631,7 +1681,7 @@ dbus_connection_dispatch_message (DBusConnection *connection) result = DBUS_HANDLER_RESULT_ALLOW_MORE_HANDLERS; - reply_serial = _dbus_message_get_reply_serial (message); + reply_serial = dbus_message_get_reply_serial (message); reply_handler_data = _dbus_hash_table_lookup_int (connection->pending_replies, reply_serial); diff --git a/dbus/dbus-connection.h b/dbus/dbus-connection.h index fd631c6d..6b480136 100644 --- a/dbus/dbus-connection.h +++ b/dbus/dbus-connection.h @@ -37,6 +37,7 @@ typedef struct DBusConnection DBusConnection; typedef struct DBusWatch DBusWatch; typedef struct DBusTimeout DBusTimeout; typedef struct DBusMessageHandler DBusMessageHandler; +typedef struct DBusPreallocatedSend DBusPreallocatedSend; typedef enum { @@ -85,19 +86,18 @@ DBusMessage* dbus_connection_pop_message (DBusConnection *connecti dbus_bool_t dbus_connection_dispatch_message (DBusConnection *connection); -dbus_bool_t dbus_connection_send_message (DBusConnection *connection, - DBusMessage *message, - dbus_int32_t *client_serial, - DBusResultCode *result); -dbus_bool_t dbus_connection_send_message_with_reply (DBusConnection *connection, - DBusMessage *message, - DBusMessageHandler *reply_handler, - int timeout_milliseconds, - DBusResultCode *result); -DBusMessage *dbus_connection_send_message_with_reply_and_block (DBusConnection *connection, - DBusMessage *message, - int timeout_milliseconds, - DBusResultCode *result); +dbus_bool_t dbus_connection_send (DBusConnection *connection, + DBusMessage *message, + dbus_int32_t *client_serial); +dbus_bool_t dbus_connection_send_with_reply (DBusConnection *connection, + DBusMessage *message, + DBusMessageHandler *reply_handler, + int timeout_milliseconds); +DBusMessage *dbus_connection_send_with_reply_and_block (DBusConnection *connection, + DBusMessage *message, + int timeout_milliseconds, + DBusError *error); + void dbus_connection_set_watch_functions (DBusConnection *connection, @@ -169,6 +169,14 @@ void dbus_connection_set_max_live_messages_size (DBusConnection *connection, long size); long dbus_connection_get_max_live_messages_size (DBusConnection *connection); +DBusPreallocatedSend* dbus_connection_preallocate_send (DBusConnection *connection); +void dbus_connection_free_preallocated_send (DBusConnection *connection, + DBusPreallocatedSend *preallocated); +void dbus_connection_send_preallocated (DBusConnection *connection, + DBusPreallocatedSend *preallocated, + DBusMessage *message, + dbus_int32_t *client_serial); + DBUS_END_DECLS; diff --git a/dbus/dbus-errors.c b/dbus/dbus-errors.c index e57d3538..da49e2ea 100644 --- a/dbus/dbus-errors.c +++ b/dbus/dbus-errors.c @@ -44,9 +44,6 @@ * @endcode * * @todo add docs with DBusError - * - * @todo add dbus_error_is_set() to check - * whether an error is set. * * @{ */ @@ -138,11 +135,9 @@ dbus_result_to_string (DBusResultCode code) } /** - * Initializes a DBusError structure. - * - * @todo calling dbus_error_init() in here is no good, - * for the same reason a GError* has to be set to NULL - * before you pass it in. + * Initializes a DBusError structure. Does not allocate + * any memory; the error only needs to be freed + * if it is set at some point. * * @param error the DBusError. */ @@ -164,7 +159,8 @@ dbus_error_init (DBusError *error) } /** - * Frees an error created by dbus_error_init(). + * Frees an error that's been set (or just initialized), + * then reinitializes the error as in dbus_error_init(). * * @param error memory where the error is stored. */ @@ -177,6 +173,8 @@ dbus_error_free (DBusError *error) if (!real->const_message) dbus_free (real->message); + + dbus_error_init (error); } /** @@ -211,6 +209,32 @@ dbus_set_error_const (DBusError *error, } /** + * Moves an error src into dest, freeing src and + * overwriting dest. Both src and dest must be initialized. + * src is reinitialized to an empty error. dest may not + * contain an existing error. If the destination is + * #NULL, just frees and reinits the source error. + * + * @param src the source error + * @param dest the destination error or #NULL + */ +void +dbus_move_error (DBusError *src, + DBusError *dest) +{ + _dbus_assert (!dbus_error_is_set (dest)); + + if (dest) + { + dbus_error_free (dest); + *dest = *src; + dbus_error_init (src); + } + else + dbus_error_free (src); +} + +/** * Checks whether the error is set and has the given * name. * @param error the error @@ -246,7 +270,7 @@ dbus_error_has_name (const DBusError *error, dbus_bool_t dbus_error_is_set (const DBusError *error) { - _dbus_assert (error != NULL); + _dbus_assert (error != NULL); _dbus_assert ((error->name != NULL && error->message != NULL) || (error->name == NULL && error->message == NULL)); return error->name != NULL; diff --git a/dbus/dbus-errors.h b/dbus/dbus-errors.h index e6b88465..63edbdbf 100644 --- a/dbus/dbus-errors.h +++ b/dbus/dbus-errors.h @@ -56,6 +56,20 @@ struct DBusError #define DBUS_ERROR_NO_MEMORY "org.freedesktop.DBus.Error.NoMemory" #define DBUS_ERROR_SERVICE_DOES_NOT_EXIST "org.freedesktop.DBus.Error.ServiceDoesNotExist" #define DBUS_ERROR_NO_REPLY "org.freedesktop.DBus.Error.NoReply" +#define DBUS_ERROR_IO_ERROR "org.freedesktop.DBus.Error.IOError" +#define DBUS_ERROR_BAD_ADDRESS "org.freedesktop.DBus.Error.BadAddress" +#define DBUS_ERROR_NOT_SUPPORTED "org.freedesktop.DBus.Error.NotSupported" +#define DBUS_ERROR_LIMITS_EXCEEDED "org.freedesktop.DBus.Error.LimitsExceeded" +#define DBUS_ERROR_ACCESS_DENIED "org.freedesktop.DBus.Error.AccessDenied" +#define DBUS_ERROR_AUTH_FAILED "org.freedesktop.DBus.Error.AuthFailed" +#define DBUS_ERROR_NO_SERVER "org.freedesktop.DBus.Error.NoServer" +#define DBUS_ERROR_TIMEOUT "org.freedesktop.DBus.Error.Timeout" +#define DBUS_ERROR_NO_NETWORK "org.freedesktop.DBus.Error.NoNetwork" +#define DBUS_ERROR_ADDRESS_IN_USE "org.freedesktop.DBus.Error.AddressInUse" +#define DBUS_ERROR_DISCONNECTED "org.freedesktop.DBus.Error.Disconnected" +#define DBUS_ERROR_INVALID_ARGS "org.freedesktop.DBus.Error.InvalidArgs" +#define DBUS_ERROR_FILE_NOT_FOUND "org.freedesktop.DBus.Error.FileNotFound" +#define DBUS_ERROR_UNKNOWN_MESSAGE "org.freedesktop.DBus.Error.UnknownMessage" typedef enum { @@ -90,6 +104,8 @@ void dbus_set_error (DBusError *error, void dbus_set_error_const (DBusError *error, const char *name, const char *message); +void dbus_move_error (DBusError *src, + DBusError *dest); dbus_bool_t dbus_error_has_name (const DBusError *error, const char *name); dbus_bool_t dbus_error_is_set (const DBusError *error); diff --git a/dbus/dbus-internals.c b/dbus/dbus-internals.c index 8dedb56a..acd6d72f 100644 --- a/dbus/dbus-internals.c +++ b/dbus/dbus-internals.c @@ -1,7 +1,7 @@ /* -*- mode: C; c-file-style: "gnu" -*- */ /* dbus-internals.c random utility stuff (internal to D-BUS implementation) * - * Copyright (C) 2002 Red Hat, Inc. + * Copyright (C) 2002, 2003 Red Hat, Inc. * * Licensed under the Academic Free License version 1.2 * @@ -128,6 +128,13 @@ */ /** + * Fixed "out of memory" error message, just to avoid + * making up a different string every time and wasting + * space. + */ +const char _dbus_no_memory_message[] = "Not enough memory"; + +/** * Prints a warning message to stderr. * * @param format printf-style format string. @@ -181,104 +188,6 @@ _dbus_verbose_real (const char *format, } /** - * Converts a UNIX errno into a DBusResultCode. - * - * @todo should cover more errnos, specifically those - * from open(). - * - * @param error_number the errno. - * @returns the result code. - */ -DBusResultCode -_dbus_result_from_errno (int error_number) -{ - switch (error_number) - { - case 0: - return DBUS_RESULT_SUCCESS; - -#ifdef EPROTONOSUPPORT - case EPROTONOSUPPORT: - return DBUS_RESULT_NOT_SUPPORTED; -#endif -#ifdef EAFNOSUPPORT - case EAFNOSUPPORT: - return DBUS_RESULT_NOT_SUPPORTED; -#endif -#ifdef ENFILE - case ENFILE: - return DBUS_RESULT_LIMITS_EXCEEDED; /* kernel out of memory */ -#endif -#ifdef EMFILE - case EMFILE: - return DBUS_RESULT_LIMITS_EXCEEDED; -#endif -#ifdef EACCES - case EACCES: - return DBUS_RESULT_ACCESS_DENIED; -#endif -#ifdef EPERM - case EPERM: - return DBUS_RESULT_ACCESS_DENIED; -#endif -#ifdef ENOBUFS - case ENOBUFS: - return DBUS_RESULT_NO_MEMORY; -#endif -#ifdef ENOMEM - case ENOMEM: - return DBUS_RESULT_NO_MEMORY; -#endif -#ifdef EINVAL - case EINVAL: - return DBUS_RESULT_FAILED; -#endif -#ifdef EBADF - case EBADF: - return DBUS_RESULT_FAILED; -#endif -#ifdef EFAULT - case EFAULT: - return DBUS_RESULT_FAILED; -#endif -#ifdef ENOTSOCK - case ENOTSOCK: - return DBUS_RESULT_FAILED; -#endif -#ifdef EISCONN - case EISCONN: - return DBUS_RESULT_FAILED; -#endif -#ifdef ECONNREFUSED - case ECONNREFUSED: - return DBUS_RESULT_NO_SERVER; -#endif -#ifdef ETIMEDOUT - case ETIMEDOUT: - return DBUS_RESULT_TIMEOUT; -#endif -#ifdef ENETUNREACH - case ENETUNREACH: - return DBUS_RESULT_NO_NETWORK; -#endif -#ifdef EADDRINUSE - case EADDRINUSE: - return DBUS_RESULT_ADDRESS_IN_USE; -#endif -#ifdef EEXIST - case EEXIST: - return DBUS_RESULT_FILE_NOT_FOUND; -#endif -#ifdef ENOENT - case ENOENT: - return DBUS_RESULT_FILE_NOT_FOUND; -#endif - } - - return DBUS_RESULT_FAILED; -} - -/** * Duplicates a string. Result must be freed with * dbus_free(). Returns #NULL if memory allocation fails. * If the string to be duplicated is #NULL, returns #NULL. diff --git a/dbus/dbus-internals.h b/dbus/dbus-internals.h index 19a5cdc3..2576982d 100644 --- a/dbus/dbus-internals.h +++ b/dbus/dbus-internals.h @@ -94,6 +94,8 @@ do { #define _DBUS_STRUCT_OFFSET(struct_type, member) \ ((long) ((unsigned char*) &((struct_type*) 0)->member)) +#define _DBUS_ASSERT_ERROR_IS_SET(error) _dbus_assert ((error) == NULL || dbus_error_is_set ((error))) + /* This alignment thing is from ORBit2 */ /* Align a value upward to a boundary, expressed as a number of bytes. * E.g. align to an 8-byte boundary with argument of 8. @@ -146,6 +148,9 @@ void _dbus_verbose_bytes_of_string (const DBusString *str, const char* _dbus_type_to_string (int type); +extern const char _dbus_no_memory_message[]; +#define _DBUS_SET_OOM(error) dbus_set_error ((error), DBUS_ERROR_NO_MEMORY, _dbus_no_memory_message) + #ifdef DBUS_BUILD_TESTS /* Memory debugging */ void _dbus_set_fail_alloc_counter (int until_next_fail); diff --git a/dbus/dbus-keyring.c b/dbus/dbus-keyring.c index c5c6a0b5..db432be8 100644 --- a/dbus/dbus-keyring.c +++ b/dbus/dbus-keyring.c @@ -399,6 +399,7 @@ _dbus_keyring_reload (DBusKeyring *keyring, int n_keys; int i; long now; + DBusError tmp_error; if (!_dbus_string_init (&contents, _DBUS_INT_MAX)) { @@ -434,14 +435,15 @@ _dbus_keyring_reload (DBusKeyring *keyring, have_lock = TRUE; } - result = _dbus_file_get_contents (&contents, - &keyring->filename); - - if (result != DBUS_RESULT_SUCCESS) + dbus_error_init (&tmp_error); + if (!_dbus_file_get_contents (&contents, + &keyring->filename, + &tmp_error)) { _dbus_verbose ("Failed to load keyring file: %s\n", - dbus_result_to_string (result)); + tmp_error.message); /* continue with empty keyring file, so we recreate it */ + dbus_error_free (&tmp_error); } if (!_dbus_string_validate_ascii (&contents, 0, diff --git a/dbus/dbus-list.c b/dbus/dbus-list.c index 7b306924..d0ca8dfa 100644 --- a/dbus/dbus-list.c +++ b/dbus/dbus-list.c @@ -678,6 +678,19 @@ _dbus_list_foreach (DBusList **list, } } +/** + * Check whether length is exactly one. + * + * @param list the list + * @returns #TRUE if length is exactly one + */ +dbus_bool_t +_dbus_list_length_is_one (DBusList **list) +{ + return (*list != NULL && + (*list)->next == *list); +} + /** @} */ #ifdef DBUS_BUILD_TESTS @@ -713,6 +726,11 @@ verify_list (DBusList **list) while (link != *list); _dbus_assert (length == _dbus_list_get_length (list)); + + if (length == 1) + _dbus_assert (_dbus_list_length_is_one (list)); + else + _dbus_assert (!_dbus_list_length_is_one (list)); } static dbus_bool_t diff --git a/dbus/dbus-list.h b/dbus/dbus-list.h index 2c55c6bc..3f23f2ec 100644 --- a/dbus/dbus-list.h +++ b/dbus/dbus-list.h @@ -73,6 +73,8 @@ void _dbus_list_append_link (DBusList **list, void _dbus_list_prepend_link (DBusList **list, DBusList *link); +dbus_bool_t _dbus_list_length_is_one (DBusList **list); + void _dbus_list_foreach (DBusList **list, DBusForeachFunction function, void *data); diff --git a/dbus/dbus-message-builder.c b/dbus/dbus-message-builder.c index 54b5de70..e34e1b55 100644 --- a/dbus/dbus-message-builder.c +++ b/dbus/dbus-message-builder.c @@ -314,7 +314,7 @@ _dbus_message_data_load (DBusString *dest, const DBusString *filename) { DBusString file; - DBusResultCode result; + DBusError error; DBusString line; dbus_bool_t retval; int line_no; @@ -340,14 +340,15 @@ _dbus_message_data_load (DBusString *dest, _dbus_string_get_const_data (filename, &s); _dbus_verbose ("Loading %s\n", s); } - - if ((result = _dbus_file_get_contents (&file, filename)) != DBUS_RESULT_SUCCESS) + + dbus_error_init (&error); + if (!_dbus_file_get_contents (&file, filename, &error)) { const char *s; _dbus_string_get_const_data (filename, &s); _dbus_warn ("Getting contents of %s failed: %s\n", - s, dbus_result_to_string (result)); - + s, error.message); + dbus_error_free (&error); goto out; } diff --git a/dbus/dbus-message-internal.h b/dbus/dbus-message-internal.h index 44ce62a3..86796da9 100644 --- a/dbus/dbus-message-internal.h +++ b/dbus/dbus-message-internal.h @@ -34,17 +34,12 @@ void _dbus_message_get_network_data (DBusMessage *message, const DBusString **header, const DBusString **body); -void _dbus_message_lock (DBusMessage *message); -void _dbus_message_unlock (DBusMessage *message); -void _dbus_message_set_client_serial (DBusMessage *message, - dbus_int32_t client_serial); -dbus_int32_t _dbus_message_get_client_serial (DBusMessage *message); -dbus_bool_t _dbus_message_set_reply_serial (DBusMessage *message, - dbus_int32_t reply_serial); -dbus_int32_t _dbus_message_get_reply_serial (DBusMessage *message); -void _dbus_message_add_size_counter (DBusMessage *message, - DBusCounter *counter); - +void _dbus_message_lock (DBusMessage *message); +void _dbus_message_unlock (DBusMessage *message); +void _dbus_message_set_serial (DBusMessage *message, + dbus_int32_t serial); +void _dbus_message_add_size_counter (DBusMessage *message, + DBusCounter *counter); DBusMessageLoader* _dbus_message_loader_new (void); void _dbus_message_loader_ref (DBusMessageLoader *loader); diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index a25480cb..6a3c6618 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -532,28 +532,22 @@ set_string_field (DBusMessage *message, } /** - * Sets the client serial of a message. + * Sets the serial number of a message. * This can only be done once on a message. - * - * @todo client_serial should be called simply - * "serial"; it's in outgoing messages for both - * the client and the server, it's only client-specific - * in the message bus case. It's more like origin_serial - * or something. * * @param message the message - * @param client_serial the client serial + * @param serial the serial */ void -_dbus_message_set_client_serial (DBusMessage *message, - dbus_int32_t client_serial) +_dbus_message_set_serial (DBusMessage *message, + dbus_int32_t serial) { _dbus_assert (!message->locked); - _dbus_assert (_dbus_message_get_client_serial (message) < 0); + _dbus_assert (dbus_message_get_serial (message) < 0); set_int_field (message, FIELD_CLIENT_SERIAL, - client_serial); - message->client_serial = client_serial; + serial); + message->client_serial = serial; } /** @@ -565,7 +559,7 @@ _dbus_message_set_client_serial (DBusMessage *message, * @returns #FALSE if not enough memory */ dbus_bool_t -_dbus_message_set_reply_serial (DBusMessage *message, +dbus_message_set_reply_serial (DBusMessage *message, dbus_int32_t reply_serial) { _dbus_assert (!message->locked); @@ -581,19 +575,15 @@ _dbus_message_set_reply_serial (DBusMessage *message, } /** - * Returns the client serial of a message or - * -1 if none has been specified. - * - * @todo see note in _dbus_message_set_client_serial() - * about how client_serial is a misnomer - * - * @todo this function should be public, after renaming it. + * Returns the serial of a message or -1 if none has been specified. + * The message's serial number is provided by the application sending + * the message and is used to identify replies to this message. * * @param message the message * @returns the client serial */ dbus_int32_t -_dbus_message_get_client_serial (DBusMessage *message) +dbus_message_get_serial (DBusMessage *message) { return message->client_serial; } @@ -606,7 +596,7 @@ _dbus_message_get_client_serial (DBusMessage *message) * @returns the reply serial */ dbus_int32_t -_dbus_message_get_reply_serial (DBusMessage *message) +dbus_message_get_reply_serial (DBusMessage *message) { return message->reply_serial; } @@ -845,8 +835,8 @@ dbus_message_new_reply (DBusMessage *original_message) if (message == NULL) return NULL; - if (!_dbus_message_set_reply_serial (message, - _dbus_message_get_client_serial (original_message))) + if (!dbus_message_set_reply_serial (message, + dbus_message_get_serial (original_message))) { dbus_message_unref (message); return NULL; @@ -881,8 +871,8 @@ dbus_message_new_error_reply (DBusMessage *original_message, if (message == NULL) return NULL; - if (!_dbus_message_set_reply_serial (message, - _dbus_message_get_client_serial (original_message))) + if (!dbus_message_set_reply_serial (message, + dbus_message_get_serial (original_message))) { dbus_message_unref (message); return NULL; @@ -1542,12 +1532,14 @@ dbus_message_append_dict (DBusMessage *message, * stored. The list is terminated with 0. * * @param message the message + * @param error error to be filled in on failure * @param first_arg_type the first argument type * @param ... location for first argument value, then list of type-location pairs - * @returns result code + * @returns #FALSE if the error was set */ -DBusResultCode +dbus_bool_t dbus_message_get_args (DBusMessage *message, + DBusError *error, int first_arg_type, ...) { @@ -1555,7 +1547,7 @@ dbus_message_get_args (DBusMessage *message, va_list var_args; va_start (var_args, first_arg_type); - retval = dbus_message_get_args_valist (message, first_arg_type, var_args); + retval = dbus_message_get_args_valist (message, error, first_arg_type, var_args); va_end (var_args); return retval; @@ -1575,22 +1567,31 @@ dbus_message_get_args (DBusMessage *message, * * @see dbus_message_get_args * @param message the message + * @param error error to be filled in * @param first_arg_type type of the first argument * @param var_args return location for first argument, followed by list of type/location pairs - * @returns result code + * @returns #FALSE if error was set */ -DBusResultCode +dbus_bool_t dbus_message_get_args_valist (DBusMessage *message, + DBusError *error, int first_arg_type, va_list var_args) { int spec_type, msg_type, i; DBusMessageIter *iter; - + dbus_bool_t retval; + iter = dbus_message_get_args_iter (message); if (iter == NULL) - return DBUS_RESULT_NO_MEMORY; + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory to get message arguments"); + return FALSE; + } + + retval = FALSE; spec_type = first_arg_type; i = 0; @@ -1601,13 +1602,13 @@ dbus_message_get_args_valist (DBusMessage *message, if (msg_type != spec_type) { - _dbus_verbose ("Argument %d is specified to be of type \"%s\", but " - "is actually of type \"%s\"\n", i, - _dbus_type_to_string (spec_type), - _dbus_type_to_string (msg_type)); - dbus_message_iter_unref (iter); + dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, + "Argument %d is specified to be of type \"%s\", but " + "is actually of type \"%s\"\n", i, + _dbus_type_to_string (spec_type), + _dbus_type_to_string (msg_type)); - return DBUS_RESULT_INVALID_ARGS; + goto out; } switch (spec_type) @@ -1661,7 +1662,11 @@ dbus_message_get_args_valist (DBusMessage *message, *ptr = dbus_message_iter_get_string (iter); if (!*ptr) - return DBUS_RESULT_NO_MEMORY; + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } @@ -1675,8 +1680,11 @@ dbus_message_get_args_valist (DBusMessage *message, len = va_arg (var_args, int *); if (!dbus_message_iter_get_boolean_array (iter, ptr, len)) - return DBUS_RESULT_NO_MEMORY; - + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } @@ -1689,7 +1697,11 @@ dbus_message_get_args_valist (DBusMessage *message, len = va_arg (var_args, int *); if (!dbus_message_iter_get_int32_array (iter, ptr, len)) - return DBUS_RESULT_NO_MEMORY; + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } @@ -1703,7 +1715,11 @@ dbus_message_get_args_valist (DBusMessage *message, len = va_arg (var_args, int *); if (!dbus_message_iter_get_uint32_array (iter, ptr, len)) - return DBUS_RESULT_NO_MEMORY; + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } @@ -1717,8 +1733,11 @@ dbus_message_get_args_valist (DBusMessage *message, len = va_arg (var_args, int *); if (!dbus_message_iter_get_double_array (iter, ptr, len)) - return DBUS_RESULT_NO_MEMORY; - + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } @@ -1731,8 +1750,11 @@ dbus_message_get_args_valist (DBusMessage *message, len = va_arg (var_args, int *); if (!dbus_message_iter_get_byte_array (iter, ptr, len)) - return DBUS_RESULT_NO_MEMORY; - + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } case DBUS_TYPE_STRING_ARRAY: @@ -1744,7 +1766,11 @@ dbus_message_get_args_valist (DBusMessage *message, len = va_arg (var_args, int *); if (!dbus_message_iter_get_string_array (iter, ptr, len)) - return DBUS_RESULT_NO_MEMORY; + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } case DBUS_TYPE_DICT: @@ -1754,7 +1780,11 @@ dbus_message_get_args_valist (DBusMessage *message, dict = va_arg (var_args, DBusDict **); if (!dbus_message_iter_get_dict (iter, dict)) - return DBUS_RESULT_NO_MEMORY; + { + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory for argument %d", i); + goto out; + } break; } default: @@ -1763,17 +1793,20 @@ dbus_message_get_args_valist (DBusMessage *message, spec_type = va_arg (var_args, int); if (spec_type != 0 && !dbus_message_iter_next (iter)) - { - _dbus_verbose ("More fields than exist in the message were specified or field is corrupt\n"); + { + dbus_set_error (error, DBUS_ERROR_INVALID_ARGS, + "Message has only %d arguments, but more were expected", i); + goto out; + } - dbus_message_iter_unref (iter); - return DBUS_RESULT_INVALID_ARGS; - } i++; } - + + retval = TRUE; + + out: dbus_message_iter_unref (iter); - return DBUS_RESULT_SUCCESS; + return retval; } /** @@ -2318,6 +2351,10 @@ dbus_message_name_is (DBusMessage *message, * DBusTransport implementation. The DBusTransport then hands off * the loaded messages to a DBusConnection, making the messages * visible to the application. + * + * @todo write tests for break-loader that a) randomly delete header + * fields and b) set string fields to zero-length and other funky + * values. * */ @@ -2624,6 +2661,13 @@ decode_header_data (const DBusString *data, } } + if (fields[FIELD_NAME].offset < 0) + { + _dbus_verbose ("No %s field provided\n", + DBUS_HEADER_FIELD_NAME); + return FALSE; + } + if (message_padding) *message_padding = header_len - pos; @@ -2970,13 +3014,13 @@ check_message_handling (DBusMessage *message) retval = FALSE; iter = NULL; - client_serial = _dbus_message_get_client_serial (message); + client_serial = dbus_message_get_serial (message); - /* can't use set_client_serial due to the assertions at the start of it */ + /* can't use set_serial due to the assertions at the start of it */ set_int_field (message, FIELD_CLIENT_SERIAL, client_serial); - - if (client_serial != _dbus_message_get_client_serial (message)) + + if (client_serial != dbus_message_get_serial (message)) { _dbus_warn ("get/set cycle for client_serial did not succeed\n"); goto failed; @@ -3215,14 +3259,15 @@ dbus_internal_do_not_use_load_message_file (const DBusString *filename, if (is_raw) { - DBusResultCode result; + DBusError error; - result = _dbus_file_get_contents (data, filename); - if (result != DBUS_RESULT_SUCCESS) + dbus_error_init (&error); + if (!_dbus_file_get_contents (data, filename, &error)) { const char *s; _dbus_string_get_const_data (filename, &s); - _dbus_warn ("Could not load message file %s\n", s); + _dbus_warn ("Could not load message file %s: %s\n", s, error.message); + dbus_error_free (&error); goto failed; } } @@ -3397,7 +3442,7 @@ process_test_subdir (const DBusString *test_base_dir, DBusString filename; DBusDirIter *dir; dbus_bool_t retval; - DBusResultCode result; + DBusError error; retval = FALSE; dir = NULL; @@ -3417,22 +3462,23 @@ process_test_subdir (const DBusString *test_base_dir, _dbus_string_free (&filename); if (!_dbus_string_init (&filename, _DBUS_INT_MAX)) _dbus_assert_not_reached ("didn't allocate filename string\n"); - - dir = _dbus_directory_open (&test_directory, &result); + + dbus_error_init (&error); + dir = _dbus_directory_open (&test_directory, &error); if (dir == NULL) { const char *s; _dbus_string_get_const_data (&test_directory, &s); _dbus_warn ("Could not open %s: %s\n", s, - dbus_result_to_string (result)); + error.message); + dbus_error_free (&error); goto failed; } printf ("Testing:\n"); - result = DBUS_RESULT_SUCCESS; next: - while (_dbus_directory_get_next_file (dir, &filename, &result)) + while (_dbus_directory_get_next_file (dir, &filename, &error)) { DBusString full_path; dbus_bool_t is_raw; @@ -3480,12 +3526,13 @@ process_test_subdir (const DBusString *test_base_dir, _dbus_string_free (&full_path); } - if (result != DBUS_RESULT_SUCCESS) + if (dbus_error_is_set (&error)) { const char *s; _dbus_string_get_const_data (&test_directory, &s); _dbus_warn ("Could not get next file in %s: %s\n", - s, dbus_result_to_string (result)); + s, error.message); + dbus_error_free (&error); goto failed; } @@ -3563,7 +3610,7 @@ _dbus_message_test (const char *test_data_dir) /* Test the vararg functions */ message = dbus_message_new ("org.freedesktop.DBus.Test", "testMessage"); - _dbus_message_set_client_serial (message, 1); + _dbus_message_set_serial (message, 1); dbus_message_append_args (message, DBUS_TYPE_INT32, -0x12345678, DBUS_TYPE_STRING, "Test string", @@ -3574,13 +3621,13 @@ _dbus_message_test (const char *test_data_dir) _dbus_string_get_length (&message->header)); _dbus_verbose_bytes_of_string (&message->body, 0, _dbus_string_get_length (&message->body)); - - if (dbus_message_get_args (message, - DBUS_TYPE_INT32, &our_int, - DBUS_TYPE_STRING, &our_str, - DBUS_TYPE_DOUBLE, &our_double, - DBUS_TYPE_BOOLEAN, &our_bool, - 0) != DBUS_RESULT_SUCCESS) + + if (!dbus_message_get_args (message, NULL, + DBUS_TYPE_INT32, &our_int, + DBUS_TYPE_STRING, &our_str, + DBUS_TYPE_DOUBLE, &our_double, + DBUS_TYPE_BOOLEAN, &our_bool, + 0)) _dbus_assert_not_reached ("Could not get arguments"); if (our_int != -0x12345678) @@ -3599,8 +3646,8 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); message = dbus_message_new ("org.freedesktop.DBus.Test", "testMessage"); - _dbus_message_set_client_serial (message, 1); - _dbus_message_set_reply_serial (message, 0x12345678); + _dbus_message_set_serial (message, 1); + dbus_message_set_reply_serial (message, 0x12345678); dbus_message_append_string (message, "Test string"); dbus_message_append_int32 (message, -0x12345678); @@ -3645,7 +3692,7 @@ _dbus_message_test (const char *test_data_dir) if (!message) _dbus_assert_not_reached ("received a NULL message"); - if (_dbus_message_get_reply_serial (message) != 0x12345678) + if (dbus_message_get_reply_serial (message) != 0x12345678) _dbus_assert_not_reached ("reply serial fields differ"); message_iter_test (message); diff --git a/dbus/dbus-message.h b/dbus/dbus-message.h index 4ea63060..d30a0a3d 100644 --- a/dbus/dbus-message.h +++ b/dbus/dbus-message.h @@ -48,17 +48,21 @@ DBusMessage *dbus_message_new_from_message (const DBusMessage *message); void dbus_message_ref (DBusMessage *message); void dbus_message_unref (DBusMessage *message); -const char* dbus_message_get_name (DBusMessage *message); -const char* dbus_message_get_service (DBusMessage *message); -dbus_bool_t dbus_message_set_sender (DBusMessage *message, - const char *sender); -const char* dbus_message_get_sender (DBusMessage *message); -void dbus_message_set_is_error (DBusMessage *message, - dbus_bool_t is_error_reply); -dbus_bool_t dbus_message_get_is_error (DBusMessage *message); +const char* dbus_message_get_name (DBusMessage *message); +const char* dbus_message_get_service (DBusMessage *message); +dbus_bool_t dbus_message_set_sender (DBusMessage *message, + const char *sender); +const char* dbus_message_get_sender (DBusMessage *message); +void dbus_message_set_is_error (DBusMessage *message, + dbus_bool_t is_error_reply); +dbus_bool_t dbus_message_get_is_error (DBusMessage *message); +dbus_bool_t dbus_message_name_is (DBusMessage *message, + const char *name); +dbus_int32_t dbus_message_get_serial (DBusMessage *message); +dbus_bool_t dbus_message_set_reply_serial (DBusMessage *message, + dbus_int32_t reply_serial); +dbus_int32_t dbus_message_get_reply_serial (DBusMessage *message); -dbus_bool_t dbus_message_name_is (DBusMessage *message, - const char *name); dbus_bool_t dbus_message_append_args (DBusMessage *message, int first_arg_type, @@ -99,13 +103,14 @@ dbus_bool_t dbus_message_append_dict (DBusMessage *message, DBusDict *dict); DBusMessageIter *dbus_message_get_args_iter (DBusMessage *message); -DBusResultCode dbus_message_get_args (DBusMessage *message, - int first_arg_type, - ...); -DBusResultCode dbus_message_get_args_valist (DBusMessage *message, - int first_arg_type, - va_list var_args); - +dbus_bool_t dbus_message_get_args (DBusMessage *message, + DBusError *error, + int first_arg_type, + ...); +dbus_bool_t dbus_message_get_args_valist (DBusMessage *message, + DBusError *error, + int first_arg_type, + va_list var_args); void dbus_message_iter_ref (DBusMessageIter *iter); diff --git a/dbus/dbus-sha.c b/dbus/dbus-sha.c index 2f73e363..8f047122 100644 --- a/dbus/dbus-sha.c +++ b/dbus/dbus-sha.c @@ -752,6 +752,7 @@ process_test_data (const char *test_data_dir) int line_no; dbus_bool_t retval; int success_count; + DBusError error; retval = FALSE; @@ -784,21 +785,24 @@ process_test_data (const char *test_data_dir) if (!_dbus_concat_dir_and_file (&results_file, &tmp)) _dbus_assert_not_reached ("no memory"); - if (_dbus_file_get_contents (&tests, &tests_file) != DBUS_RESULT_SUCCESS) + dbus_error_init (&error); + if (!_dbus_file_get_contents (&tests, &tests_file, &error)) { const char *s; _dbus_string_get_const_data (&tests_file, &s); - fprintf (stderr, "could not load test data file %s\n", - s); + fprintf (stderr, "could not load test data file %s: %s\n", + s, error.message); + dbus_error_free (&error); goto out; } - if (_dbus_file_get_contents (&results, &results_file) != DBUS_RESULT_SUCCESS) + if (!_dbus_file_get_contents (&results, &results_file, &error)) { const char *s; _dbus_string_get_const_data (&results_file, &s); - fprintf (stderr, "could not load results data file %s\n", - s); + fprintf (stderr, "could not load results data file %s: %s\n", + s, error.message); + dbus_error_free (&error); goto out; } diff --git a/dbus/dbus-sysdeps.c b/dbus/dbus-sysdeps.c index d096ce3e..5d0be321 100644 --- a/dbus/dbus-sysdeps.c +++ b/dbus/dbus-sysdeps.c @@ -1,7 +1,7 @@ /* -*- mode: C; c-file-style: "gnu" -*- */ /* dbus-sysdeps.c Wrappers around system/libc features (internal to D-BUS implementation) * - * Copyright (C) 2002 Red Hat, Inc. + * Copyright (C) 2002, 2003 Red Hat, Inc. * * Licensed under the Academic Free License version 1.2 * @@ -1604,11 +1604,13 @@ _dbus_get_current_time (long *tv_sec, * * @param str the string to append to * @param filename filename to load - * @returns result + * @param error place to set an error + * @returns #FALSE if error was set */ -DBusResultCode +dbus_bool_t _dbus_file_get_contents (DBusString *str, - const DBusString *filename) + const DBusString *filename, + DBusError *error) { int fd; struct stat sb; @@ -1621,28 +1623,32 @@ _dbus_file_get_contents (DBusString *str, /* O_BINARY useful on Cygwin */ fd = open (filename_c, O_RDONLY | O_BINARY); if (fd < 0) - return _dbus_result_from_errno (errno); + { + dbus_set_error (error, _dbus_error_from_errno (errno), + "%s", _dbus_strerror (errno)); + return FALSE; + } if (fstat (fd, &sb) < 0) { - DBusResultCode result; - - result = _dbus_result_from_errno (errno); /* prior to close() */ + dbus_set_error (error, _dbus_error_from_errno (errno), + "%s", _dbus_strerror (errno)); _dbus_verbose ("fstat() failed: %s", _dbus_strerror (errno)); close (fd); - return result; + return FALSE; } if (sb.st_size > _DBUS_ONE_MEGABYTE) { - _dbus_verbose ("File size %lu is too large.\n", + dbus_set_error (error, DBUS_ERROR_FAILED, + "File size %lu is too large.\n", (unsigned long) sb.st_size); close (fd); - return DBUS_RESULT_FAILED; + return FALSE; } total = 0; @@ -1657,34 +1663,35 @@ _dbus_file_get_contents (DBusString *str, sb.st_size - total); if (bytes_read <= 0) { - DBusResultCode result; - - result = _dbus_result_from_errno (errno); /* prior to close() */ + dbus_set_error (error, _dbus_error_from_errno (errno), + "%s", _dbus_strerror (errno)); _dbus_verbose ("read() failed: %s", _dbus_strerror (errno)); close (fd); _dbus_string_set_length (str, orig_len); - return result; + return FALSE; } else total += bytes_read; } close (fd); - return DBUS_RESULT_SUCCESS; + return TRUE; } else if (sb.st_size != 0) { _dbus_verbose ("Can only open regular files at the moment.\n"); + dbus_set_error (error, DBUS_ERROR_FAILED, + "Not a regular file"); close (fd); - return DBUS_RESULT_FAILED; + return FALSE; } else { close (fd); - return DBUS_RESULT_SUCCESS; + return TRUE; } } @@ -1972,12 +1979,12 @@ struct DBusDirIter * Open a directory to iterate over. * * @param filename the directory name - * @param result return location for error code if #NULL returned + * @param error exception return object or #NULL * @returns new iterator, or #NULL on error */ DBusDirIter* _dbus_directory_open (const DBusString *filename, - DBusResultCode *result) + DBusError *error) { DIR *d; DBusDirIter *iter; @@ -1988,15 +1995,16 @@ _dbus_directory_open (const DBusString *filename, d = opendir (filename_c); if (d == NULL) { - dbus_set_result (result, _dbus_result_from_errno (errno)); + dbus_set_error (error, _dbus_error_from_errno (errno), + "%s", _dbus_strerror (errno)); return NULL; } - iter = dbus_new0 (DBusDirIter, 1); if (iter == NULL) { closedir (d); - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "Could not allocate memory for directory iterator"); return NULL; } @@ -2006,39 +2014,38 @@ _dbus_directory_open (const DBusString *filename, } /** - * Get next file in the directory. Will not return "." or ".." - * on UNIX. If an error occurs, the contents of "filename" - * are undefined. #DBUS_RESULT_SUCCESS is always returned - * in result if no error occurs. + * Get next file in the directory. Will not return "." or ".." on + * UNIX. If an error occurs, the contents of "filename" are + * undefined. The error is never set if the function succeeds. * * @todo for thread safety, I think we have to use * readdir_r(). (GLib has the same issue, should file a bug.) * * @param iter the iterator * @param filename string to be set to the next file in the dir - * @param result return location for error, or #DBUS_RESULT_SUCCESS + * @param error return location for error * @returns #TRUE if filename was filled in with a new filename */ dbus_bool_t _dbus_directory_get_next_file (DBusDirIter *iter, DBusString *filename, - DBusResultCode *result) + DBusError *error) { /* we always have to put something in result, since return * value means whether there's a filename and doesn't * reliably indicate whether an error was set. */ struct dirent *ent; - - dbus_set_result (result, DBUS_RESULT_SUCCESS); again: errno = 0; ent = readdir (iter->d); if (ent == NULL) { - dbus_set_result (result, - _dbus_result_from_errno (errno)); + if (errno != 0) + dbus_set_error (error, + _dbus_error_from_errno (errno), + "%s", _dbus_strerror (errno)); return FALSE; } else if (ent->d_name[0] == '.' && @@ -2050,7 +2057,8 @@ _dbus_directory_get_next_file (DBusDirIter *iter, _dbus_string_set_length (filename, 0); if (!_dbus_string_append (filename, ent->d_name)) { - dbus_set_result (result, DBUS_RESULT_NO_MEMORY); + dbus_set_error (error, DBUS_ERROR_NO_MEMORY, + "No memory to read directory entry"); return FALSE; } else @@ -2501,4 +2509,249 @@ _dbus_fd_set_close_on_exec (int fd) fcntl (fd, F_SETFD, val); } + +/** + * Converts a UNIX errno into a DBusResultCode. + * + * @todo should cover more errnos, specifically those + * from open(). + * + * @param error_number the errno. + * @returns the result code. + */ +DBusResultCode +_dbus_result_from_errno (int error_number) +{ + switch (error_number) + { + case 0: + return DBUS_RESULT_SUCCESS; + +#ifdef EPROTONOSUPPORT + case EPROTONOSUPPORT: + return DBUS_RESULT_NOT_SUPPORTED; +#endif +#ifdef EAFNOSUPPORT + case EAFNOSUPPORT: + return DBUS_RESULT_NOT_SUPPORTED; +#endif +#ifdef ENFILE + case ENFILE: + return DBUS_RESULT_LIMITS_EXCEEDED; /* kernel out of memory */ +#endif +#ifdef EMFILE + case EMFILE: + return DBUS_RESULT_LIMITS_EXCEEDED; +#endif +#ifdef EACCES + case EACCES: + return DBUS_RESULT_ACCESS_DENIED; +#endif +#ifdef EPERM + case EPERM: + return DBUS_RESULT_ACCESS_DENIED; +#endif +#ifdef ENOBUFS + case ENOBUFS: + return DBUS_RESULT_NO_MEMORY; +#endif +#ifdef ENOMEM + case ENOMEM: + return DBUS_RESULT_NO_MEMORY; +#endif +#ifdef EINVAL + case EINVAL: + return DBUS_RESULT_FAILED; +#endif +#ifdef EBADF + case EBADF: + return DBUS_RESULT_FAILED; +#endif +#ifdef EFAULT + case EFAULT: + return DBUS_RESULT_FAILED; +#endif +#ifdef ENOTSOCK + case ENOTSOCK: + return DBUS_RESULT_FAILED; +#endif +#ifdef EISCONN + case EISCONN: + return DBUS_RESULT_FAILED; +#endif +#ifdef ECONNREFUSED + case ECONNREFUSED: + return DBUS_RESULT_NO_SERVER; +#endif +#ifdef ETIMEDOUT + case ETIMEDOUT: + return DBUS_RESULT_TIMEOUT; +#endif +#ifdef ENETUNREACH + case ENETUNREACH: + return DBUS_RESULT_NO_NETWORK; +#endif +#ifdef EADDRINUSE + case EADDRINUSE: + return DBUS_RESULT_ADDRESS_IN_USE; +#endif +#ifdef EEXIST + case EEXIST: + return DBUS_RESULT_FILE_NOT_FOUND; +#endif +#ifdef ENOENT + case ENOENT: + return DBUS_RESULT_FILE_NOT_FOUND; +#endif + } + + return DBUS_RESULT_FAILED; +} + +/** + * Converts a UNIX errno into a #DBusError name. + * + * @todo should cover more errnos, specifically those + * from open(). + * + * @param error_number the errno. + * @returns an error name + */ +const char* +_dbus_error_from_errno (int error_number) +{ + switch (error_number) + { + case 0: + return DBUS_ERROR_FAILED; + +#ifdef EPROTONOSUPPORT + case EPROTONOSUPPORT: + return DBUS_ERROR_NOT_SUPPORTED; +#endif +#ifdef EAFNOSUPPORT + case EAFNOSUPPORT: + return DBUS_ERROR_NOT_SUPPORTED; +#endif +#ifdef ENFILE + case ENFILE: + return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */ +#endif +#ifdef EMFILE + case EMFILE: + return DBUS_ERROR_LIMITS_EXCEEDED; +#endif +#ifdef EACCES + case EACCES: + return DBUS_ERROR_ACCESS_DENIED; +#endif +#ifdef EPERM + case EPERM: + return DBUS_ERROR_ACCESS_DENIED; +#endif +#ifdef ENOBUFS + case ENOBUFS: + return DBUS_ERROR_NO_MEMORY; +#endif +#ifdef ENOMEM + case ENOMEM: + return DBUS_ERROR_NO_MEMORY; +#endif +#ifdef EINVAL + case EINVAL: + return DBUS_ERROR_FAILED; +#endif +#ifdef EBADF + case EBADF: + return DBUS_ERROR_FAILED; +#endif +#ifdef EFAULT + case EFAULT: + return DBUS_ERROR_FAILED; +#endif +#ifdef ENOTSOCK + case ENOTSOCK: + return DBUS_ERROR_FAILED; +#endif +#ifdef EISCONN + case EISCONN: + return DBUS_ERROR_FAILED; +#endif +#ifdef ECONNREFUSED + case ECONNREFUSED: + return DBUS_ERROR_NO_SERVER; +#endif +#ifdef ETIMEDOUT + case ETIMEDOUT: + return DBUS_ERROR_TIMEOUT; +#endif +#ifdef ENETUNREACH + case ENETUNREACH: + return DBUS_ERROR_NO_NETWORK; +#endif +#ifdef EADDRINUSE + case EADDRINUSE: + return DBUS_ERROR_ADDRESS_IN_USE; +#endif +#ifdef EEXIST + case EEXIST: + return DBUS_ERROR_FILE_NOT_FOUND; +#endif +#ifdef ENOENT + case ENOENT: + return DBUS_ERROR_FILE_NOT_FOUND; +#endif + } + + return DBUS_ERROR_FAILED; +} + +/** + * Exit the process, returning the given value. + * + * @param code the exit code + */ +void +_dbus_exit (int code) +{ + _exit (code); +} + +/** + * stat() wrapper. + * + * @param filename the filename to stat + * @param statbuf the stat info to fill in + * @param error return location for error + * @returns #FALSE if error was set + */ +dbus_bool_t +_dbus_stat (const DBusString *filename, + DBusStat *statbuf, + DBusError *error) +{ + const char *filename_c; + struct stat sb; + + _dbus_string_get_const_data (filename, &filename_c); + + if (stat (filename_c, &sb) < 0) + { + dbus_set_error (error, _dbus_error_from_errno (errno), + "%s", _dbus_strerror (errno)); + return FALSE; + } + + statbuf->mode = sb.st_mode; + statbuf->nlink = sb.st_nlink; + statbuf->uid = sb.st_uid; + statbuf->gid = sb.st_gid; + statbuf->size = sb.st_size; + statbuf->atime = sb.st_atime; + statbuf->mtime = sb.st_mtime; + statbuf->ctime = sb.st_ctime; + + return TRUE; +} + /** @} end of sysdeps */ diff --git a/dbus/dbus-sysdeps.h b/dbus/dbus-sysdeps.h index fb8362e2..f1ac47c8 100644 --- a/dbus/dbus-sysdeps.h +++ b/dbus/dbus-sysdeps.h @@ -138,8 +138,9 @@ void _dbus_sleep_milliseconds (int milliseconds); void _dbus_get_current_time (long *tv_sec, long *tv_usec); -DBusResultCode _dbus_file_get_contents (DBusString *str, - const DBusString *filename); +dbus_bool_t _dbus_file_get_contents (DBusString *str, + const DBusString *filename, + DBusError *error); DBusResultCode _dbus_string_save_to_file (const DBusString *str, const DBusString *filename); @@ -156,17 +157,18 @@ dbus_bool_t _dbus_concat_dir_and_file (DBusString *dir, typedef struct DBusDirIter DBusDirIter; DBusDirIter* _dbus_directory_open (const DBusString *filename, - DBusResultCode *result); + DBusError *error); dbus_bool_t _dbus_directory_get_next_file (DBusDirIter *iter, DBusString *filename, - DBusResultCode *result); + DBusError *error); void _dbus_directory_close (DBusDirIter *iter); dbus_bool_t _dbus_generate_random_bytes (DBusString *str, int n_bytes); -const char *_dbus_errno_to_string (int errnum); +const char *_dbus_errno_to_string (int errnum); +const char* _dbus_error_from_errno (int error_number); typedef void (* DBusSpawnChildSetupFunc) (void *user_data); @@ -180,6 +182,24 @@ void _dbus_disable_sigpipe (void); void _dbus_fd_set_close_on_exec (int fd); +void _dbus_exit (int code); + +typedef struct +{ + unsigned long mode; + unsigned long nlink; + unsigned long uid; + unsigned long gid; + unsigned long size; + unsigned long atime; + unsigned long mtime; + unsigned long ctime; +} DBusStat; + +dbus_bool_t _dbus_stat (const DBusString *filename, + DBusStat *statbuf, + DBusError *error); + DBUS_END_DECLS; #endif /* DBUS_SYSDEPS_H */ diff --git a/glib/test-dbus-glib.c b/glib/test-dbus-glib.c index fe9cd6b9..b5c44024 100644 --- a/glib/test-dbus-glib.c +++ b/glib/test-dbus-glib.c @@ -7,13 +7,13 @@ main (int argc, char **argv) { DBusConnection *connection; DBusResultCode result; - DBusMessage *message, *reply; - + DBusMessage *message, *reply; GMainLoop *loop; + DBusError error; if (argc < 2) { - fprintf (stderr, "Give the server address as an argument\n"); + g_printerr ("Give the server address as an argument\n"); return 1; } @@ -22,8 +22,8 @@ main (int argc, char **argv) connection = dbus_connection_open (argv[1], &result); if (connection == NULL) { - fprintf (stderr, "Failed to open connection to %s: %s\n", argv[1], - dbus_result_to_string (result)); + g_printerr ("Failed to open connection to %s: %s\n", argv[1], + dbus_result_to_string (result)); return 1; } @@ -31,7 +31,15 @@ main (int argc, char **argv) message = dbus_message_new ("org.freedesktop.DBus", "org.freedesktop.DBus.Hello"); - reply = dbus_connection_send_message_with_reply_and_block (connection, message, -1, &result); + dbus_error_init (&error); + reply = dbus_connection_send_with_reply_and_block (connection, message, -1, &error); + if (reply == NULL) + { + g_printerr ("Error on hello message: %s\n", error.message); + dbus_error_free (&error); + return 1; + } + g_print ("reply name: %s\n", dbus_message_get_name (reply)); g_main_loop_run (loop); diff --git a/glib/test-thread-client.c b/glib/test-thread-client.c index ca78dbb8..23ec3f33 100644 --- a/glib/test-thread-client.c +++ b/glib/test-thread-client.c @@ -37,12 +37,13 @@ thread_func (gpointer data) } g_free (str); - if (!dbus_connection_send_message (connection, - message, - NULL, NULL)) + if (!dbus_connection_send (connection, + message, + NULL)) { - g_print ("thread %d: send message failerd\n", threadnr); + g_print ("thread %d: send message failed\n", threadnr); } + dbus_message_unref (message); counter ++; diff --git a/test/bus-test.c b/test/bus-test.c index 342e806b..e059e6cb 100644 --- a/test/bus-test.c +++ b/test/bus-test.c @@ -62,24 +62,34 @@ test_hello_client1_handler (DBusMessageHandler *handler, if (!test_hello_succeeding) goto out; + +#if 1 + printf ("In stage %d got message %s\n", + client1_stage, dbus_message_get_name (message)); +#endif if (dbus_message_name_is (message, DBUS_MESSAGE_HELLO)) { TEST_HELLO_HANDLE_FAIL (client1_stage == 0); - TEST_HELLO_HANDLE_FAIL ((dbus_message_get_args (message, - DBUS_TYPE_STRING, &client1_name, - 0) == DBUS_RESULT_SUCCESS)); + TEST_HELLO_HANDLE_FAIL (dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &client1_name, + 0)); client1_stage += 1; } else if (dbus_message_name_is (message, DBUS_MESSAGE_SERVICE_CREATED)) { - TEST_HELLO_HANDLE_FAIL (client1_stage == 1 || client1_stage == 3); + TEST_HELLO_HANDLE_FAIL (dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &tmp, + 0)); - TEST_HELLO_HANDLE_FAIL ((dbus_message_get_args (message, - DBUS_TYPE_STRING, &tmp, - 0) == DBUS_RESULT_SUCCESS)); +#if 0 + printf ("ServiceCreated is %s\n", tmp); +#endif + + TEST_HELLO_HANDLE_FAIL (client1_stage == 1 || client1_stage == 3); + if (client1_stage == 1) TEST_HELLO_HANDLE_FAIL (strcmp (client1_name, tmp) == 0); else @@ -94,9 +104,9 @@ test_hello_client1_handler (DBusMessageHandler *handler, { TEST_HELLO_HANDLE_FAIL (client1_stage == 2); - TEST_HELLO_HANDLE_FAIL ((dbus_message_get_args (message, - DBUS_TYPE_STRING, &tmp, - 0) == DBUS_RESULT_SUCCESS)); + TEST_HELLO_HANDLE_FAIL (dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &tmp, + 0)); TEST_HELLO_HANDLE_FAIL (strcmp (client1_name, tmp) == 0); client1_stage += 1; @@ -132,9 +142,9 @@ test_hello_client2_handler (DBusMessageHandler *handler, { TEST_HELLO_HANDLE_FAIL (client2_stage == 0); - TEST_HELLO_HANDLE_FAIL ((dbus_message_get_args (message, - DBUS_TYPE_STRING, &client2_name, - 0) == DBUS_RESULT_SUCCESS)); + TEST_HELLO_HANDLE_FAIL (dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &client2_name, + 0)); client2_stage += 1; } @@ -142,9 +152,9 @@ test_hello_client2_handler (DBusMessageHandler *handler, { TEST_HELLO_HANDLE_FAIL (client2_stage == 1); - TEST_HELLO_HANDLE_FAIL ((dbus_message_get_args (message, - DBUS_TYPE_STRING, &tmp, - 0) == DBUS_RESULT_SUCCESS)); + TEST_HELLO_HANDLE_FAIL (dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &tmp, + 0)); TEST_HELLO_HANDLE_FAIL (strcmp (client2_name, tmp) == 0); client2_stage += 1; @@ -153,9 +163,9 @@ test_hello_client2_handler (DBusMessageHandler *handler, { TEST_HELLO_HANDLE_FAIL (client2_stage == 2); - TEST_HELLO_HANDLE_FAIL ((dbus_message_get_args (message, - DBUS_TYPE_STRING, &tmp, - 0) == DBUS_RESULT_SUCCESS)); + TEST_HELLO_HANDLE_FAIL (dbus_message_get_args (message, NULL, + DBUS_TYPE_STRING, &tmp, + 0)); TEST_HELLO_HANDLE_FAIL (strcmp (client2_name, tmp) == 0); client2_stage += 1; @@ -177,9 +187,9 @@ static dbus_bool_t test_hello_replies (void) { DBusConnection *connection; - DBusResultCode result; DBusMessage *message; DBusMessageHandler *handler; + DBusResultCode result; /* First start client 1 */ connection = dbus_connection_open ("debug:name=test-server", &result); @@ -188,7 +198,8 @@ test_hello_replies (void) DBUS_MESSAGE_HELLO); handler = dbus_message_handler_new (test_hello_client1_handler, NULL, NULL); dbus_connection_add_filter (connection, handler); - dbus_connection_send_message (connection, message, NULL, NULL); + if (!dbus_connection_send (connection, message, NULL)) + die ("no memory to send message"); dbus_message_unref (message); /* Then start client 2 */ @@ -198,7 +209,8 @@ test_hello_replies (void) DBUS_MESSAGE_HELLO); handler = dbus_message_handler_new (test_hello_client2_handler, NULL, NULL); dbus_connection_add_filter (connection, handler); - dbus_connection_send_message (connection, message, NULL, NULL); + if (!dbus_connection_send (connection, message, NULL)) + die ("no memory to send message"); dbus_message_unref (message); bus_test_loop_run (); diff --git a/test/data/valid-messages/dict-simple.message b/test/data/valid-messages/dict-simple.message index 0b9d0186..0de1a782 100644 --- a/test/data/valid-messages/dict-simple.message +++ b/test/data/valid-messages/dict-simple.message @@ -1,6 +1,9 @@ # A simple dict VALID_HEADER +FIELD_NAME name +TYPE STRING +STRING 'org.freedesktop.Foo' END_LENGTH Header ALIGN 8 START_LENGTH Body diff --git a/test/data/valid-messages/dict.message b/test/data/valid-messages/dict.message index 0532e682..ce99a282 100644 --- a/test/data/valid-messages/dict.message +++ b/test/data/valid-messages/dict.message @@ -1,8 +1,11 @@ # Dict with different values VALID_HEADER -END_LENGTH Header +FIELD_NAME name +TYPE STRING +STRING 'org.freedesktop.Foo' ALIGN 8 +END_LENGTH Header START_LENGTH Body TYPE DICT STRING_ARRAY { 'boolean', 'int32', 'uint32', 'double', 'string', 'boolean_array', 'int32_array', 'uint32_array', 'double_array', 'string_array' } diff --git a/test/data/valid-messages/lots-of-arguments.message b/test/data/valid-messages/lots-of-arguments.message index 6a7d5eba..cc9c5a75 100644 --- a/test/data/valid-messages/lots-of-arguments.message +++ b/test/data/valid-messages/lots-of-arguments.message @@ -1,6 +1,9 @@ # Message with lots of different argument types VALID_HEADER +FIELD_NAME name +TYPE STRING +STRING 'org.freedesktop.Foo' END_LENGTH Header ALIGN 8 START_LENGTH Body diff --git a/test/data/valid-messages/no-padding.message b/test/data/valid-messages/no-padding.message index c21c84d3..ab5b5a80 100644 --- a/test/data/valid-messages/no-padding.message +++ b/test/data/valid-messages/no-padding.message @@ -3,6 +3,10 @@ ## VALID_HEADER includes a LENGTH Header and LENGTH Body VALID_HEADER +FIELD_NAME name +TYPE STRING +STRING 'org.freedesktop.Foo' + ## this byte array is filled with zeros to the natural length ## of the header FIELD_NAME unkn diff --git a/test/data/valid-messages/simplest-manual.message b/test/data/valid-messages/simplest-manual.message index 3f002ed1..8eed1e5f 100644 --- a/test/data/valid-messages/simplest-manual.message +++ b/test/data/valid-messages/simplest-manual.message @@ -10,6 +10,9 @@ LENGTH Header LENGTH Body ## client serial INT32 7 +FIELD_NAME name +TYPE STRING +STRING 'org.freedesktop.Foo' ALIGN 8 END_LENGTH Header START_LENGTH Body diff --git a/test/data/valid-messages/simplest.message b/test/data/valid-messages/simplest.message index a0283aa2..7bb1872d 100644 --- a/test/data/valid-messages/simplest.message +++ b/test/data/valid-messages/simplest.message @@ -2,6 +2,9 @@ ## VALID_HEADER includes a LENGTH Header and LENGTH Body VALID_HEADER +FIELD_NAME name +TYPE STRING +STRING 'org.freedesktop.Foo' ALIGN 8 END_LENGTH Header START_LENGTH Body diff --git a/test/echo-client.c b/test/echo-client.c index 47d7314d..de32957f 100644 --- a/test/echo-client.c +++ b/test/echo-client.c @@ -28,10 +28,10 @@ main (int argc, /* Send a message to get things going */ message = dbus_message_new ("org.freedesktop.DBus.Test", "org.freedesktop.DBus.Test"); - dbus_connection_send_message (connection, - message, - NULL, - NULL); + if (!dbus_connection_send (connection, + message, + NULL)) + fprintf (stderr, "No memory to send reply\n"); dbus_message_unref (message); do_mainloop (); diff --git a/test/unbase64.c b/test/unbase64.c index cc123658..f3894bd8 100644 --- a/test/unbase64.c +++ b/test/unbase64.c @@ -14,6 +14,7 @@ main (int argc, DBusString decoded; DBusString filename; const char *s; + DBusError error; if (argc < 2) { @@ -29,8 +30,13 @@ main (int argc, if (!_dbus_string_init (&decoded, _DBUS_INT_MAX)) return 1; - if (_dbus_file_get_contents (&contents, &filename) != DBUS_RESULT_SUCCESS) - return 1; + dbus_error_init (&error); + if (!_dbus_file_get_contents (&contents, &filename, &error)) + { + fprintf (stderr, "Failed to load file: %s\n", error.message); + dbus_error_free (&error); + return 1; + } if (!_dbus_string_base64_decode (&contents, 0, &decoded, 0)) diff --git a/test/watch.c b/test/watch.c index 1a31e64b..d8e91b78 100644 --- a/test/watch.c +++ b/test/watch.c @@ -168,10 +168,10 @@ check_messages (void) fprintf (stderr, "Received message %d, sending reply\n", count); reply = dbus_message_new ("org.freedesktop.DBus.Test", "org.freedesktop.DBus.Test"); - dbus_connection_send_message (connection, - reply, - NULL, - NULL); + if (!dbus_connection_send (connection, + reply, + NULL)) + fprintf (stderr, "No memory to send reply\n"); dbus_message_unref (reply); dbus_message_unref (message); |