Make it pass the Hello handling test including all OOM codepaths.
Now to do other messages...
* bus/services.c (bus_service_remove_owner): fix crash when
removing owner from an empty list of owners
(bus_registry_ensure): don't leave service in the list of
a connection's owned services if we fail to put the service
in the hash table.
* bus/connection.c (bus_connection_preallocate_oom_error): set
error flag on the OOM error.
* dbus/dbus-connection.c (_dbus_connection_new_for_transport):
handle _dbus_transport_set_connection failure
* dbus/dbus-transport-unix.c (_dbus_transport_new_for_fd): modify
to create watches up front and simply enable/disable them as
needed.
(unix_connection_set): this can now fail on OOM
* dbus/dbus-timeout.c, dbus/dbus-watch.c: add concept
of enabling/disabling a watch or timeout.
* bus/loop.c (bus_loop_iterate): don't touch disabled
watches/timeouts
* glib/dbus-gmain.c: adapt to enable/disable watches and timeouts
2003-03-15 Havoc Pennington <hp@pobox.com>
+ Make it pass the Hello handling test including all OOM codepaths.
+ Now to do other messages...
+
+ * bus/services.c (bus_service_remove_owner): fix crash when
+ removing owner from an empty list of owners
+ (bus_registry_ensure): don't leave service in the list of
+ a connection's owned services if we fail to put the service
+ in the hash table.
+
+ * bus/connection.c (bus_connection_preallocate_oom_error): set
+ error flag on the OOM error.
+
+ * dbus/dbus-connection.c (_dbus_connection_new_for_transport):
+ handle _dbus_transport_set_connection failure
+
+ * dbus/dbus-transport-unix.c (_dbus_transport_new_for_fd): modify
+ to create watches up front and simply enable/disable them as
+ needed.
+ (unix_connection_set): this can now fail on OOM
+
+ * dbus/dbus-timeout.c, dbus/dbus-watch.c: add concept
+ of enabling/disabling a watch or timeout.
+
+ * bus/loop.c (bus_loop_iterate): don't touch disabled
+ watches/timeouts
+
+ * glib/dbus-gmain.c: adapt to enable/disable watches and timeouts
+
+2003-03-15 Havoc Pennington <hp@pobox.com>
+
* bus/dispatch.c (bus_dispatch_test): OK, now finally actually
write useful test code, after all that futzing around ;-)
if (!dbus_server_set_watch_functions (context->server,
(DBusAddWatchFunction) add_server_watch,
(DBusRemoveWatchFunction) remove_server_watch,
+ NULL,
context,
NULL))
{
if (!dbus_server_set_timeout_functions (context->server,
(DBusAddTimeoutFunction) add_server_timeout,
(DBusRemoveTimeoutFunction) remove_server_timeout,
+ NULL,
context, NULL))
{
BUS_SET_OOM (error);
return;
if (!dbus_server_set_watch_functions (context->server,
- NULL, NULL,
+ NULL, NULL, NULL,
context,
NULL))
_dbus_assert_not_reached ("setting watch functions to NULL failed");
if (!dbus_server_set_timeout_functions (context->server,
- NULL, NULL,
+ NULL, NULL, NULL,
context,
NULL))
_dbus_assert_not_reached ("setting timeout functions to NULL failed");
/* no more watching */
if (!dbus_connection_set_watch_functions (connection,
- NULL, NULL,
+ NULL, NULL, NULL,
connection,
NULL))
_dbus_assert_not_reached ("setting watch functions to NULL failed");
if (!dbus_connection_set_timeout_functions (connection,
- NULL, NULL,
+ NULL, NULL, NULL,
connection,
NULL))
_dbus_assert_not_reached ("setting timeout functions to NULL failed");
if (!dbus_connection_set_watch_functions (connection,
(DBusAddWatchFunction) add_connection_watch,
(DBusRemoveWatchFunction) remove_connection_watch,
+ NULL,
connection,
NULL))
{
if (!dbus_connection_set_timeout_functions (connection,
(DBusAddTimeoutFunction) add_connection_timeout,
(DBusRemoveTimeoutFunction) remove_connection_timeout,
+ NULL,
connection, NULL))
{
dbus_connection_disconnect (connection);
return FALSE;
}
+ dbus_message_set_is_error (message, TRUE);
+
/* set reply serial to placeholder value just so space is already allocated
* for it.
*/
BusConnectionData *d;
DBusList *link;
+ _dbus_verbose (" trying to add message %s to transaction\n",
+ dbus_message_get_name (message));
+
if (!dbus_connection_get_is_connected (connection))
return TRUE; /* silently ignore disconnected connections */
_dbus_assert (error != NULL);
_DBUS_ASSERT_ERROR_IS_SET (error);
+
+ _dbus_verbose (" trying to add error %s to transaction\n",
+ error->name);
reply = dbus_message_new_error_reply (in_reply_to,
error->name,
if (!bus_setup_debug_client (connection))
{
+ dbus_connection_disconnect (connection);
dbus_connection_unref (connection);
return TRUE;
}
&error);
if (context == NULL)
_dbus_assert_not_reached ("could not alloc context");
-
- check1_try_iterations (context, "create_and_hello",
- check_hello_connection);
foo = dbus_connection_open ("debug-pipe:name=test-server", &result);
if (foo == NULL)
if (!check_hello_message (context, baz))
_dbus_assert_not_reached ("hello message failed");
+ check1_try_iterations (context, "create_and_hello",
+ check_hello_connection);
+
+ dbus_connection_disconnect (foo);
dbus_connection_unref (foo);
+ dbus_connection_disconnect (bar);
dbus_connection_unref (bar);
+ dbus_connection_disconnect (baz);
dbus_connection_unref (baz);
return TRUE;
bus_loop_quit ();
goto next_iteration;
}
+
+ /* count enabled watches */
+ n_fds = 0;
+ link = _dbus_list_get_first_link (&callbacks);
+ while (link != NULL)
+ {
+ DBusList *next = _dbus_list_get_next_link (&callbacks, link);
+ Callback *cb = link->data;
+ if (cb->type == CALLBACK_WATCH)
+ {
+ WatchCallback *wcb = WATCH_CALLBACK (cb);
+
+ if (dbus_watch_get_enabled (wcb->watch))
+ ++n_fds;
+ }
- n_fds = watch_count;
+ link = next;
+ }
+ /* fill our array of fds and watches */
if (n_fds > 0)
{
fds = dbus_new0 (DBusPollFD, n_fds);
{
unsigned int flags;
WatchCallback *wcb = WATCH_CALLBACK (cb);
+
+ if (dbus_watch_get_enabled (wcb->watch))
+ {
+ watches_for_fds[i] = wcb;
- watches_for_fds[i] = wcb;
-
- flags = dbus_watch_get_flags (wcb->watch);
+ flags = dbus_watch_get_flags (wcb->watch);
- fds[i].fd = dbus_watch_get_fd (wcb->watch);
- if (flags & DBUS_WATCH_READABLE)
- fds[i].events |= _DBUS_POLLIN;
- if (flags & DBUS_WATCH_WRITABLE)
- fds[i].events |= _DBUS_POLLOUT;
+ fds[i].fd = dbus_watch_get_fd (wcb->watch);
+ if (flags & DBUS_WATCH_READABLE)
+ fds[i].events |= _DBUS_POLLIN;
+ if (flags & DBUS_WATCH_WRITABLE)
+ fds[i].events |= _DBUS_POLLOUT;
- ++i;
+ ++i;
+ }
}
link = next;
DBusList *next = _dbus_list_get_next_link (&callbacks, link);
Callback *cb = link->data;
- if (cb->type == CALLBACK_TIMEOUT)
+ if (cb->type == CALLBACK_TIMEOUT &&
+ dbus_timeout_get_enabled (TIMEOUT_CALLBACK (cb)->timeout))
{
TimeoutCallback *tcb = TIMEOUT_CALLBACK (cb);
unsigned long interval;
if (exited)
goto next_iteration;
- if (cb->type == CALLBACK_TIMEOUT)
+ if (cb->type == CALLBACK_TIMEOUT &&
+ dbus_timeout_get_enabled (TIMEOUT_CALLBACK (cb)->timeout))
{
TimeoutCallback *tcb = TIMEOUT_CALLBACK (cb);
unsigned long interval;
* weird POLLFOO thing like POLLWRBAND
*/
- if (condition != 0)
+ if (condition != 0 &&
+ dbus_watch_get_enabled (wcb->watch))
{
(* wcb->function) (wcb->watch,
condition,
service->name,
service))
{
+ bus_connection_remove_owned_service (owner_if_created,
+ service);
_dbus_list_clear (&service->owners);
dbus_free (service->name);
_dbus_mem_pool_dealloc (registry->service_pool, service);
return FALSE;
}
- if (_dbus_list_length_is_one (&service->owners))
+ if (service->owners == NULL)
+ {
+ _dbus_assert_not_reached ("Tried to remove owner of a service that has no owners");
+ }
+ else if (_dbus_list_length_is_one (&service->owners))
{
/* We are the only owner - send service deleted */
if (!bus_driver_send_service_deleted (service->name,
{
DBusList *link;
link = _dbus_list_get_first (&service->owners);
+ _dbus_assert (link != NULL);
link = _dbus_list_get_next_link (&service->owners, link);
if (link != NULL)
if (service->owners == NULL)
{
/* Delete service (already sent message that it was deleted above) */
- _dbus_hash_table_remove_string (service->registry->service_hash, service->name);
+ _dbus_hash_table_remove_string (service->registry->service_hash,
+ service->name);
dbus_free (service->name);
_dbus_mem_pool_dealloc (service->registry->service_pool, service);
if (!dbus_connection_set_watch_functions (connection,
(DBusAddWatchFunction) add_client_watch,
(DBusRemoveWatchFunction) remove_client_watch,
+ NULL,
connection,
NULL))
goto out;
if (!dbus_connection_set_timeout_functions (connection,
(DBusAddTimeoutFunction) add_client_timeout,
(DBusRemoveTimeoutFunction) remove_client_timeout,
+ NULL,
connection, NULL))
goto out;
_DBUS_N_ELEMENTS (to_handle));
dbus_connection_set_watch_functions (connection,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL, NULL);
dbus_connection_set_timeout_functions (connection,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL, NULL);
}
dbus_message_handler_unref (disconnect_handler);
DBusWatch *watch);
void _dbus_connection_remove_watch (DBusConnection *connection,
DBusWatch *watch);
+void _dbus_connection_toggle_watch (DBusConnection *connection,
+ DBusWatch *watch,
+ dbus_bool_t enabled);
dbus_bool_t _dbus_connection_add_timeout (DBusConnection *connection,
DBusTimeout *timeout);
void _dbus_connection_remove_timeout (DBusConnection *connection,
DBusTimeout *timeout);
+void _dbus_connection_toggle_timeout (DBusConnection *connection,
+ DBusTimeout *timeout,
+ dbus_bool_t enabled);
DBusConnection* _dbus_connection_new_for_transport (DBusTransport *transport);
void _dbus_connection_do_iteration (DBusConnection *connection,
}
/**
+ * Toggles a watch and notifies app via connection's
+ * DBusWatchToggledFunction if available. It's an error to call this
+ * function on a watch that was not previously added.
+ *
+ * @param connection the connection.
+ * @param timeout the timeout to toggle.
+ * @param enabled whether to enable or disable
+ */
+void
+_dbus_connection_toggle_watch (DBusConnection *connection,
+ DBusWatch *watch,
+ dbus_bool_t enabled)
+{
+ if (connection->watches) /* null during finalize */
+ _dbus_watch_list_toggle_watch (connection->watches,
+ watch, enabled);
+}
+
+/**
* Adds a timeout using the connection's DBusAddTimeoutFunction if
* available. Otherwise records the timeout to be added when said
* function is available. Also re-adds the timeout if the
dbus_mutex_unlock (connection->mutex);
}
+/**
+ * Toggles a timeout and notifies app via connection's
+ * DBusTimeoutToggledFunction if available. It's an error to call this
+ * function on a timeout that was not previously added.
+ *
+ * @param connection the connection.
+ * @param timeout the timeout to toggle.
+ * @param enabled whether to enable or disable
+ */
+void
+_dbus_connection_toggle_timeout (DBusConnection *connection,
+ DBusTimeout *timeout,
+ dbus_bool_t enabled)
+{
+ if (connection->timeouts) /* null during finalize */
+ _dbus_timeout_list_toggle_timeout (connection->timeouts,
+ timeout, enabled);
+}
/**
* Tells the connection that the transport has been disconnected.
connection->disconnect_message_link = disconnect_link;
- _dbus_transport_ref (transport);
- _dbus_transport_set_connection (transport, connection);
+ if (!_dbus_transport_set_connection (transport, connection))
+ goto error;
+
+ _dbus_transport_ref (transport);
return connection;
* poll(). When using Qt, typically the DBusAddWatchFunction would
* create a QSocketNotifier. When using GLib, the DBusAddWatchFunction
* could call g_io_add_watch(), or could be used as part of a more
- * elaborate GSource.
- *
+ * elaborate GSource. Note that when a watch is added, it may
+ * not be enabled.
+ *
+ * The DBusWatchToggledFunction notifies the application that the
+ * watch has been enabled or disabled. Call dbus_watch_get_enabled()
+ * to check this. A disabled watch should have no effect, and enabled
+ * watch should be added to the main loop. This feature is used
+ * instead of simply adding/removing the watch because
+ * enabling/disabling can be done without memory allocation. The
+ * toggled function may be NULL if a main loop re-queries
+ * dbus_watch_get_enabled() every time anyway.
+ *
* The DBusWatch can be queried for the file descriptor to watch using
* dbus_watch_get_fd(), and for the events to watch for using
* dbus_watch_get_flags(). The flags returned by
* @param connection the connection.
* @param add_function function to begin monitoring a new descriptor.
* @param remove_function function to stop monitoring a descriptor.
+ * @param toggled_function function to notify of enable/disable
* @param data data to pass to add_function and remove_function.
* @param free_data_function function to be called to free the data.
* @returns #FALSE on failure (no memory)
dbus_connection_set_watch_functions (DBusConnection *connection,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
+ DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function)
{
retval = _dbus_watch_list_set_functions (connection->watches,
add_function, remove_function,
+ toggled_function,
data, free_data_function);
dbus_mutex_unlock (connection->mutex);
* When using Qt, typically the DBusAddTimeoutFunction would create a
* QTimer. When using GLib, the DBusAddTimeoutFunction would call
* g_timeout_add.
+ *
+ * The DBusTimeoutToggledFunction notifies the application that the
+ * timeout has been enabled or disabled. Call
+ * dbus_timeout_get_enabled() to check this. A disabled timeout should
+ * have no effect, and enabled timeout should be added to the main
+ * loop. This feature is used instead of simply adding/removing the
+ * timeout because enabling/disabling can be done without memory
+ * allocation. With Qt, QTimer::start() and QTimer::stop() can be used
+ * to enable and disable. The toggled function may be NULL if a main
+ * loop re-queries dbus_timeout_get_enabled() every time anyway.
*
* The DBusTimeout can be queried for the timer interval using
* dbus_timeout_get_interval(). dbus_timeout_handle() should
* @param connection the connection.
* @param add_function function to add a timeout.
* @param remove_function function to remove a timeout.
+ * @param toggled_function function to notify of enable/disable
* @param data data to pass to add_function and remove_function.
* @param free_data_function function to be called to free the data.
* @returns #FALSE on failure (no memory)
dbus_connection_set_timeout_functions (DBusConnection *connection,
DBusAddTimeoutFunction add_function,
DBusRemoveTimeoutFunction remove_function,
+ DBusTimeoutToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function)
{
retval = _dbus_timeout_list_set_functions (connection->timeouts,
add_function, remove_function,
+ toggled_function,
data, free_data_function);
dbus_mutex_unlock (connection->mutex);
* can be present in current state). */
} DBusWatchFlags;
-typedef dbus_bool_t (* DBusAddWatchFunction) (DBusWatch *watch,
- void *data);
-typedef void (* DBusRemoveWatchFunction) (DBusWatch *watch,
- void *data);
-typedef void (* DBusWakeupMainFunction) (void *data);
-typedef dbus_bool_t (* DBusAddTimeoutFunction) (DBusTimeout *timeout,
- void *data);
-typedef void (* DBusRemoveTimeoutFunction) (DBusTimeout *timeout,
- void *data);
+typedef dbus_bool_t (* DBusAddWatchFunction) (DBusWatch *watch,
+ void *data);
+typedef void (* DBusWatchToggledFunction) (DBusWatch *watch,
+ void *data);
+typedef void (* DBusRemoveWatchFunction) (DBusWatch *watch,
+ void *data);
+typedef void (* DBusWakeupMainFunction) (void *data);
+typedef dbus_bool_t (* DBusAddTimeoutFunction) (DBusTimeout *timeout,
+ void *data);
+typedef void (* DBusTimeoutToggledFunction) (DBusTimeout *timeout,
+ void *data);
+typedef void (* DBusRemoveTimeoutFunction) (DBusTimeout *timeout,
+ void *data);
DBusConnection* dbus_connection_open (const char *address,
DBusResultCode *result);
dbus_bool_t dbus_connection_set_watch_functions (DBusConnection *connection,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
+ DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
dbus_bool_t dbus_connection_set_timeout_functions (DBusConnection *connection,
DBusAddTimeoutFunction add_function,
DBusRemoveTimeoutFunction remove_function,
+ DBusTimeoutToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
void dbus_connection_set_wakeup_main_function (DBusConnection *connection,
-int dbus_watch_get_fd (DBusWatch *watch);
-unsigned int dbus_watch_get_flags (DBusWatch *watch);
-void* dbus_watch_get_data (DBusWatch *watch);
-void dbus_watch_set_data (DBusWatch *watch,
- void *data,
- DBusFreeFunction free_data_function);
-
-int dbus_timeout_get_interval (DBusTimeout *timeout);
-void* dbus_timeout_get_data (DBusTimeout *timeout);
-void dbus_timeout_set_data (DBusTimeout *timeout,
- void *data,
- DBusFreeFunction free_data_function);
-void dbus_timeout_handle (DBusTimeout *timeout);
+int dbus_watch_get_fd (DBusWatch *watch);
+unsigned int dbus_watch_get_flags (DBusWatch *watch);
+void* dbus_watch_get_data (DBusWatch *watch);
+void dbus_watch_set_data (DBusWatch *watch,
+ void *data,
+ DBusFreeFunction free_data_function);
+dbus_bool_t dbus_watch_get_enabled (DBusWatch *watch);
+int dbus_timeout_get_interval (DBusTimeout *timeout);
+void* dbus_timeout_get_data (DBusTimeout *timeout);
+void dbus_timeout_set_data (DBusTimeout *timeout,
+ void *data,
+ DBusFreeFunction free_data_function);
+void dbus_timeout_handle (DBusTimeout *timeout);
+dbus_bool_t dbus_timeout_get_enabled (DBusTimeout *timeout);
/* Handlers */
dbus_bool_t dbus_connection_add_filter (DBusConnection *connection,
};
dbus_bool_t _dbus_server_init_base (DBusServer *server,
- const DBusServerVTable *vtable);
+ const DBusServerVTable *vtable);
void _dbus_server_finalize_base (DBusServer *server);
dbus_bool_t _dbus_server_add_watch (DBusServer *server,
- DBusWatch *watch);
+ DBusWatch *watch);
void _dbus_server_remove_watch (DBusServer *server,
- DBusWatch *watch);
+ DBusWatch *watch);
+void _dbus_server_toggle_watch (DBusServer *server,
+ DBusWatch *watch,
+ dbus_bool_t enabled);
dbus_bool_t _dbus_server_add_timeout (DBusServer *server,
- DBusTimeout *timeout);
+ DBusTimeout *timeout);
void _dbus_server_remove_timeout (DBusServer *server,
- DBusTimeout *timeout);
+ DBusTimeout *timeout);
+void _dbus_server_toggle_timeout (DBusServer *server,
+ DBusTimeout *timeout,
+ dbus_bool_t enabled);
DBusWatch *watch;
watch = _dbus_watch_new (fd,
- DBUS_WATCH_READABLE);
+ DBUS_WATCH_READABLE,
+ TRUE);
if (watch == NULL)
return NULL;
}
/**
+ * Toggles a watch and notifies app via server's
+ * DBusWatchToggledFunction if available. It's an error to call this
+ * function on a watch that was not previously added.
+ *
+ * @param server the server.
+ * @param timeout the timeout to toggle.
+ * @param enabled whether to enable or disable
+ */
+void
+_dbus_server_toggle_watch (DBusServer *server,
+ DBusWatch *watch,
+ dbus_bool_t enabled)
+{
+ if (server->watches) /* null during finalize */
+ _dbus_watch_list_toggle_watch (server->watches,
+ watch, enabled);
+}
+
+/**
* Adds a timeout for this server, chaining out to
* application-provided timeout handlers. The timeout should be
* repeatedly handled with dbus_timeout_handle() at its given interval
_dbus_timeout_list_remove_timeout (server->timeouts, timeout);
}
+/**
+ * Toggles a timeout and notifies app via server's
+ * DBusTimeoutToggledFunction if available. It's an error to call this
+ * function on a timeout that was not previously added.
+ *
+ * @param server the server.
+ * @param timeout the timeout to toggle.
+ * @param enabled whether to enable or disable
+ */
+void
+_dbus_server_toggle_timeout (DBusServer *server,
+ DBusTimeout *timeout,
+ dbus_bool_t enabled)
+{
+ if (server->timeouts) /* null during finalize */
+ _dbus_timeout_list_toggle_timeout (server->timeouts,
+ timeout, enabled);
+}
+
+
/** @} */
/**
* @param server the server.
* @param add_function function to begin monitoring a new descriptor.
* @param remove_function function to stop monitoring a descriptor.
+ * @param toggled_function function to notify when the watch is enabled/disabled
* @param data data to pass to add_function and remove_function.
* @param free_data_function function to be called to free the data.
* @returns #FALSE on failure (no memory)
dbus_server_set_watch_functions (DBusServer *server,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
+ DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function)
{
return _dbus_watch_list_set_functions (server->watches,
add_function,
remove_function,
+ toggled_function,
data,
free_data_function);
}
* @param server the server.
* @param add_function function to add a timeout.
* @param remove_function function to remove a timeout.
+ * @param toggled_function function to notify when the timeout is enabled/disabled
* @param data data to pass to add_function and remove_function.
* @param free_data_function function to be called to free the data.
* @returns #FALSE on failure (no memory)
dbus_server_set_timeout_functions (DBusServer *server,
DBusAddTimeoutFunction add_function,
DBusRemoveTimeoutFunction remove_function,
+ DBusTimeoutToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function)
{
return _dbus_timeout_list_set_functions (server->timeouts,
add_function, remove_function,
+ toggled_function,
data, free_data_function);
}
dbus_bool_t dbus_server_set_watch_functions (DBusServer *server,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
+ DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
dbus_bool_t dbus_server_set_timeout_functions (DBusServer *server,
DBusAddTimeoutFunction add_function,
DBusRemoveTimeoutFunction remove_function,
+ DBusTimeoutToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
void dbus_server_handle_watch (DBusServer *server,
void *data; /**< Application data. */
DBusFreeFunction free_data_function; /**< Free the application data. */
+ unsigned int enabled : 1; /**< True if timeout is active. */
};
/**
timeout->handler = handler;
timeout->handler_data = data;
timeout->free_handler_data_function = free_data_function;
+
+ timeout->enabled = TRUE;
return timeout;
}
DBusAddTimeoutFunction add_timeout_function; /**< Callback for adding a timeout. */
DBusRemoveTimeoutFunction remove_timeout_function; /**< Callback for removing a timeout. */
+ DBusTimeoutToggledFunction timeout_toggled_function; /**< Callback when timeout is enabled/disabled */
void *timeout_data; /**< Data for timeout callbacks */
DBusFreeFunction timeout_free_data_function; /**< Free function for timeout callback data */
};
{
/* free timeout_data and remove timeouts as a side effect */
_dbus_timeout_list_set_functions (timeout_list,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL, NULL);
_dbus_list_foreach (&timeout_list->timeouts,
(DBusForeachFunction) _dbus_timeout_unref,
* @param timeout_list the timeout list
* @param add_function the add timeout function.
* @param remove_function the remove timeout function.
+ * @param toggled_function toggle notify function, or #NULL
* @param data the data for those functions.
* @param free_data_function the function to free the data.
* @returns #FALSE if no memory
_dbus_timeout_list_set_functions (DBusTimeoutList *timeout_list,
DBusAddTimeoutFunction add_function,
DBusRemoveTimeoutFunction remove_function,
+ DBusTimeoutToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function)
{
timeout_list->add_timeout_function = add_function;
timeout_list->remove_timeout_function = remove_function;
+ timeout_list->timeout_toggled_function = toggled_function;
timeout_list->timeout_data = data;
timeout_list->timeout_free_data_function = free_data_function;
_dbus_timeout_unref (timeout);
}
+/**
+ * Sets a timeout to the given enabled state, invoking the
+ * application's DBusTimeoutToggledFunction if appropriate.
+ *
+ * @param timeout_list the timeout list.
+ * @param timeout the timeout to toggle.
+ * @param enabled #TRUE to enable
+ */
+void
+_dbus_timeout_list_toggle_timeout (DBusTimeoutList *timeout_list,
+ DBusTimeout *timeout,
+ dbus_bool_t enabled)
+{
+ enabled = !!enabled;
+
+ if (enabled == timeout->enabled)
+ return;
+
+ timeout->enabled = enabled;
+
+ if (timeout_list->timeout_toggled_function != NULL)
+ (* timeout_list->timeout_toggled_function) (timeout,
+ timeout_list->timeout_data);
+}
+
/** @} */
/**
{
(* timeout->handler) (timeout->handler_data);
}
+
+
+/**
+ * Returns whether a timeout is enabled or not. If not
+ * enabled, it should not be polled by the main loop.
+ *
+ * @param timeout the DBusTimeout object
+ * @returns #TRUE if the timeout is enabled
+ */
+dbus_bool_t
+dbus_timeout_get_enabled (DBusTimeout *timeout)
+{
+ return timeout->enabled;
+}
+
+/** @} end public API docs */
dbus_bool_t _dbus_timeout_list_set_functions (DBusTimeoutList *timeout_list,
DBusAddTimeoutFunction add_function,
DBusRemoveTimeoutFunction remove_function,
+ DBusTimeoutToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
dbus_bool_t _dbus_timeout_list_add_timeout (DBusTimeoutList *timeout_list,
DBusTimeout *timeout);
void _dbus_timeout_list_remove_timeout (DBusTimeoutList *timeout_list,
DBusTimeout *timeout);
+void _dbus_timeout_list_toggle_timeout (DBusTimeoutList *timeout_list,
+ DBusTimeout *timeout,
+ dbus_bool_t enabled);
DBUS_END_DECLS;
{
if (!debug_transport->timeout_added)
{
- /* FIXME; messages_pending is going to have to
- * handle OOM somehow (probably being part of
- * PreallocatedSend). See also dbus-transport-unix.c
- * check_write_watch()
+ /* FIXME this can be fixed now, by enabling/disabling
+ * the timeout instead of adding it here
*/
while (!_dbus_connection_add_timeout (transport->connection,
debug_transport->timeout))
{
}
-static void
+static dbus_bool_t
debug_connection_set (DBusTransport *transport)
{
check_timeout (transport);
+ return TRUE;
}
static void
void (* disconnect) (DBusTransport *transport);
/**< Disconnect this transport. */
- void (* connection_set) (DBusTransport *transport);
+ dbus_bool_t (* connection_set) (DBusTransport *transport);
/**< Called when transport->connection has been filled in */
void (* messages_pending) (DBusTransport *transport,
if (transport->connection == NULL)
return;
+
+ if (transport->disconnected)
+ {
+ _dbus_assert (unix_transport->write_watch == NULL);
+ return;
+ }
_dbus_transport_ref (transport);
need_write_watch = transport->send_credentials_pending ||
_dbus_auth_do_work (transport->auth) == DBUS_AUTH_STATE_HAVE_BYTES_TO_SEND;
- if (transport->disconnected)
- need_write_watch = FALSE;
-
- if (need_write_watch &&
- unix_transport->write_watch == NULL)
- {
- unix_transport->write_watch =
- _dbus_watch_new (unix_transport->fd,
- DBUS_WATCH_WRITABLE);
-
- /* FIXME this is total crack. The proper fix is probably to
- * allocate the write watch on transport creation, keep it
- * allocated. But that doesn't solve needing memory to add the
- * watch. messages_pending is going to have to handle OOM
- * somehow (probably being part of PreallocatedSend)
- */
- if (unix_transport->write_watch == NULL)
- goto out;
+ _dbus_connection_toggle_watch (transport->connection,
+ unix_transport->write_watch,
+ need_write_watch);
- if (!_dbus_connection_add_watch (transport->connection,
- unix_transport->write_watch))
- {
- _dbus_watch_invalidate (unix_transport->write_watch);
- _dbus_watch_unref (unix_transport->write_watch);
- unix_transport->write_watch = NULL;
- }
- }
- else if (!need_write_watch &&
- unix_transport->write_watch != NULL)
- {
- _dbus_connection_remove_watch (transport->connection,
- unix_transport->write_watch);
- _dbus_watch_invalidate (unix_transport->write_watch);
- _dbus_watch_unref (unix_transport->write_watch);
- unix_transport->write_watch = NULL;
- }
- else
- {
-#if 0
- _dbus_verbose ("Write watch is unchanged from %p on fd %d\n",
- unix_transport->write_watch, unix_transport->fd);
-#endif
- }
-
- out:
_dbus_transport_unref (transport);
}
if (transport->connection == NULL)
return;
+
+ if (transport->disconnected)
+ {
+ _dbus_assert (unix_transport->read_watch == NULL);
+ return;
+ }
_dbus_transport_ref (transport);
need_read_watch = transport->receive_credentials_pending ||
_dbus_auth_do_work (transport->auth) == DBUS_AUTH_STATE_WAITING_FOR_INPUT;
-#if 0
- _dbus_verbose ("need_read_watch = %d authenticated = %d\n",
- need_read_watch, _dbus_transport_get_is_authenticated (transport));
-#endif
-
- if (transport->disconnected)
- need_read_watch = FALSE;
-
- if (need_read_watch &&
- unix_transport->read_watch == NULL)
- {
- _dbus_verbose ("Adding read watch to unix fd %d\n",
- unix_transport->fd);
-
- unix_transport->read_watch =
- _dbus_watch_new (unix_transport->fd,
- DBUS_WATCH_READABLE);
+ _dbus_connection_toggle_watch (transport->connection,
+ unix_transport->read_watch,
+ need_read_watch);
- /* we can maybe add it some other time, just silently bomb */
- if (unix_transport->read_watch == NULL)
- goto out;
-
- if (!_dbus_connection_add_watch (transport->connection,
- unix_transport->read_watch))
- {
- _dbus_watch_invalidate (unix_transport->read_watch);
- _dbus_watch_unref (unix_transport->read_watch);
- unix_transport->read_watch = NULL;
- }
- }
- else if (!need_read_watch &&
- unix_transport->read_watch != NULL)
- {
- _dbus_verbose ("Removing read watch from unix fd %d\n",
- unix_transport->fd);
-
- _dbus_connection_remove_watch (transport->connection,
- unix_transport->read_watch);
- _dbus_watch_invalidate (unix_transport->read_watch);
- _dbus_watch_unref (unix_transport->read_watch);
- unix_transport->read_watch = NULL;
- }
- else
- {
-#if 0
- _dbus_verbose ("Read watch is unchanged from %p on fd %d\n",
- unix_transport->read_watch, unix_transport->fd);
-#endif
- }
-
- out:
_dbus_transport_unref (transport);
}
unix_transport->fd = -1;
}
-static void
+static dbus_bool_t
unix_connection_set (DBusTransport *transport)
{
+ DBusTransportUnix *unix_transport = (DBusTransportUnix*) transport;
+
+ if (!_dbus_connection_add_watch (transport->connection,
+ unix_transport->write_watch))
+ return FALSE;
+
+ if (!_dbus_connection_add_watch (transport->connection,
+ unix_transport->read_watch))
+ {
+ _dbus_connection_remove_watch (transport->connection,
+ unix_transport->write_watch);
+ return FALSE;
+ }
+
check_read_watch (transport);
check_write_watch (transport);
+
+ return TRUE;
}
static void
if (!_dbus_string_init (&unix_transport->encoded_message,
_DBUS_INT_MAX))
- {
- dbus_free (unix_transport);
- return NULL;
- }
+ goto failed_0;
+
+ unix_transport->write_watch = _dbus_watch_new (fd,
+ DBUS_WATCH_WRITABLE,
+ FALSE);
+ if (unix_transport->write_watch == NULL)
+ goto failed_1;
+
+ unix_transport->read_watch = _dbus_watch_new (fd,
+ DBUS_WATCH_READABLE,
+ FALSE);
+ if (unix_transport->read_watch == NULL)
+ goto failed_2;
if (!_dbus_transport_init_base (&unix_transport->base,
&unix_vtable,
server))
- {
- _dbus_string_free (&unix_transport->encoded_message);
- dbus_free (unix_transport);
- return NULL;
- }
+ goto failed_3;
unix_transport->fd = fd;
unix_transport->message_bytes_written = 0;
/* These values should probably be tunable or something. */
unix_transport->max_bytes_read_per_iteration = 2048;
unix_transport->max_bytes_written_per_iteration = 2048;
-
- check_read_watch ((DBusTransport*) unix_transport);
- check_write_watch ((DBusTransport*) unix_transport);
return (DBusTransport*) unix_transport;
+
+ failed_3:
+ _dbus_watch_unref (unix_transport->read_watch);
+ failed_2:
+ _dbus_watch_unref (unix_transport->write_watch);
+ failed_1:
+ _dbus_string_free (&unix_transport->encoded_message);
+ failed_0:
+ dbus_free (unix_transport);
+ return NULL;
}
/**
*
* @param transport the transport.
* @param connection the connection.
+ * @returns #FALSE if not enough memory
*/
-void
+dbus_bool_t
_dbus_transport_set_connection (DBusTransport *transport,
DBusConnection *connection)
{
transport->connection = connection;
_dbus_transport_ref (transport);
- (* transport->vtable->connection_set) (transport);
+ if (!(* transport->vtable->connection_set) (transport))
+ transport->connection = NULL;
_dbus_transport_unref (transport);
+
+ return transport->connection != NULL;
}
/**
void _dbus_transport_handle_watch (DBusTransport *transport,
DBusWatch *watch,
unsigned int condition);
-void _dbus_transport_set_connection (DBusTransport *transport,
+dbus_bool_t _dbus_transport_set_connection (DBusTransport *transport,
DBusConnection *connection);
void _dbus_transport_messages_pending (DBusTransport *transport,
int queue_length);
/* -*- mode: C; c-file-style: "gnu" -*- */
/* dbus-watch.c DBusWatch implementation
*
- * Copyright (C) 2002 Red Hat Inc.
+ * Copyright (C) 2002, 2003 Red Hat Inc.
*
* Licensed under the Academic Free License version 1.2
*
unsigned int flags; /**< Conditions to watch. */
void *data; /**< Application data. */
DBusFreeFunction free_data_function; /**< Free the application data. */
+ unsigned int enabled : 1; /**< Whether it's enabled. */
};
/**
* implementation.
* @param fd the file descriptor to be watched.
* @param flags the conditions to watch for on the descriptor.
+ * @param enabled the initial enabled state
* @returns the new DBusWatch object.
*/
DBusWatch*
_dbus_watch_new (int fd,
- unsigned int flags)
+ unsigned int flags,
+ dbus_bool_t enabled)
{
DBusWatch *watch;
watch->refcount = 1;
watch->fd = fd;
watch->flags = flags;
+ watch->enabled = enabled;
return watch;
}
DBusAddWatchFunction add_watch_function; /**< Callback for adding a watch. */
DBusRemoveWatchFunction remove_watch_function; /**< Callback for removing a watch. */
+ DBusWatchToggledFunction watch_toggled_function; /**< Callback on toggling enablement */
void *watch_data; /**< Data for watch callbacks */
DBusFreeFunction watch_free_data_function; /**< Free function for watch callback data */
};
{
/* free watch_data and removes watches as a side effect */
_dbus_watch_list_set_functions (watch_list,
- NULL, NULL, NULL, NULL);
+ NULL, NULL, NULL, NULL, NULL);
_dbus_list_foreach (&watch_list->watches,
(DBusForeachFunction) _dbus_watch_unref,
* @param watch_list the watch list.
* @param add_function the add watch function.
* @param remove_function the remove watch function.
+ * @param toggled_function function on toggling enabled flag, or #NULL
* @param data the data for those functions.
* @param free_data_function the function to free the data.
* @returns #FALSE if not enough memory
_dbus_watch_list_set_functions (DBusWatchList *watch_list,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
+ DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function)
{
watch_list->add_watch_function = add_function;
watch_list->remove_watch_function = remove_function;
+ watch_list->watch_toggled_function = toggled_function;
watch_list->watch_data = data;
watch_list->watch_free_data_function = free_data_function;
_dbus_watch_unref (watch);
}
+/**
+ * Sets a watch to the given enabled state, invoking the
+ * application's DBusWatchToggledFunction if appropriate.
+ *
+ * @param watch_list the watch list.
+ * @param watch the watch to toggle.
+ * @param enabled #TRUE to enable
+ */
+void
+_dbus_watch_list_toggle_watch (DBusWatchList *watch_list,
+ DBusWatch *watch,
+ dbus_bool_t enabled)
+{
+ enabled = !!enabled;
+
+ if (enabled == watch->enabled)
+ return;
+
+ watch->enabled = enabled;
+
+ if (watch_list->watch_toggled_function != NULL)
+ (* watch_list->watch_toggled_function) (watch,
+ watch_list->watch_data);
+}
+
/** @} */
/**
watch->free_data_function = free_data_function;
}
+/**
+ * Returns whether a watch is enabled or not. If not
+ * enabled, it should not be polled by the main loop.
+ *
+ * @param watch the DBusWatch object
+ * @returns #TRUE if the watch is enabled
+ */
+dbus_bool_t
+dbus_watch_get_enabled (DBusWatch *watch)
+{
+ return watch->enabled;
+}
+
/** @} */
typedef struct DBusWatchList DBusWatchList;
DBusWatch* _dbus_watch_new (int fd,
- unsigned int flags);
+ unsigned int flags,
+ dbus_bool_t enabled);
void _dbus_watch_ref (DBusWatch *watch);
void _dbus_watch_unref (DBusWatch *watch);
void _dbus_watch_invalidate (DBusWatch *watch);
dbus_bool_t _dbus_watch_list_set_functions (DBusWatchList *watch_list,
DBusAddWatchFunction add_function,
DBusRemoveWatchFunction remove_function,
+ DBusWatchToggledFunction toggled_function,
void *data,
DBusFreeFunction free_data_function);
dbus_bool_t _dbus_watch_list_add_watch (DBusWatchList *watch_list,
DBusWatch *watch);
void _dbus_watch_list_remove_watch (DBusWatchList *watch_list,
DBusWatch *watch);
-
+void _dbus_watch_list_toggle_watch (DBusWatchList *watch_list,
+ DBusWatch *watch,
+ dbus_bool_t enabled);
DBUS_END_DECLS;
GPollFD *poll_fd;
DBusGSource *dbus_source;
guint flags;
+
+ if (!dbus_watch_get_enabled (watch))
+ return TRUE;
dbus_source = data;
GPollFD *poll_fd;
poll_fd = dbus_watch_get_data (watch);
+ if (poll_fd == NULL)
+ return; /* probably a not-enabled watch that was added */
dbus_source->poll_fds = g_list_remove (dbus_source->poll_fds, poll_fd);
g_hash_table_remove (dbus_source->watches, poll_fd);
g_free (poll_fd);
}
+static void
+watch_toggled (DBusWatch *watch,
+ void *data)
+{
+ /* Because we just exit on OOM, enable/disable is
+ * no different from add/remove
+ */
+ if (dbus_watch_get_enabled (watch))
+ add_watch (watch, data);
+ else
+ remove_watch (watch, data);
+}
+
static gboolean
timeout_handler (gpointer data)
{
{
guint timeout_tag;
+ if (!dbus_timeout_get_enabled (timeout))
+ return TRUE;
+
timeout_tag = g_timeout_add (dbus_timeout_get_interval (timeout),
timeout_handler, timeout);
guint timeout_tag;
timeout_tag = GPOINTER_TO_UINT (dbus_timeout_get_data (timeout));
-
- g_source_remove (timeout_tag);
+
+ if (timeout_tag != 0) /* if 0, probably timeout was disabled */
+ g_source_remove (timeout_tag);
+}
+
+static void
+timeout_toggled (DBusTimeout *timeout,
+ void *data)
+{
+ /* Because we just exit on OOM, enable/disable is
+ * no different from add/remove
+ */
+ if (dbus_timeout_get_enabled (timeout))
+ add_timeout (timeout, data);
+ else
+ remove_timeout (timeout, data);
}
+
static void
free_source (GSource *source)
{
if (!dbus_connection_set_watch_functions (connection,
add_watch,
remove_watch,
+ watch_toggled,
source, NULL))
goto nomem;
if (!dbus_connection_set_timeout_functions (connection,
add_timeout,
remove_timeout,
+ timeout_toggled,
NULL, NULL))
goto nomem;
dbus_server_set_watch_functions (server,
add_watch,
remove_watch,
+ watch_toggled,
source, NULL);
dbus_server_set_timeout_functions (server,
add_timeout,
remove_timeout,
+ timeout_toggled,
NULL, NULL);
g_source_attach (source, NULL);
while (link != NULL)
{
DBusList *next = _dbus_list_get_next_link (&watches, link);
- int fd;
DBusWatch *watch;
- unsigned int flags;
watch = link->data;
-
- fd = dbus_watch_get_fd (watch);
- flags = dbus_watch_get_flags (watch);
-
- max_fd = MAX (max_fd, fd);
-
- if (flags & DBUS_WATCH_READABLE)
- FD_SET (fd, &read_set);
-
- if (flags & DBUS_WATCH_WRITABLE)
- FD_SET (fd, &write_set);
- FD_SET (fd, &err_set);
+ if (dbus_watch_get_enabled (watch))
+ {
+ int fd;
+ unsigned int flags;
+
+ fd = dbus_watch_get_fd (watch);
+ flags = dbus_watch_get_flags (watch);
+
+ max_fd = MAX (max_fd, fd);
+
+ if (flags & DBUS_WATCH_READABLE)
+ FD_SET (fd, &read_set);
+
+ if (flags & DBUS_WATCH_WRITABLE)
+ FD_SET (fd, &write_set);
+
+ FD_SET (fd, &err_set);
+ }
link = next;
}
while (link != NULL)
{
DBusList *next = _dbus_list_get_next_link (&watches, link);
- int fd;
DBusWatch *watch;
- unsigned int flags;
- unsigned int condition;
if (initial_watch_serial != watch_list_serial)
{
}
watch = link->data;
+
+ if (dbus_watch_get_enabled (watch))
+ {
+ int fd;
+ unsigned int flags;
+ unsigned int condition;
+
- fd = dbus_watch_get_fd (watch);
- flags = dbus_watch_get_flags (watch);
+ fd = dbus_watch_get_fd (watch);
+ flags = dbus_watch_get_flags (watch);
- condition = 0;
+ condition = 0;
- if ((flags & DBUS_WATCH_READABLE) &&
- FD_ISSET (fd, &read_set))
- condition |= DBUS_WATCH_READABLE;
+ if ((flags & DBUS_WATCH_READABLE) &&
+ FD_ISSET (fd, &read_set))
+ condition |= DBUS_WATCH_READABLE;
- if ((flags & DBUS_WATCH_WRITABLE) &&
- FD_ISSET (fd, &write_set))
- condition |= DBUS_WATCH_WRITABLE;
+ if ((flags & DBUS_WATCH_WRITABLE) &&
+ FD_ISSET (fd, &write_set))
+ condition |= DBUS_WATCH_WRITABLE;
- if (FD_ISSET (fd, &err_set))
- condition |= DBUS_WATCH_ERROR;
+ if (FD_ISSET (fd, &err_set))
+ condition |= DBUS_WATCH_ERROR;
- if (condition != 0)
- {
- WatchData *wd;
+ if (condition != 0)
+ {
+ WatchData *wd;
- wd = dbus_watch_get_data (watch);
+ wd = dbus_watch_get_data (watch);
- if (wd->type == WATCH_CONNECTION)
- {
- DBusConnection *connection = wd->data;
+ if (wd->type == WATCH_CONNECTION)
+ {
+ DBusConnection *connection = wd->data;
- dbus_connection_handle_watch (connection,
+ dbus_connection_handle_watch (connection,
+ watch,
+ condition);
+ }
+ else if (wd->type == WATCH_SERVER)
+ {
+ DBusServer *server = wd->data;
+
+ dbus_server_handle_watch (server,
watch,
condition);
- }
- else if (wd->type == WATCH_SERVER)
- {
- DBusServer *server = wd->data;
-
- dbus_server_handle_watch (server,
- watch,
- condition);
+ }
}
}
if (!dbus_connection_set_watch_functions (connection,
(DBusAddWatchFunction) add_connection_watch,
(DBusRemoveWatchFunction) remove_connection_watch,
+ NULL,
connection,
NULL))
_dbus_assert_not_reached ("not enough memory");
if (!dbus_server_set_watch_functions (server,
(DBusAddWatchFunction) add_server_watch,
(DBusRemoveWatchFunction) remove_server_watch,
+ NULL,
server,
NULL))
_dbus_assert_not_reached ("not enough memory");
projects / platform / upstream / dbus.git / commitdiff