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