X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dbus%2Fdbus-watch.c;h=b82c57d407bb8b2ef06ecb09001215ff27b3bbc0;hb=0cb9ccf2af64af8c575fa73db9d0872b61aaacb9;hp=019b8b1c308f9bcc20403372cfee6bb3f4ac4528;hpb=7652304bff969afb3969603149bb385efe861fe8;p=platform%2Fupstream%2Fdbus.git diff --git a/dbus/dbus-watch.c b/dbus/dbus-watch.c index 019b8b1..b82c57d 100644 --- a/dbus/dbus-watch.c +++ b/dbus/dbus-watch.c @@ -1,4 +1,4 @@ -/* -*- mode: C; c-file-style: "gnu" -*- */ +/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* dbus-watch.c DBusWatch implementation * * Copyright (C) 2002, 2003 Red Hat Inc. @@ -17,10 +17,11 @@ * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ +#include #include "dbus-internals.h" #include "dbus-watch.h" #include "dbus-list.h" @@ -49,8 +50,28 @@ struct DBusWatch void *data; /**< Application data. */ DBusFreeFunction free_data_function; /**< Free the application data. */ unsigned int enabled : 1; /**< Whether it's enabled. */ + unsigned int oom_last_time : 1; /**< Whether it was OOM last time. */ }; +dbus_bool_t +_dbus_watch_get_enabled (DBusWatch *watch) +{ + return watch->enabled; +} + +dbus_bool_t +_dbus_watch_get_oom_last_time (DBusWatch *watch) +{ + return watch->oom_last_time; +} + +void +_dbus_watch_set_oom_last_time (DBusWatch *watch, + dbus_bool_t oom) +{ + watch->oom_last_time = oom; +} + /** * Creates a new DBusWatch. Used to add a file descriptor to be polled * by a main loop. @@ -122,6 +143,9 @@ _dbus_watch_unref (DBusWatch *watch) watch->refcount -= 1; if (watch->refcount == 0) { + if (watch->fd != -1) + _dbus_warn ("this watch should have been invalidated"); + dbus_watch_set_data (watch, NULL, NULL); /* call free_data_function */ if (watch->free_handler_data_function) @@ -235,6 +259,25 @@ _dbus_watch_list_free (DBusWatchList *watch_list) dbus_free (watch_list); } +#ifdef DBUS_ENABLE_VERBOSE_MODE +static const char* +watch_flags_to_string (int flags) +{ + const char *watch_type; + + if ((flags & DBUS_WATCH_READABLE) && + (flags & DBUS_WATCH_WRITABLE)) + watch_type = "readwrite"; + else if (flags & DBUS_WATCH_READABLE) + watch_type = "read"; + else if (flags & DBUS_WATCH_WRITABLE) + watch_type = "write"; + else + watch_type = "not read or write"; + return watch_type; +} +#endif /* DBUS_ENABLE_VERBOSE_MODE */ + /** * Sets the watch functions. This function is the "backend" * for dbus_connection_set_watch_functions() and @@ -268,27 +311,9 @@ _dbus_watch_list_set_functions (DBusWatchList *watch_list, DBusList *next = _dbus_list_get_next_link (&watch_list->watches, link); -#ifdef DBUS_ENABLE_VERBOSE_MODE - { - const char *watch_type; - int flags; - - flags = dbus_watch_get_flags (link->data); - if ((flags & DBUS_WATCH_READABLE) && - (flags & DBUS_WATCH_WRITABLE)) - watch_type = "readwrite"; - else if (flags & DBUS_WATCH_READABLE) - watch_type = "read"; - else if (flags & DBUS_WATCH_WRITABLE) - watch_type = "write"; - else - watch_type = "not read or write"; - - _dbus_verbose ("Adding a %s watch on fd %d using newly-set add watch function\n", - watch_type, - dbus_watch_get_fd (link->data)); - } -#endif /* DBUS_ENABLE_VERBOSE_MODE */ + _dbus_verbose ("Adding a %s watch on fd %d using newly-set add watch function\n", + watch_flags_to_string (dbus_watch_get_flags (link->data)), + dbus_watch_get_socket (link->data)); if (!(* add_function) (link->data, data)) { @@ -302,7 +327,7 @@ _dbus_watch_list_set_functions (DBusWatchList *watch_list, link2); _dbus_verbose ("Removing watch on fd %d using newly-set remove function because initial add failed\n", - dbus_watch_get_fd (link2->data)); + dbus_watch_get_socket (link2->data)); (* remove_function) (link2->data, data); @@ -359,7 +384,7 @@ _dbus_watch_list_add_watch (DBusWatchList *watch_list, if (watch_list->add_watch_function != NULL) { _dbus_verbose ("Adding watch on fd %d\n", - dbus_watch_get_fd (watch)); + dbus_watch_get_socket (watch)); if (!(* watch_list->add_watch_function) (watch, watch_list->watch_data)) @@ -390,7 +415,7 @@ _dbus_watch_list_remove_watch (DBusWatchList *watch_list, if (watch_list->remove_watch_function != NULL) { _dbus_verbose ("Removing watch on fd %d\n", - dbus_watch_get_fd (watch)); + dbus_watch_get_socket (watch)); (* watch_list->remove_watch_function) (watch, watch_list->watch_data); @@ -422,7 +447,7 @@ _dbus_watch_list_toggle_watch (DBusWatchList *watch_list, if (watch_list->watch_toggled_function != NULL) { _dbus_verbose ("Toggling watch %p on fd %d to %d\n", - watch, dbus_watch_get_fd (watch), watch->enabled); + watch, dbus_watch_get_socket (watch), watch->enabled); (* watch_list->watch_toggled_function) (watch, watch_list->watch_data); @@ -465,6 +490,9 @@ _dbus_watch_set_handler (DBusWatch *watch, * Types and functions related to DBusWatch. A watch represents * a file descriptor that the main loop needs to monitor, * as in Qt's QSocketNotifier or GLib's g_io_add_watch(). + * + * Use dbus_connection_set_watch_functions() or dbus_server_set_watch_functions() + * to be notified when libdbus needs to add or remove watches. * * @{ */ @@ -478,14 +506,66 @@ _dbus_watch_set_handler (DBusWatch *watch, */ /** - * Gets the file descriptor that should be watched. - * + * Deprecated former name of dbus_watch_get_unix_fd(). + * * @param watch the DBusWatch object. * @returns the file descriptor to watch. */ int dbus_watch_get_fd (DBusWatch *watch) { + _dbus_return_val_if_fail (watch != NULL, -1); + + return dbus_watch_get_unix_fd(watch); +} + +/** + * Returns a UNIX file descriptor to be watched, + * which may be a pipe, socket, or other type of + * descriptor. On UNIX this is preferred to + * dbus_watch_get_socket() since it works with + * more kinds of #DBusWatch. + * + * Always returns -1 on Windows. On Windows you use + * dbus_watch_get_socket() to get a Winsock socket to watch. + * + * @param watch the DBusWatch object. + * @returns the file descriptor to watch. + */ +int +dbus_watch_get_unix_fd (DBusWatch *watch) +{ + _dbus_return_val_if_fail (watch != NULL, -1); + + /* FIXME remove #ifdef and do this on a lower level + * (watch should have set_socket and set_unix_fd and track + * which it has, and the transport should provide the + * appropriate watch type) + */ +#ifdef DBUS_UNIX + return watch->fd; +#else + return dbus_watch_get_socket( watch ); +#endif +} + +/** + * Returns a socket to be watched, on UNIX this will return -1 if our + * transport is not socket-based so dbus_watch_get_unix_fd() is + * preferred. + * + * On Windows, dbus_watch_get_unix_fd() returns -1 but this function + * returns a Winsock socket (assuming the transport is socket-based, + * as it always is for now). + * + * @param watch the DBusWatch object. + * @returns the socket to watch. + */ +int +dbus_watch_get_socket (DBusWatch *watch) +{ + _dbus_return_val_if_fail (watch != NULL, -1); + return watch->fd; } @@ -505,6 +585,7 @@ dbus_watch_get_fd (DBusWatch *watch) unsigned int dbus_watch_get_flags (DBusWatch *watch) { + _dbus_return_val_if_fail (watch != NULL, 0); _dbus_assert ((watch->flags & VALID_WATCH_FLAGS) == watch->flags); return watch->flags; @@ -520,6 +601,8 @@ dbus_watch_get_flags (DBusWatch *watch) void* dbus_watch_get_data (DBusWatch *watch) { + _dbus_return_val_if_fail (watch != NULL, NULL); + return watch->data; } @@ -539,8 +622,10 @@ dbus_watch_set_data (DBusWatch *watch, void *data, DBusFreeFunction free_data_function) { + _dbus_return_if_fail (watch != NULL); + _dbus_verbose ("Setting watch fd %d data to data = %p function = %p from data = %p function = %p\n", - dbus_watch_get_fd (watch), + dbus_watch_get_socket (watch), data, free_data_function, watch->data, watch->free_data_function); if (watch->free_data_function != NULL) @@ -560,7 +645,8 @@ dbus_watch_set_data (DBusWatch *watch, dbus_bool_t dbus_watch_get_enabled (DBusWatch *watch) { - _dbus_assert (watch != NULL); + _dbus_return_val_if_fail (watch != NULL, FALSE); + return watch->enabled; } @@ -591,11 +677,12 @@ dbus_bool_t dbus_watch_handle (DBusWatch *watch, unsigned int flags) { + _dbus_return_val_if_fail (watch != NULL, FALSE); + #ifndef DBUS_DISABLE_CHECKS if (watch->fd < 0 || watch->flags == 0) { - _dbus_warn ("%s: Watch is invalid, it should have been removed\n", - _DBUS_FUNCTION_NAME); + _dbus_warn_check_failed ("Watch is invalid, it should have been removed\n"); return TRUE; } #endif