dbus/dbus-mainloop.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-mainloop.c  Main loop utility
   3  *
   4  * Copyright (C) 2003, 2004  Red Hat, Inc.
   5  *
   6  * Licensed under the Academic Free License version 2.1
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  *
  22  */
  23
  24 #include "dbus-mainloop.h"
  25
  26 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  27
  28 #include <dbus/dbus-list.h>
  29 #include <dbus/dbus-sysdeps.h>
  30
  31 #define MAINLOOP_SPEW 0
  32
  33 #if MAINLOOP_SPEW
  34 #ifdef DBUS_ENABLE_VERBOSE_MODE
  35 static const char*
  36 watch_flags_to_string (int flags)
  37 {
  38   const char *watch_type;
  39
  40   if ((flags & DBUS_WATCH_READABLE) &&
  41       (flags & DBUS_WATCH_WRITABLE))
  42     watch_type = "readwrite";
  43   else if (flags & DBUS_WATCH_READABLE)
  44     watch_type = "read";
  45   else if (flags & DBUS_WATCH_WRITABLE)
  46     watch_type = "write";
  47   else
  48     watch_type = "not read or write";
  49   return watch_type;
  50 }
  51 #endif /* DBUS_ENABLE_VERBOSE_MODE */
  52 #endif /* MAINLOOP_SPEW */
  53
  54 struct DBusLoop
  55 {
  56   int refcount;
  57   DBusList *callbacks;
  58   int callback_list_serial;
  59   int watch_count;
  60   int timeout_count;
  61   int depth; /**< number of recursive runs */
  62   DBusList *need_dispatch;
  63 };
  64
  65 typedef enum
  66 {
  67   CALLBACK_WATCH,
  68   CALLBACK_TIMEOUT
  69 } CallbackType;
  70
  71 typedef struct
  72 {
  73   int refcount;
  74   CallbackType type;
  75   void *data;
  76   DBusFreeFunction free_data_func;
  77 } Callback;
  78
  79 typedef struct
  80 {
  81   Callback callback;
  82   DBusWatchFunction function;
  83   DBusWatch *watch;
  84   /* last watch handle failed due to OOM */
  85   unsigned int last_iteration_oom : 1;
  86 } WatchCallback;
  87
  88 typedef struct
  89 {
  90   Callback callback;
  91   DBusTimeout *timeout;
  92   DBusTimeoutFunction function;
  93   unsigned long last_tv_sec;
  94   unsigned long last_tv_usec;
  95 } TimeoutCallback;
  96
  97 #define WATCH_CALLBACK(callback)   ((WatchCallback*)callback)
  98 #define TIMEOUT_CALLBACK(callback) ((TimeoutCallback*)callback)
  99
 100 static WatchCallback*
 101 watch_callback_new (DBusWatch         *watch,
 102                     DBusWatchFunction  function,
 103                     void              *data,
 104                     DBusFreeFunction   free_data_func)
 105 {
 106   WatchCallback *cb;
 107
 108   cb = dbus_new (WatchCallback, 1);
 109   if (cb == NULL)
 110     return NULL;
 111
 112   cb->watch = watch;
 113   cb->function = function;
 114   cb->last_iteration_oom = FALSE;
 115   cb->callback.refcount = 1;
 116   cb->callback.type = CALLBACK_WATCH;
 117   cb->callback.data = data;
 118   cb->callback.free_data_func = free_data_func;
 119
 120   return cb;
 121 }
 122
 123 static TimeoutCallback*
 124 timeout_callback_new (DBusTimeout         *timeout,
 125                       DBusTimeoutFunction  function,
 126                       void                *data,
 127                       DBusFreeFunction     free_data_func)
 128 {
 129   TimeoutCallback *cb;
 130
 131   cb = dbus_new (TimeoutCallback, 1);
 132   if (cb == NULL)
 133     return NULL;
 134
 135   cb->timeout = timeout;
 136   cb->function = function;
 137   _dbus_get_current_time (&cb->last_tv_sec,
 138                           &cb->last_tv_usec);
 139   cb->callback.refcount = 1;
 140   cb->callback.type = CALLBACK_TIMEOUT;
 141   cb->callback.data = data;
 142   cb->callback.free_data_func = free_data_func;
 143
 144   return cb;
 145 }
 146
 147 static Callback *
 148 callback_ref (Callback *cb)
 149 {
 150   _dbus_assert (cb->refcount > 0);
 151
 152   cb->refcount += 1;
 153
 154   return cb;
 155 }
 156
 157 static void
 158 callback_unref (Callback *cb)
 159 {
 160   _dbus_assert (cb->refcount > 0);
 161
 162   cb->refcount -= 1;
 163
 164   if (cb->refcount == 0)
 165     {
 166       if (cb->free_data_func)
 167         (* cb->free_data_func) (cb->data);
 168
 169       dbus_free (cb);
 170     }
 171 }
 172
 173 static dbus_bool_t
 174 add_callback (DBusLoop  *loop,
 175               Callback *cb)
 176 {
 177   if (!_dbus_list_append (&loop->callbacks, cb))
 178     return FALSE;
 179
 180   loop->callback_list_serial += 1;
 181
 182   switch (cb->type)
 183     {
 184     case CALLBACK_WATCH:
 185       loop->watch_count += 1;
 186       break;
 187     case CALLBACK_TIMEOUT:
 188       loop->timeout_count += 1;
 189       break;
 190     }
 191
 192   return TRUE;
 193 }
 194
 195 static void
 196 remove_callback (DBusLoop  *loop,
 197                  DBusList *link)
 198 {
 199   Callback *cb = link->data;
 200
 201   switch (cb->type)
 202     {
 203     case CALLBACK_WATCH:
 204       loop->watch_count -= 1;
 205       break;
 206     case CALLBACK_TIMEOUT:
 207       loop->timeout_count -= 1;
 208       break;
 209     }
 210
 211   callback_unref (cb);
 212   _dbus_list_remove_link (&loop->callbacks, link);
 213   loop->callback_list_serial += 1;
 214 }
 215
 216 DBusLoop*
 217 _dbus_loop_new (void)
 218 {
 219   DBusLoop *loop;
 220
 221   loop = dbus_new0 (DBusLoop, 1);
 222   if (loop == NULL)
 223     return NULL;
 224
 225   loop->refcount = 1;
 226
 227   return loop;
 228 }
 229
 230 DBusLoop *
 231 _dbus_loop_ref (DBusLoop *loop)
 232 {
 233   _dbus_assert (loop != NULL);
 234   _dbus_assert (loop->refcount > 0);
 235
 236   loop->refcount += 1;
 237
 238   return loop;
 239 }
 240
 241 void
 242 _dbus_loop_unref (DBusLoop *loop)
 243 {
 244   _dbus_assert (loop != NULL);
 245   _dbus_assert (loop->refcount > 0);
 246
 247   loop->refcount -= 1;
 248   if (loop->refcount == 0)
 249     {
 250       while (loop->need_dispatch)
 251         {
 252           DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);
 253
 254           dbus_connection_unref (connection);
 255         }
 256
 257       dbus_free (loop);
 258     }
 259 }
 260
 261 dbus_bool_t
 262 _dbus_loop_add_watch (DBusLoop          *loop,
 263                       DBusWatch        *watch,
 264                       DBusWatchFunction  function,
 265                       void             *data,
 266                       DBusFreeFunction  free_data_func)
 267 {
 268   WatchCallback *wcb;
 269
 270   wcb = watch_callback_new (watch, function, data, free_data_func);
 271   if (wcb == NULL)
 272     return FALSE;
 273
 274   if (!add_callback (loop, (Callback*) wcb))
 275     {
 276       wcb->callback.free_data_func = NULL; /* don't want to have this side effect */
 277       callback_unref ((Callback*) wcb);
 278       return FALSE;
 279     }
 280
 281   return TRUE;
 282 }
 283
 284 void
 285 _dbus_loop_remove_watch (DBusLoop          *loop,
 286                          DBusWatch        *watch,
 287                          DBusWatchFunction  function,
 288                          void             *data)
 289 {
 290   DBusList *link;
 291
 292   link = _dbus_list_get_first_link (&loop->callbacks);
 293   while (link != NULL)
 294     {
 295       DBusList *next = _dbus_list_get_next_link (&loop->callbacks, link);
 296       Callback *this = link->data;
 297
 298       if (this->type == CALLBACK_WATCH &&
 299           WATCH_CALLBACK (this)->watch == watch &&
 300           this->data == data &&
 301           WATCH_CALLBACK (this)->function == function)
 302         {
 303           remove_callback (loop, link);
 304
 305           return;
 306         }
 307
 308       link = next;
 309     }
 310
 311   _dbus_warn ("could not find watch %p function %p data %p to remove\n",
 312               watch, (void *)function, data);
 313 }
 314
 315 dbus_bool_t
 316 _dbus_loop_add_timeout (DBusLoop            *loop,
 317                         DBusTimeout        *timeout,
 318                         DBusTimeoutFunction  function,
 319                         void               *data,
 320                         DBusFreeFunction    free_data_func)
 321 {
 322   TimeoutCallback *tcb;
 323
 324   tcb = timeout_callback_new (timeout, function, data, free_data_func);
 325   if (tcb == NULL)
 326     return FALSE;
 327
 328   if (!add_callback (loop, (Callback*) tcb))
 329     {
 330       tcb->callback.free_data_func = NULL; /* don't want to have this side effect */
 331       callback_unref ((Callback*) tcb);
 332       return FALSE;
 333     }
 334
 335   return TRUE;
 336 }
 337
 338 void
 339 _dbus_loop_remove_timeout (DBusLoop            *loop,
 340                            DBusTimeout        *timeout,
 341                            DBusTimeoutFunction  function,
 342                            void               *data)
 343 {
 344   DBusList *link;
 345
 346   link = _dbus_list_get_first_link (&loop->callbacks);
 347   while (link != NULL)
 348     {
 349       DBusList *next = _dbus_list_get_next_link (&loop->callbacks, link);
 350       Callback *this = link->data;
 351
 352       if (this->type == CALLBACK_TIMEOUT &&
 353           TIMEOUT_CALLBACK (this)->timeout == timeout &&
 354           this->data == data &&
 355           TIMEOUT_CALLBACK (this)->function == function)
 356         {
 357           remove_callback (loop, link);
 358
 359           return;
 360         }
 361
 362       link = next;
 363     }
 364
 365   _dbus_warn ("could not find timeout %p function %p data %p to remove\n",
 366               timeout, (void *)function, data);
 367 }
 368
 369 /* Convolutions from GLib, there really must be a better way
 370  * to do this.
 371  */
 372 static dbus_bool_t
 373 check_timeout (unsigned long    tv_sec,
 374                unsigned long    tv_usec,
 375                TimeoutCallback *tcb,
 376                int             *timeout)
 377 {
 378   long sec_remaining;
 379   long msec_remaining;
 380   unsigned long expiration_tv_sec;
 381   unsigned long expiration_tv_usec;
 382   long interval_seconds;
 383   long interval_milliseconds;
 384   int interval;
 385
 386   /* I'm pretty sure this function could suck (a lot) less */
 387
 388   interval = dbus_timeout_get_interval (tcb->timeout);
 389
 390   interval_seconds = interval / 1000L;
 391   interval_milliseconds = interval % 1000L;
 392
 393   expiration_tv_sec = tcb->last_tv_sec + interval_seconds;
 394   expiration_tv_usec = tcb->last_tv_usec + interval_milliseconds * 1000;
 395   if (expiration_tv_usec >= 1000000)
 396     {
 397       expiration_tv_usec -= 1000000;
 398       expiration_tv_sec += 1;
 399     }
 400
 401   sec_remaining = expiration_tv_sec - tv_sec;
 402   /* need to force this to be signed, as it is intended to sometimes
 403    * produce a negative result
 404    */
 405   msec_remaining = ((long) expiration_tv_usec - (long) tv_usec) / 1000L;
 406
 407 #if MAINLOOP_SPEW
 408   _dbus_verbose ("Interval is %ld seconds %ld msecs\n",
 409                  interval_seconds,
 410                  interval_milliseconds);
 411   _dbus_verbose ("Now is  %lu seconds %lu usecs\n",
 412                  tv_sec, tv_usec);
 413   _dbus_verbose ("Last is %lu seconds %lu usecs\n",
 414                  tcb->last_tv_sec, tcb->last_tv_usec);
 415   _dbus_verbose ("Exp is  %lu seconds %lu usecs\n",
 416                  expiration_tv_sec, expiration_tv_usec);
 417   _dbus_verbose ("Pre-correction, sec_remaining %ld msec_remaining %ld\n",
 418                  sec_remaining, msec_remaining);
 419 #endif
 420
 421   /* We do the following in a rather convoluted fashion to deal with
 422    * the fact that we don't have an integral type big enough to hold
 423    * the difference of two timevals in milliseconds.
 424    */
 425   if (sec_remaining < 0 || (sec_remaining == 0 && msec_remaining < 0))
 426     {
 427       *timeout = 0;
 428     }
 429   else
 430     {
 431       if (msec_remaining < 0)
 432         {
 433           msec_remaining += 1000;
 434           sec_remaining -= 1;
 435         }
 436
 437       if (sec_remaining > (_DBUS_INT_MAX / 1000) ||
 438           msec_remaining > _DBUS_INT_MAX)
 439         *timeout = _DBUS_INT_MAX;
 440       else
 441         *timeout = sec_remaining * 1000 + msec_remaining;
 442     }
 443
 444   if (*timeout > interval)
 445     {
 446       /* This indicates that the system clock probably moved backward */
 447       _dbus_verbose ("System clock set backward! Resetting timeout.\n");
 448
 449       tcb->last_tv_sec = tv_sec;
 450       tcb->last_tv_usec = tv_usec;
 451
 452       *timeout = interval;
 453     }
 454
 455 #if MAINLOOP_SPEW
 456   _dbus_verbose ("  timeout expires in %d milliseconds\n", *timeout);
 457 #endif
 458
 459   return *timeout == 0;
 460 }
 461
 462 dbus_bool_t
 463 _dbus_loop_dispatch (DBusLoop *loop)
 464 {
 465
 466 #if MAINLOOP_SPEW
 467   _dbus_verbose ("  %d connections to dispatch\n", _dbus_list_get_length (&loop->need_dispatch));
 468 #endif
 469
 470   if (loop->need_dispatch == NULL)
 471     return FALSE;
 472
 473  next:
 474   while (loop->need_dispatch != NULL)
 475     {
 476       DBusConnection *connection = _dbus_list_pop_first (&loop->need_dispatch);
 477
 478       while (TRUE)
 479         {
 480           DBusDispatchStatus status;
 481
 482           status = dbus_connection_dispatch (connection);
 483
 484           if (status == DBUS_DISPATCH_COMPLETE)
 485             {
 486               dbus_connection_unref (connection);
 487               goto next;
 488             }
 489           else
 490             {
 491               if (status == DBUS_DISPATCH_NEED_MEMORY)
 492                 _dbus_wait_for_memory ();
 493             }
 494         }
 495     }
 496
 497   return TRUE;
 498 }
 499
 500 dbus_bool_t
 501 _dbus_loop_queue_dispatch (DBusLoop       *loop,
 502                            DBusConnection *connection)
 503 {
 504   if (_dbus_list_append (&loop->need_dispatch, connection))
 505     {
 506       dbus_connection_ref (connection);
 507       return TRUE;
 508     }
 509   else
 510     return FALSE;
 511 }
 512
 513 /* Returns TRUE if we invoked any timeouts or have ready file
 514  * descriptors, which is just used in test code as a debug hack
 515  */
 516
 517 dbus_bool_t
 518 _dbus_loop_iterate (DBusLoop     *loop,
 519                     dbus_bool_t   block)
 520 {
 521 #define N_STACK_DESCRIPTORS 64
 522   dbus_bool_t retval;
 523   DBusPollFD *fds;
 524   DBusPollFD stack_fds[N_STACK_DESCRIPTORS];
 525   int n_fds;
 526   WatchCallback **watches_for_fds;
 527   WatchCallback *stack_watches_for_fds[N_STACK_DESCRIPTORS];
 528   int i;
 529   DBusList *link;
 530   int n_ready;
 531   int initial_serial;
 532   long timeout;
 533   dbus_bool_t oom_watch_pending;
 534   int orig_depth;
 535
 536   retval = FALSE;
 537
 538   fds = NULL;
 539   watches_for_fds = NULL;
 540   n_fds = 0;
 541   oom_watch_pending = FALSE;
 542   orig_depth = loop->depth;
 543
 544 #if MAINLOOP_SPEW
 545   _dbus_verbose ("Iteration block=%d depth=%d timeout_count=%d watch_count=%d\n",
 546                  block, loop->depth, loop->timeout_count, loop->watch_count);
 547 #endif
 548
 549   if (loop->callbacks == NULL)
 550     goto next_iteration;
 551
 552   if (loop->watch_count > N_STACK_DESCRIPTORS)
 553     {
 554       fds = dbus_new0 (DBusPollFD, loop->watch_count);
 555
 556       while (fds == NULL)
 557         {
 558           _dbus_wait_for_memory ();
 559           fds = dbus_new0 (DBusPollFD, loop->watch_count);
 560         }
 561
 562       watches_for_fds = dbus_new (WatchCallback*, loop->watch_count);
 563       while (watches_for_fds == NULL)
 564         {
 565           _dbus_wait_for_memory ();
 566           watches_for_fds = dbus_new (WatchCallback*, loop->watch_count);
 567         }
 568     }
 569   else
 570     {
 571       fds = stack_fds;
 572       watches_for_fds = stack_watches_for_fds;
 573     }
 574
 575   /* fill our array of fds and watches */
 576   n_fds = 0;
 577   link = _dbus_list_get_first_link (&loop->callbacks);
 578   while (link != NULL)
 579     {
 580       DBusList *next = _dbus_list_get_next_link (&loop->callbacks, link);
 581       Callback *cb = link->data;
 582       if (cb->type == CALLBACK_WATCH)
 583         {
 584           unsigned int flags;
 585           WatchCallback *wcb = WATCH_CALLBACK (cb);
 586
 587           if (wcb->last_iteration_oom)
 588             {
 589               /* we skip this one this time, but reenable it next time,
 590                * and have a timeout on this iteration
 591                */
 592               wcb->last_iteration_oom = FALSE;
 593               oom_watch_pending = TRUE;
 594
 595               retval = TRUE; /* return TRUE here to keep the loop going,
 596                               * since we don't know the watch is inactive
 597                               */
 598
 599 #if MAINLOOP_SPEW
 600               _dbus_verbose ("  skipping watch on fd %d as it was out of memory last time\n",
 601                              dbus_watch_get_socket (wcb->watch));
 602 #endif
 603             }
 604           else if (dbus_watch_get_enabled (wcb->watch))
 605             {
 606               watches_for_fds[n_fds] = wcb;
 607
 608               callback_ref (cb);
 609
 610               flags = dbus_watch_get_flags (wcb->watch);
 611
 612               fds[n_fds].fd = dbus_watch_get_socket (wcb->watch);
 613               fds[n_fds].revents = 0;
 614               fds[n_fds].events = 0;
 615               if (flags & DBUS_WATCH_READABLE)
 616                 fds[n_fds].events |= _DBUS_POLLIN;
 617               if (flags & DBUS_WATCH_WRITABLE)
 618                 fds[n_fds].events |= _DBUS_POLLOUT;
 619
 620 #if MAINLOOP_SPEW
 621               _dbus_verbose ("  polling watch on fd %d  %s\n",
 622                              fds[n_fds].fd, watch_flags_to_string (flags));
 623 #endif
 624
 625               n_fds += 1;
 626             }
 627           else
 628             {
 629 #if MAINLOOP_SPEW
 630               _dbus_verbose ("  skipping disabled watch on fd %d  %s\n",
 631                              dbus_watch_get_socket (wcb->watch),
 632                              watch_flags_to_string (dbus_watch_get_flags (wcb->watch)));
 633 #endif
 634             }
 635         }
 636
 637       link = next;
 638     }
 639
 640   timeout = -1;
 641   if (loop->timeout_count > 0)
 642     {
 643       unsigned long tv_sec;
 644       unsigned long tv_usec;
 645
 646       _dbus_get_current_time (&tv_sec, &tv_usec);
 647
 648       link = _dbus_list_get_first_link (&loop->callbacks);
 649       while (link != NULL)
 650         {
 651           DBusList *next = _dbus_list_get_next_link (&loop->callbacks, link);
 652           Callback *cb = link->data;
 653
 654           if (cb->type == CALLBACK_TIMEOUT &&
 655               dbus_timeout_get_enabled (TIMEOUT_CALLBACK (cb)->timeout))
 656             {
 657               TimeoutCallback *tcb = TIMEOUT_CALLBACK (cb);
 658               int msecs_remaining;
 659
 660               check_timeout (tv_sec, tv_usec, tcb, &msecs_remaining);
 661
 662               if (timeout < 0)
 663                 timeout = msecs_remaining;
 664               else
 665                 timeout = MIN (msecs_remaining, timeout);
 666
 667 #if MAINLOOP_SPEW
 668               _dbus_verbose ("  timeout added, %d remaining, aggregate timeout %ld\n",
 669                              msecs_remaining, timeout);
 670 #endif
 671
 672               _dbus_assert (timeout >= 0);
 673
 674               if (timeout == 0)
 675                 break; /* it's not going to get shorter... */
 676             }
 677 #if MAINLOOP_SPEW
 678           else if (cb->type == CALLBACK_TIMEOUT)
 679             {
 680               _dbus_verbose ("  skipping disabled timeout\n");
 681             }
 682 #endif
 683
 684           link = next;
 685         }
 686     }
 687
 688   /* Never block if we have stuff to dispatch */
 689   if (!block || loop->need_dispatch != NULL)
 690     {
 691       timeout = 0;
 692 #if MAINLOOP_SPEW
 693       _dbus_verbose ("  timeout is 0 as we aren't blocking\n");
 694 #endif
 695     }
 696
 697   /* if a watch is OOM, don't wait longer than the OOM
 698    * wait to re-enable it
 699    */
 700   if (oom_watch_pending)
 701     timeout = MIN (timeout, _dbus_get_oom_wait ());
 702
 703 #if MAINLOOP_SPEW
 704   _dbus_verbose ("  polling on %d descriptors timeout %ld\n", n_fds, timeout);
 705 #endif
 706
 707   n_ready = _dbus_poll (fds, n_fds, timeout);
 708
 709   initial_serial = loop->callback_list_serial;
 710
 711   if (loop->timeout_count > 0)
 712     {
 713       unsigned long tv_sec;
 714       unsigned long tv_usec;
 715
 716       _dbus_get_current_time (&tv_sec, &tv_usec);
 717
 718       /* It'd be nice to avoid this O(n) thingy here */
 719       link = _dbus_list_get_first_link (&loop->callbacks);
 720       while (link != NULL)
 721         {
 722           DBusList *next = _dbus_list_get_next_link (&loop->callbacks, link);
 723           Callback *cb = link->data;
 724
 725           if (initial_serial != loop->callback_list_serial)
 726             goto next_iteration;
 727
 728           if (loop->depth != orig_depth)
 729             goto next_iteration;
 730
 731           if (cb->type == CALLBACK_TIMEOUT &&
 732               dbus_timeout_get_enabled (TIMEOUT_CALLBACK (cb)->timeout))
 733             {
 734               TimeoutCallback *tcb = TIMEOUT_CALLBACK (cb);
 735               int msecs_remaining;
 736
 737               if (check_timeout (tv_sec, tv_usec,
 738                                  tcb, &msecs_remaining))
 739                 {
 740                   /* Save last callback time and fire this timeout */
 741                   tcb->last_tv_sec = tv_sec;
 742                   tcb->last_tv_usec = tv_usec;
 743
 744 #if MAINLOOP_SPEW
 745                   _dbus_verbose ("  invoking timeout\n");
 746 #endif
 747
 748                   (* tcb->function) (tcb->timeout,
 749                                      cb->data);
 750
 751                   retval = TRUE;
 752                 }
 753               else
 754                 {
 755 #if MAINLOOP_SPEW
 756                   _dbus_verbose ("  timeout has not expired\n");
 757 #endif
 758                 }
 759             }
 760 #if MAINLOOP_SPEW
 761           else if (cb->type == CALLBACK_TIMEOUT)
 762             {
 763               _dbus_verbose ("  skipping invocation of disabled timeout\n");
 764             }
 765 #endif
 766
 767           link = next;
 768         }
 769     }
 770
 771   if (n_ready > 0)
 772     {
 773       i = 0;
 774       while (i < n_fds)
 775         {
 776           /* FIXME I think this "restart if we change the watches"
 777            * approach could result in starving watches
 778            * toward the end of the list.
 779            */
 780           if (initial_serial != loop->callback_list_serial)
 781             goto next_iteration;
 782
 783           if (loop->depth != orig_depth)
 784             goto next_iteration;
 785
 786           if (fds[i].revents != 0)
 787             {
 788               WatchCallback *wcb;
 789               unsigned int condition;
 790
 791               wcb = watches_for_fds[i];
 792
 793               condition = 0;
 794               if (fds[i].revents & _DBUS_POLLIN)
 795                 condition |= DBUS_WATCH_READABLE;
 796               if (fds[i].revents & _DBUS_POLLOUT)
 797                 condition |= DBUS_WATCH_WRITABLE;
 798               if (fds[i].revents & _DBUS_POLLHUP)
 799                 condition |= DBUS_WATCH_HANGUP;
 800               if (fds[i].revents & _DBUS_POLLERR)
 801                 condition |= DBUS_WATCH_ERROR;
 802
 803               /* condition may still be 0 if we got some
 804                * weird POLLFOO thing like POLLWRBAND
 805                */
 806
 807               if (condition != 0 &&
 808                   dbus_watch_get_enabled (wcb->watch))
 809                 {
 810                   if (!(* wcb->function) (wcb->watch,
 811                                           condition,
 812                                           ((Callback*)wcb)->data))
 813                     wcb->last_iteration_oom = TRUE;
 814
 815 #if MAINLOOP_SPEW
 816                   _dbus_verbose ("  Invoked watch, oom = %d\n",
 817                                  wcb->last_iteration_oom);
 818 #endif
 819
 820                   retval = TRUE;
 821                 }
 822             }
 823
 824           ++i;
 825         }
 826     }
 827
 828  next_iteration:
 829 #if MAINLOOP_SPEW
 830   _dbus_verbose ("  moving to next iteration\n");
 831 #endif
 832
 833   if (fds && fds != stack_fds)
 834     dbus_free (fds);
 835   if (watches_for_fds)
 836     {
 837       i = 0;
 838       while (i < n_fds)
 839         {
 840           callback_unref (&watches_for_fds[i]->callback);
 841           ++i;
 842         }
 843
 844       if (watches_for_fds != stack_watches_for_fds)
 845         dbus_free (watches_for_fds);
 846     }
 847
 848   if (_dbus_loop_dispatch (loop))
 849     retval = TRUE;
 850
 851 #if MAINLOOP_SPEW
 852   _dbus_verbose ("Returning %d\n", retval);
 853 #endif
 854
 855   return retval;
 856 }
 857
 858 void
 859 _dbus_loop_run (DBusLoop *loop)
 860 {
 861   int our_exit_depth;
 862
 863   _dbus_assert (loop->depth >= 0);
 864
 865   _dbus_loop_ref (loop);
 866
 867   our_exit_depth = loop->depth;
 868   loop->depth += 1;
 869
 870   _dbus_verbose ("Running main loop, depth %d -> %d\n",
 871                  loop->depth - 1, loop->depth);
 872
 873   while (loop->depth != our_exit_depth)
 874     _dbus_loop_iterate (loop, TRUE);
 875
 876   _dbus_loop_unref (loop);
 877 }
 878
 879 void
 880 _dbus_loop_quit (DBusLoop *loop)
 881 {
 882   _dbus_assert (loop->depth > 0);
 883
 884   loop->depth -= 1;
 885
 886   _dbus_verbose ("Quit main loop, depth %d -> %d\n",
 887                  loop->depth + 1, loop->depth);
 888 }
 889
 890 int
 891 _dbus_get_oom_wait (void)
 892 {
 893 #ifdef DBUS_BUILD_TESTS
 894   /* make tests go fast */
 895   return 0;
 896 #else
 897   return 500;
 898 #endif
 899 }
 900
 901 void
 902 _dbus_wait_for_memory (void)
 903 {
 904   _dbus_verbose ("Waiting for more memory\n");
 905   _dbus_sleep_milliseconds (_dbus_get_oom_wait ());
 906 }
 907
 908 #endif /* !DOXYGEN_SHOULD_SKIP_THIS */