From d6e1b2adb3d8e51ce1bb47295cef12d9fe1a15a8 Mon Sep 17 00:00:00 2001 From: Havoc Pennington Date: Thu, 16 Oct 2003 06:34:51 +0000 Subject: 2003-10-16 Havoc Pennington * bus/connection.c (bus_pending_reply_expired): either cancel or execute, not both (bus_connections_check_reply): use unlink, not remove_link, as we don't want to free the link; fixes double free mess * dbus/dbus-pending-call.c (dbus_pending_call_block): fix in case where no reply was received * dbus/dbus-connection.c (_dbus_pending_call_complete_and_unlock): fix a refcount leak * bus/signals.c (match_rule_matches): add special cases for the bus driver, so you can match on sender/destination for it. * dbus/dbus-sysdeps.c (_dbus_abort): print backtrace if DBUS_PRINT_BACKTRACE is set * dbus/dbus-internals.c: add pid to assertion failure messages * dbus/dbus-connection.c: add message type code to the debug spew * glib/dbus-gproxy.c (gproxy_get_match_rule): match rules want sender=foo not service=foo * dbus/dbus-bus.c (dbus_bus_get): if the activation bus is the session bus but DBUS_SESSION_BUS_ADDRESS isn't set, use DBUS_ACTIVATION_ADDRESS instead * bus/activation.c: set DBUS_SESSION_BUS_ADDRESS, DBUS_SYSTEM_BUS_ADDRESS if appropriate * bus/bus.c (bus_context_new): handle OOM copying bus type into context struct * dbus/dbus-message.c (dbus_message_iter_get_object_path): new function (dbus_message_iter_get_object_path_array): new function (half finished, disabled for the moment) * glib/dbus-gproxy.c (dbus_gproxy_end_call): properly handle DBUS_MESSAGE_TYPE_ERROR * tools/dbus-launch.c (babysit): support DBUS_DEBUG_OUTPUT to avoid redirecting stderr to /dev/null (babysit): close stdin if not doing the "exit_with_session" thing * dbus/dbus-sysdeps.c (_dbus_become_daemon): delete some leftover debug code; change DBUS_DEBUG_OUTPUT to only enable stderr, not stdout/stdin, so things don't get confused * bus/system.conf.in: fix to allow replies, I modified .conf instead of .conf.in again. --- dbus/dbus-bus.c | 27 ++++++++-- dbus/dbus-connection.c | 43 ++++++++++++---- dbus/dbus-internals.c | 8 +-- dbus/dbus-internals.h | 20 ++++---- dbus/dbus-message.c | 126 ++++++++++++++++++++++++++++++++++++++++++++--- dbus/dbus-message.h | 43 ++++++++-------- dbus/dbus-pending-call.c | 6 ++- dbus/dbus-sysdeps.c | 52 +++++++++++-------- 8 files changed, 252 insertions(+), 73 deletions(-) (limited to 'dbus') diff --git a/dbus/dbus-bus.c b/dbus/dbus-bus.c index 0c9f58e1..58df18d3 100644 --- a/dbus/dbus-bus.c +++ b/dbus/dbus-bus.c @@ -143,6 +143,8 @@ init_connections_unlocked (void) if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL) { + _dbus_verbose ("Filling in system bus address...\n"); + if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SYSTEM], "DBUS_SYSTEM_BUS_ADDRESS")) return FALSE; @@ -154,27 +156,44 @@ init_connections_unlocked (void) _dbus_strdup (DBUS_SYSTEM_BUS_DEFAULT_ADDRESS); if (bus_connection_addresses[DBUS_BUS_SYSTEM] == NULL) return FALSE; + + _dbus_verbose (" used default system bus \"%s\"\n", + bus_connection_addresses[DBUS_BUS_SYSTEM]); } + else + _dbus_verbose (" used env var system bus \"%s\"\n", + bus_connection_addresses[DBUS_BUS_SYSTEM]); } if (bus_connection_addresses[DBUS_BUS_SESSION] == NULL) { + _dbus_verbose ("Filling in session bus address...\n"); + if (!get_from_env (&bus_connection_addresses[DBUS_BUS_SESSION], "DBUS_SESSION_BUS_ADDRESS")) return FALSE; + _dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_SESSION] ? + bus_connection_addresses[DBUS_BUS_SESSION] : "none set"); } if (bus_connection_addresses[DBUS_BUS_ACTIVATION] == NULL) { + _dbus_verbose ("Filling in activation bus address...\n"); + if (!get_from_env (&bus_connection_addresses[DBUS_BUS_ACTIVATION], "DBUS_ACTIVATION_ADDRESS")) return FALSE; + + _dbus_verbose (" \"%s\"\n", bus_connection_addresses[DBUS_BUS_ACTIVATION] ? + bus_connection_addresses[DBUS_BUS_ACTIVATION] : "none set"); } s = _dbus_getenv ("DBUS_ACTIVATION_BUS_TYPE"); if (s != NULL) { + _dbus_verbose ("Bus activation type was set to \"%s\"\n", s); + if (strcmp (s, "system") == 0) activation_bus_type = DBUS_BUS_SYSTEM; else if (strcmp (s, "session") == 0) @@ -311,10 +330,12 @@ dbus_bus_get (DBusBusType type, address_type = type; /* Use the real type of the activation bus for getting its - * connection. (If the activating bus isn't a well-known - * bus then activation_bus_type == DBUS_BUS_ACTIVATION) + * connection, but only if the real type's address is available. (If + * the activating bus isn't a well-known bus then + * activation_bus_type == DBUS_BUS_ACTIVATION) */ - if (type == DBUS_BUS_ACTIVATION) + if (type == DBUS_BUS_ACTIVATION && + bus_connection_addresses[activation_bus_type] != NULL) type = activation_bus_type; if (bus_connections[type] != NULL) diff --git a/dbus/dbus-connection.c b/dbus/dbus-connection.c index ed7d57d0..bceef2a6 100644 --- a/dbus/dbus-connection.c +++ b/dbus/dbus-connection.c @@ -344,11 +344,13 @@ _dbus_connection_queue_received_message_link (DBusConnection *connection, _dbus_connection_wakeup_mainloop (connection); - _dbus_verbose ("Message %p (%s) added to incoming queue %p, %d incoming\n", + _dbus_verbose ("Message %p (%d %s '%s') added to incoming queue %p, %d incoming\n", message, + dbus_message_get_type (message), dbus_message_get_interface (message) ? dbus_message_get_interface (message) : "no interface", + dbus_message_get_signature (message), connection, connection->n_incoming); } @@ -430,11 +432,13 @@ _dbus_connection_message_sent (DBusConnection *connection, connection->n_outgoing -= 1; - _dbus_verbose ("Message %p (%s) removed from outgoing queue %p, %d left to send\n", + _dbus_verbose ("Message %p (%d %s '%s') removed from outgoing queue %p, %d left to send\n", message, + dbus_message_get_type (message), dbus_message_get_interface (message) ? dbus_message_get_interface (message) : "no interface", + dbus_message_get_signature (message), connection, connection->n_outgoing); /* Save this link in the link cache also */ @@ -690,12 +694,20 @@ _dbus_pending_call_complete_and_unlock (DBusPendingCall *pending, message = pending->timeout_link->data; _dbus_list_clear (&pending->timeout_link); } + else + dbus_message_ref (message); - _dbus_verbose (" handing message %p to pending call\n", message); + _dbus_verbose (" handing message %p (%s) to pending call serial %u\n", + message, + dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_METHOD_RETURN ? + "method return" : + dbus_message_get_type (message) == DBUS_MESSAGE_TYPE_ERROR ? + "error" : "other type", + pending->reply_serial); _dbus_assert (pending->reply == NULL); + _dbus_assert (pending->reply_serial == dbus_message_get_reply_serial (message)); pending->reply = message; - dbus_message_ref (pending->reply); dbus_pending_call_ref (pending); /* in case there's no app with a ref held */ _dbus_connection_detach_pending_call_and_unlock (pending->connection, pending); @@ -1505,11 +1517,13 @@ _dbus_connection_send_preallocated_unlocked (DBusConnection *connection, connection->n_outgoing += 1; - _dbus_verbose ("Message %p (%s) added to outgoing queue %p, %d pending to send\n", + _dbus_verbose ("Message %p (%d %s '%s') added to outgoing queue %p, %d pending to send\n", message, + dbus_message_get_type (message), dbus_message_get_interface (message) ? dbus_message_get_interface (message) : "no interface", + dbus_message_get_signature (message), connection, connection->n_outgoing); @@ -2178,11 +2192,13 @@ _dbus_connection_pop_message_link_unlocked (DBusConnection *connection) link = _dbus_list_pop_first_link (&connection->incoming_messages); connection->n_incoming -= 1; - _dbus_verbose ("Message %p (%s) removed from incoming queue %p, %d incoming\n", + _dbus_verbose ("Message %p (%d %s '%s') removed from incoming queue %p, %d incoming\n", link->data, + dbus_message_get_type (link->data), dbus_message_get_interface (link->data) ? dbus_message_get_interface (link->data) : "no interface", + dbus_message_get_signature (link->data), connection, connection->n_incoming); return link; @@ -2227,11 +2243,13 @@ _dbus_connection_putback_message_link_unlocked (DBusConnection *connection, message_link); connection->n_incoming += 1; - _dbus_verbose ("Message %p (%s) put back into queue %p, %d incoming\n", + _dbus_verbose ("Message %p (%d %s '%s') put back into queue %p, %d incoming\n", message_link->data, + dbus_message_get_type (message_link->data), dbus_message_get_interface (message_link->data) ? dbus_message_get_interface (message_link->data) : "no interface", + dbus_message_get_signature (message_link->data), connection, connection->n_incoming); } @@ -2558,8 +2576,9 @@ dbus_connection_dispatch (DBusConnection *connection) /* We're still protected from dispatch() reentrancy here * since we acquired the dispatcher */ - _dbus_verbose (" running object path dispatch on message %p (%s)\n", + _dbus_verbose (" running object path dispatch on message %p (%d %s '%s')\n", message, + dbus_message_get_type (message), dbus_message_get_interface (message) ? dbus_message_get_interface (message) : "no interface"); @@ -2625,15 +2644,19 @@ dbus_connection_dispatch (DBusConnection *connection) result = DBUS_HANDLER_RESULT_HANDLED; } - _dbus_verbose (" done dispatching %p (%s) on connection %p\n", message, + _dbus_verbose (" done dispatching %p (%d %s '%s') on connection %p\n", message, + dbus_message_get_type (message), dbus_message_get_interface (message) ? dbus_message_get_interface (message) : "no interface", + dbus_message_get_signature (message), connection); out: if (result == DBUS_HANDLER_RESULT_NEED_MEMORY) { + _dbus_verbose ("out of memory in %s\n", _DBUS_FUNCTION_NAME); + /* Put message back, and we'll start over. * Yes this means handlers must be idempotent if they * don't return HANDLED; c'est la vie. @@ -2643,6 +2666,8 @@ dbus_connection_dispatch (DBusConnection *connection) } else { + _dbus_verbose ("Done with message in %s\n", _DBUS_FUNCTION_NAME); + if (connection->exit_on_disconnect && dbus_message_is_signal (message, DBUS_INTERFACE_ORG_FREEDESKTOP_LOCAL, diff --git a/dbus/dbus-internals.c b/dbus/dbus-internals.c index 44f3ff47..9a2aa2b1 100644 --- a/dbus/dbus-internals.c +++ b/dbus/dbus-internals.c @@ -223,6 +223,8 @@ _dbus_verbose_real (const char *format, va_start (args, format); vfprintf (stderr, format, args); va_end (args); + + fflush (stderr); } /** @@ -424,7 +426,7 @@ _dbus_header_field_to_string (int header_field) #ifndef DBUS_DISABLE_CHECKS /** String used in _dbus_return_if_fail macro */ const char _dbus_return_if_fail_warning_format[] = -"Arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n" +"%lu: arguments to %s() were incorrect, assertion \"%s\" failed in file %s line %d.\n" "This is normally a bug in some application using the D-BUS library.\n"; #endif @@ -448,8 +450,8 @@ _dbus_real_assert (dbus_bool_t condition, { if (!condition) { - _dbus_warn ("Assertion failed \"%s\" file \"%s\" line %d process %lu\n", - condition_text, file, line, _dbus_getpid ()); + _dbus_warn ("%lu: assertion failed \"%s\" file \"%s\" line %d\n", + _dbus_getpid (), condition_text, file, line); _dbus_abort (); } } diff --git a/dbus/dbus-internals.h b/dbus/dbus-internals.h index fa1ad19c..0284da0e 100644 --- a/dbus/dbus-internals.h +++ b/dbus/dbus-internals.h @@ -94,18 +94,18 @@ void _dbus_real_assert_not_reached (const char *explanation, #else extern const char _dbus_return_if_fail_warning_format[]; -#define _dbus_return_if_fail(condition) do { \ - if (!(condition)) { \ - _dbus_warn (_dbus_return_if_fail_warning_format, \ - _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \ - return; \ +#define _dbus_return_if_fail(condition) do { \ + if (!(condition)) { \ + _dbus_warn (_dbus_return_if_fail_warning_format, \ + _dbus_getpid (), _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \ + return; \ } } while (0) -#define _dbus_return_val_if_fail(condition, val) do { \ - if (!(condition)) { \ - _dbus_warn (_dbus_return_if_fail_warning_format, \ - _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \ - return (val); \ +#define _dbus_return_val_if_fail(condition, val) do { \ + if (!(condition)) { \ + _dbus_warn (_dbus_return_if_fail_warning_format, \ + _dbus_getpid (), _DBUS_FUNCTION_NAME, #condition, __FILE__, __LINE__); \ + return (val); \ } } while (0) #endif /* !DBUS_DISABLE_ASSERT */ diff --git a/dbus/dbus-message.c b/dbus/dbus-message.c index c7e0b8cf..4c21946a 100644 --- a/dbus/dbus-message.c +++ b/dbus/dbus-message.c @@ -1870,6 +1870,9 @@ dbus_message_append_args_valist (DBusMessage *message, if (!dbus_message_iter_append_string (&iter, va_arg (var_args, const char *))) goto errorout; break; + case DBUS_TYPE_OBJECT_PATH: + + break; case DBUS_TYPE_NAMED: { const char *name; @@ -2540,7 +2543,10 @@ dbus_message_iter_get_arg_type (DBusMessageIter *iter) _dbus_return_val_if_fail (dbus_message_iter_check (real), DBUS_TYPE_INVALID); if (real->pos >= real->end) - return DBUS_TYPE_INVALID; + { + _dbus_verbose (" iterator at or beyond end of message\n"); + return DBUS_TYPE_INVALID; + } pos = dbus_message_iter_get_data_start (real, &type); @@ -2645,6 +2651,36 @@ dbus_message_iter_get_string (DBusMessageIter *iter) pos, NULL); } +#if 0 +/** + * @todo FIXME to finish this _dbus_demarshal_object_path() needs + * to not explode the path. + * + * Returns the object path value that an iterator may point to. + * Note that you need to check that the iterator points to + * an object path value before using this function. + * + * @see dbus_message_iter_get_arg_type + * @param iter the message iter + * @returns the path + */ +char * +dbus_message_iter_get_object_path (DBusMessageIter *iter) +{ + DBusMessageRealIter *real = (DBusMessageRealIter *)iter; + int type, pos; + + _dbus_return_val_if_fail (dbus_message_iter_check (real), NULL); + + pos = dbus_message_iter_get_data_start (real, &type); + + _dbus_assert (type == DBUS_TYPE_OBJECT_PATH); + + return _dbus_demarshal_object_path (&real->message->body, real->message->byte_order, + pos, NULL); +} +#endif + /** * Returns the name and data from a named type that an * iterator may point to. Note that you need to check that @@ -3226,7 +3262,7 @@ dbus_message_iter_get_double_array (DBusMessageIter *iter, /** * Returns the string array that the iterator may point to. * Note that you need to check that the iterator points - * to a byte array prior to using this function. + * to a string array prior to using this function. * * The returned value is a #NULL-terminated array of strings. * Each string is a separate malloc block, and the array @@ -3262,6 +3298,50 @@ dbus_message_iter_get_string_array (DBusMessageIter *iter, return TRUE; } +#if 0 +/** + * @todo FIXME to implement this _dbus_demarshal_object_path_array() + * needs implementing + * + * Returns the object path array that the iterator may point to. + * Note that you need to check that the iterator points + * to an object path array prior to using this function. + * + * The returned value is a #NULL-terminated array of strings. + * Each string is a separate malloc block, and the array + * itself is a malloc block. You can free this type of + * array with dbus_free_string_array(). + * + * @param iter the iterator + * @param value return location for string values + * @param len return location for length of byte array + * @returns #TRUE on success + */ +dbus_bool_t +dbus_message_iter_get_object_path_array (DBusMessageIter *iter, + char ***value, + int *len) +{ + DBusMessageRealIter *real = (DBusMessageRealIter *)iter; + int type, pos; + + _dbus_return_val_if_fail (dbus_message_iter_check (real), FALSE); + + pos = dbus_message_iter_get_data_start (real, &type); + + _dbus_assert (type == DBUS_TYPE_ARRAY); + + type = iter_get_array_type (real, NULL); + _dbus_assert (type == DBUS_TYPE_OBJECT_PATH); + + if (!_dbus_demarshal_object_path_array (&real->message->body, real->message->byte_order, + pos, NULL, value, len)) + return FALSE; + else + return TRUE; +} +#endif + /** * Returns the key name fot the dict entry that an iterator * may point to. Note that you need to check that the iterator @@ -3664,6 +3744,8 @@ dbus_message_iter_append_double (DBusMessageIter *iter, /** * Appends a UTF-8 string to the message. * + * @todo add return_val_if_fail(UTF-8 is valid) + * * @param iter an iterator pointing to the end of the message * @param value the string * @returns #TRUE on success @@ -3675,7 +3757,7 @@ dbus_message_iter_append_string (DBusMessageIter *iter, DBusMessageRealIter *real = (DBusMessageRealIter *)iter; _dbus_return_val_if_fail (dbus_message_iter_append_check (real), FALSE); - + if (!dbus_message_iter_append_type (real, DBUS_TYPE_STRING)) return FALSE; @@ -4971,7 +5053,11 @@ decode_header_data (const DBusString *data, fields[field].name_offset = pos; fields[field].value_offset = _DBUS_ALIGN_VALUE (pos, 4); - _dbus_verbose ("Found reply serial at offset %d\n", + _dbus_verbose ("Found reply serial %u at offset %d\n", + _dbus_demarshal_uint32 (data, + byte_order, + fields[field].value_offset, + NULL), fields[field].value_offset); break; @@ -6751,6 +6837,8 @@ _dbus_message_test (const char *test_data_dir) const unsigned char our_boolean_array[] = { TRUE, FALSE, TRUE, TRUE, FALSE }; char sig[64]; const char *s; + char *t; + DBusError error; _dbus_assert (sizeof (DBusMessageRealIter) <= sizeof (DBusMessageIter)); @@ -6952,7 +7040,7 @@ _dbus_message_test (const char *test_data_dir) _dbus_assert (strcmp (name1, name2) == 0); - dbus_message_unref (message); + dbus_message_unref (message); dbus_message_unref (copy); message = dbus_message_new_method_call ("org.freedesktop.DBus.TestService", @@ -6999,7 +7087,7 @@ _dbus_message_test (const char *test_data_dir) "data", 5); message_iter_test (message); - + /* Message loader test */ _dbus_message_lock (message); loader = _dbus_message_loader_new (); @@ -7030,6 +7118,7 @@ _dbus_message_test (const char *test_data_dir) _dbus_message_loader_return_buffer (loader, buffer, 1); } + copy = dbus_message_copy (message); /* save for tests below */ dbus_message_unref (message); /* Now pop back the message */ @@ -7051,6 +7140,31 @@ _dbus_message_test (const char *test_data_dir) dbus_message_unref (message); _dbus_message_loader_unref (loader); + message = dbus_message_new_method_return (copy); + if (message == NULL) + _dbus_assert_not_reached ("out of memory\n"); + dbus_message_unref (copy); + + if (!dbus_message_append_args (message, + DBUS_TYPE_STRING, "hello", + DBUS_TYPE_INVALID)) + _dbus_assert_not_reached ("no memory"); + + if (!dbus_message_has_signature (message, "s")) + _dbus_assert_not_reached ("method return has wrong signature"); + + dbus_error_init (&error); + if (!dbus_message_get_args (message, &error, DBUS_TYPE_STRING, + &t, DBUS_TYPE_INVALID)) + + { + _dbus_warn ("Failed to get expected string arg: %s\n", error.message); + exit (1); + } + dbus_free (t); + + dbus_message_unref (message); + /* Now load every message in test_data_dir if we have one */ if (test_data_dir == NULL) return TRUE; diff --git a/dbus/dbus-message.h b/dbus/dbus-message.h index 235bec6d..24955bfa 100644 --- a/dbus/dbus-message.h +++ b/dbus/dbus-message.h @@ -146,28 +146,28 @@ dbus_bool_t dbus_message_iter_get_args_valist (DBusMessageIter *iter, va_list var_args); - -void dbus_message_iter_init (DBusMessage *message, - DBusMessageIter *iter); -dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter); -dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter); -int dbus_message_iter_get_arg_type (DBusMessageIter *iter); -int dbus_message_iter_get_array_type (DBusMessageIter *iter); -unsigned char dbus_message_iter_get_byte (DBusMessageIter *iter); -dbus_bool_t dbus_message_iter_get_boolean (DBusMessageIter *iter); -dbus_int32_t dbus_message_iter_get_int32 (DBusMessageIter *iter); -dbus_uint32_t dbus_message_iter_get_uint32 (DBusMessageIter *iter); +void dbus_message_iter_init (DBusMessage *message, + DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_has_next (DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_next (DBusMessageIter *iter); +int dbus_message_iter_get_arg_type (DBusMessageIter *iter); +int dbus_message_iter_get_array_type (DBusMessageIter *iter); +unsigned char dbus_message_iter_get_byte (DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_get_boolean (DBusMessageIter *iter); +dbus_int32_t dbus_message_iter_get_int32 (DBusMessageIter *iter); +dbus_uint32_t dbus_message_iter_get_uint32 (DBusMessageIter *iter); #ifdef DBUS_HAVE_INT64 -dbus_int64_t dbus_message_iter_get_int64 (DBusMessageIter *iter); -dbus_uint64_t dbus_message_iter_get_uint64 (DBusMessageIter *iter); +dbus_int64_t dbus_message_iter_get_int64 (DBusMessageIter *iter); +dbus_uint64_t dbus_message_iter_get_uint64 (DBusMessageIter *iter); #endif /* DBUS_HAVE_INT64 */ -double dbus_message_iter_get_double (DBusMessageIter *iter); -char * dbus_message_iter_get_string (DBusMessageIter *iter); -char * dbus_message_iter_get_dict_key (DBusMessageIter *iter); -dbus_bool_t dbus_message_iter_get_named (DBusMessageIter *iter, - char **name, - unsigned char **value, - int *len); +double dbus_message_iter_get_double (DBusMessageIter *iter); +char * dbus_message_iter_get_string (DBusMessageIter *iter); +char * dbus_message_iter_get_object_path (DBusMessageIter *iter); +char * dbus_message_iter_get_dict_key (DBusMessageIter *iter); +dbus_bool_t dbus_message_iter_get_named (DBusMessageIter *iter, + char **name, + unsigned char **value, + int *len); void dbus_message_iter_init_array_iterator (DBusMessageIter *iter, DBusMessageIter *array_iter, @@ -200,6 +200,9 @@ dbus_bool_t dbus_message_iter_get_double_array (DBusMessageIter *iter, dbus_bool_t dbus_message_iter_get_string_array (DBusMessageIter *iter, char ***value, int *len); +dbus_bool_t dbus_message_iter_get_object_path_array (DBusMessageIter *iter, + char ***value, + int *len); void dbus_message_append_iter_init (DBusMessage *message, diff --git a/dbus/dbus-pending-call.c b/dbus/dbus-pending-call.c index e0d8e3ee..590f1296 100644 --- a/dbus/dbus-pending-call.c +++ b/dbus/dbus-pending-call.c @@ -293,14 +293,16 @@ dbus_pending_call_block (DBusPendingCall *pending) if (dbus_pending_call_get_completed (pending)) return; - + + /* message may be NULL if no reply */ message = _dbus_connection_block_for_reply (pending->connection, pending->reply_serial, dbus_timeout_get_interval (pending->timeout)); _dbus_connection_lock (pending->connection); _dbus_pending_call_complete_and_unlock (pending, message); - dbus_message_unref (message); + if (message) + dbus_message_unref (message); } static DBusDataSlotAllocator slot_allocator; diff --git a/dbus/dbus-sysdeps.c b/dbus/dbus-sysdeps.c index 5011f224..8e2a9071 100644 --- a/dbus/dbus-sysdeps.c +++ b/dbus/dbus-sysdeps.c @@ -76,6 +76,12 @@ void _dbus_abort (void) { +#ifdef DBUS_ENABLE_VERBOSE_MODE + const char *s; + s = _dbus_getenv ("DBUS_PRINT_BACKTRACE"); + if (s && *s) + _dbus_print_backtrace (); +#endif abort (); _exit (1); /* in case someone manages to ignore SIGABRT */ } @@ -3109,7 +3115,11 @@ _dbus_become_daemon (const DBusString *pidfile, { const char *s; pid_t child_pid; + int dev_null_fd; + + _dbus_verbose ("Becoming a daemon...\n"); + _dbus_verbose ("chdir to /\n"); if (chdir ("/") < 0) { dbus_set_error (error, DBUS_ERROR_FAILED, @@ -3117,59 +3127,61 @@ _dbus_become_daemon (const DBusString *pidfile, return FALSE; } + _dbus_verbose ("forking...\n"); switch ((child_pid = fork ())) { case -1: + _dbus_verbose ("fork failed\n"); dbus_set_error (error, _dbus_error_from_errno (errno), "Failed to fork daemon: %s", _dbus_strerror (errno)); return FALSE; break; case 0: + _dbus_verbose ("in child, closing std file descriptors\n"); - - s = _dbus_getenv ("DBUS_DEBUG_DAEMONIZE"); - if (s != NULL) - kill (_dbus_getpid (), SIGSTOP); + /* silently ignore failures here, if someone + * doesn't have /dev/null we may as well try + * to continue anyhow + */ - s = _dbus_getenv ("DBUS_DEBUG_OUTPUT"); - if (s == NULL || *s == '\0') + dev_null_fd = open ("/dev/null", O_RDWR); + if (dev_null_fd >= 0) { - int dev_null_fd; - - /* silently ignore failures here, if someone - * doesn't have /dev/null we may as well try - * to continue anyhow - */ - - dev_null_fd = open ("/dev/null", O_RDWR); - if (dev_null_fd >= 0) - { - dup2 (dev_null_fd, 0); - dup2 (dev_null_fd, 1); - dup2 (dev_null_fd, 2); - } + dup2 (dev_null_fd, 0); + dup2 (dev_null_fd, 1); + + s = _dbus_getenv ("DBUS_DEBUG_OUTPUT"); + if (s == NULL || *s == '\0') + dup2 (dev_null_fd, 2); + else + _dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n"); } /* Get a predictable umask */ + _dbus_verbose ("setting umask\n"); umask (022); break; default: if (pidfile) { + _dbus_verbose ("parent writing pid file\n"); if (!_dbus_write_pid_file (pidfile, child_pid, error)) { + _dbus_verbose ("pid file write failed, killing child\n"); kill (child_pid, SIGTERM); return FALSE; } } + _dbus_verbose ("parent exiting\n"); _exit (0); break; } + _dbus_verbose ("calling setsid()\n"); if (setsid () == -1) _dbus_assert_not_reached ("setsid() failed"); -- cgit