642ca5e05888a1c1296dba6735ca0c750c51bacf
[profile/ivi/pulseaudio-panda.git] / src / mainloop-signal.c
1 /* $Id$ */
2
3 /***
4   This file is part of polypaudio.
5  
6   polypaudio is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published
8   by the Free Software Foundation; either version 2 of the License,
9   or (at your option) any later version.
10  
11   polypaudio is distributed in the hope that it will be useful, but
12   WITHOUT ANY WARRANTY; without even the implied warranty of
13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   General Public License for more details.
15  
16   You should have received a copy of the GNU General Public License
17   along with polypaudio; if not, write to the Free Software
18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
19   USA.
20 ***/
21
22 #ifdef HAVE_CONFIG_H
23 #include <config.h>
24 #endif
25
26 #include <stdio.h>
27 #include <assert.h>
28 #include <signal.h>
29 #include <errno.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33
34 #include "mainloop-signal.h"
35 #include "util.h"
36
37 struct signal_info {
38     int sig;
39     struct sigaction saved_sigaction;
40     void (*callback) (void *id, int signal, void *userdata);
41     void *userdata;
42     struct signal_info *previous, *next;
43 };
44
45 static struct pa_mainloop_api *api = NULL;
46 static int signal_pipe[2] = { -1, -1 };
47 static void* mainloop_source = NULL;
48 static struct signal_info *signals = NULL;
49
50 static void signal_handler(int sig) {
51     write(signal_pipe[1], &sig, sizeof(sig));
52 }
53
54 static void callback(struct pa_mainloop_api*a, void *id, int fd, enum pa_mainloop_api_io_events events, void *userdata) {
55     assert(a && id && events == PA_MAINLOOP_API_IO_EVENT_INPUT && id == mainloop_source && fd == signal_pipe[0]);
56
57     for (;;) {
58         ssize_t r;
59         int sig;
60         struct signal_info*s;
61         
62         if ((r = read(signal_pipe[0], &sig, sizeof(sig))) < 0) {
63             if (errno == EAGAIN)
64                 return;
65
66             fprintf(stderr, "signal.c: read(): %s\n", strerror(errno));
67             return;
68         }
69
70         if (r != sizeof(sig)) {
71             fprintf(stderr, "signal.c: short read()\n");
72             return;
73         }
74
75         for (s = signals; s; s = s->next) 
76             if (s->sig == sig) {
77                 assert(s->callback);
78                 s->callback(s, sig, s->userdata);
79                 break;
80             }
81     }
82 }
83
84 int pa_signal_init(struct pa_mainloop_api *a) {
85     assert(a);
86     if (pipe(signal_pipe) < 0) {
87         fprintf(stderr, "pipe() failed: %s\n", strerror(errno));
88         return -1;
89     }
90
91     pa_make_nonblock_fd(signal_pipe[0]);
92     pa_make_nonblock_fd(signal_pipe[1]);
93
94     api = a;
95     mainloop_source = api->source_io(api, signal_pipe[0], PA_MAINLOOP_API_IO_EVENT_INPUT, callback, NULL);
96     assert(mainloop_source);
97     return 0;
98 }
99
100 void pa_signal_done(void) {
101     assert(api && signal_pipe[0] >= 0 && signal_pipe[1] >= 0 && mainloop_source);
102
103     api->cancel_io(api, mainloop_source);
104     mainloop_source = NULL;
105
106     close(signal_pipe[0]);
107     close(signal_pipe[1]);
108     signal_pipe[0] = signal_pipe[1] = -1;
109
110     while (signals)
111         pa_signal_unregister(signals);
112     
113     api = NULL;
114 }
115
116 void* pa_signal_register(int sig, void (*callback) (void *id, int signal, void *userdata), void *userdata) {
117     struct signal_info *s = NULL;
118     struct sigaction sa;
119     assert(sig > 0 && callback);
120
121     for (s = signals; s; s = s->next)
122         if (s->sig == sig)
123             goto fail;
124     
125     s = malloc(sizeof(struct signal_info));
126     assert(s);
127     s->sig = sig;
128     s->callback = callback;
129     s->userdata = userdata;
130
131     memset(&sa, 0, sizeof(sa));
132     sa.sa_handler = signal_handler;
133     sigemptyset(&sa.sa_mask);
134     sa.sa_flags = SA_RESTART;
135     
136     if (sigaction(sig, &sa, &s->saved_sigaction) < 0)
137         goto fail;
138
139     s->previous = NULL;
140     s->next = signals;
141     signals = s;
142
143     return s;
144 fail:
145     if (s)
146         free(s);
147     return NULL;
148 }
149
150 void pa_signal_unregister(void *id) {
151     struct signal_info *s = id;
152     assert(s);
153
154     if (s->next)
155         s->next->previous = s->previous;
156     if (s->previous)
157         s->previous->next = s->next;
158     else
159         signals = s->next;
160
161     sigaction(s->sig, &s->saved_sigaction, NULL);
162     free(s);
163 }