indenting
[dana/openbox.git] / openbox / mainloop.c
1 /* -*- indent-tabs-mode: nil; tab-width: 4; c-basic-offset: 4; -*-
2
3    mainloop.c for the Openbox window manager
4    Copyright (c) 2003        Ben Jansens
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 2 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    See the COPYING file for a copy of the GNU General Public License.
17 */
18
19 #include "mainloop.h"
20
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <sys/select.h>
24 #include <signal.h>
25
26 typedef struct _ObMainLoopTimer             ObMainLoopTimer;
27 typedef struct _ObMainLoopSignal            ObMainLoopSignal;
28 typedef struct _ObMainLoopSignalHandlerType ObMainLoopSignalHandlerType;
29 typedef struct _ObMainLoopXHandlerType      ObMainLoopXHandlerType;
30 typedef struct _ObMainLoopFdHandlerType     ObMainLoopFdHandlerType;
31
32 /* this should be more than the number of possible signals on any
33    architecture... */
34 #define NUM_SIGNALS 99
35
36 /* all created ObMainLoops. Used by the signal handler to pass along signals */
37 static GSList *all_loops;
38
39 /* signals are global to all loops */
40 struct {
41     guint installed; /* a ref count */
42     struct sigaction oldact;
43 } all_signals[NUM_SIGNALS];
44
45 /* a set of all possible signals */
46 sigset_t all_signals_set;
47
48 /* signals which cause a core dump, these can't be used for callbacks */
49 static gint core_signals[] =
50 {
51     SIGABRT,
52     SIGSEGV,
53     SIGFPE,
54     SIGILL,
55     SIGQUIT,
56     SIGTRAP,
57     SIGSYS,
58     SIGBUS,
59     SIGXCPU,
60     SIGXFSZ
61 };
62 #define NUM_CORE_SIGNALS (sizeof(core_signals) / sizeof(core_signals[0]))
63
64 static void sighandler(gint sig);
65 static void timer_dispatch(ObMainLoop *loop, GTimeVal **wait);
66 static void fd_handler_destroy(gpointer data);
67
68 struct _ObMainLoop
69 {
70     Display *display;
71
72     gboolean run;     /* do keep running */
73     gboolean running; /* is still running */
74
75     GSList *x_handlers;
76
77     gint fd_x; /* The X fd is a special case! */
78     gint fd_max;
79     GHashTable *fd_handlers;
80     fd_set fd_set;
81
82     GSList *timers;
83     GTimeVal now;
84     GTimeVal ret_wait;
85
86     gboolean signal_fired;
87     guint signals_fired[NUM_SIGNALS];
88     GSList *signal_handlers[NUM_SIGNALS];
89 };
90
91 struct _ObMainLoopTimer
92 {
93     gulong delay;
94     GSourceFunc func;
95     gpointer data;
96     GDestroyNotify destroy;
97
98     /* The timer needs to be freed */
99     gboolean del_me;
100     /* The time the last fire should've been at */
101     GTimeVal last;
102     /* When this timer will next trigger */
103     GTimeVal timeout;
104 };
105
106 struct _ObMainLoopSignalHandlerType
107 {
108     ObMainLoop *loop;
109     gint signal;
110     gpointer data;
111     ObMainLoopSignalHandler func;
112     GDestroyNotify destroy;
113 };
114
115 struct _ObMainLoopXHandlerType
116 {
117     ObMainLoop *loop;
118     gpointer data;
119     ObMainLoopXHandler func;
120     GDestroyNotify destroy;
121 };
122
123 struct _ObMainLoopFdHandlerType
124 {
125     ObMainLoop *loop;
126     gint fd;
127     gpointer data;
128     ObMainLoopFdHandler func;
129     GDestroyNotify destroy;
130 };
131
132 ObMainLoop *ob_main_loop_new(Display *display)
133 {
134     ObMainLoop *loop;
135
136     loop = g_new0(ObMainLoop, 1);
137     loop->display = display;
138     loop->fd_x = ConnectionNumber(display);
139     FD_ZERO(&loop->fd_set);
140     FD_SET(loop->fd_x, &loop->fd_set);
141     loop->fd_max = loop->fd_x;
142
143     loop->fd_handlers = g_hash_table_new_full(g_int_hash, g_int_equal,
144                                               NULL, fd_handler_destroy);
145
146     g_get_current_time(&loop->now);
147
148     /* only do this if we're the first loop created */
149     if (!all_loops) {
150         guint i;
151         struct sigaction action;
152         sigset_t sigset;
153
154         /* initialize the all_signals_set */
155         sigfillset(&all_signals_set);
156
157         sigemptyset(&sigset);
158         action.sa_handler = sighandler;
159         action.sa_mask = sigset;
160         action.sa_flags = SA_NOCLDSTOP;
161
162         /* grab all the signals that cause core dumps */
163         for (i = 0; i < NUM_CORE_SIGNALS; ++i) {
164             /* SIGABRT is curiously not grabbed here!! that's because when we
165                get one of the core_signals, we use abort() to dump the core.
166                And having the abort() only go back to our signal handler again
167                is less than optimal */
168             if (core_signals[i] != SIGABRT) {
169                 sigaction(core_signals[i], &action,
170                           &all_signals[core_signals[i]].oldact);
171                 all_signals[core_signals[i]].installed++;
172             }
173         }
174     }
175
176     all_loops = g_slist_prepend(all_loops, loop);
177
178     return loop;
179 }
180
181 void ob_main_loop_destroy(ObMainLoop *loop)
182 {
183     guint i;
184     GSList *it, *next;
185
186     if (loop) {
187         g_assert(loop->running == FALSE);
188
189         for (it = loop->x_handlers; it; it = next) {
190             ObMainLoopXHandlerType *h = it->data;
191             next = g_slist_next(it);
192             ob_main_loop_x_remove(loop, h->func);
193         }
194
195         g_hash_table_destroy(loop->fd_handlers);
196
197         for (it = loop->timers; it; it = g_slist_next(it)) {
198             ObMainLoopTimer *t = it->data;
199             if (t->destroy) t->destroy(t->data);
200             g_free(t);
201         }
202         g_slist_free(loop->timers);
203         loop->timers = NULL;
204
205         for (i = 0; i < NUM_SIGNALS; ++i)
206             for (it = loop->signal_handlers[i]; it; it = next) {
207                 ObMainLoopSignalHandlerType *h = it->data;
208                 next = g_slist_next(it);
209                 ob_main_loop_signal_remove(loop, h->func);
210             }
211
212         all_loops = g_slist_remove(all_loops, loop);
213
214         /* only do this if we're the last loop destroyed */
215         if (!all_loops) {
216             guint i;
217
218             /* grab all the signals that cause core dumps */
219             for (i = 0; i < NUM_CORE_SIGNALS; ++i) {
220                 if (all_signals[core_signals[i]].installed) {
221                     sigaction(core_signals[i],
222                               &all_signals[core_signals[i]].oldact, NULL);
223                     all_signals[core_signals[i]].installed--;
224                 }
225             }
226         }
227
228         g_free(loop);
229     }
230 }
231
232 static void fd_handle_foreach(gpointer key,
233                               gpointer value,
234                               gpointer data)
235 {
236     ObMainLoopFdHandlerType *h = value;
237     fd_set *set = data;
238
239     if (FD_ISSET(h->fd, set))
240         h->func(h->fd, h->data);
241 }
242
243 void ob_main_loop_run(ObMainLoop *loop)
244 {
245     XEvent e;
246     struct timeval *wait;
247     fd_set selset;
248     GSList *it;
249
250     loop->run = TRUE;
251     loop->running = TRUE;
252
253     while (loop->run) {
254         if (loop->signal_fired) {
255             guint i;
256             sigset_t oldset;
257
258             /* block signals so that we can do this without the data changing
259                on us */
260             sigprocmask(SIG_SETMASK, &all_signals_set, &oldset);
261
262             for (i = 0; i < NUM_SIGNALS; ++i) {
263                 while (loop->signals_fired[i]) {
264                     for (it = loop->signal_handlers[i];
265                          it; it = g_slist_next(it)) {
266                         ObMainLoopSignalHandlerType *h = it->data;
267                         h->func(i, h->data);
268                     }
269                     loop->signals_fired[i]--;
270                 }
271             }
272             loop->signal_fired = FALSE;
273
274             sigprocmask(SIG_SETMASK, &oldset, NULL);
275         } else if (XPending(loop->display)) {
276             do {
277                 XNextEvent(loop->display, &e);
278
279                 for (it = loop->x_handlers; it; it = g_slist_next(it)) {
280                     ObMainLoopXHandlerType *h = it->data;
281                     h->func(&e, h->data);
282                 }
283             } while (XPending(loop->display));
284         } else {
285             /* this only runs if there were no x events received */
286
287             timer_dispatch(loop, (GTimeVal**)&wait);
288             selset = loop->fd_set;
289             /* there is a small race condition here. if a signal occurs
290                between this if() and the select() then we will not process
291                the signal until 'wait' expires. possible solutions include
292                using GStaticMutex, and having the signal handler set 'wait'
293                to 0 */
294             if (!loop->signal_fired)
295                 select(loop->fd_max + 1, &selset, NULL, NULL, wait);
296
297             /* handle the X events with highest prioirity */
298             if (FD_ISSET(loop->fd_x, &selset))
299                 continue;
300
301             g_hash_table_foreach(loop->fd_handlers,
302                                  fd_handle_foreach, &selset);
303         }
304     }
305
306     loop->running = FALSE;
307 }
308
309 void ob_main_loop_exit(ObMainLoop *loop)
310 {
311     loop->run = FALSE;
312 }
313
314 /*** XEVENT WATCHERS ***/
315
316 void ob_main_loop_x_add(ObMainLoop *loop,
317                         ObMainLoopXHandler handler,
318                         gpointer data,
319                         GDestroyNotify notify)
320 {
321     ObMainLoopXHandlerType *h;
322
323     h = g_new(ObMainLoopXHandlerType, 1);
324     h->loop = loop;
325     h->func = handler;
326     h->data = data;
327     h->destroy = notify;
328     loop->x_handlers = g_slist_prepend(loop->x_handlers, h);
329 }
330
331 void ob_main_loop_x_remove(ObMainLoop *loop,
332                            ObMainLoopXHandler handler)
333 {
334     GSList *it, *next;
335
336     for (it = loop->x_handlers; it; it = next) {
337         ObMainLoopXHandlerType *h = it->data;
338         next = g_slist_next(it);
339         if (h->func == handler) {
340             loop->x_handlers = g_slist_delete_link(loop->x_handlers, it);
341             if (h->destroy) h->destroy(h->data);
342             g_free(h);
343         }
344     }
345 }
346
347 /*** SIGNAL WATCHERS ***/
348
349 static void sighandler(gint sig)
350 {
351     GSList *it;
352     guint i;
353
354     g_return_if_fail(sig < NUM_SIGNALS);
355
356     for (i = 0; i < NUM_CORE_SIGNALS; ++i)
357         if (sig == core_signals[i]) {
358             /* XXX special case for signals that default to core dump.
359                but throw some helpful output here... */
360
361             fprintf(stderr, "Fuck yah. Core dump. (Signal=%d)\n", sig);
362
363             /* die with a core dump */
364             abort();
365         }
366
367     for (it = all_loops; it; it = g_slist_next(it)) {
368         ObMainLoop *loop = it->data;
369         loop->signal_fired = TRUE;
370         loop->signals_fired[sig]++;
371     }
372 }
373
374 void ob_main_loop_signal_add(ObMainLoop *loop,
375                              gint signal,
376                              ObMainLoopSignalHandler handler,
377                              gpointer data,
378                              GDestroyNotify notify)
379 {
380     ObMainLoopSignalHandlerType *h;
381
382     g_return_if_fail(signal < NUM_SIGNALS);
383
384     h = g_new(ObMainLoopSignalHandlerType, 1);
385     h->loop = loop;
386     h->signal = signal;
387     h->func = handler;
388     h->data = data;
389     h->destroy = notify;
390     loop->signal_handlers[h->signal] =
391         g_slist_prepend(loop->signal_handlers[h->signal], h);
392
393     if (!all_signals[signal].installed) {
394         struct sigaction action;
395         sigset_t sigset;
396
397         sigemptyset(&sigset);
398         action.sa_handler = sighandler;
399         action.sa_mask = sigset;
400         action.sa_flags = SA_NOCLDSTOP;
401
402         sigaction(signal, &action, &all_signals[signal].oldact);
403     }
404
405     all_signals[signal].installed++;
406 }
407
408 void ob_main_loop_signal_remove(ObMainLoop *loop,
409                                 ObMainLoopSignalHandler handler)
410 {
411     guint i;
412     GSList *it, *next;
413
414     for (i = 0; i < NUM_SIGNALS; ++i) {
415         for (it = loop->signal_handlers[i]; it; it = next) {
416             ObMainLoopSignalHandlerType *h = it->data;
417
418             next = g_slist_next(it);
419
420             if (h->func == handler) {
421                 g_assert(all_signals[h->signal].installed > 0);
422
423                 all_signals[h->signal].installed--;
424                 if (!all_signals[h->signal].installed) {
425                     sigaction(h->signal, &all_signals[h->signal].oldact, NULL);
426                 }
427
428                 loop->signal_handlers[i] =
429                     g_slist_delete_link(loop->signal_handlers[i], it);
430                 if (h->destroy) h->destroy(h->data);
431
432                 g_free(h);
433             }
434         }
435     }
436
437 }
438
439 /*** FILE DESCRIPTOR WATCHERS ***/
440
441 static void max_fd_func(gpointer key, gpointer value, gpointer data)
442 {
443     ObMainLoop *loop = data;
444
445     /* key is the fd */
446     loop->fd_max = MAX(loop->fd_max, *(gint*)key);
447 }
448
449 static void calc_max_fd(ObMainLoop *loop)
450 {
451     loop->fd_max = loop->fd_x;
452
453     g_hash_table_foreach(loop->fd_handlers, max_fd_func, loop);
454 }
455
456 void ob_main_loop_fd_add(ObMainLoop *loop,
457                          gint fd,
458                          ObMainLoopFdHandler handler,
459                          gpointer data,
460                          GDestroyNotify notify)
461 {
462     ObMainLoopFdHandlerType *h;
463
464     h = g_new(ObMainLoopFdHandlerType, 1);
465     h->loop = loop;
466     h->fd = fd;
467     h->func = handler;
468     h->data = data;
469     h->destroy = notify;
470
471     g_hash_table_replace(loop->fd_handlers, &h->fd, h);
472     FD_SET(h->fd, &loop->fd_set);
473     calc_max_fd(loop);
474 }
475
476 static void fd_handler_destroy(gpointer data)
477 {
478     ObMainLoopFdHandlerType *h = data;
479
480     FD_CLR(h->fd, &h->loop->fd_set);
481
482     if (h->destroy)
483         h->destroy(h->data);
484 }
485
486 void ob_main_loop_fd_remove(ObMainLoop *loop,
487                             gint fd)
488 {
489     g_hash_table_remove(loop->fd_handlers, &fd);
490 }
491
492 /*** TIMEOUTS ***/
493
494 #define NEAREST_TIMEOUT(loop) \
495     (((ObMainLoopTimer*)(loop)->timers->data)->timeout)
496
497 static long timecompare(GTimeVal *a, GTimeVal *b)
498 {
499     long r;
500
501     if ((r = b->tv_sec - a->tv_sec)) return r;
502     return b->tv_usec - a->tv_usec;
503     
504 }
505
506 static void insert_timer(ObMainLoop *loop, ObMainLoopTimer *ins)
507 {
508     GSList *it;
509     for (it = loop->timers; it; it = g_slist_next(it)) {
510         ObMainLoopTimer *t = it->data;
511         if (timecompare(&ins->timeout, &t->timeout) <= 0) {
512             loop->timers = g_slist_insert_before(loop->timers, it, ins);
513             break;
514         }
515     }
516     if (it == NULL) /* didnt fit anywhere in the list */
517         loop->timers = g_slist_append(loop->timers, ins);
518 }
519
520 void ob_main_loop_timeout_add(ObMainLoop *loop,
521                               gulong microseconds,
522                               GSourceFunc handler,
523                               gpointer data,
524                               GDestroyNotify notify)
525 {
526     ObMainLoopTimer *t = g_new(ObMainLoopTimer, 1);
527     t->delay = microseconds;
528     t->func = handler;
529     t->data = data;
530     t->destroy = notify;
531     t->del_me = FALSE;
532     g_get_current_time(&loop->now);
533     t->last = t->timeout = loop->now;
534     g_time_val_add(&t->timeout, t->delay);
535
536     insert_timer(loop, t);
537 }
538
539 void ob_main_loop_timeout_remove(ObMainLoop *loop,
540                                  GSourceFunc handler)
541 {
542     GSList *it;
543
544     for (it = loop->timers; it; it = g_slist_next(it)) {
545         ObMainLoopTimer *t = it->data;
546         if (t->func == handler)
547             t->del_me = TRUE;
548     }
549 }
550
551 void ob_main_loop_timeout_remove_data(ObMainLoop *loop,
552                                       GSourceFunc handler,
553                                       gpointer data)
554 {
555     GSList *it;
556
557     for (it = loop->timers; it; it = g_slist_next(it)) {
558         ObMainLoopTimer *t = it->data;
559         if (t->func == handler && t->data == data)
560             t->del_me = TRUE;
561     }
562 }
563
564 /* find the time to wait for the nearest timeout */
565 static gboolean nearest_timeout_wait(ObMainLoop *loop, GTimeVal *tm)
566 {
567   if (loop->timers == NULL)
568     return FALSE;
569
570   tm->tv_sec = NEAREST_TIMEOUT(loop).tv_sec - loop->now.tv_sec;
571   tm->tv_usec = NEAREST_TIMEOUT(loop).tv_usec - loop->now.tv_usec;
572
573   while (tm->tv_usec < 0) {
574     tm->tv_usec += G_USEC_PER_SEC;
575     tm->tv_sec--;
576   }
577   tm->tv_sec += tm->tv_usec / G_USEC_PER_SEC;
578   tm->tv_usec %= G_USEC_PER_SEC;
579   if (tm->tv_sec < 0)
580     tm->tv_sec = 0;
581
582   return TRUE;
583 }
584
585 static void timer_dispatch(ObMainLoop *loop, GTimeVal **wait)
586 {
587     GSList *it, *next;
588
589     gboolean fired = FALSE;
590
591     g_get_current_time(&loop->now);
592
593     for (it = loop->timers; it; it = next) {
594         ObMainLoopTimer *curr;
595         
596         next = g_slist_next(it);
597
598         curr = it->data;
599
600         /* since timer_stop doesn't actually free the timer, we have to do our
601            real freeing in here.
602         */
603         if (curr->del_me) {
604             /* delete the top */
605             loop->timers = g_slist_delete_link(loop->timers, it); 
606             g_free(curr);
607             continue;
608         }
609         
610         /* the queue is sorted, so if this timer shouldn't fire, none are 
611            ready */
612         if (timecompare(&NEAREST_TIMEOUT(loop), &loop->now) <= 0)
613             break;
614
615         /* we set the last fired time to delay msec after the previous firing,
616            then re-insert.  timers maintain their order and may trigger more
617            than once if they've waited more than one delay's worth of time.
618         */
619         loop->timers = g_slist_delete_link(loop->timers, it);
620         g_time_val_add(&curr->last, curr->delay);
621         if (curr->func(curr->data)) {
622             g_time_val_add(&curr->timeout, curr->delay);
623             insert_timer(loop, curr);
624         } else {
625             if (curr->destroy)
626                 curr->destroy(curr->data);
627             g_free(curr);
628         }
629
630         fired = TRUE;
631     }
632
633     if (fired) {
634         /* if at least one timer fires, then don't wait on X events, as there
635            may already be some in the queue from the timer callbacks.
636         */
637         loop->ret_wait.tv_sec = loop->ret_wait.tv_usec = 0;
638         *wait = &loop->ret_wait;
639     } else if (nearest_timeout_wait(loop, &loop->ret_wait))
640         *wait = &loop->ret_wait;
641     else
642         *wait = NULL;
643 }