*
*/
+#include <../config.h>
#include "dbus-transport-protected.h"
#include "dbus-transport-unix.h"
#include "dbus-transport-socket.h"
#include "dbus-auth.h"
#include "dbus-address.h"
#include "dbus-credentials.h"
-#include "dbus-message-private.h"
-#include "dbus-marshal-header.h"
-#ifdef DBUS_BUILD_TESTS
+#include "dbus-mainloop.h"
+#include "dbus-message.h"
+#include "dbus-transport-kdbus.h"
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
#include "dbus-server-debug-pipe.h"
#endif
_dbus_verbose ("Unix FD counter value is now %d\n",
(int) _dbus_counter_get_unix_fd_value (counter));
#endif
-
+
/* disable or re-enable the read watch for the transport if
* required.
*/
if (transport->vtable->live_messages_changed)
- (* transport->vtable->live_messages_changed) (transport);
+ {
+ _dbus_connection_lock (transport->connection);
+ (* transport->vtable->live_messages_changed) (transport);
+ _dbus_connection_unlock (transport->connection);
+ }
_dbus_transport_unref (transport);
}
if (server_guid)
auth = _dbus_auth_server_new (server_guid);
else
- auth = _dbus_auth_client_new ();
+ {
+ _dbus_assert (address != NULL);
+ if (!_dbus_string_copy_data (address, &address_copy))
+ {
+ _dbus_message_loader_unref (loader);
+ return FALSE;
+ }
+ if(address_copy == strstr(address_copy, "kdbus:path="))
+ auth = _dbus_auth_client_new_kdbus();
+ else
+ auth = _dbus_auth_client_new ();
+ }
+
if (auth == NULL)
{
_dbus_message_loader_unref (loader);
_dbus_assert (address == NULL);
address_copy = NULL;
}
- else
- {
- _dbus_assert (address != NULL);
-
- if (!_dbus_string_copy_data (address, &address_copy))
- {
- _dbus_credentials_unref (creds);
- _dbus_counter_unref (counter);
- _dbus_auth_unref (auth);
- _dbus_message_loader_unref (loader);
- return FALSE;
- }
- }
transport->refcount = 1;
transport->vtable = vtable;
* opened DBusTransport object. If it isn't, returns #NULL
* and sets @p error.
*
+ * @param address the address to be checked.
* @param error address where an error can be returned.
* @returns a new transport, or #NULL on failure.
*/
int len, i;
_dbus_assert (address != NULL);
- _dbus_assert (*address != '\0');
if (!dbus_parse_address (address, &entries, &len, error))
return NULL; /* not a valid address */
* Creates a new transport for the "autostart" method.
* This creates a client-side of a transport.
*
+ * @param scope scope of autolaunch (Windows only)
* @param error address where an error can be returned.
* @returns a new transport, or #NULL on failure.
*/
static DBusTransport*
-_dbus_transport_new_for_autolaunch (DBusError *error)
+_dbus_transport_new_for_autolaunch (const char *scope, DBusError *error)
{
DBusString address;
DBusTransport *result = NULL;
return NULL;
}
- if (!_dbus_get_autolaunch_address (&address, error))
+ if (!_dbus_get_autolaunch_address (scope, &address, error))
{
_DBUS_ASSERT_ERROR_IS_SET (error);
goto out;
if (strcmp (method, "autolaunch") == 0)
{
- *transport_p = _dbus_transport_new_for_autolaunch (error);
+ const char *scope = dbus_address_entry_get_value (entry, "scope");
+
+ *transport_p = _dbus_transport_new_for_autolaunch (scope, error);
if (*transport_p == NULL)
{
DBusTransport **transport_p,
DBusError *error);
} open_funcs[] = {
+ { _dbus_transport_open_kdbus },
{ _dbus_transport_open_socket },
{ _dbus_transport_open_platform_specific },
{ _dbus_transport_open_autolaunch }
-#ifdef DBUS_BUILD_TESTS
+#ifdef DBUS_ENABLE_EMBEDDED_TESTS
, { _dbus_transport_open_debug_pipe }
#endif
};
transport->refcount -= 1;
if (transport->refcount == 0)
{
- _dbus_verbose ("%s: finalizing\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("finalizing\n");
_dbus_assert (transport->vtable->finalize != NULL);
void
_dbus_transport_disconnect (DBusTransport *transport)
{
- _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("start\n");
_dbus_assert (transport->vtable->disconnect != NULL);
transport->disconnected = TRUE;
- _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("end\n");
}
/**
unix_user_data = transport->unix_user_data;
uid = _dbus_credentials_get_unix_uid (auth_identity);
- _dbus_verbose ("unlock %s\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("unlock\n");
_dbus_connection_unlock (connection);
allow = (* unix_user_function) (connection,
uid,
unix_user_data);
- _dbus_verbose ("lock %s post unix user function\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("lock post unix user function\n");
_dbus_connection_lock (connection);
if (allow)
return FALSE;
}
- _dbus_verbose ("unlock %s\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("unlock\n");
_dbus_connection_unlock (connection);
allow = (* windows_user_function) (connection,
windows_sid,
windows_user_data);
- _dbus_verbose ("lock %s post windows user function\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("lock post windows user function\n");
_dbus_connection_lock (connection);
if (allow)
return allow;
}
+/**
+ * Returns #TRUE if we have been authenticated. It will return #TRUE even if
+ * the transport is now disconnected, but was ever authenticated before
+ * disconnecting.
+ *
+ * This replaces the older _dbus_transport_get_is_authenticated() which
+ * had side-effects.
+ *
+ * @param transport the transport
+ * @returns whether we're authenticated
+ */
+dbus_bool_t
+_dbus_transport_peek_is_authenticated (DBusTransport *transport)
+{
+ return transport->authenticated;
+}
/**
- * Returns #TRUE if we have been authenticated. Will return #TRUE
- * even if the transport is disconnected.
+ * Returns #TRUE if we have been authenticated. It will return #TRUE even if
+ * the transport is now disconnected, but was ever authenticated before
+ * disconnecting.
+ *
+ * If we have not finished authenticating, but we have enough buffered input
+ * to finish the job, then this function will do so before it returns.
+ *
+ * This used to be called _dbus_transport_get_is_authenticated(), but that
+ * name seems inappropriate for a function with side-effects.
*
* @todo we drop connection->mutex when calling the unix_user_function,
* and windows_user_function, which may not be safe really.
* @returns whether we're authenticated
*/
dbus_bool_t
-_dbus_transport_get_is_authenticated (DBusTransport *transport)
+_dbus_transport_try_to_authenticate (DBusTransport *transport)
{
if (transport->authenticated)
return TRUE;
_dbus_connection_unref_unlocked (transport->connection);
return FALSE;
}
-
- if (transport->expected_guid == NULL)
- {
- transport->expected_guid = _dbus_strdup (server_guid);
-
- if (transport->expected_guid == NULL)
- {
- _dbus_verbose ("No memory to complete auth in %s\n", _DBUS_FUNCTION_NAME);
- return FALSE;
- }
- }
}
/* If we're the server, see if we want to allow this identity to proceed.
{
if (transport->is_server)
return NULL;
+ else if (transport->authenticated)
+ return _dbus_auth_get_guid_from_server (transport->auth);
else
return transport->expected_guid;
}
timeout_milliseconds);
_dbus_transport_unref (transport);
- _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME);
+ _dbus_verbose ("end\n");
}
static dbus_bool_t
const DBusString *encoded;
DBusString *buffer;
int orig_len;
-
+
if (!_dbus_string_init (&plaintext))
goto nomem;
_dbus_string_free (&plaintext);
goto nomem;
}
-
+
_dbus_message_loader_get_buffer (transport->loader,
&buffer);
orig_len = _dbus_string_get_length (buffer);
-
+
if (!_dbus_string_move (&plaintext, 0, buffer,
orig_len))
{
&buffer);
orig_len = _dbus_string_get_length (buffer);
-
+
_dbus_auth_get_unused_bytes (transport->auth,
&bytes);
_dbus_counter_get_unix_fd_value (transport->live_messages) >= transport->max_live_messages_unix_fds)
return DBUS_DISPATCH_COMPLETE; /* complete for now */
- if (!_dbus_transport_get_is_authenticated (transport))
+ if (!_dbus_transport_try_to_authenticate (transport))
{
if (_dbus_auth_do_work (transport->auth) ==
DBUS_AUTH_STATE_WAITING_FOR_MEMORY)
return DBUS_DISPATCH_NEED_MEMORY;
- else if (!_dbus_transport_get_is_authenticated (transport))
+ else if (!_dbus_transport_try_to_authenticate (transport))
return DBUS_DISPATCH_COMPLETE;
}
}
else
{
+ /* We didn't call the notify function when we added the counter, so
+ * catch up now. Since we have the connection's lock, it's desirable
+ * that we bypass the notify function and call this virtual method
+ * directly. */
+ if (transport->vtable->live_messages_changed)
+ (* transport->vtable->live_messages_changed) (transport);
+
/* pass ownership of link and message ref to connection */
_dbus_connection_queue_received_message_link (transport->connection,
link);
if (_dbus_credentials_include (auth_identity,
DBUS_CREDENTIAL_UNIX_PROCESS_ID))
{
- *pid = _dbus_credentials_get_unix_pid (auth_identity);
+ *pid = _dbus_credentials_get_pid (auth_identity);
return TRUE;
}
else
transport->allow_anonymous = value != FALSE;
}
+#ifdef DBUS_ENABLE_STATS
+void
+_dbus_transport_get_stats (DBusTransport *transport,
+ dbus_uint32_t *queue_bytes,
+ dbus_uint32_t *queue_fds,
+ dbus_uint32_t *peak_queue_bytes,
+ dbus_uint32_t *peak_queue_fds)
+{
+ if (queue_bytes != NULL)
+ *queue_bytes = _dbus_counter_get_size_value (transport->live_messages);
+
+ if (queue_fds != NULL)
+ *queue_fds = _dbus_counter_get_unix_fd_value (transport->live_messages);
+
+ if (peak_queue_bytes != NULL)
+ *peak_queue_bytes = _dbus_counter_get_peak_size_value (transport->live_messages);
+
+ if (peak_queue_fds != NULL)
+ *peak_queue_fds = _dbus_counter_get_peak_unix_fd_value (transport->live_messages);
+}
+#endif /* DBUS_ENABLE_STATS */
+
/** @} */