Add new logo.
[gnupg.git] / g10 / signal.c
1 /* signal.c - signal handling
2  * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004,
3  *               2005 Free Software Foundation, Inc.
4  *
5  * This file is part of GnuPG.
6  *
7  * GnuPG 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  * GnuPG 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  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20  * USA.
21  */
22
23 #include <config.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <signal.h>
27 #include <unistd.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <assert.h>
31
32 #include "gpg.h"
33 #include "options.h"
34 #include "errors.h"
35 #include "util.h"
36 #include "main.h"
37 #include "ttyio.h"
38
39 #ifdef HAVE_DOSISH_SYSTEM
40 void init_signals(void) {}
41 void pause_on_sigusr(int which) {}
42 #else
43 static volatile int caught_fatal_sig = 0;
44 static volatile int caught_sigusr1 = 0;
45
46 static void
47 init_one_signal (int sig, RETSIGTYPE (*handler)(int), int check_ign )
48 {
49 #if defined(HAVE_SIGACTION) && defined(HAVE_STRUCT_SIGACTION)
50     struct sigaction oact, nact;
51
52     if (check_ign) {
53         /* we don't want to change an IGN handler */
54         sigaction (sig, NULL, &oact );
55         if (oact.sa_handler == SIG_IGN )
56             return;
57     }
58
59     nact.sa_handler = handler;
60     sigemptyset (&nact.sa_mask);
61     nact.sa_flags = 0;
62     sigaction ( sig, &nact, NULL);
63 #else 
64     RETSIGTYPE (*ohandler)(int);
65
66     ohandler = signal (sig, handler);
67     if (check_ign && ohandler == SIG_IGN) {
68         /* Change it back if it was already set to IGN */
69         signal (sig, SIG_IGN);
70     }
71 #endif
72 }
73
74 static RETSIGTYPE
75 got_fatal_signal( int sig )
76 {
77     const char *s;
78
79     if( caught_fatal_sig )
80         raise( sig );
81     caught_fatal_sig = 1;
82
83     gcry_control (GCRYCTL_TERM_SECMEM );
84
85     tty_cleanup_rl_after_signal ();
86
87     /* Better don't translate these messages. */
88     write(2, "\n", 1 );
89     s = log_get_name(); if( s ) write(2, s, strlen(s) );
90     write(2, ": ", 2 );
91
92 #if HAVE_DECL_SYS_SIGLIST && defined(NSIG)
93     s = (sig >= 0 && sig < NSIG) ? sys_siglist[sig] : "?";
94     write (2, s, strlen(s) );
95 #else
96     write (2, "signal ", 7 );
97     if (sig < 0 || sig >=100)
98         write (2, "?", 1);
99     else {
100         if (sig >= 10)
101             write (2, "0123456789"+(sig/10), 1 );
102         write (2, "0123456789"+(sig%10), 1 );
103     }
104 #endif
105     write(2, " caught ... exiting\n", 20 );
106
107     /* Reset action to default action and raise signal again. */
108     init_one_signal (sig, SIG_DFL, 0);
109     dotlock_remove_lockfiles ();
110 #ifdef __riscos__
111     riscos_close_fds ();
112 #endif /* __riscos__ */
113     raise( sig );
114 }
115
116
117 static RETSIGTYPE
118 got_usr_signal( int sig )
119 {
120     caught_sigusr1 = 1;
121 }
122
123
124 void
125 init_signals()
126 {
127     init_one_signal (SIGINT, got_fatal_signal, 1 );
128     init_one_signal (SIGHUP, got_fatal_signal, 1 );
129     init_one_signal (SIGTERM, got_fatal_signal, 1 );
130     init_one_signal (SIGQUIT, got_fatal_signal, 1 );
131     init_one_signal (SIGSEGV, got_fatal_signal, 1 );
132     init_one_signal (SIGUSR1, got_usr_signal, 0 );
133     init_one_signal (SIGPIPE, SIG_IGN, 0 );
134 }
135
136
137 void
138 pause_on_sigusr( int which )
139 {
140 #if defined(HAVE_SIGPROCMASK) && defined(HAVE_SIGSET_T)
141     sigset_t mask, oldmask;
142
143     assert( which == 1 );
144     sigemptyset( &mask );
145     sigaddset( &mask, SIGUSR1 );
146
147     sigprocmask( SIG_BLOCK, &mask, &oldmask );
148     while( !caught_sigusr1 )
149         sigsuspend( &oldmask );
150     caught_sigusr1 = 0;
151     sigprocmask( SIG_UNBLOCK, &mask, NULL );
152 #else 
153      assert (which == 1);
154      sighold (SIGUSR1);
155      while (!caught_sigusr1)
156          sigpause(SIGUSR1);
157      caught_sigusr1 = 0;
158      sigrelse(SIGUSR1);
159 #endif /*! HAVE_SIGPROCMASK && HAVE_SIGSET_T */
160 }
161
162 /* Disabled - see comment in tdbio.c:tdbio_begin_transaction() */
163 #if 0
164 static void
165 do_block( int block )
166 {
167     static int is_blocked;
168 #if defined(HAVE_SIGPROCMASK) && defined(HAVE_SIGSET_T)
169     static sigset_t oldmask;
170
171     if( block ) {
172         sigset_t newmask;
173
174         if( is_blocked )
175             log_bug("signals are already blocked\n");
176         sigfillset( &newmask );
177         sigprocmask( SIG_BLOCK, &newmask, &oldmask );
178         is_blocked = 1;
179     }
180     else {
181         if( !is_blocked )
182             log_bug("signals are not blocked\n");
183         sigprocmask( SIG_SETMASK, &oldmask, NULL );
184         is_blocked = 0;
185     }
186 #else /*! HAVE_SIGPROCMASK && HAVE_SIGSET_T */
187
188 #if defined(NSIG)
189 #define SIGSMAX (NSIG)
190 #elif defined(MAXSIG)
191 #define SIGSMAX (MAXSIG+1)
192 #else
193 #error "define SIGSMAX to the number of signals on your platform plus one"
194 #endif
195
196     static void (*disposition[SIGSMAX])(int);
197     int sig;
198
199     if( block ) {
200         if( is_blocked )
201             log_bug("signals are already blocked\n");
202         for (sig=1; sig < SIGSMAX; sig++) {
203             disposition[sig] = sigset (sig, SIG_HOLD);
204         }
205         is_blocked = 1;
206     }
207     else {
208         if( !is_blocked )
209             log_bug("signals are not blocked\n");
210         for (sig=1; sig < SIGSMAX; sig++) {
211             sigset (sig, disposition[sig]);
212         }
213         is_blocked = 0;
214     }
215 #endif /*! HAVE_SIGPROCMASK && HAVE_SIGSET_T */
216 }
217
218 void
219 block_all_signals()
220 {
221     do_block(1);
222 }
223
224 void
225 unblock_all_signals()
226 {
227     do_block(0);
228 }
229 #endif
230
231 #endif /* !HAVE_DOSISH_SYSTEM */