X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dbus%2Fdbus-transport.c;h=6b503721aaa8c1407c08645b3471fb45e32d99c5;hb=bb8dd7fec5389db4df9b5e8863974149e8a650dc;hp=bec4a5acf84dbcdc73f47a9e2026e56c8166080f;hpb=df89cfeb3808acc213c9620db6988611a34207c5;p=platform%2Fupstream%2Fdbus.git diff --git a/dbus/dbus-transport.c b/dbus/dbus-transport.c index bec4a5a..6b50372 100644 --- a/dbus/dbus-transport.c +++ b/dbus/dbus-transport.c @@ -2,6 +2,7 @@ /* dbus-transport.c DBusTransport object (internal to D-Bus implementation) * * Copyright (C) 2002, 2003 Red Hat Inc. + * Copyright (C) 2013 Samsung Electronics * * Licensed under the Academic Free License version 2.1 * @@ -21,7 +22,8 @@ * */ -#include + +#include <../config.h> #include "dbus-transport-protected.h" #include "dbus-transport-unix.h" #include "dbus-transport-socket.h" @@ -30,9 +32,12 @@ #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" +#ifdef ENABLE_KDBUS_TRANSPORT +#include "dbus-transport-kdbus.h" +#endif +#ifdef DBUS_ENABLE_EMBEDDED_TESTS #include "dbus-server-debug-pipe.h" #endif @@ -71,12 +76,16 @@ live_messages_notify (DBusCounter *counter, _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); } @@ -113,7 +122,21 @@ _dbus_transport_init_base (DBusTransport *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; + } +#ifdef ENABLE_KDBUS_TRANSPORT + if(address_copy == strstr(address_copy, "kdbus:path=")) + auth = _dbus_auth_client_new_kdbus(); + else +#endif + auth = _dbus_auth_client_new (); + } + if (auth == NULL) { _dbus_message_loader_unref (loader); @@ -142,19 +165,6 @@ _dbus_transport_init_base (DBusTransport *transport, _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; @@ -238,6 +248,7 @@ _dbus_transport_finalize_base (DBusTransport *transport) * 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. */ @@ -249,7 +260,6 @@ check_address (const char *address, DBusError *error) 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 */ @@ -269,11 +279,12 @@ check_address (const char *address, DBusError *error) * 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; @@ -286,7 +297,7 @@ _dbus_transport_new_for_autolaunch (DBusError *error) 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; @@ -315,7 +326,9 @@ _dbus_transport_open_autolaunch (DBusAddressEntry *entry, 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) { @@ -340,10 +353,13 @@ static const struct { DBusTransport **transport_p, DBusError *error); } open_funcs[] = { +#ifdef ENABLE_KDBUS_TRANSPORT + { _dbus_transport_open_kdbus }, +#endif { _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 }; @@ -475,7 +491,7 @@ _dbus_transport_unref (DBusTransport *transport) 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); @@ -494,7 +510,7 @@ _dbus_transport_unref (DBusTransport *transport) void _dbus_transport_disconnect (DBusTransport *transport) { - _dbus_verbose ("%s start\n", _DBUS_FUNCTION_NAME); + _dbus_verbose ("start\n"); _dbus_assert (transport->vtable->disconnect != NULL); @@ -505,7 +521,7 @@ _dbus_transport_disconnect (DBusTransport *transport) transport->disconnected = TRUE; - _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME); + _dbus_verbose ("end\n"); } /** @@ -542,14 +558,14 @@ auth_via_unix_user_function (DBusTransport *transport) 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) @@ -593,14 +609,14 @@ auth_via_windows_user_function (DBusTransport *transport) 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) @@ -679,10 +695,33 @@ auth_via_default_rules (DBusTransport *transport) 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. @@ -691,7 +730,7 @@ auth_via_default_rules (DBusTransport *transport) * @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; @@ -739,17 +778,6 @@ _dbus_transport_get_is_authenticated (DBusTransport *transport) _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. @@ -851,6 +879,8 @@ _dbus_transport_get_server_id (DBusTransport *transport) { if (transport->is_server) return NULL; + else if (transport->authenticated) + return _dbus_auth_get_guid_from_server (transport->auth); else return transport->expected_guid; } @@ -981,7 +1011,7 @@ _dbus_transport_do_iteration (DBusTransport *transport, timeout_milliseconds); _dbus_transport_unref (transport); - _dbus_verbose ("%s end\n", _DBUS_FUNCTION_NAME); + _dbus_verbose ("end\n"); } static dbus_bool_t @@ -993,7 +1023,7 @@ recover_unused_bytes (DBusTransport *transport) const DBusString *encoded; DBusString *buffer; int orig_len; - + if (!_dbus_string_init (&plaintext)) goto nomem; @@ -1006,12 +1036,12 @@ recover_unused_bytes (DBusTransport *transport) _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)) { @@ -1043,7 +1073,7 @@ recover_unused_bytes (DBusTransport *transport) &buffer); orig_len = _dbus_string_get_length (buffer); - + _dbus_auth_get_unused_bytes (transport->auth, &bytes); @@ -1087,12 +1117,12 @@ _dbus_transport_get_dispatch_status (DBusTransport *transport) _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; } @@ -1150,6 +1180,13 @@ _dbus_transport_queue_messages (DBusTransport *transport) } 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); @@ -1334,7 +1371,7 @@ _dbus_transport_get_unix_process_id (DBusTransport *transport, 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 @@ -1488,4 +1525,26 @@ _dbus_transport_set_allow_anonymous (DBusTransport *transport, 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 */ + /** @} */