* call-scd.c (learn_status_cb): Handle CERTINFO status.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  *      Copyright (C) 2000, 2001, 2002 Free Software Foundation, Inc.
3  *
4  * This file is part of GnuPG.
5  *
6  * GnuPG is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GnuPG is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <config.h>
22
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <stddef.h>
26 #include <stdarg.h>
27 #include <string.h>
28 #include <errno.h>
29 #include <assert.h>
30 #include <time.h>
31 #include <fcntl.h>
32 #include <sys/socket.h>
33 #include <sys/un.h>
34 #include <unistd.h>
35 #include <signal.h>
36 #ifdef USE_GNU_PTH
37 # include <pth.h>
38 #endif
39
40 #include <gcrypt.h>
41
42 #define JNLIB_NEED_LOG_LOGV
43 #include "agent.h"
44 #include "../assuan/assuan.h" /* malloc hooks */
45
46 #include "i18n.h"
47 #include "sysutils.h"
48
49
50 enum cmd_and_opt_values 
51 { aNull = 0,
52   oCsh            = 'c',
53   oQuiet          = 'q',
54   oSh             = 's',
55   oVerbose        = 'v',
56   
57   oNoVerbose = 500,
58   oOptions,
59   oDebug,
60   oDebugAll,
61   oDebugWait,
62   oNoGreeting,
63   oNoOptions,
64   oHomedir,
65   oNoDetach,
66   oNoGrab,
67   oLogFile,
68   oServer,
69   oBatch,
70
71   oPinentryProgram,
72   oDisplay,
73   oTTYname,
74   oTTYtype,
75   oLCctype,
76   oLCmessages,
77   oScdaemonProgram,
78   oDefCacheTTL,
79   oDisablePth,
80
81   oIgnoreCacheForSigning,
82
83 aTest };
84
85
86
87 static ARGPARSE_OPTS opts[] = {
88   
89   { 301, NULL, 0, N_("@Options:\n ") },
90
91   { oServer,   "server",     0, N_("run in server mode") },
92   { oVerbose, "verbose",   0, N_("verbose") },
93   { oQuiet,     "quiet",     0, N_("be somewhat more quiet") },
94   { oSh,        "sh",        0, N_("sh-style command output") },
95   { oCsh,       "csh",       0, N_("csh-style command output") },
96   { oOptions, "options"  , 2, N_("read options from file")},
97   { oDebug,     "debug"     ,4|16, N_("set debugging flags")},
98   { oDebugAll, "debug-all" ,0, N_("enable full debugging")},
99   { oDebugWait,"debug-wait",1, "@"},
100   { oNoDetach, "no-detach" ,0, N_("do not detach from the console")},
101   { oNoGrab, "no-grab"     ,0, N_("do not grab keyboard and mouse")},
102   { oLogFile, "log-file"   ,2, N_("use a log file for the server")},
103   { oDisablePth, "disable-pth", 0, N_("do not allow multiple connections")},
104
105   { oPinentryProgram, "pinentry-program", 2 , "path to PIN Entry program" },
106   { oDisplay,    "display",     2, "set the display" },
107   { oTTYname,    "ttyname",     2, "set the tty terminal node name" },
108   { oTTYtype,    "ttytype",     2, "set the tty terminal type" },
109   { oLCctype,    "lc-ctype",    2, "set the tty LC_CTYPE value" },
110   { oLCmessages, "lc-messages", 2, "set the tty LC_MESSAGES value" },
111
112   { oScdaemonProgram, "scdaemon-program", 2 , "path to SCdaemon program" },
113   { oDefCacheTTL, "default-cache-ttl", 4,
114                                  "|N|expire cached PINs after N seconds"},
115   { oIgnoreCacheForSigning, "ignore-cache-for-signing", 0,
116                                  "do not use the PIN cache when signing"},
117
118   {0}
119 };
120
121
122 static volatile int caught_fatal_sig = 0;
123
124 /* flag to indicate that a shutdown was requested */
125 static int shutdown_pending;
126
127
128 /* It is possible that we are currently running under setuid permissions */
129 static int maybe_setuid = 1;
130
131 /* Name of the communication socket */
132 static char socket_name[128];
133
134
135 #ifdef USE_GNU_PTH
136 static void handle_connections (int listen_fd);
137 #endif
138
139
140
141 static const char *
142 my_strusage (int level)
143 {
144   const char *p;
145   switch (level)
146     {
147     case 11: p = "gpg-agent (GnuPG)";
148       break;
149     case 13: p = VERSION; break;
150     case 17: p = PRINTABLE_OS_NAME; break;
151     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
152       break;
153     case 1:
154     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
155       break;
156     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
157                     "Secret key management for GnuPG\n");
158     break;
159     
160     default: p = NULL;
161     }
162   return p;
163 }
164
165
166
167 static void
168 i18n_init (void)
169 {
170 #ifdef USE_SIMPLE_GETTEXT
171     set_gettext_file( PACKAGE );
172 #else
173 #ifdef ENABLE_NLS
174     /* gtk_set_locale (); HMMM: We have not yet called gtk_init */
175     bindtextdomain( PACKAGE, LOCALEDIR );
176     textdomain( PACKAGE );
177 #endif
178 #endif
179 }
180
181
182
183 /* Used by gcry for logging */
184 static void
185 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
186 {
187   /* translate the log levels */
188   switch (level)
189     {
190     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
191     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
192     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
193     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
194     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
195     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
196     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
197     default:            level = JNLIB_LOG_ERROR; break;  
198     }
199   log_logv (level, fmt, arg_ptr);
200 }
201
202
203 static void
204 cleanup (void)
205 {
206   if (*socket_name)
207     {
208       char *p;
209
210       remove (socket_name);
211       p = strrchr (socket_name, '/');
212       if (p)
213         {
214           *p = 0;
215           rmdir (socket_name);
216           *p = '/';
217         }
218       *socket_name = 0;
219     }
220 }
221
222
223 static RETSIGTYPE
224 cleanup_sh (int sig)
225 {
226   if (caught_fatal_sig)
227     raise (sig);
228   caught_fatal_sig = 1;
229
230   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
231   cleanup ();
232
233 #ifndef HAVE_DOSISH_SYSTEM
234   {     /* reset action to default action and raise signal again */
235     struct sigaction nact;
236     nact.sa_handler = SIG_DFL;
237     sigemptyset( &nact.sa_mask );
238     nact.sa_flags = 0;
239     sigaction( sig, &nact, NULL);
240   }
241 #endif
242   raise( sig );
243 }
244
245 int
246 main (int argc, char **argv )
247 {
248   ARGPARSE_ARGS pargs;
249   int orig_argc;
250   int may_coredump;
251   char **orig_argv;
252   FILE *configfp = NULL;
253   char *configname = NULL;
254   const char *shell;
255   unsigned configlineno;
256   int parse_debug = 0;
257   int default_config =1;
258   int greeting = 0;
259   int nogreeting = 0;
260   int pipe_server = 0;
261   int nodetach = 0;
262   int csh_style = 0;
263   char *logfile = NULL;
264   int debug_wait = 0;
265   int disable_pth = 0;
266
267   set_strusage (my_strusage);
268   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
269   /* Please note that we may running SUID(ROOT), so be very CAREFUL
270      when adding any stuff between here and the call to INIT_SECMEM()
271      somewhere after the option parsing */
272   log_set_prefix ("gpg-agent", 1|4); 
273   i18n_init ();
274
275   /* check that the libraries are suitable.  Do it here because
276      the option parsing may need services of the library */
277   if (!gcry_check_version ( "1.1.5" ) )
278     {
279       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
280                  "1.1.5", gcry_check_version (NULL) );
281     }
282
283   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
284 #ifdef USE_GNU_PTH
285     assuan_set_io_func (pth_read, pth_write);
286 #endif
287
288   gcry_set_log_handler (my_gcry_logger, NULL);
289   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
290
291   may_coredump = disable_core_dumps ();
292
293   shell = getenv ("SHELL");
294   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
295     csh_style = 1;
296   
297   opt.homedir = getenv("GNUPGHOME");
298   if (!opt.homedir || !*opt.homedir)
299     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
300   opt.def_cache_ttl = 10*60; /* default to 10 minutes */
301
302
303   /* check whether we have a config file on the commandline */
304   orig_argc = argc;
305   orig_argv = argv;
306   pargs.argc = &argc;
307   pargs.argv = &argv;
308   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
309   while (arg_parse( &pargs, opts))
310     {
311       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
312         parse_debug++;
313       else if (pargs.r_opt == oOptions)
314         { /* yes there is one, so we do not try the default one, but
315              read the option file when it is encountered at the
316              commandline */
317           default_config = 0;
318         }
319         else if (pargs.r_opt == oNoOptions)
320           default_config = 0; /* --no-options */
321         else if (pargs.r_opt == oHomedir)
322           opt.homedir = pargs.r.ret_str;
323     }
324
325   /* initialize the secure memory. */
326   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
327   maybe_setuid = 0;
328
329   /* 
330      Now we are now working under our real uid 
331   */
332
333
334   if (default_config)
335     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
336   
337   argc = orig_argc;
338   argv = orig_argv;
339   pargs.argc = &argc;
340   pargs.argv = &argv;
341   pargs.flags=  1;  /* do not remove the args */
342  next_pass:
343   if (configname)
344     {
345       configlineno = 0;
346       configfp = fopen (configname, "r");
347       if (!configfp)
348         {
349           if (default_config)
350             {
351               if( parse_debug )
352                 log_info (_("NOTE: no default option file `%s'\n"),
353                           configname );
354             }
355           else
356             {
357               log_error (_("option file `%s': %s\n"),
358                          configname, strerror(errno) );
359               exit(2);
360             }
361           xfree (configname); 
362           configname = NULL;
363         }
364       if (parse_debug && configname )
365         log_info (_("reading options from `%s'\n"), configname );
366       default_config = 0;
367     }
368
369   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
370     {
371       switch (pargs.r_opt)
372         {
373         case oQuiet: opt.quiet = 1; break;
374         case oVerbose: opt.verbose++; break;
375         case oBatch: opt.batch=1; break;
376
377         case oDebug: opt.debug |= pargs.r.ret_ulong; break;
378         case oDebugAll: opt.debug = ~0; break;
379         case oDebugWait: debug_wait = pargs.r.ret_int; break;
380
381         case oOptions:
382           /* config files may not be nested (silently ignore them) */
383           if (!configfp)
384             {
385                 xfree(configname);
386                 configname = xstrdup(pargs.r.ret_str);
387                 goto next_pass;
388             }
389           break;
390         case oNoGreeting: nogreeting = 1; break;
391         case oNoVerbose: opt.verbose = 0; break;
392         case oNoOptions: break; /* no-options */
393         case oHomedir: opt.homedir = pargs.r.ret_str; break;
394         case oNoDetach: nodetach = 1; break;
395         case oNoGrab: opt.no_grab = 1; break;
396         case oLogFile: logfile = pargs.r.ret_str; break;
397         case oCsh: csh_style = 1; break;
398         case oSh: csh_style = 0; break;
399         case oServer: pipe_server = 1; break;
400         case oDisablePth: disable_pth = 1; break;
401
402         case oPinentryProgram: opt.pinentry_program = pargs.r.ret_str; break;
403         case oDisplay: opt.display = xstrdup (pargs.r.ret_str); break;
404         case oTTYname: opt.ttyname = xstrdup (pargs.r.ret_str); break;
405         case oTTYtype: opt.ttytype = xstrdup (pargs.r.ret_str); break;
406         case oLCctype: opt.lc_ctype = xstrdup (pargs.r.ret_str); break;
407         case oLCmessages: opt.lc_messages = xstrdup (pargs.r.ret_str); break;
408         case oScdaemonProgram: opt.scdaemon_program = pargs.r.ret_str; break;
409         case oDefCacheTTL: opt.def_cache_ttl = pargs.r.ret_ulong; break;
410
411         case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
412
413         default : pargs.err = configfp? 1:2; break;
414         }
415     }
416   if (configfp)
417     {
418       fclose( configfp );
419       configfp = NULL;
420       xfree(configname);
421       configname = NULL;
422       goto next_pass;
423     }
424   xfree (configname);
425   configname = NULL;
426   if (log_get_errorcount(0))
427     exit(2);
428   if (nogreeting )
429     greeting = 0;
430
431   if (greeting)
432     {
433       fprintf (stderr, "%s %s; %s\n",
434                  strusage(11), strusage(13), strusage(14) );
435       fprintf (stderr, "%s\n", strusage(15) );
436     }
437 #ifdef IS_DEVELOPMENT_VERSION
438   log_info ("NOTE: this is a development version!\n");
439 #endif
440
441   
442   if (atexit (cleanup))
443     {
444       log_error ("atexit failed\n");
445       cleanup ();
446       exit (1);
447     }
448
449   if (debug_wait && pipe_server)
450     {
451       log_debug ("waiting for debugger - my pid is %u .....\n",
452                  (unsigned int)getpid());
453       sleep (debug_wait);
454       log_debug ("... okay\n");
455     }
456   
457   /* now start with logging to a file if this is desired */
458   if (logfile)
459     {
460       log_set_file (logfile);
461       log_set_prefix (NULL, 1|2|4);
462     }
463
464
465   if (pipe_server)
466     { /* this is the simple pipe based server */
467       start_command_handler (-1, -1);
468     }
469   else
470     { /* regular server mode */
471       int fd;
472       pid_t pid;
473       int len;
474       struct sockaddr_un serv_addr;
475       char *p;
476
477       *socket_name = 0;
478       snprintf (socket_name, DIM(socket_name)-1,
479                 "/tmp/gpg-XXXXXX/S.gpg-agent");
480       socket_name[DIM(socket_name)-1] = 0;
481       p = strrchr (socket_name, '/');
482       if (!p)
483         BUG ();
484       *p = 0;;
485       if (!mkdtemp(socket_name))
486         {
487           log_error ("can't create directory `%s': %s\n",
488                      socket_name, strerror(errno) );
489           exit (1);
490         }
491       *p = '/';
492
493       if (strchr (socket_name, ':') )
494         {
495           log_error ("colons are not allowed in the socket name\n");
496           exit (1);
497         }
498       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
499         {
500           log_error ("name of socket too long\n");
501           exit (1);
502         }
503    
504
505       fd = socket (AF_UNIX, SOCK_STREAM, 0);
506       if (fd == -1)
507         {
508           log_error ("can't create socket: %s\n", strerror(errno) );
509           exit (1);
510         }
511
512       memset (&serv_addr, 0, sizeof serv_addr);
513       serv_addr.sun_family = AF_UNIX;
514       strcpy (serv_addr.sun_path, socket_name);
515       len = (offsetof (struct sockaddr_un, sun_path)
516              + strlen(serv_addr.sun_path) + 1);
517
518       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
519         {
520           log_error ("error binding socket to `%s': %s\n",
521                      serv_addr.sun_path, strerror (errno) );
522           close (fd);
523           exit (1);
524         }
525   
526       if (listen (fd, 5 ) == -1)
527         {
528           log_error ("listen() failed: %s\n", strerror (errno));
529           close (fd);
530           exit (1);
531         }
532
533       if (opt.verbose)
534         log_info ("listening on socket `%s'\n", socket_name );
535
536
537       fflush (NULL);
538       pid = fork ();
539       if (pid == (pid_t)-1) 
540         {
541           log_fatal ("fork failed: %s\n", strerror (errno) );
542           exit (1);
543         }
544       else if (pid) 
545         { /* we are the parent */
546           char *infostr;
547           
548           close (fd);
549           
550           /* create the info string: <name>:<pid>:<protocol_version> */
551           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
552                         socket_name, (ulong)pid ) < 0)
553             {
554               log_error ("out of core\n");
555               kill (pid, SIGTERM);
556               exit (1);
557             }
558           *socket_name = 0; /* don't let cleanup() remove the socket -
559                                the child should do this from now on */
560           if (argc) 
561             { /* run the program given on the commandline */
562               if (putenv (infostr))
563                 {
564                   log_error ("failed to set environment: %s\n",
565                              strerror (errno) );
566                   kill (pid, SIGTERM );
567                   exit (1);
568                 }
569               execvp (argv[0], argv);
570               log_error ("failed to run the command: %s\n", strerror (errno));
571               kill (pid, SIGTERM);
572               exit (1);
573             }
574           else
575             {
576               /* print the environment string, so that the caller can use
577                  shell's eval to set it */
578               if (csh_style)
579                 {
580                   *strchr (infostr, '=') = ' ';
581                   printf ( "setenv %s\n", infostr);
582                 }
583               else
584                 {
585                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
586                 }
587               free (infostr);
588               exit (0); 
589             }
590           /*NEVER REACHED*/
591         } /* end parent */
592       
593
594       /* this is the child */
595
596       /* detach from tty and put process into a new session */
597       if (!nodetach )
598         { 
599           int i;
600
601           /* close stdin, stdout and stderr unless it is the log stream */
602           for (i=0; i <= 2; i++) 
603             {
604               if ( log_get_fd () != i)
605                 close (i);
606             }
607           if (setsid() == -1)
608             {
609               log_error ("setsid() failed: %s\n", strerror(errno) );
610               cleanup ();
611               exit (1);
612             }
613           opt.running_detached = 1;
614         }
615
616       if (chdir("/"))
617         {
618           log_error ("chdir to / failed: %s\n", strerror (errno));
619           exit (1);
620         }
621
622
623 #ifdef USE_GNU_PTH
624       if (!disable_pth)
625         {
626           if (!pth_init ())
627             {
628               log_error ("failed to initialize the Pth library\n");
629               exit (1);
630             }
631           signal (SIGPIPE, SIG_IGN);
632           handle_connections (fd);
633         }
634       else
635 #endif /*!USE_GNU_PTH*/
636       /* setup signals */
637         {
638           struct sigaction oact, nact;
639           
640           nact.sa_handler = cleanup_sh;
641           sigemptyset (&nact.sa_mask);
642           nact.sa_flags = 0;
643           
644           sigaction (SIGHUP, NULL, &oact);
645           if (oact.sa_handler != SIG_IGN)
646             sigaction (SIGHUP, &nact, NULL);
647           sigaction( SIGTERM, NULL, &oact );
648           if (oact.sa_handler != SIG_IGN)
649             sigaction (SIGTERM, &nact, NULL);
650           nact.sa_handler = SIG_IGN;
651           sigaction (SIGPIPE, &nact, NULL);
652           sigaction (SIGINT, &nact, NULL);
653
654           start_command_handler (fd, -1);
655         }
656       close (fd);
657     }
658   
659   return 0;
660 }
661
662 void
663 agent_exit (int rc)
664 {
665   /*FIXME: update_random_seed_file();*/
666 #if 1
667   /* at this time a bit annoying */
668   if (opt.debug & DBG_MEMSTAT_VALUE)
669     {
670       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
671       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
672     }
673   if (opt.debug)
674     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
675 #endif
676   gcry_control (GCRYCTL_TERM_SECMEM );
677   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
678   exit (rc);
679 }
680
681
682 static void
683 reread_configuration (void)
684 {
685   /* FIXME: Move parts of the option parsing to here. */
686 }
687
688
689 #ifdef USE_GNU_PTH
690 static void
691 handle_signal (int signo)
692 {
693   switch (signo)
694     {
695     case SIGHUP:
696       log_info ("SIGHUP received - re-reading configuration\n");
697       reread_configuration ();
698       break;
699       
700     case SIGUSR1:
701       if (opt.verbose < 5)
702         opt.verbose++;
703       log_info ("SIGUSR1 received - verbosity set to %d\n", opt.verbose);
704       break;
705
706     case SIGUSR2:
707       if (opt.verbose)
708         opt.verbose--;
709       log_info ("SIGUSR2 received - verbosity set to %d\n", opt.verbose );
710       break;
711
712     case SIGTERM:
713       if (!shutdown_pending)
714         log_info ("SIGTERM received - shutting down ...\n");
715       else
716         log_info ("SIGTERM received - still %ld running threads\n",
717                   pth_ctrl( PTH_CTRL_GETTHREADS ));
718       shutdown_pending++;
719       if (shutdown_pending > 2)
720         {
721           log_info ("shutdown forced\n");
722           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
723           cleanup ();
724           agent_exit (0);
725         }
726         break;
727         
728     case SIGINT:
729       log_info ("SIGINT received - immediate shutdown\n");
730       log_info( "%s %s stopped\n", strusage(11), strusage(13));
731       cleanup ();
732       agent_exit (0);
733       break;
734
735     default:
736       log_info ("signal %d received - no action defined\n", signo);
737     }
738 }
739
740
741 static void *
742 start_connection_thread (void *arg)
743 {
744   int fd = (int)arg;
745
746   if (opt.verbose)
747     log_info ("handler for fd %d started\n", fd);
748   start_command_handler (-1, fd);
749   if (opt.verbose)
750     log_info ("handler for fd %d terminated\n", fd);
751   
752   return NULL;
753 }
754
755
756 static void
757 handle_connections (int listen_fd)
758 {
759   pth_attr_t tattr;
760   pth_event_t ev;
761   sigset_t sigs;
762   int signo;
763   struct sockaddr_un paddr;
764   socklen_t plen = sizeof( paddr );
765   int fd;
766
767   tattr = pth_attr_new();
768   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
769   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 32*1024);
770   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
771
772   sigemptyset (&sigs );
773   sigaddset (&sigs, SIGHUP);
774   sigaddset (&sigs, SIGUSR1);
775   sigaddset (&sigs, SIGUSR2);
776   sigaddset (&sigs, SIGINT);
777   sigaddset (&sigs, SIGTERM);
778   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
779
780   for (;;)
781     {
782       if (shutdown_pending)
783         {
784           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
785             break; /* ready */
786
787           /* Do not accept anymore connections and wait for existing
788              connections to terminate */
789           signo = 0;
790           pth_wait (ev);
791           if (pth_event_occurred (ev) && signo)
792             handle_signal (signo);
793           continue;
794         }
795
796       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
797       if (fd == -1)
798         {
799           if (pth_event_occurred (ev))
800             {
801               handle_signal (signo);
802               continue;
803             }
804           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
805           pth_sleep(1);
806           continue;
807         }
808
809       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
810         {
811           log_error ("error spawning connection handler: %s\n",
812                      strerror (errno) );
813           close (fd);
814         }
815     }
816
817   pth_event_free (ev, PTH_FREE_ALL);
818   cleanup ();
819   log_info ("%s %s stopped\n", strusage(11), strusage(13));
820 }
821 #endif /*USE_GNU_PTH*/