+2003-03-24 Havoc Pennington <hp@redhat.com>
+
+ * dbus/dbus-sysdeps.c (_dbus_set_fd_nonblocking): move to this
+ file
+
+ * dbus/dbus-errors.c (dbus_set_error, dbus_set_error_const): allow
+ NULL argument for "message" if the error is a well-known one,
+ fill in a generic message in this case.
+
+ * dbus/dbus-errors.h (DBusResultCode): Kill DBusResultCode in
+ favor of DBusError
+
+ * bus/test.c (bus_test_flush_bus): add
+
+ * bus/policy.c (bus_policy_test): test code stub
+
2003-03-24 Havoc Pennington <hp@pobox.com>
* bus/connection.c (bus_connections_setup_connection): set up
DBusError *error)
{
BusContext *context;
- DBusResultCode result;
context = dbus_new0 (BusContext, 1);
if (context == NULL)
goto failed;
}
- context->server = dbus_server_listen (address, &result);
+ context->server = dbus_server_listen (address, error);
if (context->server == NULL)
- {
- dbus_set_error (error, DBUS_ERROR_FAILED,
- "Failed to start server on %s: %s\n",
- address, dbus_result_to_string (result));
- goto failed;
- }
+ goto failed;
context->activation = bus_activation_new (context, address, service_dirs,
error);
static dbus_bool_t check_no_leftovers (BusContext *context);
-static void
-flush_bus (BusContext *context)
-{
- /* This is race condition city, obviously. since we're all in one
- * process we can't block, we just have to wait for data we put in
- * one end of the debug pipe to come out the other end...
- * a more robust setup would be good.
- */
-
- while (bus_loop_iterate (FALSE))
- ;
- _dbus_sleep_milliseconds (15);
- while (bus_loop_iterate (FALSE))
- ;
-}
-
typedef struct
{
const char *expected_service_name;
/* kick in the disconnect handler that unrefs the connection */
dbus_connection_disconnect (connection);
- flush_bus (context);
+ bus_test_flush_bus (context);
_dbus_assert (bus_test_client_listed (connection));
dbus_message_unref (message);
message = NULL;
- flush_bus (context);
+ bus_test_flush_bus (context);
if (!dbus_connection_get_is_connected (connection))
{
check_hello_connection (BusContext *context)
{
DBusConnection *connection;
- DBusResultCode result;
+ DBusError error;
- result = DBUS_RESULT_SUCCESS;
- connection = dbus_connection_open ("debug-pipe:name=test-server", &result);
+ dbus_error_init (&error);
+
+ connection = dbus_connection_open ("debug-pipe:name=test-server", &error);
if (connection == NULL)
{
- _dbus_assert (result != DBUS_RESULT_SUCCESS);
+ _DBUS_ASSERT_ERROR_IS_SET (&error);
+ dbus_error_free (&error);
return TRUE;
}
DBusConnection *foo;
DBusConnection *bar;
DBusConnection *baz;
- DBusResultCode result;
dbus_error_init (&error);
context = bus_context_new ("debug-pipe:name=test-server",
if (context == NULL)
_dbus_assert_not_reached ("could not alloc context");
- foo = dbus_connection_open ("debug-pipe:name=test-server", &result);
+ foo = dbus_connection_open ("debug-pipe:name=test-server", &error);
if (foo == NULL)
_dbus_assert_not_reached ("could not alloc connection");
if (!check_hello_message (context, foo))
_dbus_assert_not_reached ("hello message failed");
- bar = dbus_connection_open ("debug-pipe:name=test-server", &result);
+ bar = dbus_connection_open ("debug-pipe:name=test-server", &error);
if (bar == NULL)
_dbus_assert_not_reached ("could not alloc connection");
if (!check_hello_message (context, bar))
_dbus_assert_not_reached ("hello message failed");
- baz = dbus_connection_open ("debug-pipe:name=test-server", &result);
+ baz = dbus_connection_open ("debug-pipe:name=test-server", &error);
if (baz == NULL)
_dbus_assert_not_reached ("could not alloc connection");
#include "policy.h"
#include "services.h"
+#include "test.h"
#include <dbus/dbus-list.h>
#include <dbus/dbus-internals.h>
return allowed;
}
+
+#ifdef DBUS_BUILD_TESTS
+
+dbus_bool_t
+bus_policy_test (const DBusString *test_data_dir)
+{
+ /* This doesn't do anything for now because I decided to do it in
+ * dispatch.c instead by having some of the clients in dispatch.c
+ * have particular policies applied to them.
+ */
+
+ return TRUE;
+}
+
+#endif /* DBUS_BUILD_TESTS */
return FALSE;
}
+
+void
+bus_test_flush_bus (BusContext *context)
+{
+ /* This is race condition city, obviously. since we're all in one
+ * process we can't block, we just have to wait for data we put in
+ * one end of the debug pipe to come out the other end...
+ * a more robust setup would be good. Blocking on the other
+ * end of pipes we've pushed data into or something.
+ */
+
+ while (bus_loop_iterate (FALSE))
+ ;
+ _dbus_sleep_milliseconds (15);
+ while (bus_loop_iterate (FALSE))
+ ;
+}
+
#endif
#include "connection.h"
dbus_bool_t bus_dispatch_test (const DBusString *test_data_dir);
+dbus_bool_t bus_policy_test (const DBusString *test_data_dir);
dbus_bool_t bus_setup_debug_client (DBusConnection *connection);
void bus_test_clients_foreach (BusConnectionForeachFunction function,
void *data);
dbus_bool_t bus_test_client_listed (DBusConnection *connection);
+void bus_test_flush_bus (BusContext *context);
#endif
dbus_parse_address (const char *address,
DBusAddressEntry ***entry,
int *array_len,
- DBusResultCode *result)
+ DBusError *error)
{
DBusString str;
int pos, end_pos, len, i;
DBusList *entries, *link;
DBusAddressEntry **entry_array;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_string_init_const (&str, address);
entries = NULL;
entry = create_entry ();
if (!entry)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto error;
}
/* Append the entry */
if (!_dbus_list_append (&entries, entry))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
dbus_address_entry_free (entry);
goto error;
}
/* Look for the colon : */
if (!_dbus_string_find_to (&str, pos, end_pos, ":", &found_pos))
{
- dbus_set_result (result, DBUS_RESULT_BAD_ADDRESS);
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS, "Address does not contain a colon");
goto error;
}
if (!_dbus_string_copy_len (&str, pos, found_pos - pos, &entry->method, 0))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto error;
}
if (!_dbus_string_find (&str, pos, "=", &equals_pos) ||
equals_pos == pos || equals_pos + 1 == end_pos)
{
- dbus_set_result (result, DBUS_RESULT_BAD_ADDRESS);
- goto error;
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
+ "'=' character not found or has no value following it");
+ goto error;
}
else
{
if (!key)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto error;
}
value = dbus_new0 (DBusString, 1);
if (!value)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
dbus_free (key);
goto error;
}
if (!_dbus_string_init (key, _DBUS_INT_MAX))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
dbus_free (key);
dbus_free (value);
if (!_dbus_string_init (value, _DBUS_INT_MAX))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (key);
dbus_free (key);
if (!_dbus_string_copy_len (&str, pos, equals_pos - pos, key, 0))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (key);
_dbus_string_free (value);
if (!_dbus_string_copy_len (&str, equals_pos + 1, comma_pos - equals_pos - 1, value, 0))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (key);
_dbus_string_free (value);
if (!_dbus_list_append (&entry->keys, key))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (key);
_dbus_string_free (value);
if (!_dbus_list_append (&entry->values, value))
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (value);
dbus_free (value);
if (!entry_array)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto error;
}
_dbus_list_clear (&entries);
*entry = entry_array;
- dbus_set_result (result, DBUS_RESULT_SUCCESS);
return TRUE;
error:
{
DBusAddressEntry **entries;
int len;
- DBusResultCode result;
+ DBusError error;
+ dbus_error_init (&error);
+
if (!dbus_parse_address ("unix:path=/tmp/foo;debug:name=test,sliff=sloff;",
- &entries, &len, &result))
+ &entries, &len, &error))
_dbus_assert_not_reached ("could not parse address");
_dbus_assert (len == 2);
_dbus_assert (strcmp (dbus_address_entry_get_value (entries[0], "path"), "/tmp/foo") == 0);
dbus_address_entries_free (entries);
/* Different possible errors */
- if (dbus_parse_address ("foo", &entries, &len, &result))
+ if (dbus_parse_address ("foo", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
-
- if (dbus_parse_address ("foo:bar", &entries, &len, &result))
+ else
+ dbus_error_free (&error);
+
+ if (dbus_parse_address ("foo:bar", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
-
- if (dbus_parse_address ("foo:bar,baz", &entries, &len, &result))
+ else
+ dbus_error_free (&error);
+
+ if (dbus_parse_address ("foo:bar,baz", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
-
- if (dbus_parse_address ("foo:bar=foo,baz", &entries, &len, &result))
+ else
+ dbus_error_free (&error);
+
+ if (dbus_parse_address ("foo:bar=foo,baz", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
-
- if (dbus_parse_address ("foo:bar=foo;baz", &entries, &len, &result))
+ else
+ dbus_error_free (&error);
+
+ if (dbus_parse_address ("foo:bar=foo;baz", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
-
- if (dbus_parse_address ("foo:=foo", &entries, &len, &result))
+ else
+ dbus_error_free (&error);
+
+ if (dbus_parse_address ("foo:=foo", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
-
- if (dbus_parse_address ("foo:foo=", &entries, &len, &result))
+ else
+ dbus_error_free (&error);
+
+ if (dbus_parse_address ("foo:foo=", &entries, &len, &error))
_dbus_assert_not_reached ("Parsed incorrect address.");
+ else
+ dbus_error_free (&error);
return TRUE;
}
dbus_bool_t dbus_parse_address (const char *address,
DBusAddressEntry ***entry,
int *array_len,
- DBusResultCode *result);
+ DBusError *error);
const char *dbus_address_entry_get_value (DBusAddressEntry *entry,
const char *key);
const char *dbus_address_entry_get_method (DBusAddressEntry *entry);
char *name;
BusData *bd;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
bd = ensure_bus_data (connection);
if (bd == NULL)
{
{
DBusMessage *message, *reply;
unsigned int exists;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
message = dbus_message_new (DBUS_SERVICE_DBUS,
DBUS_MESSAGE_SERVICE_EXISTS);
* in the reason for failure.
*
* @param address the address.
- * @param result address where a result code can be returned.
+ * @param error address where an error can be returned.
* @returns new connection, or #NULL on failure.
*/
DBusConnection*
dbus_connection_open (const char *address,
- DBusResultCode *result)
+ DBusError *error)
{
DBusConnection *connection;
DBusTransport *transport;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- transport = _dbus_transport_open (address, result);
+ transport = _dbus_transport_open (address, error);
if (transport == NULL)
- return NULL;
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return NULL;
+ }
connection = _dbus_connection_new_for_transport (transport);
if (connection == NULL)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
long end_tv_sec, end_tv_usec;
long tv_sec, tv_usec;
DBusDispatchStatus status;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
if (timeout_milliseconds == -1)
timeout_milliseconds = DEFAULT_TIMEOUT_VALUE;
void *data);
DBusConnection* dbus_connection_open (const char *address,
- DBusResultCode *result);
+ DBusError *error);
void dbus_connection_ref (DBusConnection *connection);
void dbus_connection_unref (DBusConnection *connection);
void dbus_connection_disconnect (DBusConnection *connection);
#include "dbus-internals.h"
#include <stdarg.h>
#include <stdio.h>
+#include <string.h>
/**
* @defgroup DBusErrors Error reporting
} DBusRealError;
/**
- * Set a result code at a result code location,
- * if code_address is not #NULL.
+ * Returns a longer message describing an error name.
+ * If the error name is unknown, returns the name
+ * itself.
*
- * @param code_address place to store the result code.
- * @param code the result code itself.
+ * @param error the error to describe
+ * @returns a constant string describing the error.
*/
-void
-dbus_set_result (DBusResultCode *code_address,
- DBusResultCode code)
-{
- if (code_address)
- *code_address = code;
-}
-
-/**
- * Returns a string describing the given result code.
- *
- * @param code the result code to describe.
- * @returns a constant string describing the code.
- */
-const char*
-dbus_result_to_string (DBusResultCode code)
+static const char*
+message_from_error (const char *error)
{
- /* This is a switch to the compiler will complain if we
- * aren't handling some codes
- */
- switch (code)
- {
- case DBUS_RESULT_SUCCESS:
- return "Success";
- case DBUS_RESULT_FAILED:
- return "Unknown error";
- case DBUS_RESULT_NO_MEMORY:
- return "Not enough memory available";
- case DBUS_RESULT_IO_ERROR:
- return "Error reading or writing data";
- case DBUS_RESULT_BAD_ADDRESS:
- return "Could not parse address";
- case DBUS_RESULT_NOT_SUPPORTED:
- return "Feature not supported";
- case DBUS_RESULT_LIMITS_EXCEEDED:
- return "Resource limits exceeded";
- case DBUS_RESULT_ACCESS_DENIED:
- return "Permission denied";
- case DBUS_RESULT_AUTH_FAILED:
- return "Could not authenticate to server";
- case DBUS_RESULT_NO_SERVER:
- return "No server";
- case DBUS_RESULT_TIMEOUT:
- return "Connection timed out";
- case DBUS_RESULT_NO_NETWORK:
- return "Network unavailable";
- case DBUS_RESULT_ADDRESS_IN_USE:
- return "Address already in use";
- case DBUS_RESULT_DISCONNECTED:
- return "Disconnected.";
- case DBUS_RESULT_INVALID_ARGS:
- return "Invalid argumemts.";
- case DBUS_RESULT_NO_REPLY:
- return "Did not get a reply message.";
- case DBUS_RESULT_FILE_NOT_FOUND:
- return "File doesn't exist.";
-
- /* no default, it would break our compiler warnings */
- }
-
- return "Invalid error code";
+ if (strcmp (error, DBUS_ERROR_FAILED) == 0)
+ return "Unknown error";
+ else if (strcmp (error, DBUS_ERROR_NO_MEMORY) == 0)
+ return "Not enough memory available";
+ else if (strcmp (error, DBUS_ERROR_IO_ERROR) == 0)
+ return "Error reading or writing data";
+ else if (strcmp (error, DBUS_ERROR_BAD_ADDRESS) == 0)
+ return "Could not parse address";
+ else if (strcmp (error, DBUS_ERROR_NOT_SUPPORTED) == 0)
+ return "Feature not supported";
+ else if (strcmp (error, DBUS_ERROR_LIMITS_EXCEEDED) == 0)
+ return "Resource limits exceeded";
+ else if (strcmp (error, DBUS_ERROR_ACCESS_DENIED) == 0)
+ return "Permission denied";
+ else if (strcmp (error, DBUS_ERROR_AUTH_FAILED) == 0)
+ return "Could not authenticate to server";
+ else if (strcmp (error, DBUS_ERROR_NO_SERVER) == 0)
+ return "No server";
+ else if (strcmp (error, DBUS_ERROR_TIMEOUT) == 0)
+ return "Connection timed out";
+ else if (strcmp (error, DBUS_ERROR_NO_NETWORK) == 0)
+ return "Network unavailable";
+ else if (strcmp (error, DBUS_ERROR_ADDRESS_IN_USE) == 0)
+ return "Address already in use";
+ else if (strcmp (error, DBUS_ERROR_DISCONNECTED) == 0)
+ return "Disconnected.";
+ else if (strcmp (error, DBUS_ERROR_INVALID_ARGS) == 0)
+ return "Invalid argumemts.";
+ else if (strcmp (error, DBUS_ERROR_NO_REPLY) == 0)
+ return "Did not get a reply message.";
+ else if (strcmp (error, DBUS_ERROR_FILE_NOT_FOUND) == 0)
+ return "File doesn't exist.";
+ else
+ return error;
}
/**
/**
* Assigns an error name and message to a DBusError.
- * Does nothing if error is #NULL.
+ * Does nothing if error is #NULL. The message may
+ * be NULL only if the error is DBUS_ERROR_NO_MEMORY.
*
* @param error the error.
* @param name the error name (not copied!!!)
_dbus_assert (error->name == NULL);
_dbus_assert (error->message == NULL);
_dbus_assert (name != NULL);
- _dbus_assert (message != NULL);
+
+ if (message == NULL)
+ message = message_from_error (name);
real = (DBusRealError *)error;
* Assigns an error name and message to a DBusError.
* Does nothing if error is #NULL.
*
+ * The format may be NULL only if the error is DBUS_ERROR_NO_MEMORY.
+ *
* If no memory can be allocated for the error message,
* an out-of-memory error message will be set instead.
*
_dbus_assert (error->name == NULL);
_dbus_assert (error->message == NULL);
_dbus_assert (name != NULL);
- _dbus_assert (format != NULL);
+
+ if (format == NULL)
+ format = message_from_error (name);
va_start (args, format);
/* Measure the message length */
if (!message)
{
- dbus_set_error_const (error, DBUS_ERROR_NO_MEMORY,
- "Failed to allocate memory for error message.");
+ dbus_set_error_const (error, DBUS_ERROR_NO_MEMORY, NULL);
return;
}
#define DBUS_ERROR_FILE_NOT_FOUND "org.freedesktop.DBus.Error.FileNotFound"
#define DBUS_ERROR_UNKNOWN_MESSAGE "org.freedesktop.DBus.Error.UnknownMessage"
-typedef enum
-{
- DBUS_RESULT_SUCCESS, /**< Operation was successful. */
- DBUS_RESULT_FAILED, /**< Operation failed for unspecified reason. */
- DBUS_RESULT_NO_MEMORY, /**< Operation failed for lack of memory. */
- DBUS_RESULT_IO_ERROR, /**< Operation failed because of an IO error,
- * typically the other end closed the
- * connection.
- */
- DBUS_RESULT_BAD_ADDRESS, /**< Address was bad, could not be parsed. */
- DBUS_RESULT_NOT_SUPPORTED, /**< Feature is not supported. */
- DBUS_RESULT_LIMITS_EXCEEDED, /**< Some kernel resource limit exceeded. */
- DBUS_RESULT_ACCESS_DENIED, /**< Some sort of permissions/security problem. */
- DBUS_RESULT_AUTH_FAILED, /**< Could not authenticate. */
- DBUS_RESULT_NO_SERVER, /**< No one listening on the other end. */
- DBUS_RESULT_TIMEOUT, /**< Timed out trying to connect. */
- DBUS_RESULT_NO_NETWORK, /**< Can't find the network */
- DBUS_RESULT_ADDRESS_IN_USE, /**< Someone's already using the address */
- DBUS_RESULT_DISCONNECTED, /**< No more connection. */
- DBUS_RESULT_INVALID_ARGS, /**< One or more invalid arguments encountered. */
- DBUS_RESULT_NO_REPLY, /**< Did not get a reply message. */
- DBUS_RESULT_FILE_NOT_FOUND /**< File doesn't exist */
-} DBusResultCode;
-
void dbus_error_init (DBusError *error);
void dbus_error_free (DBusError *error);
void dbus_set_error (DBusError *error,
const char *name);
dbus_bool_t dbus_error_is_set (const DBusError *error);
-
-void dbus_set_result (DBusResultCode *code_address,
- DBusResultCode code);
-const char* dbus_result_to_string (DBusResultCode code);
-
DBUS_END_DECLS;
#endif /* DBUS_ERROR_H */
}
/**
- * Sets a file descriptor to be nonblocking.
- *
- * @param fd the file descriptor.
- * @param result address of result code.
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_set_fd_nonblocking (int fd,
- DBusResultCode *result)
-{
- int val;
-
- val = fcntl (fd, F_GETFL, 0);
- if (val < 0)
- {
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
- _dbus_strerror (errno));
- return FALSE;
- }
-
- if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
- {
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
- fd, _dbus_strerror (errno));
-
- return FALSE;
- }
-
- return TRUE;
-}
-
-/**
* Returns a string describing the given type.
*
* @param type the type to describe
const char* _dbus_strerror (int error_number);
-DBusResultCode _dbus_result_from_errno (int error_number);
-
#ifdef DBUS_DISABLE_ASSERT
#define _dbus_assert(condition)
#else
#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)))
+#define _DBUS_ASSERT_ERROR_IS_SET(error) _dbus_assert ((error) == NULL || dbus_error_is_set ((error)))
+#define _DBUS_ASSERT_ERROR_IS_CLEAR(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.
void *data);
dbus_bool_t _dbus_set_fd_nonblocking (int fd,
- DBusResultCode *result);
+ DBusError *error);
void _dbus_verbose_bytes (const unsigned char *data,
int len);
dbus_bool_t retval;
DBusKey *keys;
int n_keys;
-
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
if (!_dbus_string_init (&bytes, _DBUS_INT_MAX))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to generate new secret key");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
}
if (!_dbus_generate_random_bytes (&bytes, 4))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to generate new secret key");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
_dbus_string_set_length (&bytes, 0);
if (!_dbus_generate_random_bytes (&bytes, KEY_LENGTH_BYTES))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to generate new secret key");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
new = dbus_realloc (keys, sizeof (DBusKey) * (n_keys + 1));
if (new == NULL)
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to reallocate secret key list");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
_DBUS_INT_MAX))
{
n_keys -= 1; /* we don't want to free the one we didn't init */
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to store secret key");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
&keys[n_keys-1].secret,
0))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to store secret key");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
{
DBusString contents;
DBusString line;
- DBusResultCode result;
dbus_bool_t retval;
dbus_bool_t have_lock;
DBusKey *keys;
int i;
long now;
DBusError tmp_error;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
if (!_dbus_string_init (&contents, _DBUS_INT_MAX))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to reload keyring");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
}
if (!_dbus_string_init (&line, _DBUS_INT_MAX))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to reload keyring");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_string_free (&contents);
return FALSE;
}
new = dbus_realloc (keys, sizeof (DBusKey) * (n_keys + 1));
if (new == NULL)
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to reallocate secret key list");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
_DBUS_INT_MAX))
{
n_keys -= 1; /* we don't want to free the one we didn't init */
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to store secret key");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
&keys[n_keys-1].secret,
0))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to store secret key or invalid hex encoding");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
}
continue;
nomem:
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to save secret keyring");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
- result = _dbus_string_save_to_file (&contents, &keyring->filename);
- if (result != DBUS_RESULT_SUCCESS)
- {
- dbus_set_error (error, DBUS_ERROR_FAILED,
- "Failed to save keyring file: %s",
- dbus_result_to_string (result));
- goto out;
- }
+ if (!_dbus_string_save_to_file (&contents, &keyring->filename,
+ error))
+ goto out;
}
dbus_free (keyring->keys);
dbus_bool_t error_set;
DBusString dotdir;
DBusError tmp_error;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
keyring = NULL;
error_set = FALSE;
{
DBusKey *key;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
key = find_recent_key (keyring);
if (key)
return key->id;
int first_arg_type,
...)
{
- DBusResultCode retval;
+ dbus_bool_t retval;
va_list var_args;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
va_start (var_args, first_arg_type);
retval = dbus_message_get_args_valist (message, error, first_arg_type, var_args);
va_end (var_args);
int spec_type, msg_type, i;
DBusMessageIter *iter;
dbus_bool_t retval;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
iter = dbus_message_get_args_iter (message);
if (iter == NULL)
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory to get message arguments");
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return FALSE;
}
if (!*ptr)
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
if (!dbus_message_iter_get_boolean_array (iter, ptr, len))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
break;
if (!dbus_message_iter_get_int32_array (iter, ptr, len))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
if (!dbus_message_iter_get_uint32_array (iter, ptr, len))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
if (!dbus_message_iter_get_double_array (iter, ptr, len))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
break;
if (!dbus_message_iter_get_byte_array (iter, ptr, len))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
break;
if (!dbus_message_iter_get_string_array (iter, ptr, len))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
break;
if (!dbus_message_iter_get_dict (iter, dict))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
- "No memory for argument %d", i);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
goto out;
}
break;
* Creates a new debug server using an in-process pipe
*
* @param server_name the name of the server.
- * @param result address where a result code can be returned.
+ * @param error address where an error can be returned.
* @returns a new server, or #NULL on failure.
*/
DBusServer*
_dbus_server_debug_pipe_new (const char *server_name,
- DBusResultCode *result)
+ DBusError *error)
{
DBusServerDebugPipe *debug_server;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
if (!pipe_hash_ref ())
return NULL;
if (_dbus_hash_table_lookup_string (server_pipe_hash, server_name) != NULL)
{
- dbus_set_result (result, DBUS_RESULT_ADDRESS_IN_USE);
+ dbus_set_error (error, DBUS_ERROR_ADDRESS_IN_USE, NULL);
pipe_hash_unref ();
return NULL;
}
dbus_free (debug_server->name);
dbus_free (debug_server);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
pipe_hash_unref ();
return NULL;
dbus_free (debug_server->name);
dbus_free (debug_server);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
pipe_hash_unref ();
return NULL;
dbus_free (debug_server->name);
dbus_free (debug_server);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
pipe_hash_unref ();
return NULL;
}
- dbus_set_result (result, DBUS_RESULT_SUCCESS);
-
return (DBusServer *)debug_server;
}
*/
DBusTransport*
_dbus_transport_debug_pipe_new (const char *server_name,
- DBusResultCode *result)
+ DBusError *error)
{
DBusTransport *client_transport;
DBusTransport *server_transport;
int client_fd, server_fd;
DBusServer *server;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
server = _dbus_hash_table_lookup_string (server_pipe_hash,
server_name);
if (server == NULL ||
((DBusServerDebugPipe*)server)->disconnected)
{
- dbus_set_result (result, DBUS_RESULT_BAD_ADDRESS);
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS, NULL);
return NULL;
}
NULL))
{
_dbus_verbose ("failed to create full duplex pipe\n");
- dbus_set_result (result, DBUS_RESULT_FAILED);
+ dbus_set_error (error, DBUS_ERROR_FAILED, "Could not create full-duplex pipe");
return NULL;
}
{
_dbus_close (client_fd, NULL);
_dbus_close (server_fd, NULL);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
{
_dbus_transport_unref (client_transport);
_dbus_close (server_fd, NULL);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
if (connection == NULL)
{
_dbus_transport_unref (client_transport);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
DBUS_BEGIN_DECLS;
-DBusServer* _dbus_server_debug_pipe_new (const char *server_name,
- DBusResultCode *result);
-DBusTransport* _dbus_transport_debug_pipe_new (const char *server_name,
- DBusResultCode *result);
+DBusServer* _dbus_server_debug_pipe_new (const char *server_name,
+ DBusError *error);
+DBusTransport* _dbus_transport_debug_pipe_new (const char *server_name,
+ DBusError *error);
DBUS_END_DECLS;
* Creates a new debug server.
*
* @param server_name the name of the server.
- * @param result address where a result code can be returned.
+ * @param error address where an error can be returned.
* @returns a new server, or #NULL on failure.
*/
DBusServer*
_dbus_server_debug_new (const char *server_name,
- DBusResultCode *result)
+ DBusError *error)
{
DBusServerDebug *debug_server;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
if (!server_hash)
{
server_hash = _dbus_hash_table_new (DBUS_HASH_STRING, NULL, NULL);
if (!server_hash)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
}
if (_dbus_hash_table_lookup_string (server_hash, server_name) != NULL)
{
- dbus_set_result (result, DBUS_RESULT_ADDRESS_IN_USE);
+ dbus_set_error (error, DBUS_ERROR_ADDRESS_IN_USE,
+ NULL);
return NULL;
}
dbus_free (debug_server->name);
dbus_free (debug_server);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
}
if (!_dbus_server_init_base (&debug_server->base,
dbus_free (debug_server->name);
dbus_free (debug_server);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
dbus_free (debug_server->name);
dbus_free (debug_server);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
- dbus_set_result (result, DBUS_RESULT_SUCCESS);
-
return (DBusServer *)debug_server;
}
DBUS_BEGIN_DECLS;
DBusServer* _dbus_server_debug_new (const char *server_name,
- DBusResultCode *result);
+ DBusError *error);
DBusServer* _dbus_server_debug_lookup (const char *server_name);
dbus_bool_t _dbus_server_debug_accept_transport (DBusServer *server,
DBusTransport *transport);
* Creates a new server listening on the given Unix domain socket.
*
* @param path the path for the domain socket.
- * @param result location to store reason for failure.
+ * @param error location to store reason for failure.
* @returns the new server, or #NULL on failure.
*/
DBusServer*
_dbus_server_new_for_domain_socket (const char *path,
- DBusResultCode *result)
+ DBusError *error)
{
DBusServer *server;
int listen_fd;
- listen_fd = _dbus_listen_unix_socket (path, result);
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ listen_fd = _dbus_listen_unix_socket (path, error);
_dbus_fd_set_close_on_exec (listen_fd);
if (listen_fd < 0)
server = _dbus_server_new_for_fd (listen_fd);
if (server == NULL)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
close (listen_fd);
return NULL;
}
}
/**
- * Creates a new server listening on the given hostname and port
+ * Creates a new server listening on the given hostname and port.
+ * If the hostname is NULL, listens on localhost.
*
* @param host the hostname to listen on.
* @param port the port to listen on.
- * @param result location to store reason for failure.
+ * @param error location to store reason for failure.
* @returns the new server, or #NULL on failure.
*/
DBusServer*
_dbus_server_new_for_tcp_socket (const char *host,
dbus_uint32_t port,
- DBusResultCode *result)
+ DBusError *error)
{
DBusServer *server;
int listen_fd;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- listen_fd = _dbus_listen_tcp_socket (host, port, result);
+ listen_fd = _dbus_listen_tcp_socket (host, port, error);
_dbus_fd_set_close_on_exec (listen_fd);
if (listen_fd < 0)
server = _dbus_server_new_for_fd (listen_fd);
if (server == NULL)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
close (listen_fd);
return NULL;
}
DBusServer* _dbus_server_new_for_fd (int fd);
DBusServer* _dbus_server_new_for_domain_socket (const char *path,
- DBusResultCode *result);
+ DBusError *error);
DBusServer* _dbus_server_new_for_tcp_socket (const char *host,
dbus_uint32_t port,
- DBusResultCode *result);
+ DBusError *error);
DBUS_END_DECLS;
* DBusResultCode is a bit limiting here.
*
* @param address the address of this server.
- * @param result location to store rationale for failure.
+ * @param error location to store rationale for failure.
* @returns a new DBusServer, or #NULL on failure.
*
*/
DBusServer*
dbus_server_listen (const char *address,
- DBusResultCode *result)
+ DBusError *error)
{
DBusServer *server;
DBusAddressEntry **entries;
int len, i;
+ const char *address_problem_type;
+ const char *address_problem_field;
+ const char *address_problem_other;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!dbus_parse_address (address, &entries, &len, result))
+ if (!dbus_parse_address (address, &entries, &len, error))
return NULL;
server = NULL;
+ address_problem_type = NULL;
+ address_problem_field = NULL;
+ address_problem_other = NULL;
for (i = 0; i < len; i++)
{
const char *path = dbus_address_entry_get_value (entries[i], "path");
if (path == NULL)
- goto bad_address;
+ {
+ address_problem_type = "unix";
+ address_problem_field = "path";
+ goto bad_address;
+ }
- server = _dbus_server_new_for_domain_socket (path, result);
+ server = _dbus_server_new_for_domain_socket (path, error);
if (server)
break;
dbus_bool_t sresult;
if (port == NULL)
- goto bad_address;
+ {
+ address_problem_type = "tcp";
+ address_problem_field = "port";
+ goto bad_address;
+ }
_dbus_string_init_const (&str, port);
sresult = _dbus_string_parse_int (&str, 0, &lport, NULL);
_dbus_string_free (&str);
if (sresult == FALSE || lport <= 0 || lport > 65535)
- goto bad_address;
+ {
+ address_problem_other = "Port is not an integer between 0 and 65535";
+ goto bad_address;
+ }
- server = _dbus_server_new_for_tcp_socket (host, lport, result);
+ server = _dbus_server_new_for_tcp_socket (host, lport, error);
if (server)
break;
const char *name = dbus_address_entry_get_value (entries[i], "name");
if (name == NULL)
- goto bad_address;
+ {
+ address_problem_type = "debug";
+ address_problem_field = "name";
+ goto bad_address;
+ }
- server = _dbus_server_debug_new (name, result);
+ server = _dbus_server_debug_new (name, error);
if (server)
break;
const char *name = dbus_address_entry_get_value (entries[i], "name");
if (name == NULL)
- goto bad_address;
+ {
+ address_problem_type = "debug-pipe";
+ address_problem_field = "name";
+ goto bad_address;
+ }
- server = _dbus_server_debug_pipe_new (name, result);
+ server = _dbus_server_debug_pipe_new (name, error);
if (server)
break;
}
#endif
else
- goto bad_address;
+ {
+ address_problem_other = "Unknown address type (examples of valid types are \"unix\" and \"tcp\")";
+ goto bad_address;
+ }
}
dbus_address_entries_free (entries);
bad_address:
dbus_address_entries_free (entries);
- dbus_set_result (result, DBUS_RESULT_BAD_ADDRESS);
+ if (address_problem_type != NULL)
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
+ "Server address of type %s was missing argument %s",
+ address_problem_type, address_problem_field);
+ else
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
+ "Could not parse server address: %s",
+ address_problem_other);
return NULL;
}
void *data);
DBusServer* dbus_server_listen (const char *address,
- DBusResultCode *result);
+ DBusError *error);
void dbus_server_ref (DBusServer *server);
void dbus_server_unref (DBusServer *server);
void dbus_server_disconnect (DBusServer *server);
* nonblocking.
*
* @param path the path to UNIX domain socket
- * @param result return location for error code
+ * @param error return location for error code
* @returns connection file descriptor or -1 on error
*/
int
_dbus_connect_unix_socket (const char *path,
- DBusResultCode *result)
+ DBusError *error)
{
int fd;
struct sockaddr_un addr;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
fd = socket (PF_UNIX, SOCK_STREAM, 0);
if (fd < 0)
{
- dbus_set_result (result,
- _dbus_result_from_errno (errno));
-
- _dbus_verbose ("Failed to create socket: %s\n",
- _dbus_strerror (errno));
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to create socket: %s",
+ _dbus_strerror (errno));
return -1;
}
if (connect (fd, (struct sockaddr*) &addr, sizeof (addr)) < 0)
{
- dbus_set_result (result,
- _dbus_result_from_errno (errno));
-
- _dbus_verbose ("Failed to connect to socket %s: %s\n",
- path, _dbus_strerror (errno));
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to connect to socket %s: %s",
+ path, _dbus_strerror (errno));
close (fd);
fd = -1;
return -1;
}
- if (!_dbus_set_fd_nonblocking (fd, result))
+ if (!_dbus_set_fd_nonblocking (fd, error))
{
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+
close (fd);
fd = -1;
* set to be nonblocking.
*
* @param path the socket name
- * @param result return location for errors
+ * @param error return location for errors
* @returns the listening file descriptor or -1 on error
*/
int
_dbus_listen_unix_socket (const char *path,
- DBusResultCode *result)
+ DBusError *error)
{
int listen_fd;
struct sockaddr_un addr;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
listen_fd = socket (PF_UNIX, SOCK_STREAM, 0);
if (listen_fd < 0)
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to create socket \"%s\": %s\n",
- path, _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to create socket \"%s\": %s",
+ path, _dbus_strerror (errno));
return -1;
}
if (bind (listen_fd, (struct sockaddr*) &addr, SUN_LEN (&addr)) < 0)
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to bind socket \"%s\": %s\n",
- path, _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to bind socket \"%s\": %s",
+ path, _dbus_strerror (errno));
close (listen_fd);
return -1;
}
if (listen (listen_fd, 30 /* backlog */) < 0)
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to listen on socket \"%s\": %s\n",
- path, _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to listen on socket \"%s\": %s",
+ path, _dbus_strerror (errno));
close (listen_fd);
return -1;
}
- if (!_dbus_set_fd_nonblocking (listen_fd, result))
+ if (!_dbus_set_fd_nonblocking (listen_fd, error))
{
+ _DBUS_ASSERT_ERROR_IS_SET (error);
close (listen_fd);
return -1;
}
*
* @param host the host name to connect to
* @param port the prot to connect to
- * @param result return location for error code
+ * @param error return location for error code
* @returns connection file descriptor or -1 on error
*/
int
_dbus_connect_tcp_socket (const char *host,
dbus_uint32_t port,
- DBusResultCode *result)
+ DBusError *error)
{
int fd;
struct sockaddr_in addr;
struct hostent *he;
struct in_addr *haddr;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
fd = socket (AF_INET, SOCK_STREAM, 0);
if (fd < 0)
{
- dbus_set_result (result,
- _dbus_result_from_errno (errno));
-
- _dbus_verbose ("Failed to create socket: %s\n",
- _dbus_strerror (errno));
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to create socket: %s",
+ _dbus_strerror (errno));
return -1;
}
he = gethostbyname (host);
if (he == NULL)
{
- dbus_set_result (result,
- _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to lookup hostname: %s\n",
- host);
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to lookup hostname: %s",
+ host);
return -1;
}
if (connect (fd, (struct sockaddr*) &addr, sizeof (addr)) < 0)
{
- dbus_set_result (result,
- _dbus_result_from_errno (errno));
-
- _dbus_verbose ("Failed to connect to socket %s: %s:%d\n",
- host, _dbus_strerror (errno), port);
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to connect to socket %s: %s:%d",
+ host, _dbus_strerror (errno), port);
close (fd);
fd = -1;
return -1;
}
- if (!_dbus_set_fd_nonblocking (fd, result))
+ if (!_dbus_set_fd_nonblocking (fd, error))
{
close (fd);
fd = -1;
*
* @param host the host name to listen on
* @param port the prot to listen on
- * @param result return location for errors
+ * @param error return location for errors
* @returns the listening file descriptor or -1 on error
*/
int
_dbus_listen_tcp_socket (const char *host,
dbus_uint32_t port,
- DBusResultCode *result)
+ DBusError *error)
{
int listen_fd;
struct sockaddr_in addr;
struct hostent *he;
struct in_addr *haddr;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
listen_fd = socket (AF_INET, SOCK_STREAM, 0);
if (listen_fd < 0)
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to create socket \"%s:%d\": %s\n",
- host, port, _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to create socket \"%s:%d\": %s",
+ host, port, _dbus_strerror (errno));
return -1;
}
he = gethostbyname (host);
if (he == NULL)
{
- dbus_set_result (result,
- _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to lookup hostname: %s\n",
- host);
+ dbus_set_error (error,
+ _dbus_error_from_errno (errno),
+ "Failed to lookup hostname: %s",
+ host);
return -1;
}
if (bind (listen_fd, (struct sockaddr*) &addr, sizeof (struct sockaddr)))
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to bind socket \"%s:%d\": %s\n",
- host, port, _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to bind socket \"%s:%d\": %s",
+ host, port, _dbus_strerror (errno));
close (listen_fd);
return -1;
}
if (listen (listen_fd, 30 /* backlog */) < 0)
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to listen on socket \"%s:%d\": %s\n",
- host, port, _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to listen on socket \"%s:%d\": %s",
+ host, port, _dbus_strerror (errno));
close (listen_fd);
return -1;
}
- if (!_dbus_set_fd_nonblocking (listen_fd, result))
+ if (!_dbus_set_fd_nonblocking (listen_fd, error))
{
close (listen_fd);
return -1;
static dbus_bool_t
write_credentials_byte (int server_fd,
- DBusResultCode *result)
+ DBusError *error)
{
int bytes_written;
char buf[1] = { '\0' };
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
again:
if (bytes_written < 0)
{
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to write credentials byte: %s\n",
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to write credentials byte: %s",
_dbus_strerror (errno));
return FALSE;
}
else if (bytes_written == 0)
{
- dbus_set_result (result, DBUS_RESULT_IO_ERROR);
- _dbus_verbose ("wrote zero bytes writing credentials byte\n");
+ dbus_set_error (error, DBUS_ERROR_IO_ERROR,
+ "wrote zero bytes writing credentials byte");
return FALSE;
}
else
*
* @param client_fd the client file descriptor
* @param credentials struct to fill with credentials of client
- * @param result location to store result code
+ * @param error location to store error code
* @returns #TRUE on success
*/
dbus_bool_t
_dbus_read_credentials_unix_socket (int client_fd,
DBusCredentials *credentials,
- DBusResultCode *result)
+ DBusError *error)
{
struct msghdr msg;
struct iovec iov;
struct cmsghdr *cmsg = (struct cmsghdr *) cmsgmem;
#endif
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
/* The POSIX spec certainly doesn't promise this, but
* we need these assertions to fail as soon as we're wrong about
* it so we can do the porting fixups
if (errno == EINTR)
goto again;
- dbus_set_result (result, _dbus_result_from_errno (errno));
- _dbus_verbose ("Failed to read credentials byte: %s\n",
- _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to read credentials byte: %s",
+ _dbus_strerror (errno));
return FALSE;
}
if (buf != '\0')
{
- dbus_set_result (result, DBUS_RESULT_FAILED);
- _dbus_verbose ("Credentials byte was not nul\n");
+ dbus_set_error (error, DBUS_ERROR_FAILED,
+ "Credentials byte was not nul");
return FALSE;
}
#ifdef HAVE_CMSGCRED
if (cmsg->cmsg_len < sizeof (cmsgmem) || cmsg->cmsg_type != SCM_CREDS)
{
- dbus_set_result (result, DBUS_RESULT_FAILED);
+ dbus_set_error (error, DBUS_ERROR_FAILED);
_dbus_verbose ("Message from recvmsg() was not SCM_CREDS\n");
return FALSE;
}
* use sendmsg()/recvmsg() to transmit credentials.
*
* @param server_fd file descriptor for connection to server
- * @param result return location for error code
+ * @param error return location for error code
* @returns #TRUE if the byte was sent
*/
dbus_bool_t
_dbus_send_credentials_unix_socket (int server_fd,
- DBusResultCode *result)
+ DBusError *error)
{
- if (write_credentials_byte (server_fd, result))
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ if (write_credentials_byte (server_fd, error))
return TRUE;
else
return FALSE;
/**
* Appends the contents of the given file to the string,
- * returning result code. At the moment, won't open a file
+ * returning error code. At the moment, won't open a file
* more than a megabyte in size.
*
* @param str the string to append to
int total;
const char *filename_c;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_string_get_const_data (filename, &filename_c);
/* O_BINARY useful on Cygwin */
*
* @param str the string to write out
* @param filename the file to save string to
- * @returns result code
+ * @param error error to be filled in on failure
+ * @returns #FALSE on failure
*/
-DBusResultCode
+dbus_bool_t
_dbus_string_save_to_file (const DBusString *str,
- const DBusString *filename)
+ const DBusString *filename,
+ DBusError *error)
{
int fd;
int bytes_to_write;
DBusString tmp_filename;
const char *tmp_filename_c;
int total;
- DBusResultCode result;
dbus_bool_t need_unlink;
+ dbus_bool_t retval;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
fd = -1;
- result = DBUS_RESULT_FAILED;
+ retval = FALSE;
need_unlink = FALSE;
if (!_dbus_string_init (&tmp_filename, _DBUS_INT_MAX))
- return DBUS_RESULT_NO_MEMORY;
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ return FALSE;
+ }
if (!_dbus_string_copy (filename, 0, &tmp_filename, 0))
- return DBUS_RESULT_NO_MEMORY;
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ return FALSE;
+ }
if (!_dbus_string_append (&tmp_filename, "."))
- return DBUS_RESULT_NO_MEMORY;
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ return FALSE;
+ }
if (!append_unique_chars (&tmp_filename))
- return DBUS_RESULT_NO_MEMORY;
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ return FALSE;
+ }
_dbus_string_get_const_data (filename, &filename_c);
_dbus_string_get_const_data (&tmp_filename, &tmp_filename_c);
0600);
if (fd < 0)
{
- result = _dbus_result_from_errno (errno);
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Could not create %s: %s", tmp_filename_c,
+ _dbus_strerror (errno));
goto out;
}
if (bytes_written <= 0)
{
- DBusResultCode result;
-
- result = _dbus_result_from_errno (errno); /* prior to close() */
-
- _dbus_verbose ("write() failed: %s",
- _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Could not write to %s: %s", tmp_filename_c,
+ _dbus_strerror (errno));
goto out;
}
if (close (fd) < 0)
{
- _dbus_verbose ("close() failed: %s\n", _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Could not close file %s: %s",
+ tmp_filename_c, _dbus_strerror (errno));
+
goto out;
}
if (rename (tmp_filename_c, filename_c) < 0)
{
- _dbus_verbose ("rename() failed: %s\n", _dbus_strerror (errno));
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Could not rename %s to %s: %s",
+ tmp_filename_c, filename_c,
+ _dbus_strerror (errno));
+
goto out;
}
need_unlink = FALSE;
- result = DBUS_RESULT_SUCCESS;
+ retval = TRUE;
out:
/* close first, then unlink, to prevent ".nfs34234235" garbage
tmp_filename_c, _dbus_strerror (errno));
_dbus_string_free (&tmp_filename);
+
+ if (!retval)
+ _DBUS_ASSERT_ERROR_IS_SET (error);
- return result;
+ return retval;
}
/** Creates the given file, failing if the file already exists.
int fd;
const char *filename_c;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_string_get_const_data (filename, &filename_c);
fd = open (filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
{
const char *filename_c;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_string_get_const_data (filename, &filename_c);
if (unlink (filename_c) < 0)
{
const char *filename_c;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_string_get_const_data (filename, &filename_c);
if (mkdir (filename_c, 0700) < 0)
DBusDirIter *iter;
const char *filename_c;
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
_dbus_string_get_const_data (filename, &filename_c);
d = opendir (filename_c);
DBusString *filename,
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_ASSERT_ERROR_IS_CLEAR (error);
+
again:
errno = 0;
ent = readdir (iter->d);
make_pipe (int p[2],
DBusError *error)
{
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
if (pipe (p) < 0)
{
dbus_set_error (error,
DBusError *error)
{
size_t bytes = 0;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
while (TRUE)
{
int pid = -1, grandchild_pid;
int child_err_report_pipe[2] = { -1, -1 };
int status;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
if (!make_pipe (child_err_report_pipe, error))
return FALSE;
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.
*
{
const char *filename_c;
struct stat sb;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
_dbus_string_get_const_data (filename, &filename_c);
#ifdef HAVE_SOCKETPAIR
int fds[2];
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) < 0)
{
dbus_set_error (error, _dbus_error_from_errno (errno),
_dbus_close (int fd,
DBusError *error)
{
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
again:
if (close (fd) < 0)
{
}
/**
+ * Sets a file descriptor to be nonblocking.
+ *
+ * @param fd the file descriptor.
+ * @param error address of error location.
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_set_fd_nonblocking (int fd,
+ DBusError *error)
+{
+ int val;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ val = fcntl (fd, F_GETFL, 0);
+ if (val < 0)
+ {
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to get flags from file descriptor %d: %s",
+ fd, _dbus_strerror (errno));
+ _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
+ _dbus_strerror (errno));
+ return FALSE;
+ }
+
+ if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
+ {
+ dbus_set_error (error, _dbus_error_from_errno (errno),
+ "Failed to set nonblocking flag of file descriptor %d: %s",
+ fd, _dbus_strerror (errno));
+ _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
+ fd, _dbus_strerror (errno));
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+/**
* On GNU libc systems, print a crude backtrace to the verbose log.
* On other systems, print "no backtrace support"
*
} DBusCredentials;
int _dbus_connect_unix_socket (const char *path,
- DBusResultCode *result);
+ DBusError *error);
int _dbus_listen_unix_socket (const char *path,
- DBusResultCode *result);
+ DBusError *error);
int _dbus_connect_tcp_socket (const char *host,
dbus_uint32_t port,
- DBusResultCode *result);
+ DBusError *error);
int _dbus_listen_tcp_socket (const char *host,
dbus_uint32_t port,
- DBusResultCode *result);
+ DBusError *error);
int _dbus_accept (int listen_fd);
dbus_bool_t _dbus_read_credentials_unix_socket (int client_fd,
DBusCredentials *credentials,
- DBusResultCode *result);
+ DBusError *error);
dbus_bool_t _dbus_send_credentials_unix_socket (int server_fd,
- DBusResultCode *result);
+ DBusError *error);
dbus_bool_t _dbus_credentials_from_username (const DBusString *username,
void _dbus_get_current_time (long *tv_sec,
long *tv_usec);
+
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);
+dbus_bool_t _dbus_string_save_to_file (const DBusString *str,
+ const DBusString *filename,
+ DBusError *error);
dbus_bool_t _dbus_create_file_exclusively (const DBusString *filename,
DBusError *error);
*
* @param server_name name of the server transport that
* the client should try to connect to.
- * @param result address where a result code can be returned.
+ * @param error address where an error can be returned.
* @returns a new transport, or #NULL on failure.
*/
DBusTransport*
_dbus_transport_debug_client_new (const char *server_name,
- DBusResultCode *result)
+ DBusError *error)
{
DBusServer *debug_server;
DBusTransportDebug *debug_transport;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
debug_server = _dbus_server_debug_lookup (server_name);
if (!debug_server)
{
- dbus_set_result (result, DBUS_RESULT_NO_SERVER);
+ dbus_set_error (error, DBUS_ERROR_NO_SERVER, NULL);
return NULL;
}
debug_transport = dbus_new0 (DBusTransportDebug, 1);
if (debug_transport == NULL)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
FALSE))
{
dbus_free (debug_transport);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
{
_dbus_transport_finalize_base (&debug_transport->base);
dbus_free (debug_transport);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
_dbus_timeout_unref (debug_transport->timeout);
_dbus_transport_finalize_base (&debug_transport->base);
dbus_free (debug_transport);
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
return NULL;
}
DBusTransport* _dbus_transport_debug_server_new (DBusTransport *client);
DBusTransport* _dbus_transport_debug_client_new (const char *server_name,
- DBusResultCode *result);
+ DBusError *error);
DBUS_END_DECLS;
*
* @param path the path to the domain socket.
* @param server #TRUE if this transport is on the server side of a connection
- * @param result location to store reason for failure.
+ * @param error location to store reason for failure.
* @returns a new transport, or #NULL on failure.
*/
DBusTransport*
_dbus_transport_new_for_domain_socket (const char *path,
dbus_bool_t server,
- DBusResultCode *result)
+ DBusError *error)
{
int fd;
DBusTransport *transport;
- fd = _dbus_connect_unix_socket (path, result);
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+
+ fd = _dbus_connect_unix_socket (path, error);
if (fd < 0)
- return NULL;
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return NULL;
+ }
_dbus_fd_set_close_on_exec (fd);
transport = _dbus_transport_new_for_fd (fd, server);
if (transport == NULL)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_close (fd, NULL);
fd = -1;
}
_dbus_transport_new_for_tcp_socket (const char *host,
dbus_int32_t port,
dbus_bool_t server,
- DBusResultCode *result)
+ DBusError *error)
{
int fd;
DBusTransport *transport;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- fd = _dbus_connect_tcp_socket (host, port, result);
+ fd = _dbus_connect_tcp_socket (host, port, error);
if (fd < 0)
- return NULL;
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return NULL;
+ }
_dbus_fd_set_close_on_exec (fd);
transport = _dbus_transport_new_for_fd (fd, server);
if (transport == NULL)
{
- dbus_set_result (result, DBUS_RESULT_NO_MEMORY);
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
_dbus_close (fd, NULL);
fd = -1;
}
dbus_bool_t server);
DBusTransport* _dbus_transport_new_for_domain_socket (const char *path,
dbus_bool_t server,
- DBusResultCode *result);
+ DBusError *error);
DBusTransport* _dbus_transport_new_for_tcp_socket (const char *host,
dbus_int32_t port,
dbus_bool_t server,
- DBusResultCode *result);
+ DBusError *error);
DBUS_END_DECLS;
* DBusResultCode is a bit limiting here.
*
* @param address the address.
- * @param result location to store reason for failure.
+ * @param error location to store reason for failure.
* @returns new transport of #NULL on failure.
*/
DBusTransport*
_dbus_transport_open (const char *address,
- DBusResultCode *result)
+ DBusError *error)
{
DBusTransport *transport;
DBusAddressEntry **entries;
int len, i;
+ const char *address_problem_type;
+ const char *address_problem_field;
+ const char *address_problem_other;
+
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
- if (!dbus_parse_address (address, &entries, &len, result))
+ if (!dbus_parse_address (address, &entries, &len, error))
return NULL;
transport = NULL;
+ address_problem_type = NULL;
+ address_problem_field = NULL;
+ address_problem_other = NULL;
for (i = 0; i < len; i++)
{
const char *path = dbus_address_entry_get_value (entries[i], "path");
if (path == NULL)
- goto bad_address;
+ {
+ address_problem_type = "unix";
+ address_problem_field = "path";
+ goto bad_address;
+ }
- transport = _dbus_transport_new_for_domain_socket (path, FALSE, result);
+ transport = _dbus_transport_new_for_domain_socket (path, FALSE, error);
}
else if (strcmp (method, "tcp") == 0)
{
long lport;
dbus_bool_t sresult;
- if (port == NULL)
- goto bad_address;
+ if (port == NULL)
+ {
+ address_problem_type = "tcp";
+ address_problem_field = "port";
+ goto bad_address;
+ }
_dbus_string_init_const (&str, port);
sresult = _dbus_string_parse_int (&str, 0, &lport, NULL);
_dbus_string_free (&str);
if (sresult == FALSE || lport <= 0 || lport > 65535)
- goto bad_address;
+ {
+ address_problem_other = "Port is not an integer between 0 and 65535";
+ goto bad_address;
+ }
- transport = _dbus_transport_new_for_tcp_socket (host, lport, FALSE, result);
+ transport = _dbus_transport_new_for_tcp_socket (host, lport, FALSE, error);
}
#ifdef DBUS_BUILD_TESTS
else if (strcmp (method, "debug") == 0)
const char *name = dbus_address_entry_get_value (entries[i], "name");
if (name == NULL)
- goto bad_address;
+ {
+ address_problem_type = "debug";
+ address_problem_field = "name";
+ goto bad_address;
+ }
- transport = _dbus_transport_debug_client_new (name, result);
+ transport = _dbus_transport_debug_client_new (name, error);
}
else if (strcmp (method, "debug-pipe") == 0)
{
const char *name = dbus_address_entry_get_value (entries[i], "name");
- if (name == NULL)
- goto bad_address;
+ if (name == NULL)
+ {
+ address_problem_type = "debug-pipe";
+ address_problem_field = "name";
+ goto bad_address;
+ }
- transport = _dbus_transport_debug_pipe_new (name, result);
+ transport = _dbus_transport_debug_pipe_new (name, error);
}
#endif
else
- goto bad_address;
+ {
+ address_problem_other = "Unknown address type (examples of valid types are \"unix\" and \"tcp\")";
+ goto bad_address;
+ }
if (transport)
break;
bad_address:
dbus_address_entries_free (entries);
- dbus_set_result (result, DBUS_RESULT_BAD_ADDRESS);
+
+ if (address_problem_type != NULL)
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
+ "Address of type %s was missing argument %s",
+ address_problem_type, address_problem_field);
+ else
+ dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
+ "Could not parse address: %s",
+ address_problem_other);
return NULL;
}
typedef struct DBusTransport DBusTransport;
DBusTransport* _dbus_transport_open (const char *address,
- DBusResultCode *result);
+ DBusError *error);
void _dbus_transport_ref (DBusTransport *transport);
void _dbus_transport_unref (DBusTransport *transport);
void _dbus_transport_disconnect (DBusTransport *transport);
main (int argc, char **argv)
{
DBusConnection *connection;
- DBusResultCode result;
DBusMessage *message, *reply;
GMainLoop *loop;
DBusError error;
loop = g_main_loop_new (NULL, FALSE);
- connection = dbus_connection_open (argv[1], &result);
+ dbus_error_init (&error);
+ connection = dbus_connection_open (argv[1], &error);
if (connection == NULL)
{
g_printerr ("Failed to open connection to %s: %s\n", argv[1],
- dbus_result_to_string (result));
+ error.message);
+ dbus_error_free (&error);
return 1;
}
main (int argc, char *argv[])
{
GMainLoop *loop;
- DBusResultCode result;
+ DBusError error;
int i;
g_thread_init (NULL);
return 1;
}
- connection = dbus_connection_open (argv[1], &result);
+ dbus_error_init (&error);
+ connection = dbus_connection_open (argv[1], &error);
if (connection == NULL)
{
- g_printerr ("could not open connection\n");
+ g_printerr ("could not open connection: %s\n", error.message);
+ dbus_error_free (&error);
return 1;
}
{
GMainLoop *loop;
DBusServer *server;
- DBusResultCode result;
+ DBusError error;
g_thread_init (NULL);
dbus_gthread_init ();
return 1;
}
- server = dbus_server_listen (argv[1], &result);
+ dbus_error_init (&error);
+ server = dbus_server_listen (argv[1], &error);
if (server == NULL)
{
fprintf (stderr, "Failed to start server on %s: %s\n",
- argv[1], dbus_result_to_string (result));
+ argv[1], error.message);
+ dbus_error_free (&error);
return 1;
}
if (failed)
{
const char *filename_c;
- DBusResultCode result;
+ DBusError error;
_dbus_string_append (&filename, ".message-raw");
printf ("Child failed, writing %s\n",
filename_c);
- result = _dbus_string_save_to_file (data, &filename);
-
- if (result != DBUS_RESULT_SUCCESS)
+ dbus_error_init (&error);
+ if (!_dbus_string_save_to_file (data, &filename, &error))
{
fprintf (stderr, "Failed to save failed message data: %s\n",
- dbus_result_to_string (result));
+ error.message);
+ dbus_error_free (&error);
exit (1); /* so we can see the seed that was printed out */
}
char **argv)
{
DBusConnection *connection;
- DBusResultCode result;
+ DBusError error;
DBusMessage *message;
if (argc < 2)
fprintf (stderr, "Give the server address as an argument\n");
return 1;
}
-
- connection = dbus_connection_open (argv[1], &result);
+
+ dbus_error_init (&error);
+ connection = dbus_connection_open (argv[1], &error);
if (connection == NULL)
{
fprintf (stderr, "Failed to open connection to %s: %s\n",
- argv[1], dbus_result_to_string (result));
+ argv[1], error.message);
+ dbus_error_free (&error);
return 1;
}
char **argv)
{
DBusServer *server;
- DBusResultCode result;
+ DBusError error;
if (argc < 2)
{
return 1;
}
- server = dbus_server_listen (argv[1], &result);
+ dbus_error_init (&error);
+ server = dbus_server_listen (argv[1], &error);
if (server == NULL)
{
fprintf (stderr, "Failed to start server on %s: %s\n",
- argv[1], dbus_result_to_string (result));
+ argv[1], error.message);
+ dbus_error_free (&error);
return 1;
}
projects / platform / upstream / dbus.git / commitdiff