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