avoid ascii control characters in strings
[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_slice_new0(ObtMainLoop);
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_slice_free(ObtMainLoopTimer, 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         g_slice_free(ObtMainLoop, loop);
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                 if (e.type == MappingNotify)
304                     XRefreshKeyboardMapping(&e.xmapping);
305
306                 for (it = loop->x_handlers; it; it = g_slist_next(it)) {
307                     ObtMainLoopXHandlerType *h = it->data;
308                     h->func(&e, h->data);
309                 }
310             } while (XPending(loop->display) && loop->run);
311         } else {
312             /* this only runs if there were no x events received */
313
314             timer_dispatch(loop, (GTimeVal**)&wait);
315
316             selset = loop->fd_set;
317             /* there is a small race condition here. if a signal occurs
318                between this if() and the select() then we will not process
319                the signal until 'wait' expires. possible solutions include
320                using GStaticMutex, and having the signal handler set 'wait'
321                to 0 */
322             if (!loop->signal_fired)
323                 select(loop->fd_max + 1, &selset, NULL, NULL, wait);
324
325             /* handle the X events with highest prioirity */
326             if (FD_ISSET(loop->fd_x, &selset))
327                 continue;
328
329             g_hash_table_foreach(loop->fd_handlers,
330                                  fd_handle_foreach, &selset);
331         }
332     }
333
334     loop->running = FALSE;
335 }
336
337 void obt_main_loop_exit(ObtMainLoop *loop)
338 {
339     loop->run = FALSE;
340 }
341
342 /*** XEVENT WATCHERS ***/
343
344 void obt_main_loop_x_add(ObtMainLoop *loop,
345                          ObtMainLoopXHandler handler,
346                          gpointer data,
347                          GDestroyNotify notify)
348 {
349     ObtMainLoopXHandlerType *h;
350
351     h = g_slice_new(ObtMainLoopXHandlerType);
352     h->loop = loop;
353     h->func = handler;
354     h->data = data;
355     h->destroy = notify;
356
357     if (!loop->x_handlers) {
358         g_assert(obt_display); /* is the display open? */
359
360         loop->display = obt_display;
361         loop->fd_x = ConnectionNumber(loop->display);
362         FD_SET(loop->fd_x, &loop->fd_set);
363         calc_max_fd(loop);
364     }
365
366     loop->x_handlers = g_slist_prepend(loop->x_handlers, h);
367 }
368
369 void obt_main_loop_x_remove(ObtMainLoop *loop,
370                             ObtMainLoopXHandler handler)
371 {
372     GSList *it, *next;
373
374     for (it = loop->x_handlers; it; it = next) {
375         ObtMainLoopXHandlerType *h = it->data;
376         next = g_slist_next(it);
377         if (h->func == handler) {
378             loop->x_handlers = g_slist_delete_link(loop->x_handlers, it);
379             if (h->destroy) h->destroy(h->data);
380             g_slice_free(ObtMainLoopXHandlerType, h);
381         }
382     }
383
384     if (!loop->x_handlers) {
385         FD_CLR(loop->fd_x, &loop->fd_set);
386         calc_max_fd(loop);
387     }
388 }
389
390 /*** SIGNAL WATCHERS ***/
391
392 static void sighandler(gint sig)
393 {
394     GSList *it;
395     guint i;
396
397     g_return_if_fail(sig < NUM_SIGNALS);
398
399     for (i = 0; i < NUM_CORE_SIGNALS; ++i)
400         if (sig == core_signals[i]) {
401             /* XXX special case for signals that default to core dump.
402                but throw some helpful output here... */
403
404             fprintf(stderr, "How are you gentlemen? All your base are"
405                     " belong to us. (Openbox received signal %d)\n", sig);
406
407             /* die with a core dump */
408             abort();
409         }
410
411     for (it = all_loops; it; it = g_slist_next(it)) {
412         ObtMainLoop *loop = it->data;
413         loop->signal_fired = TRUE;
414         loop->signals_fired[sig]++;
415     }
416 }
417
418 void obt_main_loop_signal_add(ObtMainLoop *loop,
419                               gint signal,
420                               ObtMainLoopSignalHandler handler,
421                               gpointer data,
422                               GDestroyNotify notify)
423 {
424     ObtMainLoopSignalHandlerType *h;
425
426     g_return_if_fail(signal < NUM_SIGNALS);
427
428     h = g_slice_new(ObtMainLoopSignalHandlerType);
429     h->loop = loop;
430     h->signal = signal;
431     h->func = handler;
432     h->data = data;
433     h->destroy = notify;
434     loop->signal_handlers[h->signal] =
435         g_slist_prepend(loop->signal_handlers[h->signal], h);
436
437     if (!all_signals[signal].installed) {
438         struct sigaction action;
439         sigset_t sigset;
440
441         sigemptyset(&sigset);
442         action.sa_handler = sighandler;
443         action.sa_mask = sigset;
444         action.sa_flags = SA_NOCLDSTOP;
445
446         sigaction(signal, &action, &all_signals[signal].oldact);
447     }
448
449     all_signals[signal].installed++;
450 }
451
452 void obt_main_loop_signal_remove(ObtMainLoop *loop,
453                                  ObtMainLoopSignalHandler handler)
454 {
455     guint i;
456     GSList *it, *next;
457
458     for (i = 0; i < NUM_SIGNALS; ++i) {
459         for (it = loop->signal_handlers[i]; it; it = next) {
460             ObtMainLoopSignalHandlerType *h = it->data;
461
462             next = g_slist_next(it);
463
464             if (h->func == handler) {
465                 g_assert(all_signals[h->signal].installed > 0);
466
467                 all_signals[h->signal].installed--;
468                 if (!all_signals[h->signal].installed) {
469                     sigaction(h->signal, &all_signals[h->signal].oldact, NULL);
470                 }
471
472                 loop->signal_handlers[i] =
473                     g_slist_delete_link(loop->signal_handlers[i], it);
474                 if (h->destroy) h->destroy(h->data);
475
476                 g_slice_free(ObtMainLoopSignalHandlerType, h);
477             }
478         }
479     }
480
481 }
482
483 /*** FILE DESCRIPTOR WATCHERS ***/
484
485 static void max_fd_func(gpointer key, gpointer value, gpointer data)
486 {
487     ObtMainLoop *loop = data;
488
489     /* key is the fd */
490     loop->fd_max = MAX(loop->fd_max, *(gint*)key);
491 }
492
493 static void calc_max_fd(ObtMainLoop *loop)
494 {
495     loop->fd_max = loop->fd_x;
496
497     g_hash_table_foreach(loop->fd_handlers, max_fd_func, loop);
498 }
499
500 void obt_main_loop_fd_add(ObtMainLoop *loop,
501                           gint fd,
502                           ObtMainLoopFdHandler handler,
503                           gpointer data,
504                           GDestroyNotify notify)
505 {
506     ObtMainLoopFdHandlerType *h;
507
508     h = g_slice_new(ObtMainLoopFdHandlerType);
509     h->loop = loop;
510     h->fd = fd;
511     h->func = handler;
512     h->data = data;
513     h->destroy = notify;
514
515     g_hash_table_replace(loop->fd_handlers, &h->fd, h);
516     FD_SET(h->fd, &loop->fd_set);
517     calc_max_fd(loop);
518 }
519
520 static void fd_handler_destroy(gpointer data)
521 {
522     ObtMainLoopFdHandlerType *h = data;
523
524     FD_CLR(h->fd, &h->loop->fd_set);
525
526     if (h->destroy)
527         h->destroy(h->data);
528     g_slice_free(ObtMainLoopFdHandlerType, h);
529 }
530
531 void obt_main_loop_fd_remove(ObtMainLoop *loop,
532                              gint fd)
533 {
534     g_hash_table_remove(loop->fd_handlers, &fd);
535     calc_max_fd(loop);
536 }
537
538 /*** TIMEOUTS ***/
539
540 #define NEAREST_TIMEOUT(loop) \
541     (((ObtMainLoopTimer*)(loop)->timers->data)->timeout)
542
543 static glong timecompare(GTimeVal *a, GTimeVal *b)
544 {
545     glong r;
546     if ((r = a->tv_sec - b->tv_sec)) return r;
547     return a->tv_usec - b->tv_usec;
548 }
549
550 static void insert_timer(ObtMainLoop *loop, ObtMainLoopTimer *ins)
551 {
552     GSList *it;
553     for (it = loop->timers; it; it = g_slist_next(it)) {
554         ObtMainLoopTimer *t = it->data;
555         if (timecompare(&ins->timeout, &t->timeout) <= 0) {
556             loop->timers = g_slist_insert_before(loop->timers, it, ins);
557             break;
558         }
559     }
560     if (it == NULL) /* didnt fit anywhere in the list */
561         loop->timers = g_slist_append(loop->timers, ins);
562 }
563
564 void obt_main_loop_timeout_add(ObtMainLoop *loop,
565                                gulong microseconds,
566                                GSourceFunc handler,
567                                gpointer data,
568                                GEqualFunc cmp,
569                                GDestroyNotify notify)
570 {
571     ObtMainLoopTimer *t = g_slice_new(ObtMainLoopTimer);
572
573     g_assert(microseconds > 0); /* if it's 0 it'll cause an infinite loop */
574
575     t->delay = microseconds;
576     t->func = handler;
577     t->data = data;
578     t->equal = cmp;
579     t->destroy = notify;
580     t->del_me = FALSE;
581     g_get_current_time(&loop->now);
582     t->last = t->timeout = loop->now;
583     g_time_val_add(&t->timeout, t->delay);
584
585     insert_timer(loop, t);
586 }
587
588 void obt_main_loop_timeout_remove(ObtMainLoop *loop,
589                                   GSourceFunc handler)
590 {
591     GSList *it;
592
593     for (it = loop->timers; it; it = g_slist_next(it)) {
594         ObtMainLoopTimer *t = it->data;
595         if (t->func == handler)
596             t->del_me = TRUE;
597     }
598 }
599
600 void obt_main_loop_timeout_remove_data(ObtMainLoop *loop, GSourceFunc handler,
601                                        gpointer data, gboolean cancel_dest)
602 {
603     GSList *it;
604
605     for (it = loop->timers; it; it = g_slist_next(it)) {
606         ObtMainLoopTimer *t = it->data;
607         if (t->func == handler && t->equal(t->data, data)) {
608             t->del_me = TRUE;
609             if (cancel_dest)
610                 t->destroy = NULL;
611         }
612     }
613 }
614
615 /* find the time to wait for the nearest timeout */
616 static gboolean nearest_timeout_wait(ObtMainLoop *loop, GTimeVal *tm)
617 {
618   if (loop->timers == NULL)
619     return FALSE;
620
621   tm->tv_sec = NEAREST_TIMEOUT(loop).tv_sec - loop->now.tv_sec;
622   tm->tv_usec = NEAREST_TIMEOUT(loop).tv_usec - loop->now.tv_usec;
623
624   while (tm->tv_usec < 0) {
625     tm->tv_usec += G_USEC_PER_SEC;
626     tm->tv_sec--;
627   }
628   tm->tv_sec += tm->tv_usec / G_USEC_PER_SEC;
629   tm->tv_usec %= G_USEC_PER_SEC;
630   if (tm->tv_sec < 0)
631     tm->tv_sec = 0;
632
633   return TRUE;
634 }
635
636 static void timer_dispatch(ObtMainLoop *loop, GTimeVal **wait)
637 {
638     GSList *it, *next;
639
640     gboolean fired = FALSE;
641
642     g_get_current_time(&loop->now);
643
644     for (it = loop->timers; it; it = next) {
645         ObtMainLoopTimer *curr;
646
647         next = g_slist_next(it);
648
649         curr = it->data;
650
651         /* since timer_stop doesn't actually free the timer, we have to do our
652            real freeing in here.
653         */
654         if (curr->del_me) {
655             /* delete the top */
656             loop->timers = g_slist_delete_link(loop->timers, it);
657             if (curr->destroy)
658                 curr->destroy(curr->data);
659             g_slice_free(ObtMainLoopTimer, curr);
660             continue;
661         }
662
663         /* the queue is sorted, so if this timer shouldn't fire, none are
664            ready */
665         if (timecompare(&NEAREST_TIMEOUT(loop), &loop->now) > 0)
666             break;
667
668         /* we set the last fired time to delay msec after the previous firing,
669            then re-insert.  timers maintain their order and may trigger more
670            than once if they've waited more than one delay's worth of time.
671         */
672         loop->timers = g_slist_delete_link(loop->timers, it);
673         g_time_val_add(&curr->last, curr->delay);
674         if (curr->func(curr->data)) {
675             g_time_val_add(&curr->timeout, curr->delay);
676             insert_timer(loop, curr);
677         } else {
678             if (curr->destroy)
679                 curr->destroy(curr->data);
680             g_slice_free(ObtMainLoopTimer, curr);
681         }
682
683         /* the timer queue has been shuffled, start from the beginning
684            (which is the next one to fire) */
685         next = loop->timers;
686
687         fired = TRUE;
688     }
689
690     if (fired) {
691         /* if at least one timer fires, then don't wait on X events, as there
692            may already be some in the queue from the timer callbacks.
693         */
694         loop->ret_wait.tv_sec = loop->ret_wait.tv_usec = 0;
695         *wait = &loop->ret_wait;
696     } else if (nearest_timeout_wait(loop, &loop->ret_wait))
697         *wait = &loop->ret_wait;
698     else
699         *wait = NULL;
700 }