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