/** * Called to notify the D-Bus library when a previously-added watch is * ready for reading or writing, or has an exception such as a hangup. * * If this function returns #FALSE, then the file descriptor may still * be ready for reading or writing, but more memory is needed in order * to do the reading or writing. If you ignore the #FALSE return, your * application may spin in a busy loop on the file descriptor until * memory becomes available, but nothing more catastrophic should * happen. * * dbus_watch_handle() cannot be called during the * DBusAddWatchFunction, as the connection will not be ready to handle * that watch yet. * * It is not allowed to reference a DBusWatch after it has been passed * to remove_function. * * @param watch the DBusWatch object. * @param flags the poll condition using #DBusWatchFlags values * @returns #FALSE if there wasn't enough memory */ dbus_bool_t dbus_watch_handle (DBusWatch *watch, unsigned int flags) { #ifndef DBUS_DISABLE_CHECKS if (watch->fd < 0 || watch->flags == 0) { _dbus_warn_check_failed ("Watch is invalid, it should have been removed\n"); return TRUE; } #endif _dbus_return_val_if_fail (watch->fd >= 0 /* fails if watch was removed */, TRUE); _dbus_watch_sanitize_condition (watch, &flags); if (flags == 0) { _dbus_verbose ("After sanitization, watch flags on fd %d were 0\n", watch->fd); return TRUE; } else return (* watch->handler) (watch, flags, watch->handler_data); }
/** * Handles a watch by reading data, writing data, or disconnecting * the transport, as appropriate for the given condition. * * @param transport the transport. * @param watch the watch. * @param condition the current state of the watched file descriptor. * @returns #FALSE if not enough memory to fully handle the watch */ dbus_bool_t _dbus_transport_handle_watch (DBusTransport *transport, DBusWatch *watch, unsigned int condition) { dbus_bool_t retval; _dbus_assert (transport->vtable->handle_watch != NULL); if (transport->disconnected) return TRUE; if (dbus_watch_get_socket (watch) < 0) { _dbus_warn_check_failed ("Tried to handle an invalidated watch; this watch should have been removed\n"); return TRUE; } _dbus_watch_sanitize_condition (watch, &condition); _dbus_transport_ref (transport); _dbus_watch_ref (watch); retval = (* transport->vtable->handle_watch) (transport, watch, condition); _dbus_watch_unref (watch); _dbus_transport_unref (transport); return retval; }
/** * Called to notify the D-Bus library when a previously-added watch is * ready for reading or writing, or has an exception such as a hangup. * * If this function returns #FALSE, then the file descriptor may still * be ready for reading or writing, but more memory is needed in order * to do the reading or writing. If you ignore the #FALSE return, your * application may spin in a busy loop on the file descriptor until * memory becomes available, but nothing more catastrophic should * happen. * * dbus_watch_handle() cannot be called during the * DBusAddWatchFunction, as the connection will not be ready to handle * that watch yet. * * It is not allowed to reference a DBusWatch after it has been passed * to remove_function. * * @param watch the DBusWatch object. * @param flags the poll condition using #DBusWatchFlags values * @returns #FALSE if there wasn't enough memory */ dbus_bool_t dbus_watch_handle (DBusWatch *watch, unsigned int flags) { _dbus_return_val_if_fail (watch != NULL, FALSE); #ifndef DBUS_DISABLE_CHECKS if (!_dbus_pollable_is_valid (watch->fd) || watch->flags == 0) { _dbus_warn_check_failed ("Watch is invalid, it should have been removed"); return TRUE; } #endif _dbus_return_val_if_fail (_dbus_pollable_is_valid (watch->fd) /* fails if watch was removed */, TRUE); _dbus_watch_sanitize_condition (watch, &flags); if (flags == 0) { _dbus_verbose ("After sanitization, watch flags on fd %" DBUS_POLLABLE_FORMAT " were 0\n", _dbus_pollable_printable (watch->fd)); return TRUE; } else return (* watch->handler) (watch, flags, watch->handler_data); }