dbus/dbus/dbus-mainloop.c - nest-cam/4320010/dbus - Git at Google

 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
 /* dbus-mainloop.c  Main loop utility
  *
  * Copyright © 2003, 2004  Red Hat, Inc.
  * Copyright © 2011 Nokia Corporation
  *
  * Licensed under the Academic Free License version 2.1
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  *
  */

 #include <config.h>
 #include "dbus-mainloop.h"

 #ifndef DOXYGEN_SHOULD_SKIP_THIS

 #include <dbus/dbus-hash.h>
 #include <dbus/dbus-list.h>
 #include <dbus/dbus-socket-set.h>
 #include <dbus/dbus-watch.h>

 #define MAINLOOP_SPEW 0

 #if MAINLOOP_SPEW
 #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 */
 #endif /* MAINLOOP_SPEW */

 struct DBusLoop
 {
   int refcount;
   /** fd => dbus_malloc'd DBusList ** of references to DBusWatch */
   DBusHashTable *watches;
   DBusSocketSet *socket_set;
   DBusList *timeouts;
   int callback_list_serial;
   int watch_count;
   int timeout_count;
   int depth; /**< number of recursive runs */
   DBusList *need_dispatch;
   /** TRUE if we will skip a watch next time because it was OOM; becomes
    * FALSE between polling, and dealing with the results of the poll */
   unsigned oom_watch_pending : 1;
 };

 typedef struct
 {
   DBusTimeout *timeout;
   unsigned long last_tv_sec;
   unsigned long last_tv_usec;
 } TimeoutCallback;

 #define TIMEOUT_CALLBACK(callback) ((TimeoutCallback*)callback)

 static TimeoutCallback*
 timeout_callback_new (DBusTimeout         *timeout)
 {
   TimeoutCallback *cb;

   cb = dbus_new (TimeoutCallback, 1);
   if (cb == NULL)
     return NULL;

   cb->timeout = timeout;
   _dbus_get_monotonic_time (&cb->last_tv_sec,
                             &cb->last_tv_usec);
   return cb;
 }

 static void
 timeout_callback_free (TimeoutCallback *cb)
 {
   dbus_free (cb);
 }

 static void
 free_watch_table_entry (void *data)
 {
   DBusList **watches = data;
   DBusWatch *watch;

   /* DBusHashTable sometimes calls free_function(NULL) even if you never
    * have NULL as a value */
   if (watches == NULL)
     return;

   for (watch = _dbus_list_pop_first (watches);
       watch != NULL;
       watch = _dbus_list_pop_first (watches))
     {
       _dbus_watch_unref (watch);
     }

   _dbus_assert (*watches == NULL);
   dbus_free (watches);
 }

 DBusLoop*
 _dbus_loop_new (void)
 {
   DBusLoop *loop;

   loop = dbus_new0 (DBusLoop, 1);
   if (loop == NULL)
     return NULL;

   loop->watches = _dbus_hash_table_new (DBUS_HASH_INT, NULL,
                                         free_watch_table_entry);

   loop->socket_set = _dbus_socket_set_new (0);

   if (loop->watches == NULL || loop->socket_set == NULL)
     {
       if (loop->watches != NULL)
         _dbus_hash_table_unref (loop->watches);

       if (loop->socket_set != NULL)
         _dbus_socket_set_free (loop->socket_set);

       dbus_free (loop);
       return NULL;
     }

   loop->refcount = 1;

   return loop;
 }

 DBusLoop *
 _dbus_loop_ref (DBusLoop *loop)
 {
   _dbus_assert (loop != NULL);
   _dbus_assert (loop->refcount > 0);

   loop->refcount += 1;

   return loop;
 }

 void
 _dbus_loop_unref (DBusLoop *loop)
 {
   _dbus_assert (loop != NULL);
   _dbus_assert (loop->refcount > 0);

   loop->refcount -= 1;
   if (loop->refcount == 0)
     {
       while (loop->need_dispatch)
         {
           DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);

           dbus_connection_unref (connection);
         }

       _dbus_hash_table_unref (loop->watches);
       _dbus_socket_set_free (loop->socket_set);
       dbus_free (loop);
     }
 }

 static DBusList **
 ensure_watch_table_entry (DBusLoop *loop,
                           int       fd)
 {
   DBusList **watches;

   watches = _dbus_hash_table_lookup_int (loop->watches, fd);

   if (watches == NULL)
     {
       watches = dbus_new0 (DBusList *, 1);

       if (watches == NULL)
         return watches;

       if (!_dbus_hash_table_insert_int (loop->watches, fd, watches))
         {
           dbus_free (watches);
           watches = NULL;
         }
     }

   return watches;
 }

 static void
 cull_watches_for_invalid_fd (DBusLoop  *loop,
                              int        fd)
 {
   DBusList *link;
   DBusList **watches;

   _dbus_warn ("invalid request, socket fd %d not open\n", fd);
   watches = _dbus_hash_table_lookup_int (loop->watches, fd);

   if (watches != NULL)
     {
       for (link = _dbus_list_get_first_link (watches);
           link != NULL;
           link = _dbus_list_get_next_link (watches, link))
         _dbus_watch_invalidate (link->data);
     }

   _dbus_hash_table_remove_int (loop->watches, fd);
 }

 static dbus_bool_t
 gc_watch_table_entry (DBusLoop  *loop,
                       DBusList **watches,
                       int        fd)
 {
   /* If watches is already NULL we have nothing to do */
   if (watches == NULL)
     return FALSE;

   /* We can't GC hash table entries if they're non-empty lists */
   if (*watches != NULL)
     return FALSE;

   _dbus_hash_table_remove_int (loop->watches, fd);
   return TRUE;
 }

 static void
 refresh_watches_for_fd (DBusLoop  *loop,
                         DBusList **watches,
                         int        fd)
 {
   DBusList *link;
   unsigned int flags = 0;
   dbus_bool_t interested = FALSE;

   _dbus_assert (fd != -1);

   if (watches == NULL)
     watches = _dbus_hash_table_lookup_int (loop->watches, fd);

   /* we allocated this in the first _dbus_loop_add_watch for the fd, and keep
    * it until there are none left */
   _dbus_assert (watches != NULL);

   for (link = _dbus_list_get_first_link (watches);
       link != NULL;
       link = _dbus_list_get_next_link (watches, link))
     {
       if (dbus_watch_get_enabled (link->data) &&
           !_dbus_watch_get_oom_last_time (link->data))
         {
           flags |= dbus_watch_get_flags (link->data);
           interested = TRUE;
         }
     }

   if (interested)
     _dbus_socket_set_enable (loop->socket_set, fd, flags);
   else
     _dbus_socket_set_disable (loop->socket_set, fd);
 }

 dbus_bool_t
 _dbus_loop_add_watch (DBusLoop  *loop,
                       DBusWatch *watch)
 {
   int fd;
   DBusList **watches;

   fd = dbus_watch_get_socket (watch);
   _dbus_assert (fd != -1);

   watches = ensure_watch_table_entry (loop, fd);

   if (watches == NULL)
     return FALSE;

   if (!_dbus_list_append (watches, _dbus_watch_ref (watch)))
     {
       _dbus_watch_unref (watch);
       gc_watch_table_entry (loop, watches, fd);

       return FALSE;
     }

   if (_dbus_list_length_is_one (watches))
     {
       if (!_dbus_socket_set_add (loop->socket_set, fd,
                                  dbus_watch_get_flags (watch),
                                  dbus_watch_get_enabled (watch)))
         {
           _dbus_hash_table_remove_int (loop->watches, fd);
           return FALSE;
         }
     }
   else
     {
       /* we're modifying, not adding, which can't fail with OOM */
       refresh_watches_for_fd (loop, watches, fd);
     }

   loop->callback_list_serial += 1;
   loop->watch_count += 1;
   return TRUE;
 }

 void
 _dbus_loop_toggle_watch (DBusLoop          *loop,
                          DBusWatch         *watch)
 {
   refresh_watches_for_fd (loop, NULL, dbus_watch_get_socket (watch));
 }

 void
 _dbus_loop_remove_watch (DBusLoop         *loop,
                          DBusWatch        *watch)
 {
   DBusList **watches;
   DBusList *link;
   int fd;

   /* This relies on people removing watches before they invalidate them,
    * which has been safe since fd.o #33336 was fixed. Assert about it
    * so we don't regress. */
   fd = dbus_watch_get_socket (watch);
   _dbus_assert (fd != -1);

   watches = _dbus_hash_table_lookup_int (loop->watches, fd);

   if (watches != NULL)
     {
       link = _dbus_list_get_first_link (watches);
       while (link != NULL)
         {
           DBusList *next = _dbus_list_get_next_link (watches, link);
           DBusWatch *this = link->data;

           if (this == watch)
             {
               _dbus_list_remove_link (watches, link);
               loop->callback_list_serial += 1;
               loop->watch_count -= 1;
               _dbus_watch_unref (this);

               /* if that was the last watch for that fd, drop the hash table
                * entry, and stop reserving space for it in the socket set */
               if (gc_watch_table_entry (loop, watches, fd))
                 {
                   _dbus_socket_set_remove (loop->socket_set, fd);
                 }

               return;
             }

           link = next;
          }
      }

   _dbus_warn ("could not find watch %p to remove\n", watch);
 }

 dbus_bool_t
 _dbus_loop_add_timeout (DBusLoop           *loop,
                         DBusTimeout        *timeout)
 {
   TimeoutCallback *tcb;

   tcb = timeout_callback_new (timeout);
   if (tcb == NULL)
     return FALSE;

   if (_dbus_list_append (&loop->timeouts, tcb))
     {
       loop->callback_list_serial += 1;
       loop->timeout_count += 1;
     }
   else
     {
       timeout_callback_free (tcb);
       return FALSE;
     }

   return TRUE;
 }

 void
 _dbus_loop_remove_timeout (DBusLoop           *loop,
                            DBusTimeout        *timeout)
 {
   DBusList *link;

   link = _dbus_list_get_first_link (&loop->timeouts);
   while (link != NULL)
     {
       DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
       TimeoutCallback *this = link->data;

       if (this->timeout == timeout)
         {
           _dbus_list_remove_link (&loop->timeouts, link);
           loop->callback_list_serial += 1;
           loop->timeout_count -= 1;
           timeout_callback_free (this);

           return;
         }

       link = next;
     }

   _dbus_warn ("could not find timeout %p to remove\n", timeout);
 }

 /* Convolutions from GLib, there really must be a better way
  * to do this.
  */
 static dbus_bool_t
 check_timeout (unsigned long    tv_sec,
                unsigned long    tv_usec,
                TimeoutCallback *tcb,
                int             *timeout)
 {
   long sec_remaining;
   long msec_remaining;
   unsigned long expiration_tv_sec;
   unsigned long expiration_tv_usec;
   long interval_seconds;
   long interval_milliseconds;
   int interval;

   /* I'm pretty sure this function could suck (a lot) less */

   interval = dbus_timeout_get_interval (tcb->timeout);

   interval_seconds = interval / 1000L;
   interval_milliseconds = interval % 1000L;

   expiration_tv_sec = tcb->last_tv_sec + interval_seconds;
   expiration_tv_usec = tcb->last_tv_usec + interval_milliseconds * 1000;
   if (expiration_tv_usec >= 1000000)
     {
       expiration_tv_usec -= 1000000;
       expiration_tv_sec += 1;
     }

   sec_remaining = expiration_tv_sec - tv_sec;
   /* need to force this to be signed, as it is intended to sometimes
    * produce a negative result
    */
   msec_remaining = ((long) expiration_tv_usec - (long) tv_usec) / 1000L;

 #if MAINLOOP_SPEW
   _dbus_verbose ("Interval is %ld seconds %ld msecs\n",
                  interval_seconds,
                  interval_milliseconds);
   _dbus_verbose ("Now is  %lu seconds %lu usecs\n",
                  tv_sec, tv_usec);
   _dbus_verbose ("Last is %lu seconds %lu usecs\n",
                  tcb->last_tv_sec, tcb->last_tv_usec);
   _dbus_verbose ("Exp is  %lu seconds %lu usecs\n",
                  expiration_tv_sec, expiration_tv_usec);
   _dbus_verbose ("Pre-correction, sec_remaining %ld msec_remaining %ld\n",
                  sec_remaining, msec_remaining);
 #endif

   /* We do the following in a rather convoluted fashion to deal with
    * the fact that we don't have an integral type big enough to hold
    * the difference of two timevals in milliseconds.
    */
   if (sec_remaining < 0 || (sec_remaining == 0 && msec_remaining < 0))
     {
       *timeout = 0;
     }
   else
     {
       if (msec_remaining < 0)
 	{
 	  msec_remaining += 1000;
 	  sec_remaining -= 1;
 	}

       if (sec_remaining > (_DBUS_INT_MAX / 1000) ||
           msec_remaining > _DBUS_INT_MAX)
         *timeout = _DBUS_INT_MAX;
       else
         *timeout = sec_remaining * 1000 + msec_remaining;
     }

   if (*timeout > interval)
     {
       /* This indicates that the system clock probably moved backward */
       _dbus_verbose ("System clock set backward! Resetting timeout.\n");

       tcb->last_tv_sec = tv_sec;
       tcb->last_tv_usec = tv_usec;

       *timeout = interval;
     }

 #if MAINLOOP_SPEW
   _dbus_verbose ("  timeout expires in %d milliseconds\n", *timeout);
 #endif

   return *timeout == 0;
 }

 dbus_bool_t
 _dbus_loop_dispatch (DBusLoop *loop)
 {

 #if MAINLOOP_SPEW
   _dbus_verbose ("  %d connections to dispatch\n", _dbus_list_get_length (&loop->need_dispatch));
 #endif

   if (loop->need_dispatch == NULL)
     return FALSE;

  next:
   while (loop->need_dispatch != NULL)
     {
       DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);

       while (TRUE)
         {
           DBusDispatchStatus status;

           status = dbus_connection_dispatch (connection);

           if (status == DBUS_DISPATCH_COMPLETE)
             {
               dbus_connection_unref (connection);
               goto next;
             }
           else
             {
               if (status == DBUS_DISPATCH_NEED_MEMORY)
                 _dbus_wait_for_memory ();
             }
         }
     }

   return TRUE;
 }

 dbus_bool_t
 _dbus_loop_queue_dispatch (DBusLoop       *loop,
                            DBusConnection *connection)
 {
   if (_dbus_list_append (&loop->need_dispatch, connection))
     {
       dbus_connection_ref (connection);
       return TRUE;
     }
   else
     return FALSE;
 }

 /* Returns TRUE if we invoked any timeouts or have ready file
  * descriptors, which is just used in test code as a debug hack
  */

 dbus_bool_t
 _dbus_loop_iterate (DBusLoop     *loop,
                     dbus_bool_t   block)
 {
 #define N_STACK_DESCRIPTORS 64
   dbus_bool_t retval;
   DBusSocketEvent ready_fds[N_STACK_DESCRIPTORS];
   int i;
   DBusList *link;
   int n_ready;
   int initial_serial;
   long timeout;
   int orig_depth;

   retval = FALSE;

   orig_depth = loop->depth;

 #if MAINLOOP_SPEW
   _dbus_verbose ("Iteration block=%d depth=%d timeout_count=%d watch_count=%d\n",
                  block, loop->depth, loop->timeout_count, loop->watch_count);
 #endif

   if (_dbus_hash_table_get_n_entries (loop->watches) == 0 &&
       loop->timeouts == NULL)
     goto next_iteration;

   timeout = -1;
   if (loop->timeout_count > 0)
     {
       unsigned long tv_sec;
       unsigned long tv_usec;

       _dbus_get_monotonic_time (&tv_sec, &tv_usec);

       link = _dbus_list_get_first_link (&loop->timeouts);
       while (link != NULL)
         {
           DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
           TimeoutCallback *tcb = link->data;

           if (dbus_timeout_get_enabled (tcb->timeout))
             {
               int msecs_remaining;

               check_timeout (tv_sec, tv_usec, tcb, &msecs_remaining);

               if (timeout < 0)
                 timeout = msecs_remaining;
               else
                 timeout = MIN (msecs_remaining, timeout);

 #if MAINLOOP_SPEW
               _dbus_verbose ("  timeout added, %d remaining, aggregate timeout %ld\n",
                              msecs_remaining, timeout);
 #endif

               _dbus_assert (timeout >= 0);

               if (timeout == 0)
                 break; /* it's not going to get shorter... */
             }
 #if MAINLOOP_SPEW
           else
             {
               _dbus_verbose ("  skipping disabled timeout\n");
             }
 #endif

           link = next;
         }
     }

   /* Never block if we have stuff to dispatch */
   if (!block || loop->need_dispatch != NULL)
     {
       timeout = 0;
 #if MAINLOOP_SPEW
       _dbus_verbose ("  timeout is 0 as we aren't blocking\n");
 #endif
     }

   /* if a watch was OOM last time, don't wait longer than the OOM
    * wait to re-enable it
    */
   if (loop->oom_watch_pending)
     timeout = MIN (timeout, _dbus_get_oom_wait ());

 #if MAINLOOP_SPEW
   _dbus_verbose ("  polling on %d descriptors timeout %ld\n", n_fds, timeout);
 #endif

   n_ready = _dbus_socket_set_poll (loop->socket_set, ready_fds,
                                    _DBUS_N_ELEMENTS (ready_fds), timeout);

   /* re-enable any watches we skipped this time */
   if (loop->oom_watch_pending)
     {
       DBusHashIter hash_iter;

       loop->oom_watch_pending = FALSE;

       _dbus_hash_iter_init (loop->watches, &hash_iter);

       while (_dbus_hash_iter_next (&hash_iter))
         {
           DBusList **watches;
           int fd;
           dbus_bool_t changed;

           changed = FALSE;
           fd = _dbus_hash_iter_get_int_key (&hash_iter);
           watches = _dbus_hash_iter_get_value (&hash_iter);

           for (link = _dbus_list_get_first_link (watches);
               link != NULL;
               link = _dbus_list_get_next_link (watches, link))
             {
               DBusWatch *watch = link->data;

               if (_dbus_watch_get_oom_last_time (watch))
                 {
                   _dbus_watch_set_oom_last_time (watch, FALSE);
                   changed = TRUE;
                 }
             }

           if (changed)
             refresh_watches_for_fd (loop, watches, fd);
         }

       retval = TRUE; /* return TRUE here to keep the loop going,
                       * since we don't know the watch was inactive */
     }

   initial_serial = loop->callback_list_serial;

   if (loop->timeout_count > 0)
     {
       unsigned long tv_sec;
       unsigned long tv_usec;

       _dbus_get_monotonic_time (&tv_sec, &tv_usec);

       /* It'd be nice to avoid this O(n) thingy here */
       link = _dbus_list_get_first_link (&loop->timeouts);
       while (link != NULL)
         {
           DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
           TimeoutCallback *tcb = link->data;

           if (initial_serial != loop->callback_list_serial)
             goto next_iteration;

           if (loop->depth != orig_depth)
             goto next_iteration;

           if (dbus_timeout_get_enabled (tcb->timeout))
             {
               int msecs_remaining;

               if (check_timeout (tv_sec, tv_usec,
                                  tcb, &msecs_remaining))
                 {
                   /* Save last callback time and fire this timeout */
                   tcb->last_tv_sec = tv_sec;
                   tcb->last_tv_usec = tv_usec;

 #if MAINLOOP_SPEW
                   _dbus_verbose ("  invoking timeout\n");
 #endif

                   /* can theoretically return FALSE on OOM, but we just
                    * let it fire again later - in practice that's what
                    * every wrapper callback in dbus-daemon used to do */
                   dbus_timeout_handle (tcb->timeout);

                   retval = TRUE;
                 }
               else
                 {
 #if MAINLOOP_SPEW
                   _dbus_verbose ("  timeout has not expired\n");
 #endif
                 }
             }
 #if MAINLOOP_SPEW
           else
             {
               _dbus_verbose ("  skipping invocation of disabled timeout\n");
             }
 #endif

           link = next;
         }
     }

   if (n_ready > 0)
     {
       for (i = 0; i < n_ready; i++)
         {
           DBusList **watches;
           DBusList *next;
           unsigned int condition;
           dbus_bool_t any_oom;

           /* FIXME I think this "restart if we change the watches"
            * approach could result in starving watches
            * toward the end of the list.
            */
           if (initial_serial != loop->callback_list_serial)
             goto next_iteration;

           if (loop->depth != orig_depth)
             goto next_iteration;

           _dbus_assert (ready_fds[i].flags != 0);

           if (_DBUS_UNLIKELY (ready_fds[i].flags & _DBUS_WATCH_NVAL))
             {
               cull_watches_for_invalid_fd (loop, ready_fds[i].fd);
               goto next_iteration;
             }

           condition = ready_fds[i].flags;
           _dbus_assert ((condition & _DBUS_WATCH_NVAL) == 0);

           /* condition may still be 0 if we got some
            * weird POLLFOO thing like POLLWRBAND
            */
           if (condition == 0)
             continue;

           watches = _dbus_hash_table_lookup_int (loop->watches,
                                                  ready_fds[i].fd);

           if (watches == NULL)
             continue;

           any_oom = FALSE;

           for (link = _dbus_list_get_first_link (watches);
               link != NULL;
               link = next)
             {
               DBusWatch *watch = link->data;

               next = _dbus_list_get_next_link (watches, link);

               if (dbus_watch_get_enabled (watch))
                 {
                   dbus_bool_t oom;

                   oom = !dbus_watch_handle (watch, condition);

                   if (oom)
                     {
                       _dbus_watch_set_oom_last_time (watch, TRUE);
                       loop->oom_watch_pending = TRUE;
                       any_oom = TRUE;
                     }

 #if MAINLOOP_SPEW
                   _dbus_verbose ("  Invoked watch, oom = %d\n", oom);
 #endif
                   retval = TRUE;

                   /* We re-check this every time, in case the callback
                    * added/removed watches, which might make our position in
                    * the linked list invalid. See the FIXME above. */
                   if (initial_serial != loop->callback_list_serial ||
                       loop->depth != orig_depth)
                     {
                       if (any_oom)
                         refresh_watches_for_fd (loop, NULL, ready_fds[i].fd);

                       goto next_iteration;
                     }
                 }
             }

           if (any_oom)
             refresh_watches_for_fd (loop, watches, ready_fds[i].fd);
         }
     }

  next_iteration:
 #if MAINLOOP_SPEW
   _dbus_verbose ("  moving to next iteration\n");
 #endif

   if (_dbus_loop_dispatch (loop))
     retval = TRUE;

 #if MAINLOOP_SPEW
   _dbus_verbose ("Returning %d\n", retval);
 #endif

   return retval;
 }

 void
 _dbus_loop_run (DBusLoop *loop)
 {
   int our_exit_depth;

   _dbus_assert (loop->depth >= 0);

   _dbus_loop_ref (loop);

   our_exit_depth = loop->depth;
   loop->depth += 1;

   _dbus_verbose ("Running main loop, depth %d -> %d\n",
                  loop->depth - 1, loop->depth);

   while (loop->depth != our_exit_depth)
     _dbus_loop_iterate (loop, TRUE);

   _dbus_loop_unref (loop);
 }

 void
 _dbus_loop_quit (DBusLoop *loop)
 {
   _dbus_assert (loop->depth > 0);

   loop->depth -= 1;

   _dbus_verbose ("Quit main loop, depth %d -> %d\n",
                  loop->depth + 1, loop->depth);
 }

 int
 _dbus_get_oom_wait (void)
 {
 #ifdef DBUS_BUILD_TESTS
   /* make tests go fast */
   return 0;
 #else
   return 500;
 #endif
 }

 void
 _dbus_wait_for_memory (void)
 {
   _dbus_verbose ("Waiting for more memory\n");
   _dbus_sleep_milliseconds (_dbus_get_oom_wait ());
 }

 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */
	/* -- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -- */
	/* dbus-mainloop.c Main loop utility
	*
	* Copyright © 2003, 2004 Red Hat, Inc.
	* Copyright © 2011 Nokia Corporation
	*
	* Licensed under the Academic Free License version 2.1
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License as published by
	* the Free Software Foundation; either version 2 of the License, or
	* (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*
	*/

	#include <config.h>
	#include "dbus-mainloop.h"

	#ifndef DOXYGEN_SHOULD_SKIP_THIS

	#include <dbus/dbus-hash.h>
	#include <dbus/dbus-list.h>
	#include <dbus/dbus-socket-set.h>
	#include <dbus/dbus-watch.h>

	#define MAINLOOP_SPEW 0

	#if MAINLOOP_SPEW
	#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 */
	#endif /* MAINLOOP_SPEW */

	struct DBusLoop
	{
	int refcount;
	/ fd => dbus_malloc'd DBusList of references to DBusWatch */
	DBusHashTable *watches;
	DBusSocketSet *socket_set;
	DBusList *timeouts;
	int callback_list_serial;
	int watch_count;
	int timeout_count;
	int depth; /*< number of recursive runs /
	DBusList *need_dispatch;
	/** TRUE if we will skip a watch next time because it was OOM; becomes
	* FALSE between polling, and dealing with the results of the poll */
	unsigned oom_watch_pending : 1;
	};

	typedef struct
	{
	DBusTimeout *timeout;
	unsigned long last_tv_sec;
	unsigned long last_tv_usec;
	} TimeoutCallback;

	#define TIMEOUT_CALLBACK(callback) ((TimeoutCallback*)callback)

	static TimeoutCallback*
	timeout_callback_new (DBusTimeout *timeout)
	{
	TimeoutCallback *cb;

	cb = dbus_new (TimeoutCallback, 1);
	if (cb == NULL)
	return NULL;

	cb->timeout = timeout;
	_dbus_get_monotonic_time (&cb->last_tv_sec,
	&cb->last_tv_usec);
	return cb;
	}

	static void
	timeout_callback_free (TimeoutCallback *cb)
	{
	dbus_free (cb);
	}

	static void
	free_watch_table_entry (void *data)
	{
	DBusList **watches = data;
	DBusWatch *watch;

	/* DBusHashTable sometimes calls free_function(NULL) even if you never
	* have NULL as a value */
	if (watches == NULL)
	return;

	for (watch = _dbus_list_pop_first (watches);
	watch != NULL;
	watch = _dbus_list_pop_first (watches))
	{
	_dbus_watch_unref (watch);
	}

	_dbus_assert (*watches == NULL);
	dbus_free (watches);
	}

	DBusLoop*
	_dbus_loop_new (void)
	{
	DBusLoop *loop;

	loop = dbus_new0 (DBusLoop, 1);
	if (loop == NULL)
	return NULL;

	loop->watches = _dbus_hash_table_new (DBUS_HASH_INT, NULL,
	free_watch_table_entry);

	loop->socket_set = _dbus_socket_set_new (0);

	if (loop->watches == NULL \|\| loop->socket_set == NULL)
	{
	if (loop->watches != NULL)
	_dbus_hash_table_unref (loop->watches);

	if (loop->socket_set != NULL)
	_dbus_socket_set_free (loop->socket_set);

	dbus_free (loop);
	return NULL;
	}

	loop->refcount = 1;

	return loop;
	}

	DBusLoop *
	_dbus_loop_ref (DBusLoop *loop)
	{
	_dbus_assert (loop != NULL);
	_dbus_assert (loop->refcount > 0);

	loop->refcount += 1;

	return loop;
	}

	void
	_dbus_loop_unref (DBusLoop *loop)
	{
	_dbus_assert (loop != NULL);
	_dbus_assert (loop->refcount > 0);

	loop->refcount -= 1;
	if (loop->refcount == 0)
	{
	while (loop->need_dispatch)
	{
	DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);

	dbus_connection_unref (connection);
	}

	_dbus_hash_table_unref (loop->watches);
	_dbus_socket_set_free (loop->socket_set);
	dbus_free (loop);
	}
	}

	static DBusList **
	ensure_watch_table_entry (DBusLoop *loop,
	int fd)
	{
	DBusList **watches;

	watches = _dbus_hash_table_lookup_int (loop->watches, fd);

	if (watches == NULL)
	{
	watches = dbus_new0 (DBusList *, 1);

	if (watches == NULL)
	return watches;

	if (!_dbus_hash_table_insert_int (loop->watches, fd, watches))
	{
	dbus_free (watches);
	watches = NULL;
	}
	}

	return watches;
	}

	static void
	cull_watches_for_invalid_fd (DBusLoop *loop,
	int fd)
	{
	DBusList *link;
	DBusList **watches;

	_dbus_warn ("invalid request, socket fd %d not open\n", fd);
	watches = _dbus_hash_table_lookup_int (loop->watches, fd);

	if (watches != NULL)
	{
	for (link = _dbus_list_get_first_link (watches);
	link != NULL;
	link = _dbus_list_get_next_link (watches, link))
	_dbus_watch_invalidate (link->data);
	}

	_dbus_hash_table_remove_int (loop->watches, fd);
	}

	static dbus_bool_t
	gc_watch_table_entry (DBusLoop *loop,
	DBusList **watches,
	int fd)
	{
	/* If watches is already NULL we have nothing to do */
	if (watches == NULL)
	return FALSE;

	/* We can't GC hash table entries if they're non-empty lists */
	if (*watches != NULL)
	return FALSE;

	_dbus_hash_table_remove_int (loop->watches, fd);
	return TRUE;
	}

	static void
	refresh_watches_for_fd (DBusLoop *loop,
	DBusList **watches,
	int fd)
	{
	DBusList *link;
	unsigned int flags = 0;
	dbus_bool_t interested = FALSE;

	_dbus_assert (fd != -1);

	if (watches == NULL)
	watches = _dbus_hash_table_lookup_int (loop->watches, fd);

	/* we allocated this in the first _dbus_loop_add_watch for the fd, and keep
	* it until there are none left */
	_dbus_assert (watches != NULL);

	for (link = _dbus_list_get_first_link (watches);
	link != NULL;
	link = _dbus_list_get_next_link (watches, link))
	{
	if (dbus_watch_get_enabled (link->data) &&
	!_dbus_watch_get_oom_last_time (link->data))
	{
	flags \|= dbus_watch_get_flags (link->data);
	interested = TRUE;
	}
	}

	if (interested)
	_dbus_socket_set_enable (loop->socket_set, fd, flags);
	else
	_dbus_socket_set_disable (loop->socket_set, fd);
	}

	dbus_bool_t
	_dbus_loop_add_watch (DBusLoop *loop,
	DBusWatch *watch)
	{
	int fd;
	DBusList **watches;

	fd = dbus_watch_get_socket (watch);
	_dbus_assert (fd != -1);

	watches = ensure_watch_table_entry (loop, fd);

	if (watches == NULL)
	return FALSE;

	if (!_dbus_list_append (watches, _dbus_watch_ref (watch)))
	{
	_dbus_watch_unref (watch);
	gc_watch_table_entry (loop, watches, fd);

	return FALSE;
	}

	if (_dbus_list_length_is_one (watches))
	{
	if (!_dbus_socket_set_add (loop->socket_set, fd,
	dbus_watch_get_flags (watch),
	dbus_watch_get_enabled (watch)))
	{
	_dbus_hash_table_remove_int (loop->watches, fd);
	return FALSE;
	}
	}
	else
	{
	/* we're modifying, not adding, which can't fail with OOM */
	refresh_watches_for_fd (loop, watches, fd);
	}

	loop->callback_list_serial += 1;
	loop->watch_count += 1;
	return TRUE;
	}

	void
	_dbus_loop_toggle_watch (DBusLoop *loop,
	DBusWatch *watch)
	{
	refresh_watches_for_fd (loop, NULL, dbus_watch_get_socket (watch));
	}

	void
	_dbus_loop_remove_watch (DBusLoop *loop,
	DBusWatch *watch)
	{
	DBusList **watches;
	DBusList *link;
	int fd;

	/* This relies on people removing watches before they invalidate them,
	* which has been safe since fd.o #33336 was fixed. Assert about it
	* so we don't regress. */
	fd = dbus_watch_get_socket (watch);
	_dbus_assert (fd != -1);

	watches = _dbus_hash_table_lookup_int (loop->watches, fd);

	if (watches != NULL)
	{
	link = _dbus_list_get_first_link (watches);
	while (link != NULL)
	{
	DBusList *next = _dbus_list_get_next_link (watches, link);
	DBusWatch *this = link->data;

	if (this == watch)
	{
	_dbus_list_remove_link (watches, link);
	loop->callback_list_serial += 1;
	loop->watch_count -= 1;
	_dbus_watch_unref (this);

	/* if that was the last watch for that fd, drop the hash table
	* entry, and stop reserving space for it in the socket set */
	if (gc_watch_table_entry (loop, watches, fd))
	{
	_dbus_socket_set_remove (loop->socket_set, fd);
	}

	return;
	}

	link = next;
	}
	}

	_dbus_warn ("could not find watch %p to remove\n", watch);
	}

	dbus_bool_t
	_dbus_loop_add_timeout (DBusLoop *loop,
	DBusTimeout *timeout)
	{
	TimeoutCallback *tcb;

	tcb = timeout_callback_new (timeout);
	if (tcb == NULL)
	return FALSE;

	if (_dbus_list_append (&loop->timeouts, tcb))
	{
	loop->callback_list_serial += 1;
	loop->timeout_count += 1;
	}
	else
	{
	timeout_callback_free (tcb);
	return FALSE;
	}

	return TRUE;
	}

	void
	_dbus_loop_remove_timeout (DBusLoop *loop,
	DBusTimeout *timeout)
	{
	DBusList *link;

	link = _dbus_list_get_first_link (&loop->timeouts);
	while (link != NULL)
	{
	DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
	TimeoutCallback *this = link->data;

	if (this->timeout == timeout)
	{
	_dbus_list_remove_link (&loop->timeouts, link);
	loop->callback_list_serial += 1;
	loop->timeout_count -= 1;
	timeout_callback_free (this);

	return;
	}

	link = next;
	}

	_dbus_warn ("could not find timeout %p to remove\n", timeout);
	}

	/* Convolutions from GLib, there really must be a better way
	* to do this.
	*/
	static dbus_bool_t
	check_timeout (unsigned long tv_sec,
	unsigned long tv_usec,
	TimeoutCallback *tcb,
	int *timeout)
	{
	long sec_remaining;
	long msec_remaining;
	unsigned long expiration_tv_sec;
	unsigned long expiration_tv_usec;
	long interval_seconds;
	long interval_milliseconds;
	int interval;

	/* I'm pretty sure this function could suck (a lot) less */

	interval = dbus_timeout_get_interval (tcb->timeout);

	interval_seconds = interval / 1000L;
	interval_milliseconds = interval % 1000L;

	expiration_tv_sec = tcb->last_tv_sec + interval_seconds;
	expiration_tv_usec = tcb->last_tv_usec + interval_milliseconds * 1000;
	if (expiration_tv_usec >= 1000000)
	{
	expiration_tv_usec -= 1000000;
	expiration_tv_sec += 1;
	}

	sec_remaining = expiration_tv_sec - tv_sec;
	/* need to force this to be signed, as it is intended to sometimes
	* produce a negative result
	*/
	msec_remaining = ((long) expiration_tv_usec - (long) tv_usec) / 1000L;

	#if MAINLOOP_SPEW
	_dbus_verbose ("Interval is %ld seconds %ld msecs\n",
	interval_seconds,
	interval_milliseconds);
	_dbus_verbose ("Now is %lu seconds %lu usecs\n",
	tv_sec, tv_usec);
	_dbus_verbose ("Last is %lu seconds %lu usecs\n",
	tcb->last_tv_sec, tcb->last_tv_usec);
	_dbus_verbose ("Exp is %lu seconds %lu usecs\n",
	expiration_tv_sec, expiration_tv_usec);
	_dbus_verbose ("Pre-correction, sec_remaining %ld msec_remaining %ld\n",
	sec_remaining, msec_remaining);
	#endif

	/* We do the following in a rather convoluted fashion to deal with
	* the fact that we don't have an integral type big enough to hold
	* the difference of two timevals in milliseconds.
	*/
	if (sec_remaining < 0 \|\| (sec_remaining == 0 && msec_remaining < 0))
	{
	*timeout = 0;
	}
	else
	{
	if (msec_remaining < 0)
	{
	msec_remaining += 1000;
	sec_remaining -= 1;
	}

	if (sec_remaining > (_DBUS_INT_MAX / 1000) \|\|
	msec_remaining > _DBUS_INT_MAX)
	*timeout = _DBUS_INT_MAX;
	else
	timeout = sec_remaining 1000 + msec_remaining;
	}

	if (*timeout > interval)
	{
	/* This indicates that the system clock probably moved backward */
	_dbus_verbose ("System clock set backward! Resetting timeout.\n");

	tcb->last_tv_sec = tv_sec;
	tcb->last_tv_usec = tv_usec;

	*timeout = interval;
	}

	#if MAINLOOP_SPEW
	_dbus_verbose (" timeout expires in %d milliseconds\n", *timeout);
	#endif

	return *timeout == 0;
	}

	dbus_bool_t
	_dbus_loop_dispatch (DBusLoop *loop)
	{

	#if MAINLOOP_SPEW
	_dbus_verbose (" %d connections to dispatch\n", _dbus_list_get_length (&loop->need_dispatch));
	#endif

	if (loop->need_dispatch == NULL)
	return FALSE;

	next:
	while (loop->need_dispatch != NULL)
	{
	DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);

	while (TRUE)
	{
	DBusDispatchStatus status;

	status = dbus_connection_dispatch (connection);

	if (status == DBUS_DISPATCH_COMPLETE)
	{
	dbus_connection_unref (connection);
	goto next;
	}
	else
	{
	if (status == DBUS_DISPATCH_NEED_MEMORY)
	_dbus_wait_for_memory ();
	}
	}
	}

	return TRUE;
	}

	dbus_bool_t
	_dbus_loop_queue_dispatch (DBusLoop *loop,
	DBusConnection *connection)
	{
	if (_dbus_list_append (&loop->need_dispatch, connection))
	{
	dbus_connection_ref (connection);
	return TRUE;
	}
	else
	return FALSE;
	}

	/* Returns TRUE if we invoked any timeouts or have ready file
	* descriptors, which is just used in test code as a debug hack
	*/

	dbus_bool_t
	_dbus_loop_iterate (DBusLoop *loop,
	dbus_bool_t block)
	{
	#define N_STACK_DESCRIPTORS 64
	dbus_bool_t retval;
	DBusSocketEvent ready_fds[N_STACK_DESCRIPTORS];
	int i;
	DBusList *link;
	int n_ready;
	int initial_serial;
	long timeout;
	int orig_depth;

	retval = FALSE;

	orig_depth = loop->depth;

	#if MAINLOOP_SPEW
	_dbus_verbose ("Iteration block=%d depth=%d timeout_count=%d watch_count=%d\n",
	block, loop->depth, loop->timeout_count, loop->watch_count);
	#endif

	if (_dbus_hash_table_get_n_entries (loop->watches) == 0 &&
	loop->timeouts == NULL)
	goto next_iteration;

	timeout = -1;
	if (loop->timeout_count > 0)
	{
	unsigned long tv_sec;
	unsigned long tv_usec;

	_dbus_get_monotonic_time (&tv_sec, &tv_usec);

	link = _dbus_list_get_first_link (&loop->timeouts);
	while (link != NULL)
	{
	DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
	TimeoutCallback *tcb = link->data;

	if (dbus_timeout_get_enabled (tcb->timeout))
	{
	int msecs_remaining;

	check_timeout (tv_sec, tv_usec, tcb, &msecs_remaining);

	if (timeout < 0)
	timeout = msecs_remaining;
	else
	timeout = MIN (msecs_remaining, timeout);

	#if MAINLOOP_SPEW
	_dbus_verbose (" timeout added, %d remaining, aggregate timeout %ld\n",
	msecs_remaining, timeout);
	#endif

	_dbus_assert (timeout >= 0);

	if (timeout == 0)
	break; /* it's not going to get shorter... */
	}
	#if MAINLOOP_SPEW
	else
	{
	_dbus_verbose (" skipping disabled timeout\n");
	}
	#endif

	link = next;
	}
	}

	/* Never block if we have stuff to dispatch */
	if (!block \|\| loop->need_dispatch != NULL)
	{
	timeout = 0;
	#if MAINLOOP_SPEW
	_dbus_verbose (" timeout is 0 as we aren't blocking\n");
	#endif
	}

	/* if a watch was OOM last time, don't wait longer than the OOM
	* wait to re-enable it
	*/
	if (loop->oom_watch_pending)
	timeout = MIN (timeout, _dbus_get_oom_wait ());

	#if MAINLOOP_SPEW
	_dbus_verbose (" polling on %d descriptors timeout %ld\n", n_fds, timeout);
	#endif

	n_ready = _dbus_socket_set_poll (loop->socket_set, ready_fds,
	_DBUS_N_ELEMENTS (ready_fds), timeout);

	/* re-enable any watches we skipped this time */
	if (loop->oom_watch_pending)
	{
	DBusHashIter hash_iter;

	loop->oom_watch_pending = FALSE;

	_dbus_hash_iter_init (loop->watches, &hash_iter);

	while (_dbus_hash_iter_next (&hash_iter))
	{
	DBusList **watches;
	int fd;
	dbus_bool_t changed;

	changed = FALSE;
	fd = _dbus_hash_iter_get_int_key (&hash_iter);
	watches = _dbus_hash_iter_get_value (&hash_iter);

	for (link = _dbus_list_get_first_link (watches);
	link != NULL;
	link = _dbus_list_get_next_link (watches, link))
	{
	DBusWatch *watch = link->data;

	if (_dbus_watch_get_oom_last_time (watch))
	{
	_dbus_watch_set_oom_last_time (watch, FALSE);
	changed = TRUE;
	}
	}

	if (changed)
	refresh_watches_for_fd (loop, watches, fd);
	}

	retval = TRUE; /* return TRUE here to keep the loop going,
	* since we don't know the watch was inactive */
	}

	initial_serial = loop->callback_list_serial;

	if (loop->timeout_count > 0)
	{
	unsigned long tv_sec;
	unsigned long tv_usec;

	_dbus_get_monotonic_time (&tv_sec, &tv_usec);

	/* It'd be nice to avoid this O(n) thingy here */
	link = _dbus_list_get_first_link (&loop->timeouts);
	while (link != NULL)
	{
	DBusList *next = _dbus_list_get_next_link (&loop->timeouts, link);
	TimeoutCallback *tcb = link->data;

	if (initial_serial != loop->callback_list_serial)
	goto next_iteration;

	if (loop->depth != orig_depth)
	goto next_iteration;

	if (dbus_timeout_get_enabled (tcb->timeout))
	{
	int msecs_remaining;

	if (check_timeout (tv_sec, tv_usec,
	tcb, &msecs_remaining))
	{
	/* Save last callback time and fire this timeout */
	tcb->last_tv_sec = tv_sec;
	tcb->last_tv_usec = tv_usec;

	#if MAINLOOP_SPEW
	_dbus_verbose (" invoking timeout\n");
	#endif

	/* can theoretically return FALSE on OOM, but we just
	* let it fire again later - in practice that's what
	* every wrapper callback in dbus-daemon used to do */
	dbus_timeout_handle (tcb->timeout);

	retval = TRUE;
	}
	else
	{
	#if MAINLOOP_SPEW
	_dbus_verbose (" timeout has not expired\n");
	#endif
	}
	}
	#if MAINLOOP_SPEW
	else
	{
	_dbus_verbose (" skipping invocation of disabled timeout\n");
	}
	#endif

	link = next;
	}
	}

	if (n_ready > 0)
	{
	for (i = 0; i < n_ready; i++)
	{
	DBusList **watches;
	DBusList *next;
	unsigned int condition;
	dbus_bool_t any_oom;

	/* FIXME I think this "restart if we change the watches"
	* approach could result in starving watches
	* toward the end of the list.
	*/
	if (initial_serial != loop->callback_list_serial)
	goto next_iteration;

	if (loop->depth != orig_depth)
	goto next_iteration;

	_dbus_assert (ready_fds[i].flags != 0);

	if (_DBUS_UNLIKELY (ready_fds[i].flags & _DBUS_WATCH_NVAL))
	{
	cull_watches_for_invalid_fd (loop, ready_fds[i].fd);
	goto next_iteration;
	}

	condition = ready_fds[i].flags;
	_dbus_assert ((condition & _DBUS_WATCH_NVAL) == 0);

	/* condition may still be 0 if we got some
	* weird POLLFOO thing like POLLWRBAND
	*/
	if (condition == 0)
	continue;

	watches = _dbus_hash_table_lookup_int (loop->watches,
	ready_fds[i].fd);

	if (watches == NULL)
	continue;

	any_oom = FALSE;

	for (link = _dbus_list_get_first_link (watches);
	link != NULL;
	link = next)
	{
	DBusWatch *watch = link->data;

	next = _dbus_list_get_next_link (watches, link);

	if (dbus_watch_get_enabled (watch))
	{
	dbus_bool_t oom;

	oom = !dbus_watch_handle (watch, condition);

	if (oom)
	{
	_dbus_watch_set_oom_last_time (watch, TRUE);
	loop->oom_watch_pending = TRUE;
	any_oom = TRUE;
	}

	#if MAINLOOP_SPEW
	_dbus_verbose (" Invoked watch, oom = %d\n", oom);
	#endif
	retval = TRUE;

	/* We re-check this every time, in case the callback
	* added/removed watches, which might make our position in
	* the linked list invalid. See the FIXME above. */
	if (initial_serial != loop->callback_list_serial \|\|
	loop->depth != orig_depth)
	{
	if (any_oom)
	refresh_watches_for_fd (loop, NULL, ready_fds[i].fd);

	goto next_iteration;
	}
	}
	}

	if (any_oom)
	refresh_watches_for_fd (loop, watches, ready_fds[i].fd);
	}
	}

	next_iteration:
	#if MAINLOOP_SPEW
	_dbus_verbose (" moving to next iteration\n");
	#endif

	if (_dbus_loop_dispatch (loop))
	retval = TRUE;

	#if MAINLOOP_SPEW
	_dbus_verbose ("Returning %d\n", retval);
	#endif

	return retval;
	}

	void
	_dbus_loop_run (DBusLoop *loop)
	{
	int our_exit_depth;

	_dbus_assert (loop->depth >= 0);

	_dbus_loop_ref (loop);

	our_exit_depth = loop->depth;
	loop->depth += 1;

	_dbus_verbose ("Running main loop, depth %d -> %d\n",
	loop->depth - 1, loop->depth);

	while (loop->depth != our_exit_depth)
	_dbus_loop_iterate (loop, TRUE);

	_dbus_loop_unref (loop);
	}

	void
	_dbus_loop_quit (DBusLoop *loop)
	{
	_dbus_assert (loop->depth > 0);

	loop->depth -= 1;

	_dbus_verbose ("Quit main loop, depth %d -> %d\n",
	loop->depth + 1, loop->depth);
	}

	int
	_dbus_get_oom_wait (void)
	{
	#ifdef DBUS_BUILD_TESTS
	/* make tests go fast */
	return 0;
	#else
	return 500;
	#endif
	}

	void
	_dbus_wait_for_memory (void)
	{
	_dbus_verbose ("Waiting for more memory\n");
	_dbus_sleep_milliseconds (_dbus_get_oom_wait ());
	}

	#endif /* !DOXYGEN_SHOULD_SKIP_THIS */