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