* agent.h (server_control_s): Add connection_fd field.
[gnupg.git] / agent / gpg-agent.c
1 /* gpg-agent.c  -  The GnuPG Agent
2  *      Copyright (C) 2000, 2001, 2002, 2003 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 #define JNLIB_NEED_LOG_LOGV
41 #include "agent.h"
42 #include <assuan.h> /* malloc hooks */
43
44 #include "i18n.h"
45 #include "sysutils.h"
46
47
48 enum cmd_and_opt_values 
49 { aNull = 0,
50   oCsh            = 'c',
51   oQuiet          = 'q',
52   oSh             = 's',
53   oVerbose        = 'v',
54   
55   oNoVerbose = 500,
56   oOptions,
57   oDebug,
58   oDebugAll,
59   oDebugWait,
60   oNoGreeting,
61   oNoOptions,
62   oHomedir,
63   oNoDetach,
64   oNoGrab,
65   oLogFile,
66   oServer,
67   oDaemon,
68   oBatch,
69
70   oPinentryProgram,
71   oDisplay,
72   oTTYname,
73   oTTYtype,
74   oLCctype,
75   oLCmessages,
76   oScdaemonProgram,
77   oDefCacheTTL,
78   oDisablePth,
79
80   oIgnoreCacheForSigning,
81   oKeepTTY,
82   oKeepDISPLAY,
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   { oKeepTTY, "keep-tty", 0,  N_("ignore requests to change the TTY")},
120   { oKeepDISPLAY, "keep-display",
121                           0, N_("ignore requests to change the X display")},
122   {0}
123 };
124
125
126 static volatile int caught_fatal_sig = 0;
127
128 /* flag to indicate that a shutdown was requested */
129 static int shutdown_pending;
130
131
132 /* It is possible that we are currently running under setuid permissions */
133 static int maybe_setuid = 1;
134
135 /* Name of the communication socket */
136 static char socket_name[128];
137
138 /* Default values for options passed to the pinentry. */
139 static char *default_display;
140 static char *default_ttyname;
141 static char *default_ttytype;
142 static char *default_lc_ctype;
143 static char *default_lc_messages;
144
145 /* Name of a config file, which will be reread on a HUP if it is not NULL. */
146 static char *config_filename;
147
148
149 /* Local prototypes. */
150 static void create_directories (void);
151 #ifdef USE_GNU_PTH
152 static void handle_connections (int listen_fd);
153 #endif
154
155
156
157 static const char *
158 my_strusage (int level)
159 {
160   const char *p;
161   switch (level)
162     {
163     case 11: p = "gpg-agent (GnuPG)";
164       break;
165     case 13: p = VERSION; break;
166     case 17: p = PRINTABLE_OS_NAME; break;
167     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
168       break;
169     case 1:
170     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
171       break;
172     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
173                     "Secret key management for GnuPG\n");
174     break;
175     
176     default: p = NULL;
177     }
178   return p;
179 }
180
181
182
183 static void
184 i18n_init (void)
185 {
186 #ifdef USE_SIMPLE_GETTEXT
187     set_gettext_file( PACKAGE );
188 #else
189 #ifdef ENABLE_NLS
190     setlocale (LC_ALL, "");
191     bindtextdomain (PACKAGE, LOCALEDIR);
192     textdomain (PACKAGE);
193 #endif
194 #endif
195 }
196
197
198
199 /* Used by gcry for logging */
200 static void
201 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
202 {
203   /* translate the log levels */
204   switch (level)
205     {
206     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
207     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
208     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
209     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
210     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
211     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
212     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
213     default:            level = JNLIB_LOG_ERROR; break;  
214     }
215   log_logv (level, fmt, arg_ptr);
216 }
217
218
219 static void
220 cleanup (void)
221 {
222   if (*socket_name)
223     {
224       char *p;
225
226       remove (socket_name);
227       p = strrchr (socket_name, '/');
228       if (p)
229         {
230           *p = 0;
231           rmdir (socket_name);
232           *p = '/';
233         }
234       *socket_name = 0;
235     }
236 }
237
238
239 static RETSIGTYPE
240 cleanup_sh (int sig)
241 {
242   if (caught_fatal_sig)
243     raise (sig);
244   caught_fatal_sig = 1;
245
246   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
247   cleanup ();
248
249 #ifndef HAVE_DOSISH_SYSTEM
250   {     /* reset action to default action and raise signal again */
251     struct sigaction nact;
252     nact.sa_handler = SIG_DFL;
253     sigemptyset( &nact.sa_mask );
254     nact.sa_flags = 0;
255     sigaction( sig, &nact, NULL);
256   }
257 #endif
258   raise( sig );
259 }
260
261
262 /* Handle options which are allowed to be reset after program start.
263    Return true when the current option in PARGS could be handled and
264    false if not.  As a special feature, passing a value of NULL for
265    PARGS, resets the options to the default. */
266 static int
267 parse_rereadable_options (ARGPARSE_ARGS *pargs)
268 {
269   if (!pargs)
270     { /* reset mode */
271       opt.quiet = 0;
272       opt.verbose = 0;
273       opt.debug = 0;
274       opt.no_grab = 0;
275       opt.pinentry_program = NULL;
276       opt.scdaemon_program = NULL;
277       opt.def_cache_ttl = 10*60; /* default to 10 minutes */
278       opt.ignore_cache_for_signing = 0;
279       return 1;
280     }
281
282   switch (pargs->r_opt)
283     {
284     case oQuiet: opt.quiet = 1; break;
285     case oVerbose: opt.verbose++; break;
286
287     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
288     case oDebugAll: opt.debug = ~0; break;
289
290     case oNoGrab: opt.no_grab = 1; break;
291       
292     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
293     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
294
295     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
296       
297     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
298
299     default:
300       return 0; /* not handled */
301     }
302   return 1; /* handled */
303 }
304
305
306 int
307 main (int argc, char **argv )
308 {
309   ARGPARSE_ARGS pargs;
310   int orig_argc;
311   int may_coredump;
312   char **orig_argv;
313   FILE *configfp = NULL;
314   char *configname = NULL;
315   const char *shell;
316   unsigned configlineno;
317   int parse_debug = 0;
318   int default_config =1;
319   int greeting = 0;
320   int nogreeting = 0;
321   int pipe_server = 0;
322   int is_daemon = 0;
323   int nodetach = 0;
324   int csh_style = 0;
325   char *logfile = NULL;
326   int debug_wait = 0;
327   int disable_pth = 0;
328
329   set_strusage (my_strusage);
330   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
331   /* Please note that we may running SUID(ROOT), so be very CAREFUL
332      when adding any stuff between here and the call to INIT_SECMEM()
333      somewhere after the option parsing */
334   log_set_prefix ("gpg-agent", 1|4); 
335   i18n_init ();
336
337   /* We need to initialize Pth before libgcrypt, because the libgcrypt
338      initialization done by gcry_check_version internally sets up its
339      mutex system.  Note that one must not link against pth if
340      USE_GNU_PTH is not defined. */
341 #ifdef USE_GNU_PTH
342   if (!pth_init ())
343     {
344       log_error ("failed to initialize the Pth library\n");
345       exit (1);
346     }
347 #endif /*USE_GNU_PTH*/
348
349   /* check that the libraries are suitable.  Do it here because
350      the option parsing may need services of the library */
351   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
352     {
353       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
354                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
355     }
356
357   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
358   assuan_set_assuan_log_stream (log_get_stream ());
359   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
360
361   gcry_set_log_handler (my_gcry_logger, NULL);
362   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
363
364   may_coredump = disable_core_dumps ();
365
366   parse_rereadable_options (NULL); /* Reset them to default values. */
367
368   shell = getenv ("SHELL");
369   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
370     csh_style = 1;
371   
372   opt.homedir = getenv("GNUPGHOME");
373   if (!opt.homedir || !*opt.homedir)
374     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
375
376
377   /* check whether we have a config file on the commandline */
378   orig_argc = argc;
379   orig_argv = argv;
380   pargs.argc = &argc;
381   pargs.argv = &argv;
382   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
383   while (arg_parse( &pargs, opts))
384     {
385       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
386         parse_debug++;
387       else if (pargs.r_opt == oOptions)
388         { /* yes there is one, so we do not try the default one, but
389              read the option file when it is encountered at the
390              commandline */
391           default_config = 0;
392         }
393         else if (pargs.r_opt == oNoOptions)
394           default_config = 0; /* --no-options */
395         else if (pargs.r_opt == oHomedir)
396           opt.homedir = pargs.r.ret_str;
397     }
398
399   /* initialize the secure memory. */
400   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
401   maybe_setuid = 0;
402
403   /* 
404      Now we are now working under our real uid 
405   */
406
407
408   if (default_config)
409     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
410   
411   argc = orig_argc;
412   argv = orig_argv;
413   pargs.argc = &argc;
414   pargs.argv = &argv;
415   pargs.flags=  1;  /* do not remove the args */
416  next_pass:
417   if (configname)
418     {
419       configlineno = 0;
420       configfp = fopen (configname, "r");
421       if (!configfp)
422         {
423           if (default_config)
424             {
425               if( parse_debug )
426                 log_info (_("NOTE: no default option file `%s'\n"),
427                           configname );
428             }
429           else
430             {
431               log_error (_("option file `%s': %s\n"),
432                          configname, strerror(errno) );
433               exit(2);
434             }
435           xfree (configname); 
436           configname = NULL;
437         }
438       if (parse_debug && configname )
439         log_info (_("reading options from `%s'\n"), configname );
440       default_config = 0;
441     }
442
443   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
444     {
445       if (parse_rereadable_options (&pargs))
446         continue; /* Already handled */
447       switch (pargs.r_opt)
448         {
449         case oBatch: opt.batch=1; break;
450
451         case oDebugWait: debug_wait = pargs.r.ret_int; break;
452
453         case oOptions:
454           /* config files may not be nested (silently ignore them) */
455           if (!configfp)
456             {
457                 xfree(configname);
458                 configname = xstrdup(pargs.r.ret_str);
459                 goto next_pass;
460             }
461           break;
462         case oNoGreeting: nogreeting = 1; break;
463         case oNoVerbose: opt.verbose = 0; break;
464         case oNoOptions: break; /* no-options */
465         case oHomedir: opt.homedir = pargs.r.ret_str; break;
466         case oNoDetach: nodetach = 1; break;
467         case oLogFile: logfile = pargs.r.ret_str; break;
468         case oCsh: csh_style = 1; break;
469         case oSh: csh_style = 0; break;
470         case oServer: pipe_server = 1; break;
471         case oDaemon: is_daemon = 1; break;
472         case oDisablePth: disable_pth = 1; break;
473
474         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
475         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
476         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
477         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
478         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str); break;
479
480         case oKeepTTY: opt.keep_tty = 1; break;
481         case oKeepDISPLAY: opt.keep_display = 1; break;
482
483         default : pargs.err = configfp? 1:2; break;
484         }
485     }
486   if (configfp)
487     {
488       fclose( configfp );
489       configfp = NULL;
490       /* Keep a copy of the name so that it can be read on SIGHUP. */
491       config_filename = configname;
492       configname = NULL;
493       goto next_pass;
494     }
495   xfree (configname);
496   configname = NULL;
497   if (log_get_errorcount(0))
498     exit(2);
499   if (nogreeting )
500     greeting = 0;
501
502   if (greeting)
503     {
504       fprintf (stderr, "%s %s; %s\n",
505                  strusage(11), strusage(13), strusage(14) );
506       fprintf (stderr, "%s\n", strusage(15) );
507     }
508 #ifdef IS_DEVELOPMENT_VERSION
509   log_info ("NOTE: this is a development version!\n");
510 #endif
511
512   
513   if (atexit (cleanup))
514     {
515       log_error ("atexit failed\n");
516       cleanup ();
517       exit (1);
518     }
519
520   create_directories ();
521
522   if (debug_wait && pipe_server)
523     {
524       log_debug ("waiting for debugger - my pid is %u .....\n",
525                  (unsigned int)getpid());
526       sleep (debug_wait);
527       log_debug ("... okay\n");
528     }
529
530   if (!pipe_server && !is_daemon)
531     log_info (_("please use the option `--daemon'"
532                 " to run the program in the background\n"));
533   
534 #ifdef ENABLE_NLS
535   /* gpg-agent usdually does not ooutput any messages becuase it runs
536      in the background.  For log files it is acceptable to have
537      messages always encoded in utf-8.  We switch here to utf-8, so
538      that commands like --help still give native messages.  It is far
539      easier to swicthnonly once instead of for every message and it
540      actually helps when more then one thread is active (avoids
541      required an extra copy step). */
542     bind_textdomain_codeset (PACKAGE, "UTF-8");
543 #endif
544
545   /* now start with logging to a file if this is desired */
546   if (logfile)
547     {
548       log_set_file (logfile);
549       log_set_prefix (NULL, 1|2|4);
550     }
551
552   /* Make sure that we have a default ttyname. */
553   if (!default_ttyname && ttyname (1))
554     default_ttyname = xstrdup (ttyname (1));
555   if (!default_ttytype && getenv ("TERM"))
556     default_ttytype = xstrdup (getenv ("TERM"));
557
558   if (pipe_server)
559     { /* this is the simple pipe based server */
560       start_command_handler (-1, -1);
561     }
562   else if (!is_daemon)
563     ;
564   else
565     { /* regular server mode */
566       int fd;
567       pid_t pid;
568       int len;
569       struct sockaddr_un serv_addr;
570       char *p;
571
572       /* Remove the DISPLAY variable so that a pinentry does not
573          default to a specific display.  There is still a default
574          display when gpg-agent weas started using --display or a
575          client requested this using an OPTION command. */
576       if (!opt.keep_display)
577         unsetenv ("DISPLAY");
578
579       *socket_name = 0;
580       snprintf (socket_name, DIM(socket_name)-1,
581                 "/tmp/gpg-XXXXXX/S.gpg-agent");
582       socket_name[DIM(socket_name)-1] = 0;
583       p = strrchr (socket_name, '/');
584       if (!p)
585         BUG ();
586       *p = 0;;
587       if (!mkdtemp(socket_name))
588         {
589           log_error ("can't create directory `%s': %s\n",
590                      socket_name, strerror(errno) );
591           exit (1);
592         }
593       *p = '/';
594
595       if (strchr (socket_name, ':') )
596         {
597           log_error ("colons are not allowed in the socket name\n");
598           exit (1);
599         }
600       if (strlen (socket_name)+1 >= sizeof serv_addr.sun_path ) 
601         {
602           log_error ("name of socket too long\n");
603           exit (1);
604         }
605    
606
607       fd = socket (AF_UNIX, SOCK_STREAM, 0);
608       if (fd == -1)
609         {
610           log_error ("can't create socket: %s\n", strerror(errno) );
611           exit (1);
612         }
613
614       memset (&serv_addr, 0, sizeof serv_addr);
615       serv_addr.sun_family = AF_UNIX;
616       strcpy (serv_addr.sun_path, socket_name);
617       len = (offsetof (struct sockaddr_un, sun_path)
618              + strlen(serv_addr.sun_path) + 1);
619
620       if (bind (fd, (struct sockaddr*)&serv_addr, len) == -1)
621         {
622           log_error ("error binding socket to `%s': %s\n",
623                      serv_addr.sun_path, strerror (errno) );
624           close (fd);
625           exit (1);
626         }
627   
628       if (listen (fd, 5 ) == -1)
629         {
630           log_error ("listen() failed: %s\n", strerror (errno));
631           close (fd);
632           exit (1);
633         }
634
635       if (opt.verbose)
636         log_info ("listening on socket `%s'\n", socket_name );
637
638
639       fflush (NULL);
640       pid = fork ();
641       if (pid == (pid_t)-1) 
642         {
643           log_fatal ("fork failed: %s\n", strerror (errno) );
644           exit (1);
645         }
646       else if (pid) 
647         { /* we are the parent */
648           char *infostr;
649           
650           close (fd);
651           
652           /* create the info string: <name>:<pid>:<protocol_version> */
653           if (asprintf (&infostr, "GPG_AGENT_INFO=%s:%lu:1",
654                         socket_name, (ulong)pid ) < 0)
655             {
656               log_error ("out of core\n");
657               kill (pid, SIGTERM);
658               exit (1);
659             }
660           *socket_name = 0; /* don't let cleanup() remove the socket -
661                                the child should do this from now on */
662           if (argc) 
663             { /* run the program given on the commandline */
664               if (putenv (infostr))
665                 {
666                   log_error ("failed to set environment: %s\n",
667                              strerror (errno) );
668                   kill (pid, SIGTERM );
669                   exit (1);
670                 }
671               execvp (argv[0], argv);
672               log_error ("failed to run the command: %s\n", strerror (errno));
673               kill (pid, SIGTERM);
674               exit (1);
675             }
676           else
677             {
678               /* print the environment string, so that the caller can use
679                  shell's eval to set it */
680               if (csh_style)
681                 {
682                   *strchr (infostr, '=') = ' ';
683                   printf ( "setenv %s\n", infostr);
684                 }
685               else
686                 {
687                   printf ( "%s; export GPG_AGENT_INFO;\n", infostr);
688                 }
689               free (infostr);
690               exit (0); 
691             }
692           /*NEVER REACHED*/
693         } /* end parent */
694       
695
696       /* this is the child */
697
698       /* detach from tty and put process into a new session */
699       if (!nodetach )
700         { 
701           int i;
702
703           /* close stdin, stdout and stderr unless it is the log stream */
704           for (i=0; i <= 2; i++) 
705             {
706               if ( log_get_fd () != i)
707                 close (i);
708             }
709           if (setsid() == -1)
710             {
711               log_error ("setsid() failed: %s\n", strerror(errno) );
712               cleanup ();
713               exit (1);
714             }
715           opt.running_detached = 1;
716         }
717
718       if (chdir("/"))
719         {
720           log_error ("chdir to / failed: %s\n", strerror (errno));
721           exit (1);
722         }
723
724
725 #ifdef USE_GNU_PTH
726       if (!disable_pth)
727         {
728           struct sigaction sa;
729
730           sa.sa_handler = SIG_IGN;
731           sigemptyset (&sa.sa_mask);
732           sa.sa_flags = 0;
733           sigaction (SIGPIPE, &sa, NULL);
734           handle_connections (fd);
735         }
736       else
737 #endif /*!USE_GNU_PTH*/
738       /* setup signals */
739         {
740           struct sigaction oact, nact;
741           
742           nact.sa_handler = cleanup_sh;
743           sigemptyset (&nact.sa_mask);
744           nact.sa_flags = 0;
745           
746           sigaction (SIGHUP, NULL, &oact);
747           if (oact.sa_handler != SIG_IGN)
748             sigaction (SIGHUP, &nact, NULL);
749           sigaction( SIGTERM, NULL, &oact );
750           if (oact.sa_handler != SIG_IGN)
751             sigaction (SIGTERM, &nact, NULL);
752           nact.sa_handler = SIG_IGN;
753           sigaction (SIGPIPE, &nact, NULL);
754           sigaction (SIGINT, &nact, NULL);
755
756           start_command_handler (fd, -1);
757         }
758       close (fd);
759     }
760   
761   return 0;
762 }
763
764 void
765 agent_exit (int rc)
766 {
767   /*FIXME: update_random_seed_file();*/
768 #if 1
769   /* at this time a bit annoying */
770   if (opt.debug & DBG_MEMSTAT_VALUE)
771     {
772       gcry_control( GCRYCTL_DUMP_MEMORY_STATS );
773       gcry_control( GCRYCTL_DUMP_RANDOM_STATS );
774     }
775   if (opt.debug)
776     gcry_control (GCRYCTL_DUMP_SECMEM_STATS );
777 #endif
778   gcry_control (GCRYCTL_TERM_SECMEM );
779   rc = rc? rc : log_get_errorcount(0)? 2 : 0;
780   exit (rc);
781 }
782
783
784 void
785 agent_init_default_ctrl (struct server_control_s *ctrl)
786 {
787   ctrl->connection_fd = -1;
788
789   /* Note we ignore malloc errors because we can't do much about it
790      and the request will fail anyway shortly after this
791      initialization. */
792   if (ctrl->display)
793     free (ctrl->display);
794   ctrl->display = default_display? strdup (default_display) : NULL;
795
796   if (ctrl->ttyname)
797     free (ctrl->ttyname);
798   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
799
800   if (ctrl->ttytype)
801     free (ctrl->ttytype);
802   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
803
804   if (ctrl->lc_ctype)
805     free (ctrl->lc_ctype);
806   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
807
808   if (ctrl->lc_messages)
809     free (ctrl->lc_messages);
810   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
811 }
812
813
814 /* Reread parts of the configuration.  Note, that this function is
815    obviously not thread-safe and should only be called from the PTH
816    signal handler. 
817
818    Fixme: Due to the way the argument parsing works, we create a
819    memory leak here for all string type arguments.  There is currently
820    no clean way to tell whether the memory for the argument has been
821    allocated or points into the process' original arguments.  Unless
822    we have a mechanism to tell this, we need to live on with this. */
823 static void
824 reread_configuration (void)
825 {
826   ARGPARSE_ARGS pargs;
827   FILE *fp;
828   unsigned int configlineno = 0;
829   int dummy;
830
831   if (!config_filename)
832     return; /* No config file. */
833
834   fp = fopen (config_filename, "r");
835   if (!fp)
836     {
837       log_error (_("option file `%s': %s\n"),
838                  config_filename, strerror(errno) );
839       return;
840     }
841
842   parse_rereadable_options (NULL); /* Start from the default values. */
843
844   memset (&pargs, 0, sizeof pargs);
845   dummy = 0;
846   pargs.argc = &dummy;
847   pargs.flags = 1;  /* do not remove the args */
848   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
849     {
850       if (pargs.r_opt < -1)
851         pargs.err = 1; /* Print a warning. */
852       else /* Try to parse this option - ignore unchangeable ones. */
853         parse_rereadable_options (&pargs);
854     }
855   fclose (fp);
856 }
857
858
859 static void
860 create_private_keys_directory (const char *home)
861 {
862   char *fname;
863   struct stat statbuf;
864
865   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
866   if (stat (fname, &statbuf) && errno == ENOENT)
867     {
868       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
869         log_error (_("can't create directory `%s': %s\n"),
870                    fname,       strerror(errno) );
871       else if (!opt.quiet)
872         log_info (_("directory `%s' created\n"), fname);
873     }
874   xfree (fname);
875 }
876
877 /* Create the directory only if the supplied directory name is the
878    same as the default one.  This way we avoid to create arbitrary
879    directories when a non-default home directory is used.  To cope
880    with HOME, we compare only the suffix if we see that the default
881    homedir does start with a tilde.  We don't stop here in case of
882    problems because other functions will throw an error anyway.*/
883 static void
884 create_directories (void)
885 {
886   struct stat statbuf;
887   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
888   char *home;
889
890   home  = make_filename (opt.homedir, NULL);
891   if ( stat (home, &statbuf) )
892     {
893       if (errno == ENOENT)
894         {
895           if ( (*defhome == '~'
896                 && (strlen (home) >= strlen (defhome+1)
897                     && !strcmp (home + strlen(home)
898                                 - strlen (defhome+1), defhome+1)))
899                || (*defhome != '~' && !strcmp (home, defhome) )
900                )
901             {
902               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
903                 log_error (_("can't create directory `%s': %s\n"),
904                            home, strerror(errno) );
905               else 
906                 {
907                   if (!opt.quiet)
908                     log_info (_("directory `%s' created\n"), home);
909                   create_private_keys_directory (home);
910                 }
911             }
912         }
913       else
914         log_error ("error stat-ing `%s': %s\n", home, strerror (errno));
915     }
916   else if ( !S_ISDIR(statbuf.st_mode))
917     {
918       log_error ("can't use `%s' as home directory\n", home);
919     }
920   else /* exists and is a directory. */
921     {
922       create_private_keys_directory (home);
923     }
924   xfree (home);
925 }
926
927
928
929 #ifdef USE_GNU_PTH
930 static void
931 handle_signal (int signo)
932 {
933   switch (signo)
934     {
935     case SIGHUP:
936       log_info ("SIGHUP received - "
937                 "re-reading configuration and flushing cache\n");
938       agent_flush_cache ();
939       reread_configuration ();
940       break;
941       
942     case SIGUSR1:
943       if (opt.verbose < 5)
944         opt.verbose++;
945       log_info ("SIGUSR1 received - verbosity set to %d\n", opt.verbose);
946       break;
947
948     case SIGUSR2:
949       if (opt.verbose)
950         opt.verbose--;
951       log_info ("SIGUSR2 received - verbosity set to %d\n", opt.verbose );
952       break;
953
954     case SIGTERM:
955       if (!shutdown_pending)
956         log_info ("SIGTERM received - shutting down ...\n");
957       else
958         log_info ("SIGTERM received - still %ld running threads\n",
959                   pth_ctrl( PTH_CTRL_GETTHREADS ));
960       shutdown_pending++;
961       if (shutdown_pending > 2)
962         {
963           log_info ("shutdown forced\n");
964           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
965           cleanup ();
966           agent_exit (0);
967         }
968       break;
969         
970     case SIGINT:
971       log_info ("SIGINT received - immediate shutdown\n");
972       log_info( "%s %s stopped\n", strusage(11), strusage(13));
973       cleanup ();
974       agent_exit (0);
975       break;
976
977     default:
978       log_info ("signal %d received - no action defined\n", signo);
979     }
980 }
981
982
983 static void *
984 start_connection_thread (void *arg)
985 {
986   int fd = (int)arg;
987
988   if (opt.verbose)
989     log_info ("handler for fd %d started\n", fd);
990   start_command_handler (-1, fd);
991   if (opt.verbose)
992     log_info ("handler for fd %d terminated\n", fd);
993   
994   return NULL;
995 }
996
997
998 static void
999 handle_connections (int listen_fd)
1000 {
1001   pth_attr_t tattr;
1002   pth_event_t ev;
1003   sigset_t sigs;
1004   int signo;
1005   struct sockaddr_un paddr;
1006   socklen_t plen = sizeof( paddr );
1007   int fd;
1008
1009   tattr = pth_attr_new();
1010   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1011   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 32*1024);
1012   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1013
1014   sigemptyset (&sigs );
1015   sigaddset (&sigs, SIGHUP);
1016   sigaddset (&sigs, SIGUSR1);
1017   sigaddset (&sigs, SIGUSR2);
1018   sigaddset (&sigs, SIGINT);
1019   sigaddset (&sigs, SIGTERM);
1020   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1021
1022   for (;;)
1023     {
1024       if (shutdown_pending)
1025         {
1026           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1027             break; /* ready */
1028
1029           /* Do not accept anymore connections and wait for existing
1030              connections to terminate */
1031           signo = 0;
1032           pth_wait (ev);
1033           if (pth_event_occurred (ev) && signo)
1034             handle_signal (signo);
1035           continue;
1036         }
1037
1038       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
1039       if (fd == -1)
1040         {
1041 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
1042           if (pth_event_status (ev) == PTH_STATUS_OCCURRED)
1043 #else
1044           if (pth_event_occurred (ev))
1045 #endif
1046             {
1047               handle_signal (signo);
1048               continue;
1049             }
1050           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
1051           pth_sleep(1);
1052           continue;
1053         }
1054
1055       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1056         {
1057           log_error ("error spawning connection handler: %s\n",
1058                      strerror (errno) );
1059           close (fd);
1060         }
1061     }
1062
1063   pth_event_free (ev, PTH_FREE_ALL);
1064   cleanup ();
1065   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1066 }
1067 #endif /*USE_GNU_PTH*/