2006-09-16 Havoc Pennington <hp@redhat.com>
+ * dbus/dbus-transport.c (_dbus_transport_open): modify to delegate
+ to _dbus_transport_open_platform_specific,
+ _dbus_transport_open_socket,
+ and _dbus_transport_open_debug_pipe
+
+ * dbus/dbus-transport-protected.h: add _dbus_transport_open_platform_specific
+
+2006-09-16 Havoc Pennington <hp@redhat.com>
+
Attempt auditing public API to remove all cases where a Unix
function returns weird emulated goo to Windows. This probably
breaks the bus daemon on Windows, to fix it again we may
DBusList *values; /**< List of values */
};
+
+void
+_dbus_set_bad_address (DBusError *error,
+ const char *address_problem_type,
+ const char *address_problem_field,
+ const char *address_problem_other)
+{
+ 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);
+}
+
+#define _DBUS_ADDRESS_OPTIONALLY_ESCAPED_BYTE(b) \
+ (((b) >= 'a' && (b) <= 'z') || \
+ ((b) >= 'A' && (b) <= 'Z') || \
+ ((b) >= '0' && (b) <= '9') || \
+ (b) == '-' || \
+ (b) == '_' || \
+ (b) == '/' || \
+ (b) == '\\' || \
+ (b) == '.')
+
+/**
+ * Appends an escaped version of one string to another string,
+ * using the D-Bus address escaping mechanism
+ *
+ * @param escaped the string to append to
+ * @param unescaped the string to escape
+ * @returns #FALSE if no memory
+ */
+dbus_bool_t
+_dbus_address_append_escaped (DBusString *escaped,
+ const DBusString *unescaped)
+{
+ const char *p;
+ const char *end;
+ dbus_bool_t ret;
+ int orig_len;
+
+ ret = FALSE;
+
+ orig_len = _dbus_string_get_length (escaped);
+ p = _dbus_string_get_const_data (unescaped);
+ end = p + _dbus_string_get_length (unescaped);
+ while (p != end)
+ {
+ if (_DBUS_ADDRESS_OPTIONALLY_ESCAPED_BYTE (*p))
+ {
+ if (!_dbus_string_append_byte (escaped, *p))
+ goto out;
+ }
+ else
+ {
+ if (!_dbus_string_append_byte (escaped, '%'))
+ goto out;
+ if (!_dbus_string_append_byte_as_hex (escaped, *p))
+ goto out;
+ }
+
+ ++p;
+ }
+
+ ret = TRUE;
+
+ out:
+ if (!ret)
+ _dbus_string_set_length (escaped, orig_len);
+ return ret;
+}
+
/** @} */ /* End of internals */
static void
return NULL;
}
-#define _DBUS_ADDRESS_OPTIONALLY_ESCAPED_BYTE(b) \
- (((b) >= 'a' && (b) <= 'z') || \
- ((b) >= 'A' && (b) <= 'Z') || \
- ((b) >= '0' && (b) <= '9') || \
- (b) == '-' || \
- (b) == '_' || \
- (b) == '/' || \
- (b) == '\\' || \
- (b) == '.')
-
-/**
- * Appends an escaped version of one string to another string,
- * using the D-Bus address escaping mechanism
- *
- * @param escaped the string to append to
- * @param unescaped the string to escape
- * @returns #FALSE if no memory
- */
-dbus_bool_t
-_dbus_address_append_escaped (DBusString *escaped,
- const DBusString *unescaped)
-{
- const char *p;
- const char *end;
- dbus_bool_t ret;
- int orig_len;
-
- ret = FALSE;
-
- orig_len = _dbus_string_get_length (escaped);
- p = _dbus_string_get_const_data (unescaped);
- end = p + _dbus_string_get_length (unescaped);
- while (p != end)
- {
- if (_DBUS_ADDRESS_OPTIONALLY_ESCAPED_BYTE (*p))
- {
- if (!_dbus_string_append_byte (escaped, *p))
- goto out;
- }
- else
- {
- if (!_dbus_string_append_byte (escaped, '%'))
- goto out;
- if (!_dbus_string_append_byte_as_hex (escaped, *p))
- goto out;
- }
-
- ++p;
- }
-
- ret = TRUE;
-
- out:
- if (!ret)
- _dbus_string_set_length (escaped, orig_len);
- return ret;
-}
-
static dbus_bool_t
append_unescaped_value (DBusString *unescaped,
const DBusString *escaped,
dbus_bool_t _dbus_address_append_escaped (DBusString *escaped,
const DBusString *unescaped);
+void _dbus_set_bad_address (DBusError *error,
+ const char *address_problem_type,
+ const char *address_problem_field,
+ const char *address_problem_other);
+
+
DBUS_END_DECLS
#endif /* DBUS_INTERNALS_H */
if (name == NULL)
{
- _dbus_server_set_bad_address(error, "debug-pipe", "name",
- NULL);
+ _dbus_set_bad_address(error, "debug-pipe", "name",
+ NULL);
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
}
}
+DBusTransportOpenResult
+_dbus_transport_open_debug_pipe (DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error)
+{
+ const char *method;
+
+ method = dbus_address_entry_get_method (entry);
+ _dbus_assert (method != NULL);
+
+ if (strcmp (method, "debug-pipe") == 0)
+ {
+ const char *name = dbus_address_entry_get_value (entry, "name");
+
+ if (name == NULL)
+ {
+ _dbus_set_bad_address (error, "debug-pipe", "name",
+ NULL);
+ return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
+ }
+
+ *transport_p = _dbus_transport_debug_pipe_new (name, error);
+
+ if (*transport_p == NULL)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_OK;
+ }
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
+ }
+}
+
+
/** @} */
#endif /* DBUS_BUILD_TESTS */
#include <dbus/dbus-internals.h>
#include <dbus/dbus-server-protected.h>
-#include <dbus/dbus-transport.h>
+#include <dbus/dbus-transport-protected.h>
DBUS_BEGIN_DECLS
-DBusServer* _dbus_server_debug_pipe_new (const char *server_name,
- DBusError *error);
-DBusTransport* _dbus_transport_debug_pipe_new (const char *server_name,
- DBusError *error);
-DBusServerListenResult _dbus_server_listen_debug_pipe (DBusAddressEntry *entry,
- DBusServer **server_p,
- DBusError *error);
+DBusServer* _dbus_server_debug_pipe_new (const char *server_name,
+ DBusError *error);
+DBusTransport* _dbus_transport_debug_pipe_new (const char *server_name,
+ DBusError *error);
+DBusServerListenResult _dbus_server_listen_debug_pipe (DBusAddressEntry *entry,
+ DBusServer **server_p,
+ DBusError *error);
+DBusTransportOpenResult _dbus_transport_open_debug_pipe (DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error);
DBUS_END_DECLS
DBusServerListenResult _dbus_server_listen_platform_specific (DBusAddressEntry *entry,
DBusServer **server_p,
DBusError *error);
-void _dbus_server_set_bad_address (DBusError *error,
- const char *address_problem_type,
- const char *address_problem_field,
- const char *address_problem_other);
#ifdef DBUS_DISABLE_CHECKS
#define TOOK_LOCK_CHECK(server)
if (port == NULL)
{
- _dbus_server_set_bad_address(error, "tcp", "port", NULL);
+ _dbus_set_bad_address(error, "tcp", "port", NULL);
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
if (sresult == FALSE || lport <= 0 || lport > 65535)
{
- _dbus_server_set_bad_address(error, NULL, NULL,
- "Port is not an integer between 0 and 65535");
+ _dbus_set_bad_address(error, NULL, NULL,
+ "Port is not an integer between 0 and 65535");
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
if (path == NULL && tmpdir == NULL && abstract == NULL)
{
- _dbus_server_set_bad_address(error, "unix",
- "path or tmpdir or abstract",
- NULL);
+ _dbus_set_bad_address(error, "unix",
+ "path or tmpdir or abstract",
+ NULL);
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
(path && abstract) ||
(tmpdir && abstract))
{
- _dbus_server_set_bad_address(error, NULL, NULL,
- "cannot specify two of \"path\" and \"tmpdir\" and \"abstract\" at the same time");
+ _dbus_set_bad_address(error, NULL, NULL,
+ "cannot specify two of \"path\" and \"tmpdir\" and \"abstract\" at the same time");
return DBUS_SERVER_LISTEN_BAD_ADDRESS;
}
enabled);
}
-void
-_dbus_server_set_bad_address (DBusError *error,
- const char *address_problem_type,
- const char *address_problem_field,
- const char *address_problem_other)
-{
- 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);
-}
-
/** @} */
/**
/**
* Listens for new connections on the given address.
- * Returns #NULL if listening fails for any reason.
+ * If there are multiple address entries in the address,
+ * tries each one and listens on the first one that
+ * works.
+ *
+ * Returns #NULL and sets error if listening fails for any reason.
* Otherwise returns a new #DBusServer.
* dbus_server_set_new_connection_function() and
* dbus_server_set_watch_functions() should be called
void _dbus_transport_finalize_base (DBusTransport *transport);
+typedef enum
+{
+ DBUS_TRANSPORT_OPEN_NOT_HANDLED, /**< we aren't in charge of this address type */
+ DBUS_TRANSPORT_OPEN_OK, /**< we set up the listen */
+ DBUS_TRANSPORT_OPEN_BAD_ADDRESS, /**< malformed address */
+ DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT /**< well-formed address but failed to set it up */
+} DBusTransportOpenResult;
+
+DBusTransportOpenResult _dbus_transport_open_platform_specific (DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error);
DBUS_END_DECLS
return NULL;
}
+DBusTransportOpenResult
+_dbus_transport_open_socket(DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error)
+{
+ const char *method;
+
+ method = dbus_address_entry_get_method (entry);
+ _dbus_assert (method != NULL);
+
+ if (strcmp (method, "tcp") == 0)
+ {
+ const char *host = dbus_address_entry_get_value (entry, "host");
+ const char *port = dbus_address_entry_get_value (entry, "port");
+ DBusString str;
+ long lport;
+ dbus_bool_t sresult;
+
+ if (port == NULL)
+ {
+ _dbus_set_bad_address (error, "tcp", "port", NULL);
+ return DBUS_TRANSPORT_OPEN_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)
+ {
+ _dbus_set_bad_address (error, NULL, NULL,
+ "Port is not an integer between 0 and 65535");
+ return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
+ }
+
+ *transport_p = _dbus_transport_new_for_tcp_socket (host, lport, error);
+ if (*transport_p == NULL)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_OK;
+ }
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
+ }
+}
+
/** @} */
#ifndef DBUS_TRANSPORT_SOCKET_H
#define DBUS_TRANSPORT_SOCKET_H
-#include <dbus/dbus-transport.h>
+#include <dbus/dbus-transport-protected.h>
DBUS_BEGIN_DECLS
-DBusTransport* _dbus_transport_new_for_socket (int fd,
- const DBusString *server_guid,
- const DBusString *address);
-DBusTransport* _dbus_transport_new_for_tcp_socket (const char *host,
- dbus_int32_t port,
- DBusError *error);
+DBusTransport* _dbus_transport_new_for_socket (int fd,
+ const DBusString *server_guid,
+ const DBusString *address);
+DBusTransport* _dbus_transport_new_for_tcp_socket (const char *host,
+ dbus_int32_t port,
+ DBusError *error);
+DBusTransportOpenResult _dbus_transport_open_socket (DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error);
+
DBUS_END_DECLS
#include "dbus-internals.h"
#include "dbus-connection-internal.h"
#include "dbus-transport-unix.h"
+#include "dbus-transport-socket.h"
#include "dbus-transport-protected.h"
#include "dbus-watch.h"
#include "dbus-sysdeps-unix.h"
return NULL;
}
+DBusTransportOpenResult
+_dbus_transport_open_platform_specific (DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error)
+{
+ const char *method;
+
+ method = dbus_address_entry_get_method (entry);
+ _dbus_assert (method != NULL);
+
+ if (strcmp (method, "unix") == 0)
+ {
+ const char *path = dbus_address_entry_get_value (entry, "path");
+ const char *tmpdir = dbus_address_entry_get_value (entry, "tmpdir");
+ const char *abstract = dbus_address_entry_get_value (entry, "abstract");
+
+ if (tmpdir != NULL)
+ {
+ _dbus_set_bad_address (error, NULL, NULL,
+ "cannot use the \"tmpdir\" option for an address to connect to, only in an address to listen on");
+ return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
+ }
+
+ if (path == NULL && abstract == NULL)
+ {
+ _dbus_set_bad_address (error, "unix",
+ "path or abstract",
+ NULL);
+ return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
+ }
+
+ if (path != NULL && abstract != NULL)
+ {
+ _dbus_set_bad_address (error, NULL, NULL,
+ "can't specify both \"path\" and \"abstract\" options in an address");
+ return DBUS_TRANSPORT_OPEN_BAD_ADDRESS;
+ }
+
+ if (path)
+ *transport_p = _dbus_transport_new_for_domain_socket (path, FALSE,
+ error);
+ else
+ *transport_p = _dbus_transport_new_for_domain_socket (abstract, TRUE,
+ error);
+ if (*transport_p == NULL)
+ {
+ _DBUS_ASSERT_ERROR_IS_SET (error);
+ return DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT;
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_OK;
+ }
+ }
+ else
+ {
+ _DBUS_ASSERT_ERROR_IS_CLEAR (error);
+ return DBUS_TRANSPORT_OPEN_NOT_HANDLED;
+ }
+}
+
/** @} */
dbus_free (transport->expected_guid);
}
+static const struct {
+ DBusTransportOpenResult (* func) (DBusAddressEntry *entry,
+ DBusTransport **transport_p,
+ DBusError *error);
+} open_funcs[] = {
+ { _dbus_transport_open_socket },
+ { _dbus_transport_open_platform_specific }
+#ifdef DBUS_BUILD_TESTS
+ , { _dbus_transport_open_debug_pipe }
+#endif
+};
+
/**
* Try to open a new transport for the given address entry. (This
* opens a client-side-of-the-connection transport.)
DBusError *error)
{
DBusTransport *transport;
- const char *address_problem_type;
- const char *address_problem_field;
- const char *address_problem_other;
- const char *method;
const char *expected_guid_orig;
char *expected_guid;
-
+ int i;
+ DBusError tmp_error;
+
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
transport = NULL;
- address_problem_type = NULL;
- address_problem_field = NULL;
- address_problem_other = NULL;
expected_guid_orig = dbus_address_entry_get_value (entry, "guid");
expected_guid = _dbus_strdup (expected_guid_orig);
_DBUS_SET_OOM (error);
return NULL;
}
-
- method = dbus_address_entry_get_method (entry);
- _dbus_assert (method != NULL);
-
- if (strcmp (method, "unix") == 0)
- {
- const char *path = dbus_address_entry_get_value (entry, "path");
- const char *tmpdir = dbus_address_entry_get_value (entry, "tmpdir");
- const char *abstract = dbus_address_entry_get_value (entry, "abstract");
-
- if (tmpdir != NULL)
- {
- address_problem_other = "cannot use the \"tmpdir\" option for an address to connect to, only in an address to listen on";
- goto bad_address;
- }
-
- if (path == NULL && abstract == NULL)
- {
- address_problem_type = "unix";
- address_problem_field = "path or abstract";
- goto bad_address;
- }
-
- if (path != NULL && abstract != NULL)
- {
- address_problem_other = "can't specify both \"path\" and \"abstract\" options in an address";
- goto bad_address;
- }
- if (path)
- transport = _dbus_transport_new_for_domain_socket (path, FALSE,
- error);
- else
- transport = _dbus_transport_new_for_domain_socket (abstract, TRUE,
- error);
- }
- else if (strcmp (method, "tcp") == 0)
+ dbus_error_init (&tmp_error);
+ for (i = 0; i < (int) _DBUS_N_ELEMENTS (open_funcs); ++i)
{
- const char *host = dbus_address_entry_get_value (entry, "host");
- const char *port = dbus_address_entry_get_value (entry, "port");
- DBusString str;
- long lport;
- dbus_bool_t sresult;
-
- if (port == NULL)
- {
- address_problem_type = "tcp";
- address_problem_field = "port";
- goto bad_address;
- }
+ DBusTransportOpenResult result;
- _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)
- {
- address_problem_other = "Port is not an integer between 0 and 65535";
- goto bad_address;
- }
-
- transport = _dbus_transport_new_for_tcp_socket (host, lport, error);
- }
-#ifdef DBUS_BUILD_TESTS
- else if (strcmp (method, "debug-pipe") == 0)
- {
- const char *name = dbus_address_entry_get_value (entry, "name");
+ _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
+ result = (* open_funcs[i].func) (entry, &transport, &tmp_error);
- if (name == NULL)
+ switch (result)
{
- address_problem_type = "debug-pipe";
- address_problem_field = "name";
- goto bad_address;
+ case DBUS_TRANSPORT_OPEN_OK:
+ _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
+ goto out;
+ break;
+ case DBUS_TRANSPORT_OPEN_NOT_HANDLED:
+ _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
+ /* keep going through the loop of open funcs */
+ break;
+ case DBUS_TRANSPORT_OPEN_BAD_ADDRESS:
+ _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
+ goto out;
+ break;
+ case DBUS_TRANSPORT_OPEN_DID_NOT_CONNECT:
+ _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
+ goto out;
+ break;
}
-
- transport = _dbus_transport_debug_pipe_new (name, error);
- }
-#endif
- else
- {
- address_problem_other = "Unknown address type (examples of valid types are \"unix\" and \"tcp\")";
- goto bad_address;
}
+ out:
+
if (transport == NULL)
{
- _DBUS_ASSERT_ERROR_IS_SET (error);
+ if (!dbus_error_is_set (&tmp_error))
+ _dbus_set_bad_address (&tmp_error,
+ NULL, NULL,
+ "Unknown address type (examples of valid types are \"tcp\" and on UNIX \"unix\")");
+
+ _DBUS_ASSERT_ERROR_IS_SET (&tmp_error);
+ dbus_move_error(&tmp_error, error);
dbus_free (expected_guid);
}
else
{
+ _DBUS_ASSERT_ERROR_IS_CLEAR (&tmp_error);
transport->expected_guid = expected_guid;
}
-
- return transport;
-
- bad_address:
- dbus_free (expected_guid);
-
- 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;
+ return transport;
}
/**
projects / platform / upstream / dbus.git / commitdiff