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