From 29560adcc79a259a0be3511c056ee7453aa26c04 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Thu, 13 Mar 2003 00:56:43 +0000 Subject: 2003-03-12 Havoc Pennington 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 --- dbus/dbus-address.c | 4 +- dbus/dbus-auth-script.c | 12 +- dbus/dbus-auth.c | 25 ++-- dbus/dbus-bus.c | 124 +++++++++-------- dbus/dbus-bus.h | 8 +- dbus/dbus-connection.c | 220 +++++++++++++++++------------ dbus/dbus-connection.h | 34 +++-- dbus/dbus-errors.c | 44 ++++-- dbus/dbus-errors.h | 16 +++ dbus/dbus-internals.c | 107 ++------------- dbus/dbus-internals.h | 5 + dbus/dbus-keyring.c | 12 +- dbus/dbus-list.c | 18 +++ dbus/dbus-list.h | 2 + dbus/dbus-message-builder.c | 11 +- dbus/dbus-message-internal.h | 17 +-- dbus/dbus-message.c | 217 +++++++++++++++++------------ dbus/dbus-message.h | 39 +++--- dbus/dbus-sha.c | 16 ++- dbus/dbus-sysdeps.c | 321 ++++++++++++++++++++++++++++++++++++++----- dbus/dbus-sysdeps.h | 30 +++- 21 files changed, 828 insertions(+), 454 deletions(-) (limited to 'dbus') 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 -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); } /** @@ -210,6 +208,32 @@ dbus_set_error_const (DBusError *error, real->const_message = TRUE; } +/** + * 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. @@ -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 * @@ -127,6 +127,13 @@ * a DBusList. */ +/** + * 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. * @@ -180,104 +187,6 @@ _dbus_verbose_real (const char *format, va_end (args); } -/** - * 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. 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 */ -- cgit