glib/gmain.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * gmain.c: Main loop abstraction, timeouts, and idle functions
   5  * Copyright 1998 Owen Taylor
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /*
  24  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  25  * file for a list of people on the GLib Team.  See the ChangeLog
  26  * files for a list of changes.  These files are distributed with
  27  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  28  */
  29
  30 /*
  31  * MT safe
  32  */
  33
  34 #include "config.h"
  35
  36 /* Uncomment the next line (and the corresponding line in gpoll.c) to
  37  * enable debugging printouts if the environment variable
  38  * G_MAIN_POLL_DEBUG is set to some value.
  39  */
  40 /* #define G_MAIN_POLL_DEBUG */
  41
  42 #ifdef _WIN32
  43 /* Always enable debugging printout on Windows, as it is more often
  44  * needed there...
  45  */
  46 #define G_MAIN_POLL_DEBUG
  47 #endif
  48
  49 #define _GNU_SOURCE  /* for pipe2 */
  50
  51 #include "glib.h"
  52 #include "gthreadprivate.h"
  53 #include <signal.h>
  54 #include <sys/types.h>
  55 #include <time.h>
  56 #include <stdlib.h>
  57 #ifdef HAVE_SYS_TIME_H
  58 #include <sys/time.h>
  59 #endif /* HAVE_SYS_TIME_H */
  60 #ifdef HAVE_UNISTD_H
  61 #include <unistd.h>
  62 #endif /* HAVE_UNISTD_H */
  63 #include <errno.h>
  64
  65 #ifdef G_OS_WIN32
  66 #define STRICT
  67 #include <windows.h>
  68 #endif /* G_OS_WIN32 */
  69
  70 #ifdef G_OS_BEOS
  71 #include <sys/socket.h>
  72 #include <sys/wait.h>
  73 #endif /* G_OS_BEOS */
  74
  75 #ifdef G_OS_UNIX
  76 #include <fcntl.h>
  77 #include <sys/wait.h>
  78 #endif
  79
  80 #include "galias.h"
  81
  82 /* Types */
  83
  84 typedef struct _GTimeoutSource GTimeoutSource;
  85 typedef struct _GChildWatchSource GChildWatchSource;
  86 typedef struct _GPollRec GPollRec;
  87 typedef struct _GSourceCallback GSourceCallback;
  88
  89 typedef enum
  90 {
  91   G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,
  92   G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1)
  93 } GSourceFlags;
  94
  95 #ifdef G_THREADS_ENABLED
  96 typedef struct _GMainWaiter GMainWaiter;
  97
  98 struct _GMainWaiter
  99 {
 100   GCond *cond;
 101   GMutex *mutex;
 102 };
 103 #endif
 104
 105 typedef struct _GMainDispatch GMainDispatch;
 106
 107 struct _GMainDispatch
 108 {
 109   gint depth;
 110   GSList *dispatching_sources; /* stack of current sources */
 111 };
 112
 113 #ifdef G_MAIN_POLL_DEBUG
 114 gboolean _g_main_poll_debug = FALSE;
 115 #endif
 116
 117 struct _GMainContext
 118 {
 119 #ifdef G_THREADS_ENABLED
 120   /* The following lock is used for both the list of sources
 121    * and the list of poll records
 122    */
 123   GStaticMutex mutex;
 124   GCond *cond;
 125   GThread *owner;
 126   guint owner_count;
 127   GSList *waiters;
 128 #endif
 129
 130   gint ref_count;
 131
 132   GPtrArray *pending_dispatches;
 133   gint timeout;                 /* Timeout for current iteration */
 134
 135   guint next_id;
 136   GSource *source_list;
 137   gint in_check_or_prepare;
 138
 139   GPollRec *poll_records;
 140   guint n_poll_records;
 141   GPollFD *cached_poll_array;
 142   guint cached_poll_array_size;
 143
 144 #ifdef G_THREADS_ENABLED
 145 #ifndef G_OS_WIN32
 146 /* this pipe is used to wake up the main loop when a source is added.
 147  */
 148   gint wake_up_pipe[2];
 149 #else /* G_OS_WIN32 */
 150   HANDLE wake_up_semaphore;
 151 #endif /* G_OS_WIN32 */
 152
 153   GPollFD wake_up_rec;
 154   gboolean poll_waiting;
 155
 156 /* Flag indicating whether the set of fd's changed during a poll */
 157   gboolean poll_changed;
 158 #endif /* G_THREADS_ENABLED */
 159
 160   GPollFunc poll_func;
 161
 162   GTimeVal current_time;
 163   gboolean time_is_current;
 164 };
 165
 166 struct _GSourceCallback
 167 {
 168   guint ref_count;
 169   GSourceFunc func;
 170   gpointer    data;
 171   GDestroyNotify notify;
 172 };
 173
 174 struct _GMainLoop
 175 {
 176   GMainContext *context;
 177   gboolean is_running;
 178   gint ref_count;
 179 };
 180
 181 struct _GTimeoutSource
 182 {
 183   GSource     source;
 184   GTimeVal    expiration;
 185   guint       interval;
 186   guint       granularity;
 187 };
 188
 189 struct _GChildWatchSource
 190 {
 191   GSource     source;
 192   GPid        pid;
 193   gint        child_status;
 194 #ifdef G_OS_WIN32
 195   GPollFD     poll;
 196 #else /* G_OS_WIN32 */
 197   gint        count;
 198   gboolean    child_exited;
 199 #endif /* G_OS_WIN32 */
 200 };
 201
 202 struct _GPollRec
 203 {
 204   GPollFD *fd;
 205   GPollRec *next;
 206   gint priority;
 207 };
 208
 209 #ifdef G_THREADS_ENABLED
 210 #define LOCK_CONTEXT(context) g_static_mutex_lock (&context->mutex)
 211 #define UNLOCK_CONTEXT(context) g_static_mutex_unlock (&context->mutex)
 212 #define G_THREAD_SELF g_thread_self ()
 213 #else
 214 #define LOCK_CONTEXT(context) (void)0
 215 #define UNLOCK_CONTEXT(context) (void)0
 216 #define G_THREAD_SELF NULL
 217 #endif
 218
 219 #define SOURCE_DESTROYED(source) (((source)->flags & G_HOOK_FLAG_ACTIVE) == 0)
 220 #define SOURCE_BLOCKED(source) (((source)->flags & G_HOOK_FLAG_IN_CALL) != 0 && \
 221                                 ((source)->flags & G_SOURCE_CAN_RECURSE) == 0)
 222
 223 #define SOURCE_UNREF(source, context)                       \
 224    G_STMT_START {                                           \
 225     if ((source)->ref_count > 1)                            \
 226       (source)->ref_count--;                                \
 227     else                                                    \
 228       g_source_unref_internal ((source), (context), TRUE);  \
 229    } G_STMT_END
 230
 231
 232 /* Forward declarations */
 233
 234 static void g_source_unref_internal             (GSource      *source,
 235                                                  GMainContext *context,
 236                                                  gboolean      have_lock);
 237 static void g_source_destroy_internal           (GSource      *source,
 238                                                  GMainContext *context,
 239                                                  gboolean      have_lock);
 240 static void g_main_context_poll                 (GMainContext *context,
 241                                                  gint          timeout,
 242                                                  gint          priority,
 243                                                  GPollFD      *fds,
 244                                                  gint          n_fds);
 245 static void g_main_context_add_poll_unlocked    (GMainContext *context,
 246                                                  gint          priority,
 247                                                  GPollFD      *fd);
 248 static void g_main_context_remove_poll_unlocked (GMainContext *context,
 249                                                  GPollFD      *fd);
 250 static void g_main_context_wakeup_unlocked      (GMainContext *context);
 251
 252 static gboolean g_timeout_prepare  (GSource     *source,
 253                                     gint        *timeout);
 254 static gboolean g_timeout_check    (GSource     *source);
 255 static gboolean g_timeout_dispatch (GSource     *source,
 256                                     GSourceFunc  callback,
 257                                     gpointer     user_data);
 258 static gboolean g_child_watch_prepare  (GSource     *source,
 259                                         gint        *timeout);
 260 static gboolean g_child_watch_check    (GSource     *source);
 261 static gboolean g_child_watch_dispatch (GSource     *source,
 262                                         GSourceFunc  callback,
 263                                         gpointer     user_data);
 264 static gboolean g_idle_prepare     (GSource     *source,
 265                                     gint        *timeout);
 266 static gboolean g_idle_check       (GSource     *source);
 267 static gboolean g_idle_dispatch    (GSource     *source,
 268                                     GSourceFunc  callback,
 269                                     gpointer     user_data);
 270
 271 G_LOCK_DEFINE_STATIC (main_loop);
 272 static GMainContext *default_main_context;
 273 static GSList *main_contexts_without_pipe = NULL;
 274
 275 #ifndef G_OS_WIN32
 276 /* Child status monitoring code */
 277 enum {
 278   CHILD_WATCH_UNINITIALIZED,
 279   CHILD_WATCH_INITIALIZED_SINGLE,
 280   CHILD_WATCH_INITIALIZED_THREADED
 281 };
 282 static gint child_watch_init_state = CHILD_WATCH_UNINITIALIZED;
 283 static gint child_watch_count = 1;
 284 static gint child_watch_wake_up_pipe[2] = {0, 0};
 285 #endif /* !G_OS_WIN32 */
 286 G_LOCK_DEFINE_STATIC (main_context_list);
 287 static GSList *main_context_list = NULL;
 288
 289 static gint timer_perturb = -1;
 290
 291 GSourceFuncs g_timeout_funcs =
 292 {
 293   g_timeout_prepare,
 294   g_timeout_check,
 295   g_timeout_dispatch,
 296   NULL
 297 };
 298
 299 GSourceFuncs g_child_watch_funcs =
 300 {
 301   g_child_watch_prepare,
 302   g_child_watch_check,
 303   g_child_watch_dispatch,
 304   NULL
 305 };
 306
 307 GSourceFuncs g_idle_funcs =
 308 {
 309   g_idle_prepare,
 310   g_idle_check,
 311   g_idle_dispatch,
 312   NULL
 313 };
 314
 315 /**
 316  * g_main_context_ref:
 317  * @context: a #GMainContext
 318  *
 319  * Increases the reference count on a #GMainContext object by one.
 320  *
 321  * Returns: the @context that was passed in (since 2.6)
 322  **/
 323 GMainContext *
 324 g_main_context_ref (GMainContext *context)
 325 {
 326   g_return_val_if_fail (context != NULL, NULL);
 327   g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL);
 328
 329   g_atomic_int_inc (&context->ref_count);
 330
 331   return context;
 332 }
 333
 334 static inline void
 335 poll_rec_list_free (GMainContext *context,
 336                     GPollRec     *list)
 337 {
 338   g_slice_free_chain (GPollRec, list, next);
 339 }
 340
 341 /**
 342  * g_main_context_unref:
 343  * @context: a #GMainContext
 344  *
 345  * Decreases the reference count on a #GMainContext object by one. If
 346  * the result is zero, free the context and free all associated memory.
 347  **/
 348 void
 349 g_main_context_unref (GMainContext *context)
 350 {
 351   GSource *source;
 352   g_return_if_fail (context != NULL);
 353   g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
 354
 355   if (!g_atomic_int_dec_and_test (&context->ref_count))
 356     return;
 357
 358   G_LOCK (main_context_list);
 359   main_context_list = g_slist_remove (main_context_list, context);
 360   G_UNLOCK (main_context_list);
 361
 362   source = context->source_list;
 363   while (source)
 364     {
 365       GSource *next = source->next;
 366       g_source_destroy_internal (source, context, FALSE);
 367       source = next;
 368     }
 369
 370 #ifdef G_THREADS_ENABLED
 371   g_static_mutex_free (&context->mutex);
 372 #endif
 373
 374   g_ptr_array_free (context->pending_dispatches, TRUE);
 375   g_free (context->cached_poll_array);
 376
 377   poll_rec_list_free (context, context->poll_records);
 378
 379 #ifdef G_THREADS_ENABLED
 380   if (g_thread_supported())
 381     {
 382 #ifndef G_OS_WIN32
 383       close (context->wake_up_pipe[0]);
 384       close (context->wake_up_pipe[1]);
 385 #else
 386       CloseHandle (context->wake_up_semaphore);
 387 #endif
 388     }
 389   else
 390     main_contexts_without_pipe = g_slist_remove (main_contexts_without_pipe,
 391                                                  context);
 392
 393   if (context->cond != NULL)
 394     g_cond_free (context->cond);
 395 #endif
 396
 397   g_free (context);
 398 }
 399
 400 #ifdef G_THREADS_ENABLED
 401 static void
 402 g_main_context_init_pipe (GMainContext *context)
 403 {
 404 # ifndef G_OS_WIN32
 405   if (context->wake_up_pipe[0] != -1)
 406     return;
 407
 408 #ifdef HAVE_PIPE2
 409   /* if this fails, we fall through and try pipe */
 410   pipe2 (context->wake_up_pipe, O_CLOEXEC);
 411 #endif
 412   if (context->wake_up_pipe[0] == -1)
 413     {
 414       if (pipe (context->wake_up_pipe) < 0)
 415         g_error ("Cannot create pipe main loop wake-up: %s\n",
 416                  g_strerror (errno));
 417
 418       fcntl (context->wake_up_pipe[0], F_SETFD, FD_CLOEXEC);
 419       fcntl (context->wake_up_pipe[1], F_SETFD, FD_CLOEXEC);
 420     }
 421
 422   context->wake_up_rec.fd = context->wake_up_pipe[0];
 423   context->wake_up_rec.events = G_IO_IN;
 424 # else
 425   if (context->wake_up_semaphore != NULL)
 426     return;
 427   context->wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL);
 428   if (context->wake_up_semaphore == NULL)
 429     g_error ("Cannot create wake-up semaphore: %s",
 430              g_win32_error_message (GetLastError ()));
 431   context->wake_up_rec.fd = (gintptr) context->wake_up_semaphore;
 432   context->wake_up_rec.events = G_IO_IN;
 433
 434   if (_g_main_poll_debug)
 435     g_print ("wake-up semaphore: %p\n", context->wake_up_semaphore);
 436 # endif
 437   g_main_context_add_poll_unlocked (context, 0, &context->wake_up_rec);
 438 }
 439
 440 void
 441 _g_main_thread_init (void)
 442 {
 443   GSList *curr = main_contexts_without_pipe;
 444   while (curr)
 445     {
 446       g_main_context_init_pipe ((GMainContext *)curr->data);
 447       curr = curr->next;
 448     }
 449   g_slist_free (main_contexts_without_pipe);
 450   main_contexts_without_pipe = NULL;
 451 }
 452 #endif /* G_THREADS_ENABLED */
 453
 454 /**
 455  * g_main_context_new:
 456  *
 457  * Creates a new #GMainContext structure.
 458  *
 459  * Return value: the new #GMainContext
 460  **/
 461 GMainContext *
 462 g_main_context_new (void)
 463 {
 464   GMainContext *context = g_new0 (GMainContext, 1);
 465
 466 #ifdef G_MAIN_POLL_DEBUG
 467   {
 468     static gboolean beenhere = FALSE;
 469
 470     if (!beenhere)
 471       {
 472         if (getenv ("G_MAIN_POLL_DEBUG") != NULL)
 473           _g_main_poll_debug = TRUE;
 474         beenhere = TRUE;
 475       }
 476   }
 477 #endif
 478
 479 #ifdef G_THREADS_ENABLED
 480   g_static_mutex_init (&context->mutex);
 481
 482   context->owner = NULL;
 483   context->waiters = NULL;
 484
 485 # ifndef G_OS_WIN32
 486   context->wake_up_pipe[0] = -1;
 487   context->wake_up_pipe[1] = -1;
 488 # else
 489   context->wake_up_semaphore = NULL;
 490 # endif
 491 #endif
 492
 493   context->ref_count = 1;
 494
 495   context->next_id = 1;
 496
 497   context->source_list = NULL;
 498
 499   context->poll_func = g_poll;
 500
 501   context->cached_poll_array = NULL;
 502   context->cached_poll_array_size = 0;
 503
 504   context->pending_dispatches = g_ptr_array_new ();
 505
 506   context->time_is_current = FALSE;
 507
 508 #ifdef G_THREADS_ENABLED
 509   if (g_thread_supported ())
 510     g_main_context_init_pipe (context);
 511   else
 512     main_contexts_without_pipe = g_slist_prepend (main_contexts_without_pipe,
 513                                                   context);
 514 #endif
 515
 516   G_LOCK (main_context_list);
 517   main_context_list = g_slist_append (main_context_list, context);
 518
 519 #ifdef G_MAIN_POLL_DEBUG
 520   if (_g_main_poll_debug)
 521     g_print ("created context=%p\n", context);
 522 #endif
 523
 524   G_UNLOCK (main_context_list);
 525
 526   return context;
 527 }
 528
 529 /**
 530  * g_main_context_default:
 531  *
 532  * Returns the global default main context. This is the main context
 533  * used for main loop functions when a main loop is not explicitly
 534  * specified, and corresponds to the "main" main loop. See also
 535  * g_main_context_get_thread_default().
 536  *
 537  * Return value: the global default main context.
 538  **/
 539 GMainContext *
 540 g_main_context_default (void)
 541 {
 542   /* Slow, but safe */
 543
 544   G_LOCK (main_loop);
 545
 546   if (!default_main_context)
 547     {
 548       default_main_context = g_main_context_new ();
 549 #ifdef G_MAIN_POLL_DEBUG
 550       if (_g_main_poll_debug)
 551         g_print ("default context=%p\n", default_main_context);
 552 #endif
 553     }
 554
 555   G_UNLOCK (main_loop);
 556
 557   return default_main_context;
 558 }
 559
 560 static GStaticPrivate thread_context_stack = G_STATIC_PRIVATE_INIT;
 561
 562 static void
 563 free_context_stack (gpointer data)
 564 {
 565   GQueue *stack = data;
 566   GMainContext *context;
 567
 568   while (!g_queue_is_empty (stack))
 569     {
 570       context = g_queue_pop_head (stack);
 571       g_main_context_release (context);
 572       if (context)
 573         g_main_context_unref (context);
 574     }
 575   g_queue_free (stack);
 576 }
 577
 578 /**
 579  * g_main_context_push_thread_default:
 580  * @context: a #GMainContext, or %NULL for the global default context
 581  *
 582  * Acquires @context and sets it as the thread-default context for the
 583  * current thread. This will cause certain asynchronous operations
 584  * (such as most <link linkend="gio">gio</link>-based I/O) which are
 585  * started in this thread to run under @context and deliver their
 586  * results to its main loop, rather than running under the global
 587  * default context in the main thread. Note that calling this function
 588  * changes the context returned by
 589  * g_main_context_get_thread_default(), <emphasis>not</emphasis> the
 590  * one returned by g_main_context_default(), so it does not affect the
 591  * context used by functions like g_idle_add().
 592  *
 593  * Normally you would call this function shortly after creating a new
 594  * thread, passing it a #GMainContext which will be run by a
 595  * #GMainLoop in that thread, to set a new default context for all
 596  * async operations in that thread. (In this case, you don't need to
 597  * ever call g_main_context_pop_thread_default().) In some cases
 598  * however, you may want to schedule a single operation in a
 599  * non-default context, or temporarily use a non-default context in
 600  * the main thread. In that case, you can wrap the call to the
 601  * asynchronous operation inside a
 602  * g_main_context_push_thread_default() /
 603  * g_main_context_pop_thread_default() pair, but it is up to you to
 604  * ensure that no other asynchronous operations accidentally get
 605  * started while the non-default context is active.
 606  *
 607  * Beware that libraries that predate this function may not correctly
 608  * handle being used from a thread with a thread-default context. Eg,
 609  * see g_file_supports_thread_contexts().
 610  *
 611  * Since: 2.22
 612  **/
 613 void
 614 g_main_context_push_thread_default (GMainContext *context)
 615 {
 616   GQueue *stack;
 617   gboolean acquired_context;
 618
 619   acquired_context = g_main_context_acquire (context);
 620   g_return_if_fail (acquired_context);
 621
 622   if (context == g_main_context_default ())
 623     context = NULL;
 624   else if (context)
 625     g_main_context_ref (context);
 626
 627   stack = g_static_private_get (&thread_context_stack);
 628   if (!stack)
 629     {
 630       stack = g_queue_new ();
 631       g_static_private_set (&thread_context_stack, stack,
 632                             free_context_stack);
 633     }
 634
 635   g_queue_push_head (stack, context);
 636 }
 637
 638 /**
 639  * g_main_context_pop_thread_default:
 640  * @context: a #GMainContext object, or %NULL
 641  *
 642  * Pops @context off the thread-default context stack (verifying that
 643  * it was on the top of the stack).
 644  *
 645  * Since: 2.22
 646  **/
 647 void
 648 g_main_context_pop_thread_default (GMainContext *context)
 649 {
 650   GQueue *stack;
 651
 652   if (context == g_main_context_default ())
 653     context = NULL;
 654
 655   stack = g_static_private_get (&thread_context_stack);
 656
 657   g_return_if_fail (stack != NULL);
 658   g_return_if_fail (g_queue_peek_head (stack) == context);
 659
 660   g_queue_pop_head (stack);
 661
 662   g_main_context_release (context);
 663   if (context)
 664     g_main_context_unref (context);
 665 }
 666
 667 /**
 668  * g_main_context_get_thread_default:
 669  *
 670  * Gets the thread-default #GMainContext for this thread. Asynchronous
 671  * operations that want to be able to be run in contexts other than
 672  * the default one should call this method to get a #GMainContext to
 673  * add their #GSource<!-- -->s to. (Note that even in single-threaded
 674  * programs applications may sometimes want to temporarily push a
 675  * non-default context, so it is not safe to assume that this will
 676  * always return %NULL if threads are not initialized.)
 677  *
 678  * Returns: the thread-default #GMainContext, or %NULL if the
 679  * thread-default context is the global default context.
 680  *
 681  * Since: 2.22
 682  **/
 683 GMainContext *
 684 g_main_context_get_thread_default (void)
 685 {
 686   GQueue *stack;
 687
 688   stack = g_static_private_get (&thread_context_stack);
 689   if (stack)
 690     return g_queue_peek_head (stack);
 691   else
 692     return NULL;
 693 }
 694
 695 /* Hooks for adding to the main loop */
 696
 697 /**
 698  * g_source_new:
 699  * @source_funcs: structure containing functions that implement
 700  *                the sources behavior.
 701  * @struct_size: size of the #GSource structure to create.
 702  *
 703  * Creates a new #GSource structure. The size is specified to
 704  * allow creating structures derived from #GSource that contain
 705  * additional data. The size passed in must be at least
 706  * <literal>sizeof (GSource)</literal>.
 707  *
 708  * The source will not initially be associated with any #GMainContext
 709  * and must be added to one with g_source_attach() before it will be
 710  * executed.
 711  *
 712  * Return value: the newly-created #GSource.
 713  **/
 714 GSource *
 715 g_source_new (GSourceFuncs *source_funcs,
 716               guint         struct_size)
 717 {
 718   GSource *source;
 719
 720   g_return_val_if_fail (source_funcs != NULL, NULL);
 721   g_return_val_if_fail (struct_size >= sizeof (GSource), NULL);
 722
 723   source = (GSource*) g_malloc0 (struct_size);
 724
 725   source->source_funcs = source_funcs;
 726   source->ref_count = 1;
 727
 728   source->priority = G_PRIORITY_DEFAULT;
 729
 730   source->flags = G_HOOK_FLAG_ACTIVE;
 731
 732   /* NULL/0 initialization for all other fields */
 733
 734   return source;
 735 }
 736
 737 /* Holds context's lock
 738  */
 739 static void
 740 g_source_list_add (GSource      *source,
 741                    GMainContext *context)
 742 {
 743   GSource *tmp_source, *last_source;
 744
 745   last_source = NULL;
 746   tmp_source = context->source_list;
 747   while (tmp_source && tmp_source->priority <= source->priority)
 748     {
 749       last_source = tmp_source;
 750       tmp_source = tmp_source->next;
 751     }
 752
 753   source->next = tmp_source;
 754   if (tmp_source)
 755     tmp_source->prev = source;
 756
 757   source->prev = last_source;
 758   if (last_source)
 759     last_source->next = source;
 760   else
 761     context->source_list = source;
 762 }
 763
 764 /* Holds context's lock
 765  */
 766 static void
 767 g_source_list_remove (GSource      *source,
 768                       GMainContext *context)
 769 {
 770   if (source->prev)
 771     source->prev->next = source->next;
 772   else
 773     context->source_list = source->next;
 774
 775   if (source->next)
 776     source->next->prev = source->prev;
 777
 778   source->prev = NULL;
 779   source->next = NULL;
 780 }
 781
 782 /**
 783  * g_source_attach:
 784  * @source: a #GSource
 785  * @context: a #GMainContext (if %NULL, the default context will be used)
 786  *
 787  * Adds a #GSource to a @context so that it will be executed within
 788  * that context. Remove it by calling g_source_destroy().
 789  *
 790  * Return value: the ID (greater than 0) for the source within the
 791  *   #GMainContext.
 792  **/
 793 guint
 794 g_source_attach (GSource      *source,
 795                  GMainContext *context)
 796 {
 797   guint result = 0;
 798   GSList *tmp_list;
 799
 800   g_return_val_if_fail (source->context == NULL, 0);
 801   g_return_val_if_fail (!SOURCE_DESTROYED (source), 0);
 802
 803   if (!context)
 804     context = g_main_context_default ();
 805
 806   LOCK_CONTEXT (context);
 807
 808   source->context = context;
 809   result = source->source_id = context->next_id++;
 810
 811   source->ref_count++;
 812   g_source_list_add (source, context);
 813
 814   tmp_list = source->poll_fds;
 815   while (tmp_list)
 816     {
 817       g_main_context_add_poll_unlocked (context, source->priority, tmp_list->data);
 818       tmp_list = tmp_list->next;
 819     }
 820
 821 #ifdef G_THREADS_ENABLED
 822   /* Now wake up the main loop if it is waiting in the poll() */
 823   g_main_context_wakeup_unlocked (context);
 824 #endif
 825
 826   UNLOCK_CONTEXT (context);
 827
 828   return result;
 829 }
 830
 831 static void
 832 g_source_destroy_internal (GSource      *source,
 833                            GMainContext *context,
 834                            gboolean      have_lock)
 835 {
 836   if (!have_lock)
 837     LOCK_CONTEXT (context);
 838
 839   if (!SOURCE_DESTROYED (source))
 840     {
 841       GSList *tmp_list;
 842       gpointer old_cb_data;
 843       GSourceCallbackFuncs *old_cb_funcs;
 844
 845       source->flags &= ~G_HOOK_FLAG_ACTIVE;
 846
 847       old_cb_data = source->callback_data;
 848       old_cb_funcs = source->callback_funcs;
 849
 850       source->callback_data = NULL;
 851       source->callback_funcs = NULL;
 852
 853       if (old_cb_funcs)
 854         {
 855           UNLOCK_CONTEXT (context);
 856           old_cb_funcs->unref (old_cb_data);
 857           LOCK_CONTEXT (context);
 858         }
 859
 860       if (!SOURCE_BLOCKED (source))
 861         {
 862           tmp_list = source->poll_fds;
 863           while (tmp_list)
 864             {
 865               g_main_context_remove_poll_unlocked (context, tmp_list->data);
 866               tmp_list = tmp_list->next;
 867             }
 868         }
 869
 870       g_source_unref_internal (source, context, TRUE);
 871     }
 872
 873   if (!have_lock)
 874     UNLOCK_CONTEXT (context);
 875 }
 876
 877 /**
 878  * g_source_destroy:
 879  * @source: a #GSource
 880  *
 881  * Removes a source from its #GMainContext, if any, and mark it as
 882  * destroyed.  The source cannot be subsequently added to another
 883  * context.
 884  **/
 885 void
 886 g_source_destroy (GSource *source)
 887 {
 888   GMainContext *context;
 889
 890   g_return_if_fail (source != NULL);
 891
 892   context = source->context;
 893
 894   if (context)
 895     g_source_destroy_internal (source, context, FALSE);
 896   else
 897     source->flags &= ~G_HOOK_FLAG_ACTIVE;
 898 }
 899
 900 /**
 901  * g_source_get_id:
 902  * @source: a #GSource
 903  *
 904  * Returns the numeric ID for a particular source. The ID of a source
 905  * is a positive integer which is unique within a particular main loop
 906  * context. The reverse
 907  * mapping from ID to source is done by g_main_context_find_source_by_id().
 908  *
 909  * Return value: the ID (greater than 0) for the source
 910  **/
 911 guint
 912 g_source_get_id (GSource *source)
 913 {
 914   guint result;
 915
 916   g_return_val_if_fail (source != NULL, 0);
 917   g_return_val_if_fail (source->context != NULL, 0);
 918
 919   LOCK_CONTEXT (source->context);
 920   result = source->source_id;
 921   UNLOCK_CONTEXT (source->context);
 922
 923   return result;
 924 }
 925
 926 /**
 927  * g_source_get_context:
 928  * @source: a #GSource
 929  *
 930  * Gets the #GMainContext with which the source is associated.
 931  * Calling this function on a destroyed source is an error.
 932  *
 933  * Return value: the #GMainContext with which the source is associated,
 934  *               or %NULL if the context has not yet been added
 935  *               to a source.
 936  **/
 937 GMainContext *
 938 g_source_get_context (GSource *source)
 939 {
 940   g_return_val_if_fail (!SOURCE_DESTROYED (source), NULL);
 941
 942   return source->context;
 943 }
 944
 945 /**
 946  * g_source_add_poll:
 947  * @source:a #GSource
 948  * @fd: a #GPollFD structure holding information about a file
 949  *      descriptor to watch.
 950  *
 951  * Adds a file descriptor to the set of file descriptors polled for
 952  * this source. This is usually combined with g_source_new() to add an
 953  * event source. The event source's check function will typically test
 954  * the @revents field in the #GPollFD struct and return %TRUE if events need
 955  * to be processed.
 956  **/
 957 void
 958 g_source_add_poll (GSource *source,
 959                    GPollFD *fd)
 960 {
 961   GMainContext *context;
 962
 963   g_return_if_fail (source != NULL);
 964   g_return_if_fail (fd != NULL);
 965   g_return_if_fail (!SOURCE_DESTROYED (source));
 966
 967   context = source->context;
 968
 969   if (context)
 970     LOCK_CONTEXT (context);
 971
 972   source->poll_fds = g_slist_prepend (source->poll_fds, fd);
 973
 974   if (context)
 975     {
 976       if (!SOURCE_BLOCKED (source))
 977         g_main_context_add_poll_unlocked (context, source->priority, fd);
 978       UNLOCK_CONTEXT (context);
 979     }
 980 }
 981
 982 /**
 983  * g_source_remove_poll:
 984  * @source:a #GSource
 985  * @fd: a #GPollFD structure previously passed to g_source_add_poll().
 986  *
 987  * Removes a file descriptor from the set of file descriptors polled for
 988  * this source.
 989  **/
 990 void
 991 g_source_remove_poll (GSource *source,
 992                       GPollFD *fd)
 993 {
 994   GMainContext *context;
 995
 996   g_return_if_fail (source != NULL);
 997   g_return_if_fail (fd != NULL);
 998   g_return_if_fail (!SOURCE_DESTROYED (source));
 999
1000   context = source->context;
1001
1002   if (context)
1003     LOCK_CONTEXT (context);
1004
1005   source->poll_fds = g_slist_remove (source->poll_fds, fd);
1006
1007   if (context)
1008     {
1009       if (!SOURCE_BLOCKED (source))
1010         g_main_context_remove_poll_unlocked (context, fd);
1011       UNLOCK_CONTEXT (context);
1012     }
1013 }
1014
1015 /**
1016  * g_source_set_callback_indirect:
1017  * @source: the source
1018  * @callback_data: pointer to callback data "object"
1019  * @callback_funcs: functions for reference counting @callback_data
1020  *                  and getting the callback and data
1021  *
1022  * Sets the callback function storing the data as a refcounted callback
1023  * "object". This is used internally. Note that calling
1024  * g_source_set_callback_indirect() assumes
1025  * an initial reference count on @callback_data, and thus
1026  * @callback_funcs->unref will eventually be called once more
1027  * than @callback_funcs->ref.
1028  **/
1029 void
1030 g_source_set_callback_indirect (GSource              *source,
1031                                 gpointer              callback_data,
1032                                 GSourceCallbackFuncs *callback_funcs)
1033 {
1034   GMainContext *context;
1035   gpointer old_cb_data;
1036   GSourceCallbackFuncs *old_cb_funcs;
1037
1038   g_return_if_fail (source != NULL);
1039   g_return_if_fail (callback_funcs != NULL || callback_data == NULL);
1040
1041   context = source->context;
1042
1043   if (context)
1044     LOCK_CONTEXT (context);
1045
1046   old_cb_data = source->callback_data;
1047   old_cb_funcs = source->callback_funcs;
1048
1049   source->callback_data = callback_data;
1050   source->callback_funcs = callback_funcs;
1051
1052   if (context)
1053     UNLOCK_CONTEXT (context);
1054
1055   if (old_cb_funcs)
1056     old_cb_funcs->unref (old_cb_data);
1057 }
1058
1059 static void
1060 g_source_callback_ref (gpointer cb_data)
1061 {
1062   GSourceCallback *callback = cb_data;
1063
1064   callback->ref_count++;
1065 }
1066
1067
1068 static void
1069 g_source_callback_unref (gpointer cb_data)
1070 {
1071   GSourceCallback *callback = cb_data;
1072
1073   callback->ref_count--;
1074   if (callback->ref_count == 0)
1075     {
1076       if (callback->notify)
1077         callback->notify (callback->data);
1078       g_free (callback);
1079     }
1080 }
1081
1082 static void
1083 g_source_callback_get (gpointer     cb_data,
1084                        GSource     *source,
1085                        GSourceFunc *func,
1086                        gpointer    *data)
1087 {
1088   GSourceCallback *callback = cb_data;
1089
1090   *func = callback->func;
1091   *data = callback->data;
1092 }
1093
1094 static GSourceCallbackFuncs g_source_callback_funcs = {
1095   g_source_callback_ref,
1096   g_source_callback_unref,
1097   g_source_callback_get,
1098 };
1099
1100 /**
1101  * g_source_set_callback:
1102  * @source: the source
1103  * @func: a callback function
1104  * @data: the data to pass to callback function
1105  * @notify: a function to call when @data is no longer in use, or %NULL.
1106  *
1107  * Sets the callback function for a source. The callback for a source is
1108  * called from the source's dispatch function.
1109  *
1110  * The exact type of @func depends on the type of source; ie. you
1111  * should not count on @func being called with @data as its first
1112  * parameter.
1113  *
1114  * Typically, you won't use this function. Instead use functions specific
1115  * to the type of source you are using.
1116  **/
1117 void
1118 g_source_set_callback (GSource        *source,
1119                        GSourceFunc     func,
1120                        gpointer        data,
1121                        GDestroyNotify  notify)
1122 {
1123   GSourceCallback *new_callback;
1124
1125   g_return_if_fail (source != NULL);
1126
1127   new_callback = g_new (GSourceCallback, 1);
1128
1129   new_callback->ref_count = 1;
1130   new_callback->func = func;
1131   new_callback->data = data;
1132   new_callback->notify = notify;
1133
1134   g_source_set_callback_indirect (source, new_callback, &g_source_callback_funcs);
1135 }
1136
1137
1138 /**
1139  * g_source_set_funcs:
1140  * @source: a #GSource
1141  * @funcs: the new #GSourceFuncs
1142  *
1143  * Sets the source functions (can be used to override
1144  * default implementations) of an unattached source.
1145  *
1146  * Since: 2.12
1147  */
1148 void
1149 g_source_set_funcs (GSource     *source,
1150                    GSourceFuncs *funcs)
1151 {
1152   g_return_if_fail (source != NULL);
1153   g_return_if_fail (source->context == NULL);
1154   g_return_if_fail (source->ref_count > 0);
1155   g_return_if_fail (funcs != NULL);
1156
1157   source->source_funcs = funcs;
1158 }
1159
1160 /**
1161  * g_source_set_priority:
1162  * @source: a #GSource
1163  * @priority: the new priority.
1164  *
1165  * Sets the priority of a source. While the main loop is being
1166  * run, a source will be dispatched if it is ready to be dispatched and no sources
1167  * at a higher (numerically smaller) priority are ready to be dispatched.
1168  **/
1169 void
1170 g_source_set_priority (GSource  *source,
1171                        gint      priority)
1172 {
1173   GSList *tmp_list;
1174   GMainContext *context;
1175
1176   g_return_if_fail (source != NULL);
1177
1178   context = source->context;
1179
1180   if (context)
1181     LOCK_CONTEXT (context);
1182
1183   source->priority = priority;
1184
1185   if (context)
1186     {
1187       /* Remove the source from the context's source and then
1188        * add it back so it is sorted in the correct plcae
1189        */
1190       g_source_list_remove (source, source->context);
1191       g_source_list_add (source, source->context);
1192
1193       if (!SOURCE_BLOCKED (source))
1194         {
1195           tmp_list = source->poll_fds;
1196           while (tmp_list)
1197             {
1198               g_main_context_remove_poll_unlocked (context, tmp_list->data);
1199               g_main_context_add_poll_unlocked (context, priority, tmp_list->data);
1200
1201               tmp_list = tmp_list->next;
1202             }
1203         }
1204
1205       UNLOCK_CONTEXT (source->context);
1206     }
1207 }
1208
1209 /**
1210  * g_source_get_priority:
1211  * @source: a #GSource
1212  *
1213  * Gets the priority of a source.
1214  *
1215  * Return value: the priority of the source
1216  **/
1217 gint
1218 g_source_get_priority (GSource *source)
1219 {
1220   g_return_val_if_fail (source != NULL, 0);
1221
1222   return source->priority;
1223 }
1224
1225 /**
1226  * g_source_set_can_recurse:
1227  * @source: a #GSource
1228  * @can_recurse: whether recursion is allowed for this source
1229  *
1230  * Sets whether a source can be called recursively. If @can_recurse is
1231  * %TRUE, then while the source is being dispatched then this source
1232  * will be processed normally. Otherwise, all processing of this
1233  * source is blocked until the dispatch function returns.
1234  **/
1235 void
1236 g_source_set_can_recurse (GSource  *source,
1237                           gboolean  can_recurse)
1238 {
1239   GMainContext *context;
1240
1241   g_return_if_fail (source != NULL);
1242
1243   context = source->context;
1244
1245   if (context)
1246     LOCK_CONTEXT (context);
1247
1248   if (can_recurse)
1249     source->flags |= G_SOURCE_CAN_RECURSE;
1250   else
1251     source->flags &= ~G_SOURCE_CAN_RECURSE;
1252
1253   if (context)
1254     UNLOCK_CONTEXT (context);
1255 }
1256
1257 /**
1258  * g_source_get_can_recurse:
1259  * @source: a #GSource
1260  *
1261  * Checks whether a source is allowed to be called recursively.
1262  * see g_source_set_can_recurse().
1263  *
1264  * Return value: whether recursion is allowed.
1265  **/
1266 gboolean
1267 g_source_get_can_recurse (GSource  *source)
1268 {
1269   g_return_val_if_fail (source != NULL, FALSE);
1270
1271   return (source->flags & G_SOURCE_CAN_RECURSE) != 0;
1272 }
1273
1274 /**
1275  * g_source_ref:
1276  * @source: a #GSource
1277  *
1278  * Increases the reference count on a source by one.
1279  *
1280  * Return value: @source
1281  **/
1282 GSource *
1283 g_source_ref (GSource *source)
1284 {
1285   GMainContext *context;
1286
1287   g_return_val_if_fail (source != NULL, NULL);
1288
1289   context = source->context;
1290
1291   if (context)
1292     LOCK_CONTEXT (context);
1293
1294   source->ref_count++;
1295
1296   if (context)
1297     UNLOCK_CONTEXT (context);
1298
1299   return source;
1300 }
1301
1302 /* g_source_unref() but possible to call within context lock
1303  */
1304 static void
1305 g_source_unref_internal (GSource      *source,
1306                          GMainContext *context,
1307                          gboolean      have_lock)
1308 {
1309   gpointer old_cb_data = NULL;
1310   GSourceCallbackFuncs *old_cb_funcs = NULL;
1311
1312   g_return_if_fail (source != NULL);
1313
1314   if (!have_lock && context)
1315     LOCK_CONTEXT (context);
1316
1317   source->ref_count--;
1318   if (source->ref_count == 0)
1319     {
1320       old_cb_data = source->callback_data;
1321       old_cb_funcs = source->callback_funcs;
1322
1323       source->callback_data = NULL;
1324       source->callback_funcs = NULL;
1325
1326       if (context && !SOURCE_DESTROYED (source))
1327         {
1328           g_warning (G_STRLOC ": ref_count == 0, but source is still attached to a context!");
1329           source->ref_count++;
1330         }
1331       else if (context)
1332         g_source_list_remove (source, context);
1333
1334       if (source->source_funcs->finalize)
1335         source->source_funcs->finalize (source);
1336
1337       g_slist_free (source->poll_fds);
1338       source->poll_fds = NULL;
1339       g_free (source);
1340     }
1341
1342   if (!have_lock && context)
1343     UNLOCK_CONTEXT (context);
1344
1345   if (old_cb_funcs)
1346     {
1347       if (have_lock)
1348         UNLOCK_CONTEXT (context);
1349
1350       old_cb_funcs->unref (old_cb_data);
1351
1352       if (have_lock)
1353         LOCK_CONTEXT (context);
1354     }
1355 }
1356
1357 /**
1358  * g_source_unref:
1359  * @source: a #GSource
1360  *
1361  * Decreases the reference count of a source by one. If the
1362  * resulting reference count is zero the source and associated
1363  * memory will be destroyed.
1364  **/
1365 void
1366 g_source_unref (GSource *source)
1367 {
1368   g_return_if_fail (source != NULL);
1369
1370   g_source_unref_internal (source, source->context, FALSE);
1371 }
1372
1373 /**
1374  * g_main_context_find_source_by_id:
1375  * @context: a #GMainContext (if %NULL, the default context will be used)
1376  * @source_id: the source ID, as returned by g_source_get_id().
1377  *
1378  * Finds a #GSource given a pair of context and ID.
1379  *
1380  * Return value: the #GSource if found, otherwise, %NULL
1381  **/
1382 GSource *
1383 g_main_context_find_source_by_id (GMainContext *context,
1384                                   guint         source_id)
1385 {
1386   GSource *source;
1387
1388   g_return_val_if_fail (source_id > 0, NULL);
1389
1390   if (context == NULL)
1391     context = g_main_context_default ();
1392
1393   LOCK_CONTEXT (context);
1394
1395   source = context->source_list;
1396   while (source)
1397     {
1398       if (!SOURCE_DESTROYED (source) &&
1399           source->source_id == source_id)
1400         break;
1401       source = source->next;
1402     }
1403
1404   UNLOCK_CONTEXT (context);
1405
1406   return source;
1407 }
1408
1409 /**
1410  * g_main_context_find_source_by_funcs_user_data:
1411  * @context: a #GMainContext (if %NULL, the default context will be used).
1412  * @funcs: the @source_funcs passed to g_source_new().
1413  * @user_data: the user data from the callback.
1414  *
1415  * Finds a source with the given source functions and user data.  If
1416  * multiple sources exist with the same source function and user data,
1417  * the first one found will be returned.
1418  *
1419  * Return value: the source, if one was found, otherwise %NULL
1420  **/
1421 GSource *
1422 g_main_context_find_source_by_funcs_user_data (GMainContext *context,
1423                                                GSourceFuncs *funcs,
1424                                                gpointer      user_data)
1425 {
1426   GSource *source;
1427
1428   g_return_val_if_fail (funcs != NULL, NULL);
1429
1430   if (context == NULL)
1431     context = g_main_context_default ();
1432
1433   LOCK_CONTEXT (context);
1434
1435   source = context->source_list;
1436   while (source)
1437     {
1438       if (!SOURCE_DESTROYED (source) &&
1439           source->source_funcs == funcs &&
1440           source->callback_funcs)
1441         {
1442           GSourceFunc callback;
1443           gpointer callback_data;
1444
1445           source->callback_funcs->get (source->callback_data, source, &callback, &callback_data);
1446
1447           if (callback_data == user_data)
1448             break;
1449         }
1450       source = source->next;
1451     }
1452
1453   UNLOCK_CONTEXT (context);
1454
1455   return source;
1456 }
1457
1458 /**
1459  * g_main_context_find_source_by_user_data:
1460  * @context: a #GMainContext
1461  * @user_data: the user_data for the callback.
1462  *
1463  * Finds a source with the given user data for the callback.  If
1464  * multiple sources exist with the same user data, the first
1465  * one found will be returned.
1466  *
1467  * Return value: the source, if one was found, otherwise %NULL
1468  **/
1469 GSource *
1470 g_main_context_find_source_by_user_data (GMainContext *context,
1471                                          gpointer      user_data)
1472 {
1473   GSource *source;
1474
1475   if (context == NULL)
1476     context = g_main_context_default ();
1477
1478   LOCK_CONTEXT (context);
1479
1480   source = context->source_list;
1481   while (source)
1482     {
1483       if (!SOURCE_DESTROYED (source) &&
1484           source->callback_funcs)
1485         {
1486           GSourceFunc callback;
1487           gpointer callback_data = NULL;
1488
1489           source->callback_funcs->get (source->callback_data, source, &callback, &callback_data);
1490
1491           if (callback_data == user_data)
1492             break;
1493         }
1494       source = source->next;
1495     }
1496
1497   UNLOCK_CONTEXT (context);
1498
1499   return source;
1500 }
1501
1502 /**
1503  * g_source_remove:
1504  * @tag: the ID of the source to remove.
1505  *
1506  * Removes the source with the given id from the default main context.
1507  * The id of
1508  * a #GSource is given by g_source_get_id(), or will be returned by the
1509  * functions g_source_attach(), g_idle_add(), g_idle_add_full(),
1510  * g_timeout_add(), g_timeout_add_full(), g_child_watch_add(),
1511  * g_child_watch_add_full(), g_io_add_watch(), and g_io_add_watch_full().
1512  *
1513  * See also g_source_destroy(). You must use g_source_destroy() for sources
1514  * added to a non-default main context.
1515  *
1516  * Return value: %TRUE if the source was found and removed.
1517  **/
1518 gboolean
1519 g_source_remove (guint tag)
1520 {
1521   GSource *source;
1522
1523   g_return_val_if_fail (tag > 0, FALSE);
1524
1525   source = g_main_context_find_source_by_id (NULL, tag);
1526   if (source)
1527     g_source_destroy (source);
1528
1529   return source != NULL;
1530 }
1531
1532 /**
1533  * g_source_remove_by_user_data:
1534  * @user_data: the user_data for the callback.
1535  *
1536  * Removes a source from the default main loop context given the user
1537  * data for the callback. If multiple sources exist with the same user
1538  * data, only one will be destroyed.
1539  *
1540  * Return value: %TRUE if a source was found and removed.
1541  **/
1542 gboolean
1543 g_source_remove_by_user_data (gpointer user_data)
1544 {
1545   GSource *source;
1546
1547   source = g_main_context_find_source_by_user_data (NULL, user_data);
1548   if (source)
1549     {
1550       g_source_destroy (source);
1551       return TRUE;
1552     }
1553   else
1554     return FALSE;
1555 }
1556
1557 /**
1558  * g_source_remove_by_funcs_user_data:
1559  * @funcs: The @source_funcs passed to g_source_new()
1560  * @user_data: the user data for the callback
1561  *
1562  * Removes a source from the default main loop context given the
1563  * source functions and user data. If multiple sources exist with the
1564  * same source functions and user data, only one will be destroyed.
1565  *
1566  * Return value: %TRUE if a source was found and removed.
1567  **/
1568 gboolean
1569 g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
1570                                     gpointer      user_data)
1571 {
1572   GSource *source;
1573
1574   g_return_val_if_fail (funcs != NULL, FALSE);
1575
1576   source = g_main_context_find_source_by_funcs_user_data (NULL, funcs, user_data);
1577   if (source)
1578     {
1579       g_source_destroy (source);
1580       return TRUE;
1581     }
1582   else
1583     return FALSE;
1584 }
1585
1586 /**
1587  * g_get_current_time:
1588  * @result: #GTimeVal structure in which to store current time.
1589  *
1590  * Equivalent to the UNIX gettimeofday() function, but portable.
1591  **/
1592 void
1593 g_get_current_time (GTimeVal *result)
1594 {
1595 #ifndef G_OS_WIN32
1596   struct timeval r;
1597
1598   g_return_if_fail (result != NULL);
1599
1600   /*this is required on alpha, there the timeval structs are int's
1601     not longs and a cast only would fail horribly*/
1602   gettimeofday (&r, NULL);
1603   result->tv_sec = r.tv_sec;
1604   result->tv_usec = r.tv_usec;
1605 #else
1606   FILETIME ft;
1607   guint64 time64;
1608
1609   g_return_if_fail (result != NULL);
1610
1611   GetSystemTimeAsFileTime (&ft);
1612   memmove (&time64, &ft, sizeof (FILETIME));
1613
1614   /* Convert from 100s of nanoseconds since 1601-01-01
1615    * to Unix epoch. Yes, this is Y2038 unsafe.
1616    */
1617   time64 -= G_GINT64_CONSTANT (116444736000000000);
1618   time64 /= 10;
1619
1620   result->tv_sec = time64 / 1000000;
1621   result->tv_usec = time64 % 1000000;
1622 #endif
1623 }
1624
1625 static void
1626 g_main_dispatch_free (gpointer dispatch)
1627 {
1628   g_slice_free (GMainDispatch, dispatch);
1629 }
1630
1631 /* Running the main loop */
1632
1633 static GMainDispatch *
1634 get_dispatch (void)
1635 {
1636   static GStaticPrivate depth_private = G_STATIC_PRIVATE_INIT;
1637   GMainDispatch *dispatch = g_static_private_get (&depth_private);
1638   if (!dispatch)
1639     {
1640       dispatch = g_slice_new0 (GMainDispatch);
1641       g_static_private_set (&depth_private, dispatch, g_main_dispatch_free);
1642     }
1643
1644   return dispatch;
1645 }
1646
1647 /**
1648  * g_main_depth:
1649  *
1650  * Returns the depth of the stack of calls to
1651  * g_main_context_dispatch() on any #GMainContext in the current thread.
1652  *  That is, when called from the toplevel, it gives 0. When
1653  * called from within a callback from g_main_context_iteration()
1654  * (or g_main_loop_run(), etc.) it returns 1. When called from within
1655  * a callback to a recursive call to g_main_context_iterate(),
1656  * it returns 2. And so forth.
1657  *
1658  * This function is useful in a situation like the following:
1659  * Imagine an extremely simple "garbage collected" system.
1660  *
1661  * |[
1662  * static GList *free_list;
1663  *
1664  * gpointer
1665  * allocate_memory (gsize size)
1666  * {
1667  *   gpointer result = g_malloc (size);
1668  *   free_list = g_list_prepend (free_list, result);
1669  *   return result;
1670  * }
1671  *
1672  * void
1673  * free_allocated_memory (void)
1674  * {
1675  *   GList *l;
1676  *   for (l = free_list; l; l = l->next);
1677  *     g_free (l->data);
1678  *   g_list_free (free_list);
1679  *   free_list = NULL;
1680  *  }
1681  *
1682  * [...]
1683  *
1684  * while (TRUE);
1685  *  {
1686  *    g_main_context_iteration (NULL, TRUE);
1687  *    free_allocated_memory();
1688  *   }
1689  * ]|
1690  *
1691  * This works from an application, however, if you want to do the same
1692  * thing from a library, it gets more difficult, since you no longer
1693  * control the main loop. You might think you can simply use an idle
1694  * function to make the call to free_allocated_memory(), but that
1695  * doesn't work, since the idle function could be called from a
1696  * recursive callback. This can be fixed by using g_main_depth()
1697  *
1698  * |[
1699  * gpointer
1700  * allocate_memory (gsize size)
1701  * {
1702  *   FreeListBlock *block = g_new (FreeListBlock, 1);
1703  *   block->mem = g_malloc (size);
1704  *   block->depth = g_main_depth ();
1705  *   free_list = g_list_prepend (free_list, block);
1706  *   return block->mem;
1707  * }
1708  *
1709  * void
1710  * free_allocated_memory (void)
1711  * {
1712  *   GList *l;
1713  *
1714  *   int depth = g_main_depth ();
1715  *   for (l = free_list; l; );
1716  *     {
1717  *       GList *next = l->next;
1718  *       FreeListBlock *block = l->data;
1719  *       if (block->depth > depth)
1720  *         {
1721  *           g_free (block->mem);
1722  *           g_free (block);
1723  *           free_list = g_list_delete_link (free_list, l);
1724  *         }
1725  *
1726  *       l = next;
1727  *     }
1728  *   }
1729  * ]|
1730  *
1731  * There is a temptation to use g_main_depth() to solve
1732  * problems with reentrancy. For instance, while waiting for data
1733  * to be received from the network in response to a menu item,
1734  * the menu item might be selected again. It might seem that
1735  * one could make the menu item's callback return immediately
1736  * and do nothing if g_main_depth() returns a value greater than 1.
1737  * However, this should be avoided since the user then sees selecting
1738  * the menu item do nothing. Furthermore, you'll find yourself adding
1739  * these checks all over your code, since there are doubtless many,
1740  * many things that the user could do. Instead, you can use the
1741  * following techniques:
1742  *
1743  * <orderedlist>
1744  *  <listitem>
1745  *   <para>
1746  *     Use gtk_widget_set_sensitive() or modal dialogs to prevent
1747  *     the user from interacting with elements while the main
1748  *     loop is recursing.
1749  *   </para>
1750  *  </listitem>
1751  *  <listitem>
1752  *   <para>
1753  *     Avoid main loop recursion in situations where you can't handle
1754  *     arbitrary  callbacks. Instead, structure your code so that you
1755  *     simply return to the main loop and then get called again when
1756  *     there is more work to do.
1757  *   </para>
1758  *  </listitem>
1759  * </orderedlist>
1760  *
1761  * Return value: The main loop recursion level in the current thread
1762  **/
1763 int
1764 g_main_depth (void)
1765 {
1766   GMainDispatch *dispatch = get_dispatch ();
1767   return dispatch->depth;
1768 }
1769
1770 /**
1771  * g_main_current_source:
1772  *
1773  * Returns the currently firing source for this thread.
1774  *
1775  * Return value: The currently firing source or %NULL.
1776  *
1777  * Since: 2.12
1778  */
1779 GSource *
1780 g_main_current_source (void)
1781 {
1782   GMainDispatch *dispatch = get_dispatch ();
1783   return dispatch->dispatching_sources ? dispatch->dispatching_sources->data : NULL;
1784 }
1785
1786 /**
1787  * g_source_is_destroyed:
1788  * @source: a #GSource
1789  *
1790  * Returns whether @source has been destroyed.
1791  *
1792  * This is important when you operate upon your objects
1793  * from within idle handlers, but may have freed the object
1794  * before the dispatch of your idle handler.
1795  *
1796  * |[
1797  * static gboolean
1798  * idle_callback (gpointer data)
1799  * {
1800  *   SomeWidget *self = data;
1801  *
1802  *   GDK_THREADS_ENTER (<!-- -->);
1803  *   /<!-- -->* do stuff with self *<!-- -->/
1804  *   self->idle_id = 0;
1805  *   GDK_THREADS_LEAVE (<!-- -->);
1806  *
1807  *   return FALSE;
1808  * }
1809  *
1810  * static void
1811  * some_widget_do_stuff_later (SomeWidget *self)
1812  * {
1813  *   self->idle_id = g_idle_add (idle_callback, self);
1814  * }
1815  *
1816  * static void
1817  * some_widget_finalize (GObject *object)
1818  * {
1819  *   SomeWidget *self = SOME_WIDGET (object);
1820  *
1821  *   if (self->idle_id)
1822  *     g_source_remove (self->idle_id);
1823  *
1824  *   G_OBJECT_CLASS (parent_class)->finalize (object);
1825  * }
1826  * ]|
1827  *
1828  * This will fail in a multi-threaded application if the
1829  * widget is destroyed before the idle handler fires due
1830  * to the use after free in the callback. A solution, to
1831  * this particular problem, is to check to if the source
1832  * has already been destroy within the callback.
1833  *
1834  * |[
1835  * static gboolean
1836  * idle_callback (gpointer data)
1837  * {
1838  *   SomeWidget *self = data;
1839  *
1840  *   GDK_THREADS_ENTER ();
1841  *   if (!g_source_is_destroyed (g_main_current_source ()))
1842  *     {
1843  *       /<!-- -->* do stuff with self *<!-- -->/
1844  *     }
1845  *   GDK_THREADS_LEAVE ();
1846  *
1847  *   return FALSE;
1848  * }
1849  * ]|
1850  *
1851  * Return value: %TRUE if the source has been destroyed
1852  *
1853  * Since: 2.12
1854  */
1855 gboolean
1856 g_source_is_destroyed (GSource *source)
1857 {
1858   return SOURCE_DESTROYED (source);
1859 }
1860
1861
1862 /* Temporarily remove all this source's file descriptors from the
1863  * poll(), so that if data comes available for one of the file descriptors
1864  * we don't continually spin in the poll()
1865  */
1866 /* HOLDS: source->context's lock */
1867 static void
1868 block_source (GSource *source)
1869 {
1870   GSList *tmp_list;
1871
1872   g_return_if_fail (!SOURCE_BLOCKED (source));
1873
1874   tmp_list = source->poll_fds;
1875   while (tmp_list)
1876     {
1877       g_main_context_remove_poll_unlocked (source->context, tmp_list->data);
1878       tmp_list = tmp_list->next;
1879     }
1880 }
1881
1882 /* HOLDS: source->context's lock */
1883 static void
1884 unblock_source (GSource *source)
1885 {
1886   GSList *tmp_list;
1887
1888   g_return_if_fail (!SOURCE_BLOCKED (source)); /* Source already unblocked */
1889   g_return_if_fail (!SOURCE_DESTROYED (source));
1890
1891   tmp_list = source->poll_fds;
1892   while (tmp_list)
1893     {
1894       g_main_context_add_poll_unlocked (source->context, source->priority, tmp_list->data);
1895       tmp_list = tmp_list->next;
1896     }
1897 }
1898
1899 /* HOLDS: context's lock */
1900 static void
1901 g_main_dispatch (GMainContext *context)
1902 {
1903   GMainDispatch *current = get_dispatch ();
1904   guint i;
1905
1906   for (i = 0; i < context->pending_dispatches->len; i++)
1907     {
1908       GSource *source = context->pending_dispatches->pdata[i];
1909
1910       context->pending_dispatches->pdata[i] = NULL;
1911       g_assert (source);
1912
1913       source->flags &= ~G_SOURCE_READY;
1914
1915       if (!SOURCE_DESTROYED (source))
1916         {
1917           gboolean was_in_call;
1918           gpointer user_data = NULL;
1919           GSourceFunc callback = NULL;
1920           GSourceCallbackFuncs *cb_funcs;
1921           gpointer cb_data;
1922           gboolean need_destroy;
1923
1924           gboolean (*dispatch) (GSource *,
1925                                 GSourceFunc,
1926                                 gpointer);
1927           GSList current_source_link;
1928
1929           dispatch = source->source_funcs->dispatch;
1930           cb_funcs = source->callback_funcs;
1931           cb_data = source->callback_data;
1932
1933           if (cb_funcs)
1934             cb_funcs->ref (cb_data);
1935
1936           if ((source->flags & G_SOURCE_CAN_RECURSE) == 0)
1937             block_source (source);
1938
1939           was_in_call = source->flags & G_HOOK_FLAG_IN_CALL;
1940           source->flags |= G_HOOK_FLAG_IN_CALL;
1941
1942           if (cb_funcs)
1943             cb_funcs->get (cb_data, source, &callback, &user_data);
1944
1945           UNLOCK_CONTEXT (context);
1946
1947           current->depth++;
1948           /* The on-stack allocation of the GSList is unconventional, but
1949            * we know that the lifetime of the link is bounded to this
1950            * function as the link is kept in a thread specific list and
1951            * not manipulated outside of this function and its descendants.
1952            * Avoiding the overhead of a g_slist_alloc() is useful as many
1953            * applications do little more than dispatch events.
1954            *
1955            * This is a performance hack - do not revert to g_slist_prepend()!
1956            */
1957           current_source_link.data = source;
1958           current_source_link.next = current->dispatching_sources;
1959           current->dispatching_sources = &current_source_link;
1960           need_destroy = ! dispatch (source,
1961                                      callback,
1962                                      user_data);
1963           g_assert (current->dispatching_sources == &current_source_link);
1964           current->dispatching_sources = current_source_link.next;
1965           current->depth--;
1966
1967           if (cb_funcs)
1968             cb_funcs->unref (cb_data);
1969
1970           LOCK_CONTEXT (context);
1971
1972           if (!was_in_call)
1973             source->flags &= ~G_HOOK_FLAG_IN_CALL;
1974
1975           if ((source->flags & G_SOURCE_CAN_RECURSE) == 0 &&
1976               !SOURCE_DESTROYED (source))
1977             unblock_source (source);
1978
1979           /* Note: this depends on the fact that we can't switch
1980            * sources from one main context to another
1981            */
1982           if (need_destroy && !SOURCE_DESTROYED (source))
1983             {
1984               g_assert (source->context == context);
1985               g_source_destroy_internal (source, context, TRUE);
1986             }
1987         }
1988
1989       SOURCE_UNREF (source, context);
1990     }
1991
1992   g_ptr_array_set_size (context->pending_dispatches, 0);
1993 }
1994
1995 /* Holds context's lock */
1996 static inline GSource *
1997 next_valid_source (GMainContext *context,
1998                    GSource      *source)
1999 {
2000   GSource *new_source = source ? source->next : context->source_list;
2001
2002   while (new_source)
2003     {
2004       if (!SOURCE_DESTROYED (new_source))
2005         {
2006           new_source->ref_count++;
2007           break;
2008         }
2009
2010       new_source = new_source->next;
2011     }
2012
2013   if (source)
2014     SOURCE_UNREF (source, context);
2015
2016   return new_source;
2017 }
2018
2019 /**
2020  * g_main_context_acquire:
2021  * @context: a #GMainContext
2022  *
2023  * Tries to become the owner of the specified context.
2024  * If some other thread is the owner of the context,
2025  * returns %FALSE immediately. Ownership is properly
2026  * recursive: the owner can require ownership again
2027  * and will release ownership when g_main_context_release()
2028  * is called as many times as g_main_context_acquire().
2029  *
2030  * You must be the owner of a context before you
2031  * can call g_main_context_prepare(), g_main_context_query(),
2032  * g_main_context_check(), g_main_context_dispatch().
2033  *
2034  * Return value: %TRUE if the operation succeeded, and
2035  *   this thread is now the owner of @context.
2036  **/
2037 gboolean
2038 g_main_context_acquire (GMainContext *context)
2039 {
2040 #ifdef G_THREADS_ENABLED
2041   gboolean result = FALSE;
2042   GThread *self = G_THREAD_SELF;
2043
2044   if (context == NULL)
2045     context = g_main_context_default ();
2046
2047   LOCK_CONTEXT (context);
2048
2049   if (!context->owner)
2050     {
2051       context->owner = self;
2052       g_assert (context->owner_count == 0);
2053     }
2054
2055   if (context->owner == self)
2056     {
2057       context->owner_count++;
2058       result = TRUE;
2059     }
2060
2061   UNLOCK_CONTEXT (context);
2062
2063   return result;
2064 #else /* !G_THREADS_ENABLED */
2065   return TRUE;
2066 #endif /* G_THREADS_ENABLED */
2067 }
2068
2069 /**
2070  * g_main_context_release:
2071  * @context: a #GMainContext
2072  *
2073  * Releases ownership of a context previously acquired by this thread
2074  * with g_main_context_acquire(). If the context was acquired multiple
2075  * times, the ownership will be released only when g_main_context_release()
2076  * is called as many times as it was acquired.
2077  **/
2078 void
2079 g_main_context_release (GMainContext *context)
2080 {
2081 #ifdef G_THREADS_ENABLED
2082   if (context == NULL)
2083     context = g_main_context_default ();
2084
2085   LOCK_CONTEXT (context);
2086
2087   context->owner_count--;
2088   if (context->owner_count == 0)
2089     {
2090       context->owner = NULL;
2091
2092       if (context->waiters)
2093         {
2094           GMainWaiter *waiter = context->waiters->data;
2095           gboolean loop_internal_waiter =
2096             (waiter->mutex == g_static_mutex_get_mutex (&context->mutex));
2097           context->waiters = g_slist_delete_link (context->waiters,
2098                                                   context->waiters);
2099           if (!loop_internal_waiter)
2100             g_mutex_lock (waiter->mutex);
2101
2102           g_cond_signal (waiter->cond);
2103
2104           if (!loop_internal_waiter)
2105             g_mutex_unlock (waiter->mutex);
2106         }
2107     }
2108
2109   UNLOCK_CONTEXT (context);
2110 #endif /* G_THREADS_ENABLED */
2111 }
2112
2113 /**
2114  * g_main_context_wait:
2115  * @context: a #GMainContext
2116  * @cond: a condition variable
2117  * @mutex: a mutex, currently held
2118  *
2119  * Tries to become the owner of the specified context,
2120  * as with g_main_context_acquire(). But if another thread
2121  * is the owner, atomically drop @mutex and wait on @cond until
2122  * that owner releases ownership or until @cond is signaled, then
2123  * try again (once) to become the owner.
2124  *
2125  * Return value: %TRUE if the operation succeeded, and
2126  *   this thread is now the owner of @context.
2127  **/
2128 gboolean
2129 g_main_context_wait (GMainContext *context,
2130                      GCond        *cond,
2131                      GMutex       *mutex)
2132 {
2133 #ifdef G_THREADS_ENABLED
2134   gboolean result = FALSE;
2135   GThread *self = G_THREAD_SELF;
2136   gboolean loop_internal_waiter;
2137
2138   if (context == NULL)
2139     context = g_main_context_default ();
2140
2141   loop_internal_waiter = (mutex == g_static_mutex_get_mutex (&context->mutex));
2142
2143   if (!loop_internal_waiter)
2144     LOCK_CONTEXT (context);
2145
2146   if (context->owner && context->owner != self)
2147     {
2148       GMainWaiter waiter;
2149
2150       waiter.cond = cond;
2151       waiter.mutex = mutex;
2152
2153       context->waiters = g_slist_append (context->waiters, &waiter);
2154
2155       if (!loop_internal_waiter)
2156         UNLOCK_CONTEXT (context);
2157       g_cond_wait (cond, mutex);
2158       if (!loop_internal_waiter)
2159         LOCK_CONTEXT (context);
2160
2161       context->waiters = g_slist_remove (context->waiters, &waiter);
2162     }
2163
2164   if (!context->owner)
2165     {
2166       context->owner = self;
2167       g_assert (context->owner_count == 0);
2168     }
2169
2170   if (context->owner == self)
2171     {
2172       context->owner_count++;
2173       result = TRUE;
2174     }
2175
2176   if (!loop_internal_waiter)
2177     UNLOCK_CONTEXT (context);
2178
2179   return result;
2180 #else /* !G_THREADS_ENABLED */
2181   return TRUE;
2182 #endif /* G_THREADS_ENABLED */
2183 }
2184
2185 /**
2186  * g_main_context_prepare:
2187  * @context: a #GMainContext
2188  * @priority: location to store priority of highest priority
2189  *            source already ready.
2190  *
2191  * Prepares to poll sources within a main loop. The resulting information
2192  * for polling is determined by calling g_main_context_query ().
2193  *
2194  * Return value: %TRUE if some source is ready to be dispatched
2195  *               prior to polling.
2196  **/
2197 gboolean
2198 g_main_context_prepare (GMainContext *context,
2199                         gint         *priority)
2200 {
2201   gint i;
2202   gint n_ready = 0;
2203   gint current_priority = G_MAXINT;
2204   GSource *source;
2205
2206   if (context == NULL)
2207     context = g_main_context_default ();
2208
2209   LOCK_CONTEXT (context);
2210
2211   context->time_is_current = FALSE;
2212
2213   if (context->in_check_or_prepare)
2214     {
2215       g_warning ("g_main_context_prepare() called recursively from within a source's check() or "
2216                  "prepare() member.");
2217       UNLOCK_CONTEXT (context);
2218       return FALSE;
2219     }
2220
2221 #ifdef G_THREADS_ENABLED
2222   if (context->poll_waiting)
2223     {
2224       g_warning("g_main_context_prepare(): main loop already active in another thread");
2225       UNLOCK_CONTEXT (context);
2226       return FALSE;
2227     }
2228
2229   context->poll_waiting = TRUE;
2230 #endif /* G_THREADS_ENABLED */
2231
2232 #if 0
2233   /* If recursing, finish up current dispatch, before starting over */
2234   if (context->pending_dispatches)
2235     {
2236       if (dispatch)
2237         g_main_dispatch (context, &current_time);
2238
2239       UNLOCK_CONTEXT (context);
2240       return TRUE;
2241     }
2242 #endif
2243
2244   /* If recursing, clear list of pending dispatches */
2245
2246   for (i = 0; i < context->pending_dispatches->len; i++)
2247     {
2248       if (context->pending_dispatches->pdata[i])
2249         SOURCE_UNREF ((GSource *)context->pending_dispatches->pdata[i], context);
2250     }
2251   g_ptr_array_set_size (context->pending_dispatches, 0);
2252
2253   /* Prepare all sources */
2254
2255   context->timeout = -1;
2256
2257   source = next_valid_source (context, NULL);
2258   while (source)
2259     {
2260       gint source_timeout = -1;
2261
2262       if ((n_ready > 0) && (source->priority > current_priority))
2263         {
2264           SOURCE_UNREF (source, context);
2265           break;
2266         }
2267       if (SOURCE_BLOCKED (source))
2268         goto next;
2269
2270       if (!(source->flags & G_SOURCE_READY))
2271         {
2272           gboolean result;
2273           gboolean (*prepare)  (GSource  *source,
2274                                 gint     *timeout);
2275
2276           prepare = source->source_funcs->prepare;
2277           context->in_check_or_prepare++;
2278           UNLOCK_CONTEXT (context);
2279
2280           result = (*prepare) (source, &source_timeout);
2281
2282           LOCK_CONTEXT (context);
2283           context->in_check_or_prepare--;
2284
2285           if (result)
2286             source->flags |= G_SOURCE_READY;
2287         }
2288
2289       if (source->flags & G_SOURCE_READY)
2290         {
2291           n_ready++;
2292           current_priority = source->priority;
2293           context->timeout = 0;
2294         }
2295
2296       if (source_timeout >= 0)
2297         {
2298           if (context->timeout < 0)
2299             context->timeout = source_timeout;
2300           else
2301             context->timeout = MIN (context->timeout, source_timeout);
2302         }
2303
2304     next:
2305       source = next_valid_source (context, source);
2306     }
2307
2308   UNLOCK_CONTEXT (context);
2309
2310   if (priority)
2311     *priority = current_priority;
2312
2313   return (n_ready > 0);
2314 }
2315
2316 /**
2317  * g_main_context_query:
2318  * @context: a #GMainContext
2319  * @max_priority: maximum priority source to check
2320  * @timeout_: location to store timeout to be used in polling
2321  * @fds: location to store #GPollFD records that need to be polled.
2322  * @n_fds: length of @fds.
2323  *
2324  * Determines information necessary to poll this main loop.
2325  *
2326  * Return value: the number of records actually stored in @fds,
2327  *   or, if more than @n_fds records need to be stored, the number
2328  *   of records that need to be stored.
2329  **/
2330 gint
2331 g_main_context_query (GMainContext *context,
2332                       gint          max_priority,
2333                       gint         *timeout,
2334                       GPollFD      *fds,
2335                       gint          n_fds)
2336 {
2337   gint n_poll;
2338   GPollRec *pollrec;
2339
2340   LOCK_CONTEXT (context);
2341
2342   pollrec = context->poll_records;
2343   n_poll = 0;
2344   while (pollrec && max_priority >= pollrec->priority)
2345     {
2346       /* We need to include entries with fd->events == 0 in the array because
2347        * otherwise if the application changes fd->events behind our back and
2348        * makes it non-zero, we'll be out of sync when we check the fds[] array.
2349        * (Changing fd->events after adding an FD wasn't an anticipated use of
2350        * this API, but it occurs in practice.) */
2351       if (n_poll < n_fds)
2352         {
2353           fds[n_poll].fd = pollrec->fd->fd;
2354           /* In direct contradiction to the Unix98 spec, IRIX runs into
2355            * difficulty if you pass in POLLERR, POLLHUP or POLLNVAL
2356            * flags in the events field of the pollfd while it should
2357            * just ignoring them. So we mask them out here.
2358            */
2359           fds[n_poll].events = pollrec->fd->events & ~(G_IO_ERR|G_IO_HUP|G_IO_NVAL);
2360           fds[n_poll].revents = 0;
2361         }
2362
2363       pollrec = pollrec->next;
2364       n_poll++;
2365     }
2366
2367 #ifdef G_THREADS_ENABLED
2368   context->poll_changed = FALSE;
2369 #endif
2370
2371   if (timeout)
2372     {
2373       *timeout = context->timeout;
2374       if (*timeout != 0)
2375         context->time_is_current = FALSE;
2376     }
2377
2378   UNLOCK_CONTEXT (context);
2379
2380   return n_poll;
2381 }
2382
2383 /**
2384  * g_main_context_check:
2385  * @context: a #GMainContext
2386  * @max_priority: the maximum numerical priority of sources to check
2387  * @fds: array of #GPollFD's that was passed to the last call to
2388  *       g_main_context_query()
2389  * @n_fds: return value of g_main_context_query()
2390  *
2391  * Passes the results of polling back to the main loop.
2392  *
2393  * Return value: %TRUE if some sources are ready to be dispatched.
2394  **/
2395 gboolean
2396 g_main_context_check (GMainContext *context,
2397                       gint          max_priority,
2398                       GPollFD      *fds,
2399                       gint          n_fds)
2400 {
2401   GSource *source;
2402   GPollRec *pollrec;
2403   gint n_ready = 0;
2404   gint i;
2405
2406   LOCK_CONTEXT (context);
2407
2408   if (context->in_check_or_prepare)
2409     {
2410       g_warning ("g_main_context_check() called recursively from within a source's check() or "
2411                  "prepare() member.");
2412       UNLOCK_CONTEXT (context);
2413       return FALSE;
2414     }
2415
2416 #ifdef G_THREADS_ENABLED
2417   if (!context->poll_waiting)
2418     {
2419 #ifndef G_OS_WIN32
2420       gchar a;
2421       read (context->wake_up_pipe[0], &a, 1);
2422 #endif
2423     }
2424   else
2425     context->poll_waiting = FALSE;
2426
2427   /* If the set of poll file descriptors changed, bail out
2428    * and let the main loop rerun
2429    */
2430   if (context->poll_changed)
2431     {
2432       UNLOCK_CONTEXT (context);
2433       return FALSE;
2434     }
2435 #endif /* G_THREADS_ENABLED */
2436
2437   pollrec = context->poll_records;
2438   i = 0;
2439   while (i < n_fds)
2440     {
2441       if (pollrec->fd->events)
2442         pollrec->fd->revents = fds[i].revents;
2443
2444       pollrec = pollrec->next;
2445       i++;
2446     }
2447
2448   source = next_valid_source (context, NULL);
2449   while (source)
2450     {
2451       if ((n_ready > 0) && (source->priority > max_priority))
2452         {
2453           SOURCE_UNREF (source, context);
2454           break;
2455         }
2456       if (SOURCE_BLOCKED (source))
2457         goto next;
2458
2459       if (!(source->flags & G_SOURCE_READY))
2460         {
2461           gboolean result;
2462           gboolean (*check) (GSource  *source);
2463
2464           check = source->source_funcs->check;
2465
2466           context->in_check_or_prepare++;
2467           UNLOCK_CONTEXT (context);
2468
2469           result = (*check) (source);
2470
2471           LOCK_CONTEXT (context);
2472           context->in_check_or_prepare--;
2473
2474           if (result)
2475             source->flags |= G_SOURCE_READY;
2476         }
2477
2478       if (source->flags & G_SOURCE_READY)
2479         {
2480           source->ref_count++;
2481           g_ptr_array_add (context->pending_dispatches, source);
2482
2483           n_ready++;
2484
2485           /* never dispatch sources with less priority than the first
2486            * one we choose to dispatch
2487            */
2488           max_priority = source->priority;
2489         }
2490
2491     next:
2492       source = next_valid_source (context, source);
2493     }
2494
2495   UNLOCK_CONTEXT (context);
2496
2497   return n_ready > 0;
2498 }
2499
2500 /**
2501  * g_main_context_dispatch:
2502  * @context: a #GMainContext
2503  *
2504  * Dispatches all pending sources.
2505  **/
2506 void
2507 g_main_context_dispatch (GMainContext *context)
2508 {
2509   LOCK_CONTEXT (context);
2510
2511   if (context->pending_dispatches->len > 0)
2512     {
2513       g_main_dispatch (context);
2514     }
2515
2516   UNLOCK_CONTEXT (context);
2517 }
2518
2519 /* HOLDS context lock */
2520 static gboolean
2521 g_main_context_iterate (GMainContext *context,
2522                         gboolean      block,
2523                         gboolean      dispatch,
2524                         GThread      *self)
2525 {
2526   gint max_priority;
2527   gint timeout;
2528   gboolean some_ready;
2529   gint nfds, allocated_nfds;
2530   GPollFD *fds = NULL;
2531
2532   UNLOCK_CONTEXT (context);
2533
2534 #ifdef G_THREADS_ENABLED
2535   if (!g_main_context_acquire (context))
2536     {
2537       gboolean got_ownership;
2538
2539       LOCK_CONTEXT (context);
2540
2541       g_return_val_if_fail (g_thread_supported (), FALSE);
2542
2543       if (!block)
2544         return FALSE;
2545
2546       if (!context->cond)
2547         context->cond = g_cond_new ();
2548
2549       got_ownership = g_main_context_wait (context,
2550                                            context->cond,
2551                                            g_static_mutex_get_mutex (&context->mutex));
2552
2553       if (!got_ownership)
2554         return FALSE;
2555     }
2556   else
2557     LOCK_CONTEXT (context);
2558 #endif /* G_THREADS_ENABLED */
2559
2560   if (!context->cached_poll_array)
2561     {
2562       context->cached_poll_array_size = context->n_poll_records;
2563       context->cached_poll_array = g_new (GPollFD, context->n_poll_records);
2564     }
2565
2566   allocated_nfds = context->cached_poll_array_size;
2567   fds = context->cached_poll_array;
2568
2569   UNLOCK_CONTEXT (context);
2570
2571   g_main_context_prepare (context, &max_priority);
2572
2573   while ((nfds = g_main_context_query (context, max_priority, &timeout, fds,
2574                                        allocated_nfds)) > allocated_nfds)
2575     {
2576       LOCK_CONTEXT (context);
2577       g_free (fds);
2578       context->cached_poll_array_size = allocated_nfds = nfds;
2579       context->cached_poll_array = fds = g_new (GPollFD, nfds);
2580       UNLOCK_CONTEXT (context);
2581     }
2582
2583   if (!block)
2584     timeout = 0;
2585
2586   g_main_context_poll (context, timeout, max_priority, fds, nfds);
2587
2588   some_ready = g_main_context_check (context, max_priority, fds, nfds);
2589
2590   if (dispatch)
2591     g_main_context_dispatch (context);
2592
2593 #ifdef G_THREADS_ENABLED
2594   g_main_context_release (context);
2595 #endif /* G_THREADS_ENABLED */
2596
2597   LOCK_CONTEXT (context);
2598
2599   return some_ready;
2600 }
2601
2602 /**
2603  * g_main_context_pending:
2604  * @context: a #GMainContext (if %NULL, the default context will be used)
2605  *
2606  * Checks if any sources have pending events for the given context.
2607  *
2608  * Return value: %TRUE if events are pending.
2609  **/
2610 gboolean
2611 g_main_context_pending (GMainContext *context)
2612 {
2613   gboolean retval;
2614
2615   if (!context)
2616     context = g_main_context_default();
2617
2618   LOCK_CONTEXT (context);
2619   retval = g_main_context_iterate (context, FALSE, FALSE, G_THREAD_SELF);
2620   UNLOCK_CONTEXT (context);
2621
2622   return retval;
2623 }
2624
2625 /**
2626  * g_main_context_iteration:
2627  * @context: a #GMainContext (if %NULL, the default context will be used)
2628  * @may_block: whether the call may block.
2629  *
2630  * Runs a single iteration for the given main loop. This involves
2631  * checking to see if any event sources are ready to be processed,
2632  * then if no events sources are ready and @may_block is %TRUE, waiting
2633  * for a source to become ready, then dispatching the highest priority
2634  * events sources that are ready. Otherwise, if @may_block is %FALSE
2635  * sources are not waited to become ready, only those highest priority
2636  * events sources will be dispatched (if any), that are ready at this
2637  * given moment without further waiting.
2638  *
2639  * Note that even when @may_block is %TRUE, it is still possible for
2640  * g_main_context_iteration() to return %FALSE, since the the wait may
2641  * be interrupted for other reasons than an event source becoming ready.
2642  *
2643  * Return value: %TRUE if events were dispatched.
2644  **/
2645 gboolean
2646 g_main_context_iteration (GMainContext *context, gboolean may_block)
2647 {
2648   gboolean retval;
2649
2650   if (!context)
2651     context = g_main_context_default();
2652
2653   LOCK_CONTEXT (context);
2654   retval = g_main_context_iterate (context, may_block, TRUE, G_THREAD_SELF);
2655   UNLOCK_CONTEXT (context);
2656
2657   return retval;
2658 }
2659
2660 /**
2661  * g_main_loop_new:
2662  * @context: a #GMainContext  (if %NULL, the default context will be used).
2663  * @is_running: set to %TRUE to indicate that the loop is running. This
2664  * is not very important since calling g_main_loop_run() will set this to
2665  * %TRUE anyway.
2666  *
2667  * Creates a new #GMainLoop structure.
2668  *
2669  * Return value: a new #GMainLoop.
2670  **/
2671 GMainLoop *
2672 g_main_loop_new (GMainContext *context,
2673                  gboolean      is_running)
2674 {
2675   GMainLoop *loop;
2676
2677   if (!context)
2678     context = g_main_context_default();
2679
2680   g_main_context_ref (context);
2681
2682   loop = g_new0 (GMainLoop, 1);
2683   loop->context = context;
2684   loop->is_running = is_running != FALSE;
2685   loop->ref_count = 1;
2686
2687   return loop;
2688 }
2689
2690 /**
2691  * g_main_loop_ref:
2692  * @loop: a #GMainLoop
2693  *
2694  * Increases the reference count on a #GMainLoop object by one.
2695  *
2696  * Return value: @loop
2697  **/
2698 GMainLoop *
2699 g_main_loop_ref (GMainLoop *loop)
2700 {
2701   g_return_val_if_fail (loop != NULL, NULL);
2702   g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, NULL);
2703
2704   g_atomic_int_inc (&loop->ref_count);
2705
2706   return loop;
2707 }
2708
2709 /**
2710  * g_main_loop_unref:
2711  * @loop: a #GMainLoop
2712  *
2713  * Decreases the reference count on a #GMainLoop object by one. If
2714  * the result is zero, free the loop and free all associated memory.
2715  **/
2716 void
2717 g_main_loop_unref (GMainLoop *loop)
2718 {
2719   g_return_if_fail (loop != NULL);
2720   g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
2721
2722   if (!g_atomic_int_dec_and_test (&loop->ref_count))
2723     return;
2724
2725   g_main_context_unref (loop->context);
2726   g_free (loop);
2727 }
2728
2729 /**
2730  * g_main_loop_run:
2731  * @loop: a #GMainLoop
2732  *
2733  * Runs a main loop until g_main_loop_quit() is called on the loop.
2734  * If this is called for the thread of the loop's #GMainContext,
2735  * it will process events from the loop, otherwise it will
2736  * simply wait.
2737  **/
2738 void
2739 g_main_loop_run (GMainLoop *loop)
2740 {
2741   GThread *self = G_THREAD_SELF;
2742
2743   g_return_if_fail (loop != NULL);
2744   g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
2745
2746 #ifdef G_THREADS_ENABLED
2747   if (!g_main_context_acquire (loop->context))
2748     {
2749       gboolean got_ownership = FALSE;
2750
2751       /* Another thread owns this context */
2752       if (!g_thread_supported ())
2753         {
2754           g_warning ("g_main_loop_run() was called from second thread but "
2755                      "g_thread_init() was never called.");
2756           return;
2757         }
2758
2759       LOCK_CONTEXT (loop->context);
2760
2761       g_atomic_int_inc (&loop->ref_count);
2762
2763       if (!loop->is_running)
2764         loop->is_running = TRUE;
2765
2766       if (!loop->context->cond)
2767         loop->context->cond = g_cond_new ();
2768
2769       while (loop->is_running && !got_ownership)
2770         got_ownership = g_main_context_wait (loop->context,
2771                                              loop->context->cond,
2772                                              g_static_mutex_get_mutex (&loop->context->mutex));
2773
2774       if (!loop->is_running)
2775         {
2776           UNLOCK_CONTEXT (loop->context);
2777           if (got_ownership)
2778             g_main_context_release (loop->context);
2779           g_main_loop_unref (loop);
2780           return;
2781         }
2782
2783       g_assert (got_ownership);
2784     }
2785   else
2786     LOCK_CONTEXT (loop->context);
2787 #endif /* G_THREADS_ENABLED */
2788
2789   if (loop->context->in_check_or_prepare)
2790     {
2791       g_warning ("g_main_loop_run(): called recursively from within a source's "
2792                  "check() or prepare() member, iteration not possible.");
2793       return;
2794     }
2795
2796   g_atomic_int_inc (&loop->ref_count);
2797   loop->is_running = TRUE;
2798   while (loop->is_running)
2799     g_main_context_iterate (loop->context, TRUE, TRUE, self);
2800
2801   UNLOCK_CONTEXT (loop->context);
2802
2803 #ifdef G_THREADS_ENABLED
2804   g_main_context_release (loop->context);
2805 #endif /* G_THREADS_ENABLED */
2806
2807   g_main_loop_unref (loop);
2808 }
2809
2810 /**
2811  * g_main_loop_quit:
2812  * @loop: a #GMainLoop
2813  *
2814  * Stops a #GMainLoop from running. Any calls to g_main_loop_run()
2815  * for the loop will return.
2816  *
2817  * Note that sources that have already been dispatched when
2818  * g_main_loop_quit() is called will still be executed.
2819  **/
2820 void
2821 g_main_loop_quit (GMainLoop *loop)
2822 {
2823   g_return_if_fail (loop != NULL);
2824   g_return_if_fail (g_atomic_int_get (&loop->ref_count) > 0);
2825
2826   LOCK_CONTEXT (loop->context);
2827   loop->is_running = FALSE;
2828   g_main_context_wakeup_unlocked (loop->context);
2829
2830 #ifdef G_THREADS_ENABLED
2831   if (loop->context->cond)
2832     g_cond_broadcast (loop->context->cond);
2833 #endif /* G_THREADS_ENABLED */
2834
2835   UNLOCK_CONTEXT (loop->context);
2836 }
2837
2838 /**
2839  * g_main_loop_is_running:
2840  * @loop: a #GMainLoop.
2841  *
2842  * Checks to see if the main loop is currently being run via g_main_loop_run().
2843  *
2844  * Return value: %TRUE if the mainloop is currently being run.
2845  **/
2846 gboolean
2847 g_main_loop_is_running (GMainLoop *loop)
2848 {
2849   g_return_val_if_fail (loop != NULL, FALSE);
2850   g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, FALSE);
2851
2852   return loop->is_running;
2853 }
2854
2855 /**
2856  * g_main_loop_get_context:
2857  * @loop: a #GMainLoop.
2858  *
2859  * Returns the #GMainContext of @loop.
2860  *
2861  * Return value: the #GMainContext of @loop
2862  **/
2863 GMainContext *
2864 g_main_loop_get_context (GMainLoop *loop)
2865 {
2866   g_return_val_if_fail (loop != NULL, NULL);
2867   g_return_val_if_fail (g_atomic_int_get (&loop->ref_count) > 0, NULL);
2868
2869   return loop->context;
2870 }
2871
2872 /* HOLDS: context's lock */
2873 static void
2874 g_main_context_poll (GMainContext *context,
2875                      gint          timeout,
2876                      gint          priority,
2877                      GPollFD      *fds,
2878                      gint          n_fds)
2879 {
2880 #ifdef  G_MAIN_POLL_DEBUG
2881   GTimer *poll_timer;
2882   GPollRec *pollrec;
2883   gint i;
2884 #endif
2885
2886   GPollFunc poll_func;
2887
2888   if (n_fds || timeout != 0)
2889     {
2890 #ifdef  G_MAIN_POLL_DEBUG
2891       if (_g_main_poll_debug)
2892         {
2893           g_print ("polling context=%p n=%d timeout=%d\n",
2894                    context, n_fds, timeout);
2895           poll_timer = g_timer_new ();
2896         }
2897 #endif
2898
2899       LOCK_CONTEXT (context);
2900
2901       poll_func = context->poll_func;
2902
2903       UNLOCK_CONTEXT (context);
2904       if ((*poll_func) (fds, n_fds, timeout) < 0 && errno != EINTR)
2905         {
2906 #ifndef G_OS_WIN32
2907           g_warning ("poll(2) failed due to: %s.",
2908                      g_strerror (errno));
2909 #else
2910           /* If g_poll () returns -1, it has already called g_warning() */
2911 #endif
2912         }
2913
2914 #ifdef  G_MAIN_POLL_DEBUG
2915       if (_g_main_poll_debug)
2916         {
2917           LOCK_CONTEXT (context);
2918
2919           g_print ("g_main_poll(%d) timeout: %d - elapsed %12.10f seconds",
2920                    n_fds,
2921                    timeout,
2922                    g_timer_elapsed (poll_timer, NULL));
2923           g_timer_destroy (poll_timer);
2924           pollrec = context->poll_records;
2925
2926           while (pollrec != NULL)
2927             {
2928               i = 0;
2929               while (i < n_fds)
2930                 {
2931                   if (fds[i].fd == pollrec->fd->fd &&
2932                       pollrec->fd->events &&
2933                       fds[i].revents)
2934                     {
2935                       g_print (" [" G_POLLFD_FORMAT " :", fds[i].fd);
2936                       if (fds[i].revents & G_IO_IN)
2937                         g_print ("i");
2938                       if (fds[i].revents & G_IO_OUT)
2939                         g_print ("o");
2940                       if (fds[i].revents & G_IO_PRI)
2941                         g_print ("p");
2942                       if (fds[i].revents & G_IO_ERR)
2943                         g_print ("e");
2944                       if (fds[i].revents & G_IO_HUP)
2945                         g_print ("h");
2946                       if (fds[i].revents & G_IO_NVAL)
2947                         g_print ("n");
2948                       g_print ("]");
2949                     }
2950                   i++;
2951                 }
2952               pollrec = pollrec->next;
2953             }
2954           g_print ("\n");
2955
2956           UNLOCK_CONTEXT (context);
2957         }
2958 #endif
2959     } /* if (n_fds || timeout != 0) */
2960 }
2961
2962 /**
2963  * g_main_context_add_poll:
2964  * @context: a #GMainContext (or %NULL for the default context)
2965  * @fd: a #GPollFD structure holding information about a file
2966  *      descriptor to watch.
2967  * @priority: the priority for this file descriptor which should be
2968  *      the same as the priority used for g_source_attach() to ensure that the
2969  *      file descriptor is polled whenever the results may be needed.
2970  *
2971  * Adds a file descriptor to the set of file descriptors polled for
2972  * this context. This will very seldomly be used directly. Instead
2973  * a typical event source will use g_source_add_poll() instead.
2974  **/
2975 void
2976 g_main_context_add_poll (GMainContext *context,
2977                          GPollFD      *fd,
2978                          gint          priority)
2979 {
2980   if (!context)
2981     context = g_main_context_default ();
2982
2983   g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
2984   g_return_if_fail (fd);
2985
2986   LOCK_CONTEXT (context);
2987   g_main_context_add_poll_unlocked (context, priority, fd);
2988   UNLOCK_CONTEXT (context);
2989 }
2990
2991 /* HOLDS: main_loop_lock */
2992 static void
2993 g_main_context_add_poll_unlocked (GMainContext *context,
2994                                   gint          priority,
2995                                   GPollFD      *fd)
2996 {
2997   GPollRec *lastrec, *pollrec;
2998   GPollRec *newrec = g_slice_new (GPollRec);
2999
3000   /* This file descriptor may be checked before we ever poll */
3001   fd->revents = 0;
3002   newrec->fd = fd;
3003   newrec->priority = priority;
3004
3005   lastrec = NULL;
3006   pollrec = context->poll_records;
3007   while (pollrec && priority >= pollrec->priority)
3008     {
3009       lastrec = pollrec;
3010       pollrec = pollrec->next;
3011     }
3012
3013   if (lastrec)
3014     lastrec->next = newrec;
3015   else
3016     context->poll_records = newrec;
3017
3018   newrec->next = pollrec;
3019
3020   context->n_poll_records++;
3021
3022 #ifdef G_THREADS_ENABLED
3023   context->poll_changed = TRUE;
3024
3025   /* Now wake up the main loop if it is waiting in the poll() */
3026   g_main_context_wakeup_unlocked (context);
3027 #endif
3028 }
3029
3030 /**
3031  * g_main_context_remove_poll:
3032  * @context:a #GMainContext
3033  * @fd: a #GPollFD descriptor previously added with g_main_context_add_poll()
3034  *
3035  * Removes file descriptor from the set of file descriptors to be
3036  * polled for a particular context.
3037  **/
3038 void
3039 g_main_context_remove_poll (GMainContext *context,
3040                             GPollFD      *fd)
3041 {
3042   if (!context)
3043     context = g_main_context_default ();
3044
3045   g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3046   g_return_if_fail (fd);
3047
3048   LOCK_CONTEXT (context);
3049   g_main_context_remove_poll_unlocked (context, fd);
3050   UNLOCK_CONTEXT (context);
3051 }
3052
3053 static void
3054 g_main_context_remove_poll_unlocked (GMainContext *context,
3055                                      GPollFD      *fd)
3056 {
3057   GPollRec *pollrec, *lastrec;
3058
3059   lastrec = NULL;
3060   pollrec = context->poll_records;
3061
3062   while (pollrec)
3063     {
3064       if (pollrec->fd == fd)
3065         {
3066           if (lastrec != NULL)
3067             lastrec->next = pollrec->next;
3068           else
3069             context->poll_records = pollrec->next;
3070
3071           g_slice_free (GPollRec, pollrec);
3072
3073           context->n_poll_records--;
3074           break;
3075         }
3076       lastrec = pollrec;
3077       pollrec = pollrec->next;
3078     }
3079
3080 #ifdef G_THREADS_ENABLED
3081   context->poll_changed = TRUE;
3082
3083   /* Now wake up the main loop if it is waiting in the poll() */
3084   g_main_context_wakeup_unlocked (context);
3085 #endif
3086 }
3087
3088 /**
3089  * g_source_get_current_time:
3090  * @source:  a #GSource
3091  * @timeval: #GTimeVal structure in which to store current time.
3092  *
3093  * Gets the "current time" to be used when checking
3094  * this source. The advantage of calling this function over
3095  * calling g_get_current_time() directly is that when
3096  * checking multiple sources, GLib can cache a single value
3097  * instead of having to repeatedly get the system time.
3098  **/
3099 void
3100 g_source_get_current_time (GSource  *source,
3101                            GTimeVal *timeval)
3102 {
3103   GMainContext *context;
3104
3105   g_return_if_fail (source->context != NULL);
3106
3107   context = source->context;
3108
3109   LOCK_CONTEXT (context);
3110
3111   if (!context->time_is_current)
3112     {
3113       g_get_current_time (&context->current_time);
3114       context->time_is_current = TRUE;
3115     }
3116
3117   *timeval = context->current_time;
3118
3119   UNLOCK_CONTEXT (context);
3120 }
3121
3122 /**
3123  * g_main_context_set_poll_func:
3124  * @context: a #GMainContext
3125  * @func: the function to call to poll all file descriptors
3126  *
3127  * Sets the function to use to handle polling of file descriptors. It
3128  * will be used instead of the poll() system call
3129  * (or GLib's replacement function, which is used where
3130  * poll() isn't available).
3131  *
3132  * This function could possibly be used to integrate the GLib event
3133  * loop with an external event loop.
3134  **/
3135 void
3136 g_main_context_set_poll_func (GMainContext *context,
3137                               GPollFunc     func)
3138 {
3139   if (!context)
3140     context = g_main_context_default ();
3141
3142   g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3143
3144   LOCK_CONTEXT (context);
3145
3146   if (func)
3147     context->poll_func = func;
3148   else
3149     context->poll_func = g_poll;
3150
3151   UNLOCK_CONTEXT (context);
3152 }
3153
3154 /**
3155  * g_main_context_get_poll_func:
3156  * @context: a #GMainContext
3157  *
3158  * Gets the poll function set by g_main_context_set_poll_func().
3159  *
3160  * Return value: the poll function
3161  **/
3162 GPollFunc
3163 g_main_context_get_poll_func (GMainContext *context)
3164 {
3165   GPollFunc result;
3166
3167   if (!context)
3168     context = g_main_context_default ();
3169
3170   g_return_val_if_fail (g_atomic_int_get (&context->ref_count) > 0, NULL);
3171
3172   LOCK_CONTEXT (context);
3173   result = context->poll_func;
3174   UNLOCK_CONTEXT (context);
3175
3176   return result;
3177 }
3178
3179 /* HOLDS: context's lock */
3180 /* Wake the main loop up from a poll() */
3181 static void
3182 g_main_context_wakeup_unlocked (GMainContext *context)
3183 {
3184 #ifdef G_THREADS_ENABLED
3185   if (g_thread_supported() && context->poll_waiting)
3186     {
3187       context->poll_waiting = FALSE;
3188 #ifndef G_OS_WIN32
3189       write (context->wake_up_pipe[1], "A", 1);
3190 #else
3191       ReleaseSemaphore (context->wake_up_semaphore, 1, NULL);
3192 #endif
3193     }
3194 #endif
3195 }
3196
3197 /**
3198  * g_main_context_wakeup:
3199  * @context: a #GMainContext
3200  *
3201  * If @context is currently waiting in a poll(), interrupt
3202  * the poll(), and continue the iteration process.
3203  **/
3204 void
3205 g_main_context_wakeup (GMainContext *context)
3206 {
3207   if (!context)
3208     context = g_main_context_default ();
3209
3210   g_return_if_fail (g_atomic_int_get (&context->ref_count) > 0);
3211
3212   LOCK_CONTEXT (context);
3213   g_main_context_wakeup_unlocked (context);
3214   UNLOCK_CONTEXT (context);
3215 }
3216
3217 /**
3218  * g_main_context_is_owner:
3219  * @context: a #GMainContext
3220  *
3221  * Determines whether this thread holds the (recursive)
3222  * ownership of this #GMaincontext. This is useful to
3223  * know before waiting on another thread that may be
3224  * blocking to get ownership of @context.
3225  *
3226  * Returns: %TRUE if current thread is owner of @context.
3227  *
3228  * Since: 2.10
3229  **/
3230 gboolean
3231 g_main_context_is_owner (GMainContext *context)
3232 {
3233   gboolean is_owner;
3234
3235   if (!context)
3236     context = g_main_context_default ();
3237
3238 #ifdef G_THREADS_ENABLED
3239   LOCK_CONTEXT (context);
3240   is_owner = context->owner == G_THREAD_SELF;
3241   UNLOCK_CONTEXT (context);
3242 #else
3243   is_owner = TRUE;
3244 #endif
3245
3246   return is_owner;
3247 }
3248
3249 /* Timeouts */
3250
3251 static void
3252 g_timeout_set_expiration (GTimeoutSource *timeout_source,
3253                           GTimeVal       *current_time)
3254 {
3255   guint seconds = timeout_source->interval / 1000;
3256   guint msecs = timeout_source->interval - seconds * 1000;
3257
3258   timeout_source->expiration.tv_sec = current_time->tv_sec + seconds;
3259   timeout_source->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
3260   if (timeout_source->expiration.tv_usec >= 1000000)
3261     {
3262       timeout_source->expiration.tv_usec -= 1000000;
3263       timeout_source->expiration.tv_sec++;
3264     }
3265   if (timer_perturb==-1)
3266     {
3267       /*
3268        * we want a per machine/session unique 'random' value; try the dbus
3269        * address first, that has a UUID in it. If there is no dbus, use the
3270        * hostname for hashing.
3271        */
3272       const char *session_bus_address = g_getenv ("DBUS_SESSION_BUS_ADDRESS");
3273       if (!session_bus_address)
3274         session_bus_address = g_getenv ("HOSTNAME");
3275       if (session_bus_address)
3276         timer_perturb = ABS ((gint) g_str_hash (session_bus_address));
3277       else
3278         timer_perturb = 0;
3279     }
3280   if (timeout_source->granularity)
3281     {
3282       gint remainder;
3283       gint gran; /* in usecs */
3284       gint perturb;
3285
3286       gran = timeout_source->granularity * 1000;
3287       perturb = timer_perturb % gran;
3288       /*
3289        * We want to give each machine a per machine pertubation;
3290        * shift time back first, and forward later after the rounding
3291        */
3292
3293       timeout_source->expiration.tv_usec -= perturb;
3294       if (timeout_source->expiration.tv_usec < 0)
3295         {
3296           timeout_source->expiration.tv_usec += 1000000;
3297           timeout_source->expiration.tv_sec--;
3298         }
3299
3300       remainder = timeout_source->expiration.tv_usec % gran;
3301       if (remainder >= gran/4) /* round up */
3302         timeout_source->expiration.tv_usec += gran;
3303       timeout_source->expiration.tv_usec -= remainder;
3304       /* shift back */
3305       timeout_source->expiration.tv_usec += perturb;
3306
3307       /* the rounding may have overflown tv_usec */
3308       while (timeout_source->expiration.tv_usec > 1000000)
3309         {
3310           timeout_source->expiration.tv_usec -= 1000000;
3311           timeout_source->expiration.tv_sec++;
3312         }
3313     }
3314 }
3315
3316 static gboolean
3317 g_timeout_prepare (GSource *source,
3318                    gint    *timeout)
3319 {
3320   glong sec;
3321   glong msec;
3322   GTimeVal current_time;
3323
3324   GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3325
3326   g_source_get_current_time (source, &current_time);
3327
3328   sec = timeout_source->expiration.tv_sec - current_time.tv_sec;
3329   msec = (timeout_source->expiration.tv_usec - current_time.tv_usec) / 1000;
3330
3331   /* We do the following in a rather convoluted fashion to deal with
3332    * the fact that we don't have an integral type big enough to hold
3333    * the difference of two timevals in millseconds.
3334    */
3335   if (sec < 0 || (sec == 0 && msec < 0))
3336     msec = 0;
3337   else
3338     {
3339       glong interval_sec = timeout_source->interval / 1000;
3340       glong interval_msec = timeout_source->interval % 1000;
3341
3342       if (msec < 0)
3343         {
3344           msec += 1000;
3345           sec -= 1;
3346         }
3347
3348       if (sec > interval_sec ||
3349           (sec == interval_sec && msec > interval_msec))
3350         {
3351           /* The system time has been set backwards, so we
3352            * reset the expiration time to now + timeout_source->interval;
3353            * this at least avoids hanging for long periods of time.
3354            */
3355           g_timeout_set_expiration (timeout_source, &current_time);
3356           msec = MIN (G_MAXINT, timeout_source->interval);
3357         }
3358       else
3359         {
3360           msec = MIN (G_MAXINT, (guint)msec + 1000 * (guint)sec);
3361         }
3362     }
3363
3364   *timeout = (gint)msec;
3365
3366   return msec == 0;
3367 }
3368
3369 static gboolean
3370 g_timeout_check (GSource *source)
3371 {
3372   GTimeVal current_time;
3373   GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3374
3375   g_source_get_current_time (source, &current_time);
3376
3377   return ((timeout_source->expiration.tv_sec < current_time.tv_sec) ||
3378           ((timeout_source->expiration.tv_sec == current_time.tv_sec) &&
3379            (timeout_source->expiration.tv_usec <= current_time.tv_usec)));
3380 }
3381
3382 static gboolean
3383 g_timeout_dispatch (GSource     *source,
3384                     GSourceFunc  callback,
3385                     gpointer     user_data)
3386 {
3387   GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3388
3389   if (!callback)
3390     {
3391       g_warning ("Timeout source dispatched without callback\n"
3392                  "You must call g_source_set_callback().");
3393       return FALSE;
3394     }
3395
3396   if (callback (user_data))
3397     {
3398       GTimeVal current_time;
3399
3400       g_source_get_current_time (source, &current_time);
3401       g_timeout_set_expiration (timeout_source, &current_time);
3402
3403       return TRUE;
3404     }
3405   else
3406     return FALSE;
3407 }
3408
3409 /**
3410  * g_timeout_source_new:
3411  * @interval: the timeout interval in milliseconds.
3412  *
3413  * Creates a new timeout source.
3414  *
3415  * The source will not initially be associated with any #GMainContext
3416  * and must be added to one with g_source_attach() before it will be
3417  * executed.
3418  *
3419  * Return value: the newly-created timeout source
3420  **/
3421 GSource *
3422 g_timeout_source_new (guint interval)
3423 {
3424   GSource *source = g_source_new (&g_timeout_funcs, sizeof (GTimeoutSource));
3425   GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3426   GTimeVal current_time;
3427
3428   timeout_source->interval = interval;
3429
3430   g_get_current_time (&current_time);
3431   g_timeout_set_expiration (timeout_source, &current_time);
3432
3433   return source;
3434 }
3435
3436 /**
3437  * g_timeout_source_new_seconds:
3438  * @interval: the timeout interval in seconds
3439  *
3440  * Creates a new timeout source.
3441  *
3442  * The source will not initially be associated with any #GMainContext
3443  * and must be added to one with g_source_attach() before it will be
3444  * executed.
3445  *
3446  * The scheduling granularity/accuracy of this timeout source will be
3447  * in seconds.
3448  *
3449  * Return value: the newly-created timeout source
3450  *
3451  * Since: 2.14
3452  **/
3453 GSource *
3454 g_timeout_source_new_seconds (guint interval)
3455 {
3456   GSource *source = g_source_new (&g_timeout_funcs, sizeof (GTimeoutSource));
3457   GTimeoutSource *timeout_source = (GTimeoutSource *)source;
3458   GTimeVal current_time;
3459
3460   timeout_source->interval = 1000*interval;
3461   timeout_source->granularity = 1000;
3462
3463   g_get_current_time (&current_time);
3464   g_timeout_set_expiration (timeout_source, &current_time);
3465
3466   return source;
3467 }
3468
3469
3470 /**
3471  * g_timeout_add_full:
3472  * @priority: the priority of the timeout source. Typically this will be in
3473  *            the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
3474  * @interval: the time between calls to the function, in milliseconds
3475  *             (1/1000ths of a second)
3476  * @function: function to call
3477  * @data:     data to pass to @function
3478  * @notify:   function to call when the timeout is removed, or %NULL
3479  *
3480  * Sets a function to be called at regular intervals, with the given
3481  * priority.  The function is called repeatedly until it returns
3482  * %FALSE, at which point the timeout is automatically destroyed and
3483  * the function will not be called again.  The @notify function is
3484  * called when the timeout is destroyed.  The first call to the
3485  * function will be at the end of the first @interval.
3486  *
3487  * Note that timeout functions may be delayed, due to the processing of other
3488  * event sources. Thus they should not be relied on for precise timing.
3489  * After each call to the timeout function, the time of the next
3490  * timeout is recalculated based on the current time and the given interval
3491  * (it does not try to 'catch up' time lost in delays).
3492  *
3493  * This internally creates a main loop source using g_timeout_source_new()
3494  * and attaches it to the main loop context using g_source_attach(). You can
3495  * do these steps manually if you need greater control.
3496  *
3497  * Return value: the ID (greater than 0) of the event source.
3498  **/
3499 guint
3500 g_timeout_add_full (gint           priority,
3501                     guint          interval,
3502                     GSourceFunc    function,
3503                     gpointer       data,
3504                     GDestroyNotify notify)
3505 {
3506   GSource *source;
3507   guint id;
3508
3509   g_return_val_if_fail (function != NULL, 0);
3510
3511   source = g_timeout_source_new (interval);
3512
3513   if (priority != G_PRIORITY_DEFAULT)
3514     g_source_set_priority (source, priority);
3515
3516   g_source_set_callback (source, function, data, notify);
3517   id = g_source_attach (source, NULL);
3518   g_source_unref (source);
3519
3520   return id;
3521 }
3522
3523 /**
3524  * g_timeout_add:
3525  * @interval: the time between calls to the function, in milliseconds
3526  *             (1/1000ths of a second)
3527  * @function: function to call
3528  * @data:     data to pass to @function
3529  *
3530  * Sets a function to be called at regular intervals, with the default
3531  * priority, #G_PRIORITY_DEFAULT.  The function is called repeatedly
3532  * until it returns %FALSE, at which point the timeout is automatically
3533  * destroyed and the function will not be called again.  The first call
3534  * to the function will be at the end of the first @interval.
3535  *
3536  * Note that timeout functions may be delayed, due to the processing of other
3537  * event sources. Thus they should not be relied on for precise timing.
3538  * After each call to the timeout function, the time of the next
3539  * timeout is recalculated based on the current time and the given interval
3540  * (it does not try to 'catch up' time lost in delays).
3541  *
3542  * If you want to have a timer in the "seconds" range and do not care
3543  * about the exact time of the first call of the timer, use the
3544  * g_timeout_add_seconds() function; this function allows for more
3545  * optimizations and more efficient system power usage.
3546  *
3547  * This internally creates a main loop source using g_timeout_source_new()
3548  * and attaches it to the main loop context using g_source_attach(). You can
3549  * do these steps manually if you need greater control.
3550  *
3551  * Return value: the ID (greater than 0) of the event source.
3552  **/
3553 guint
3554 g_timeout_add (guint32        interval,
3555                GSourceFunc    function,
3556                gpointer       data)
3557 {
3558   return g_timeout_add_full (G_PRIORITY_DEFAULT,
3559                              interval, function, data, NULL);
3560 }
3561
3562 /**
3563  * g_timeout_add_seconds_full:
3564  * @priority: the priority of the timeout source. Typically this will be in
3565  *            the range between #G_PRIORITY_DEFAULT and #G_PRIORITY_HIGH.
3566  * @interval: the time between calls to the function, in seconds
3567  * @function: function to call
3568  * @data:     data to pass to @function
3569  * @notify:   function to call when the timeout is removed, or %NULL
3570  *
3571  * Sets a function to be called at regular intervals, with @priority.
3572  * The function is called repeatedly until it returns %FALSE, at which
3573  * point the timeout is automatically destroyed and the function will
3574  * not be called again.
3575  *
3576  * Unlike g_timeout_add(), this function operates at whole second granularity.
3577  * The initial starting point of the timer is determined by the implementation
3578  * and the implementation is expected to group multiple timers together so that
3579  * they fire all at the same time.
3580  * To allow this grouping, the @interval to the first timer is rounded
3581  * and can deviate up to one second from the specified interval.
3582  * Subsequent timer iterations will generally run at the specified interval.
3583  *
3584  * Note that timeout functions may be delayed, due to the processing of other
3585  * event sources. Thus they should not be relied on for precise timing.
3586  * After each call to the timeout function, the time of the next
3587  * timeout is recalculated based on the current time and the given @interval
3588  *
3589  * If you want timing more precise than whole seconds, use g_timeout_add()
3590  * instead.
3591  *
3592  * The grouping of timers to fire at the same time results in a more power
3593  * and CPU efficient behavior so if your timer is in multiples of seconds
3594  * and you don't require the first timer exactly one second from now, the
3595  * use of g_timeout_add_seconds() is preferred over g_timeout_add().
3596  *
3597  * This internally creates a main loop source using
3598  * g_timeout_source_new_seconds() and attaches it to the main loop context
3599  * using g_source_attach(). You can do these steps manually if you need
3600  * greater control.
3601  *
3602  * Return value: the ID (greater than 0) of the event source.
3603  *
3604  * Since: 2.14
3605  **/
3606 guint
3607 g_timeout_add_seconds_full (gint           priority,
3608                             guint32        interval,
3609                             GSourceFunc    function,
3610                             gpointer       data,
3611                             GDestroyNotify notify)
3612 {
3613   GSource *source;
3614   guint id;
3615
3616   g_return_val_if_fail (function != NULL, 0);
3617
3618   source = g_timeout_source_new_seconds (interval);
3619
3620   if (priority != G_PRIORITY_DEFAULT)
3621     g_source_set_priority (source, priority);
3622
3623   g_source_set_callback (source, function, data, notify);
3624   id = g_source_attach (source, NULL);
3625   g_source_unref (source);
3626
3627   return id;
3628 }
3629
3630 /**
3631  * g_timeout_add_seconds:
3632  * @interval: the time between calls to the function, in seconds
3633  * @function: function to call
3634  * @data: data to pass to @function
3635  *
3636  * Sets a function to be called at regular intervals with the default
3637  * priority, #G_PRIORITY_DEFAULT. The function is called repeatedly until
3638  * it returns %FALSE, at which point the timeout is automatically destroyed
3639  * and the function will not be called again.
3640  *
3641  * This internally creates a main loop source using
3642  * g_timeout_source_new_seconds() and attaches it to the main loop context
3643  * using g_source_attach(). You can do these steps manually if you need
3644  * greater control. Also see g_timout_add_seconds_full().
3645  *
3646  * Return value: the ID (greater than 0) of the event source.
3647  *
3648  * Since: 2.14
3649  **/
3650 guint
3651 g_timeout_add_seconds (guint       interval,
3652                        GSourceFunc function,
3653                        gpointer    data)
3654 {
3655   g_return_val_if_fail (function != NULL, 0);
3656
3657   return g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, interval, function, data, NULL);
3658 }
3659
3660 /* Child watch functions */
3661
3662 #ifdef G_OS_WIN32
3663
3664 static gboolean
3665 g_child_watch_prepare (GSource *source,
3666                        gint    *timeout)
3667 {
3668   *timeout = -1;
3669   return FALSE;
3670 }
3671
3672
3673 static gboolean
3674 g_child_watch_check (GSource  *source)
3675 {
3676   GChildWatchSource *child_watch_source;
3677   gboolean child_exited;
3678
3679   child_watch_source = (GChildWatchSource *) source;
3680
3681   child_exited = child_watch_source->poll.revents & G_IO_IN;
3682
3683   if (child_exited)
3684     {
3685       DWORD child_status;
3686
3687       /*
3688        * Note: We do _not_ check for the special value of STILL_ACTIVE
3689        * since we know that the process has exited and doing so runs into
3690        * problems if the child process "happens to return STILL_ACTIVE(259)"
3691        * as Microsoft's Platform SDK puts it.
3692        */
3693       if (!GetExitCodeProcess (child_watch_source->pid, &child_status))
3694         {
3695           gchar *emsg = g_win32_error_message (GetLastError ());
3696           g_warning (G_STRLOC ": GetExitCodeProcess() failed: %s", emsg);
3697           g_free (emsg);
3698
3699           child_watch_source->child_status = -1;
3700         }
3701       else
3702         child_watch_source->child_status = child_status;
3703     }
3704
3705   return child_exited;
3706 }
3707
3708 #else /* G_OS_WIN32 */
3709
3710 static gboolean
3711 check_for_child_exited (GSource *source)
3712 {
3713   GChildWatchSource *child_watch_source;
3714   gint count;
3715
3716   /* protect against another SIGCHLD in the middle of this call */
3717   count = child_watch_count;
3718
3719   child_watch_source = (GChildWatchSource *) source;
3720
3721   if (child_watch_source->child_exited)
3722     return TRUE;
3723
3724   if (child_watch_source->count < count)
3725     {
3726       gint child_status;
3727
3728       if (waitpid (child_watch_source->pid, &child_status, WNOHANG) > 0)
3729         {
3730           child_watch_source->child_status = child_status;
3731           child_watch_source->child_exited = TRUE;
3732         }
3733       child_watch_source->count = count;
3734     }
3735
3736   return child_watch_source->child_exited;
3737 }
3738
3739 static gboolean
3740 g_child_watch_prepare (GSource *source,
3741                        gint    *timeout)
3742 {
3743   *timeout = -1;
3744
3745   return check_for_child_exited (source);
3746 }
3747
3748
3749 static gboolean
3750 g_child_watch_check (GSource  *source)
3751 {
3752   return check_for_child_exited (source);
3753 }
3754
3755 #endif /* G_OS_WIN32 */
3756
3757 static gboolean
3758 g_child_watch_dispatch (GSource    *source,
3759                         GSourceFunc callback,
3760                         gpointer    user_data)
3761 {
3762   GChildWatchSource *child_watch_source;
3763   GChildWatchFunc child_watch_callback = (GChildWatchFunc) callback;
3764
3765   child_watch_source = (GChildWatchSource *) source;
3766
3767   if (!callback)
3768     {
3769       g_warning ("Child watch source dispatched without callback\n"
3770                  "You must call g_source_set_callback().");
3771       return FALSE;
3772     }
3773
3774   (child_watch_callback) (child_watch_source->pid, child_watch_source->child_status, user_data);
3775
3776   /* We never keep a child watch source around as the child is gone */
3777   return FALSE;
3778 }
3779
3780 #ifndef G_OS_WIN32
3781
3782 static void
3783 g_child_watch_signal_handler (int signum)
3784 {
3785   child_watch_count ++;
3786
3787   if (child_watch_init_state == CHILD_WATCH_INITIALIZED_THREADED)
3788     {
3789       write (child_watch_wake_up_pipe[1], "B", 1);
3790     }
3791   else
3792     {
3793       /* We count on the signal interrupting the poll in the same thread.
3794        */
3795     }
3796 }
3797
3798 static void
3799 g_child_watch_source_init_single (void)
3800 {
3801   struct sigaction action;
3802
3803   g_assert (! g_thread_supported());
3804   g_assert (child_watch_init_state == CHILD_WATCH_UNINITIALIZED);
3805
3806   child_watch_init_state = CHILD_WATCH_INITIALIZED_SINGLE;
3807
3808   action.sa_handler = g_child_watch_signal_handler;
3809   sigemptyset (&action.sa_mask);
3810   action.sa_flags = SA_NOCLDSTOP;
3811   sigaction (SIGCHLD, &action, NULL);
3812 }
3813
3814 G_GNUC_NORETURN static gpointer
3815 child_watch_helper_thread (gpointer data)
3816 {
3817   while (1)
3818     {
3819       gchar b[20];
3820       GSList *list;
3821
3822       read (child_watch_wake_up_pipe[0], b, 20);
3823
3824       /* We were woken up.  Wake up all other contexts in all other threads */
3825       G_LOCK (main_context_list);
3826       for (list = main_context_list; list; list = list->next)
3827         {
3828           GMainContext *context;
3829
3830           context = list->data;
3831           if (g_atomic_int_get (&context->ref_count) > 0)
3832             /* Due to racing conditions we can find ref_count == 0, in
3833              * that case, however, the context is still not destroyed
3834              * and no poll can be active, otherwise the ref_count
3835              * wouldn't be 0 */
3836             g_main_context_wakeup (context);
3837         }
3838       G_UNLOCK (main_context_list);
3839     }
3840 }
3841
3842 static void
3843 g_child_watch_source_init_multi_threaded (void)
3844 {
3845   GError *error = NULL;
3846   struct sigaction action;
3847
3848   g_assert (g_thread_supported());
3849
3850   if (pipe (child_watch_wake_up_pipe) < 0)
3851     g_error ("Cannot create wake up pipe: %s\n", g_strerror (errno));
3852   fcntl (child_watch_wake_up_pipe[1], F_SETFL, O_NONBLOCK | fcntl (child_watch_wake_up_pipe[1], F_GETFL));
3853
3854   /* We create a helper thread that polls on the wakeup pipe indefinitely */
3855   /* FIXME: Think this through for races */
3856   if (g_thread_create (child_watch_helper_thread, NULL, FALSE, &error) == NULL)
3857     g_error ("Cannot create a thread to monitor child exit status: %s\n", error->message);
3858   child_watch_init_state = CHILD_WATCH_INITIALIZED_THREADED;
3859
3860   action.sa_handler = g_child_watch_signal_handler;
3861   sigemptyset (&action.sa_mask);
3862   action.sa_flags = SA_RESTART | SA_NOCLDSTOP;
3863   sigaction (SIGCHLD, &action, NULL);
3864 }
3865
3866 static void
3867 g_child_watch_source_init_promote_single_to_threaded (void)
3868 {
3869   g_child_watch_source_init_multi_threaded ();
3870 }
3871
3872 static void
3873 g_child_watch_source_init (void)
3874 {
3875   if (g_thread_supported())
3876     {
3877       if (child_watch_init_state == CHILD_WATCH_UNINITIALIZED)
3878         g_child_watch_source_init_multi_threaded ();
3879       else if (child_watch_init_state == CHILD_WATCH_INITIALIZED_SINGLE)
3880         g_child_watch_source_init_promote_single_to_threaded ();
3881     }
3882   else
3883     {
3884       if (child_watch_init_state == CHILD_WATCH_UNINITIALIZED)
3885         g_child_watch_source_init_single ();
3886     }
3887 }
3888
3889 #endif /* !G_OS_WIN32 */
3890
3891 /**
3892  * g_child_watch_source_new:
3893  * @pid: process to watch. On POSIX the pid of a child process. On
3894  * Windows a handle for a process (which doesn't have to be a child).
3895  *
3896  * Creates a new child_watch source.
3897  *
3898  * The source will not initially be associated with any #GMainContext
3899  * and must be added to one with g_source_attach() before it will be
3900  * executed.
3901  *
3902  * Note that child watch sources can only be used in conjunction with
3903  * <literal>g_spawn...</literal> when the %G_SPAWN_DO_NOT_REAP_CHILD
3904  * flag is used.
3905  *
3906  * Note that on platforms where #GPid must be explicitly closed
3907  * (see g_spawn_close_pid()) @pid must not be closed while the
3908  * source is still active. Typically, you will want to call
3909  * g_spawn_close_pid() in the callback function for the source.
3910  *
3911  * Note further that using g_child_watch_source_new() is not
3912  * compatible with calling <literal>waitpid(-1)</literal> in
3913  * the application. Calling waitpid() for individual pids will
3914  * still work fine.
3915  *
3916  * Return value: the newly-created child watch source
3917  *
3918  * Since: 2.4
3919  **/
3920 GSource *
3921 g_child_watch_source_new (GPid pid)
3922 {
3923   GSource *source = g_source_new (&g_child_watch_funcs, sizeof (GChildWatchSource));
3924   GChildWatchSource *child_watch_source = (GChildWatchSource *)source;
3925
3926 #ifdef G_OS_WIN32
3927   child_watch_source->poll.fd = (gintptr) pid;
3928   child_watch_source->poll.events = G_IO_IN;
3929
3930   g_source_add_poll (source, &child_watch_source->poll);
3931 #else /* G_OS_WIN32 */
3932   g_child_watch_source_init ();
3933 #endif /* G_OS_WIN32 */
3934
3935   child_watch_source->pid = pid;
3936
3937   return source;
3938 }
3939
3940 /**
3941  * g_child_watch_add_full:
3942  * @priority: the priority of the idle source. Typically this will be in the
3943  *            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
3944  * @pid:      process to watch. On POSIX the pid of a child process. On
3945  * Windows a handle for a process (which doesn't have to be a child).
3946  * @function: function to call
3947  * @data:     data to pass to @function
3948  * @notify:   function to call when the idle is removed, or %NULL
3949  *
3950  * Sets a function to be called when the child indicated by @pid
3951  * exits, at the priority @priority.
3952  *
3953  * If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
3954  * you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
3955  * the spawn function for the child watching to work.
3956  *
3957  * Note that on platforms where #GPid must be explicitly closed
3958  * (see g_spawn_close_pid()) @pid must not be closed while the
3959  * source is still active. Typically, you will want to call
3960  * g_spawn_close_pid() in the callback function for the source.
3961  *
3962  * GLib supports only a single callback per process id.
3963  *
3964  * This internally creates a main loop source using
3965  * g_child_watch_source_new() and attaches it to the main loop context
3966  * using g_source_attach(). You can do these steps manually if you
3967  * need greater control.
3968  *
3969  * Return value: the ID (greater than 0) of the event source.
3970  *
3971  * Since: 2.4
3972  **/
3973 guint
3974 g_child_watch_add_full (gint            priority,
3975                         GPid            pid,
3976                         GChildWatchFunc function,
3977                         gpointer        data,
3978                         GDestroyNotify  notify)
3979 {
3980   GSource *source;
3981   guint id;
3982
3983   g_return_val_if_fail (function != NULL, 0);
3984
3985   source = g_child_watch_source_new (pid);
3986
3987   if (priority != G_PRIORITY_DEFAULT)
3988     g_source_set_priority (source, priority);
3989
3990   g_source_set_callback (source, (GSourceFunc) function, data, notify);
3991   id = g_source_attach (source, NULL);
3992   g_source_unref (source);
3993
3994   return id;
3995 }
3996
3997 /**
3998  * g_child_watch_add:
3999  * @pid:      process id to watch. On POSIX the pid of a child process. On
4000  * Windows a handle for a process (which doesn't have to be a child).
4001  * @function: function to call
4002  * @data:     data to pass to @function
4003  *
4004  * Sets a function to be called when the child indicated by @pid
4005  * exits, at a default priority, #G_PRIORITY_DEFAULT.
4006  *
4007  * If you obtain @pid from g_spawn_async() or g_spawn_async_with_pipes()
4008  * you will need to pass #G_SPAWN_DO_NOT_REAP_CHILD as flag to
4009  * the spawn function for the child watching to work.
4010  *
4011  * Note that on platforms where #GPid must be explicitly closed
4012  * (see g_spawn_close_pid()) @pid must not be closed while the
4013  * source is still active. Typically, you will want to call
4014  * g_spawn_close_pid() in the callback function for the source.
4015  *
4016  * GLib supports only a single callback per process id.
4017  *
4018  * This internally creates a main loop source using
4019  * g_child_watch_source_new() and attaches it to the main loop context
4020  * using g_source_attach(). You can do these steps manually if you
4021  * need greater control.
4022  *
4023  * Return value: the ID (greater than 0) of the event source.
4024  *
4025  * Since: 2.4
4026  **/
4027 guint
4028 g_child_watch_add (GPid            pid,
4029                    GChildWatchFunc function,
4030                    gpointer        data)
4031 {
4032   return g_child_watch_add_full (G_PRIORITY_DEFAULT, pid, function, data, NULL);
4033 }
4034
4035
4036 /* Idle functions */
4037
4038 static gboolean
4039 g_idle_prepare  (GSource  *source,
4040                  gint     *timeout)
4041 {
4042   *timeout = 0;
4043
4044   return TRUE;
4045 }
4046
4047 static gboolean
4048 g_idle_check    (GSource  *source)
4049 {
4050   return TRUE;
4051 }
4052
4053 static gboolean
4054 g_idle_dispatch (GSource    *source,
4055                  GSourceFunc callback,
4056                  gpointer    user_data)
4057 {
4058   if (!callback)
4059     {
4060       g_warning ("Idle source dispatched without callback\n"
4061                  "You must call g_source_set_callback().");
4062       return FALSE;
4063     }
4064
4065   return callback (user_data);
4066 }
4067
4068 /**
4069  * g_idle_source_new:
4070  *
4071  * Creates a new idle source.
4072  *
4073  * The source will not initially be associated with any #GMainContext
4074  * and must be added to one with g_source_attach() before it will be
4075  * executed. Note that the default priority for idle sources is
4076  * %G_PRIORITY_DEFAULT_IDLE, as compared to other sources which
4077  * have a default priority of %G_PRIORITY_DEFAULT.
4078  *
4079  * Return value: the newly-created idle source
4080  **/
4081 GSource *
4082 g_idle_source_new (void)
4083 {
4084   GSource *source;
4085
4086   source = g_source_new (&g_idle_funcs, sizeof (GSource));
4087   g_source_set_priority (source, G_PRIORITY_DEFAULT_IDLE);
4088
4089   return source;
4090 }
4091
4092 /**
4093  * g_idle_add_full:
4094  * @priority: the priority of the idle source. Typically this will be in the
4095  *            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
4096  * @function: function to call
4097  * @data:     data to pass to @function
4098  * @notify:   function to call when the idle is removed, or %NULL
4099  *
4100  * Adds a function to be called whenever there are no higher priority
4101  * events pending.  If the function returns %FALSE it is automatically
4102  * removed from the list of event sources and will not be called again.
4103  *
4104  * This internally creates a main loop source using g_idle_source_new()
4105  * and attaches it to the main loop context using g_source_attach().
4106  * You can do these steps manually if you need greater control.
4107  *
4108  * Return value: the ID (greater than 0) of the event source.
4109  **/
4110 guint
4111 g_idle_add_full (gint           priority,
4112                  GSourceFunc    function,
4113                  gpointer       data,
4114                  GDestroyNotify notify)
4115 {
4116   GSource *source;
4117   guint id;
4118
4119   g_return_val_if_fail (function != NULL, 0);
4120
4121   source = g_idle_source_new ();
4122
4123   if (priority != G_PRIORITY_DEFAULT_IDLE)
4124     g_source_set_priority (source, priority);
4125
4126   g_source_set_callback (source, function, data, notify);
4127   id = g_source_attach (source, NULL);
4128   g_source_unref (source);
4129
4130   return id;
4131 }
4132
4133 /**
4134  * g_idle_add:
4135  * @function: function to call
4136  * @data: data to pass to @function.
4137  *
4138  * Adds a function to be called whenever there are no higher priority
4139  * events pending to the default main loop. The function is given the
4140  * default idle priority, #G_PRIORITY_DEFAULT_IDLE.  If the function
4141  * returns %FALSE it is automatically removed from the list of event
4142  * sources and will not be called again.
4143  *
4144  * This internally creates a main loop source using g_idle_source_new()
4145  * and attaches it to the main loop context using g_source_attach().
4146  * You can do these steps manually if you need greater control.
4147  *
4148  * Return value: the ID (greater than 0) of the event source.
4149  **/
4150 guint
4151 g_idle_add (GSourceFunc    function,
4152             gpointer       data)
4153 {
4154   return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
4155 }
4156
4157 /**
4158  * g_idle_remove_by_data:
4159  * @data: the data for the idle source's callback.
4160  *
4161  * Removes the idle function with the given data.
4162  *
4163  * Return value: %TRUE if an idle source was found and removed.
4164  **/
4165 gboolean
4166 g_idle_remove_by_data (gpointer data)
4167 {
4168   return g_source_remove_by_funcs_user_data (&g_idle_funcs, data);
4169 }
4170
4171 #define __G_MAIN_C__
4172 #include "galiasdef.c"