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