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