(main): Set the prefixes for assuan logging.
[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   /* Note we ignore malloc errors because we can't do much about it
788      and the request will fail anyway shortly after this
789      initialization. */
790   if (ctrl->display)
791     free (ctrl->display);
792   ctrl->display = default_display? strdup (default_display) : NULL;
793
794   if (ctrl->ttyname)
795     free (ctrl->ttyname);
796   ctrl->ttyname = default_ttyname? strdup (default_ttyname) : NULL;
797
798   if (ctrl->ttytype)
799     free (ctrl->ttytype);
800   ctrl->ttytype = default_ttytype? strdup (default_ttytype) : NULL;
801
802   if (ctrl->lc_ctype)
803     free (ctrl->lc_ctype);
804   ctrl->lc_ctype = default_lc_ctype? strdup (default_lc_ctype) : NULL;
805
806   if (ctrl->lc_messages)
807     free (ctrl->lc_messages);
808   ctrl->lc_messages = default_lc_messages? strdup (default_lc_messages) : NULL;
809 }
810
811
812 /* Reread parts of the configuration.  Note, that this function is
813    obviously not thread-safe and should only be called from the PTH
814    signal handler. 
815
816    Fixme: Due to the way the argument parsing works, we create a
817    memory leak here for all string type arguments.  There is currently
818    no clean way to tell whether the memory for the argument has been
819    allocated or points into the process' original arguments.  Unless
820    we have a mechanism to tell this, we need to live on with this. */
821 static void
822 reread_configuration (void)
823 {
824   ARGPARSE_ARGS pargs;
825   FILE *fp;
826   unsigned int configlineno = 0;
827   int dummy;
828
829   if (!config_filename)
830     return; /* No config file. */
831
832   fp = fopen (config_filename, "r");
833   if (!fp)
834     {
835       log_error (_("option file `%s': %s\n"),
836                  config_filename, strerror(errno) );
837       return;
838     }
839
840   parse_rereadable_options (NULL); /* Start from the default values. */
841
842   memset (&pargs, 0, sizeof pargs);
843   dummy = 0;
844   pargs.argc = &dummy;
845   pargs.flags = 1;  /* do not remove the args */
846   while (optfile_parse (fp, config_filename, &configlineno, &pargs, opts) )
847     {
848       if (pargs.r_opt < -1)
849         pargs.err = 1; /* Print a warning. */
850       else /* Try to parse this option - ignore unchangeable ones. */
851         parse_rereadable_options (&pargs);
852     }
853   fclose (fp);
854 }
855
856
857 static void
858 create_private_keys_directory (const char *home)
859 {
860   char *fname;
861   struct stat statbuf;
862
863   fname = make_filename (home, GNUPG_PRIVATE_KEYS_DIR, NULL);
864   if (stat (fname, &statbuf) && errno == ENOENT)
865     {
866       if (mkdir (fname, S_IRUSR|S_IWUSR|S_IXUSR ))
867         log_error (_("can't create directory `%s': %s\n"),
868                    fname,       strerror(errno) );
869       else if (!opt.quiet)
870         log_info (_("directory `%s' created\n"), fname);
871     }
872   xfree (fname);
873 }
874
875 /* Create the directory only if the supplied directory name is the
876    same as the default one.  This way we avoid to create arbitrary
877    directories when a non-default home directory is used.  To cope
878    with HOME, we compare only the suffix if we see that the default
879    homedir does start with a tilde.  We don't stop here in case of
880    problems because other functions will throw an error anyway.*/
881 static void
882 create_directories (void)
883 {
884   struct stat statbuf;
885   const char *defhome = GNUPG_DEFAULT_HOMEDIR;
886   char *home;
887
888   home  = make_filename (opt.homedir, NULL);
889   if ( stat (home, &statbuf) )
890     {
891       if (errno == ENOENT)
892         {
893           if ( (*defhome == '~'
894                 && (strlen (home) >= strlen (defhome+1)
895                     && !strcmp (home + strlen(home)
896                                 - strlen (defhome+1), defhome+1)))
897                || (*defhome != '~' && !strcmp (home, defhome) )
898                )
899             {
900               if (mkdir (home, S_IRUSR|S_IWUSR|S_IXUSR ))
901                 log_error (_("can't create directory `%s': %s\n"),
902                            home, strerror(errno) );
903               else 
904                 {
905                   if (!opt.quiet)
906                     log_info (_("directory `%s' created\n"), home);
907                   create_private_keys_directory (home);
908                 }
909             }
910         }
911       else
912         log_error ("error stat-ing `%s': %s\n", home, strerror (errno));
913     }
914   else if ( !S_ISDIR(statbuf.st_mode))
915     {
916       log_error ("can't use `%s' as home directory\n", home);
917     }
918   else /* exists and is a directory. */
919     {
920       create_private_keys_directory (home);
921     }
922   xfree (home);
923 }
924
925
926
927 #ifdef USE_GNU_PTH
928 static void
929 handle_signal (int signo)
930 {
931   switch (signo)
932     {
933     case SIGHUP:
934       log_info ("SIGHUP received - "
935                 "re-reading configuration and flushing cache\n");
936       agent_flush_cache ();
937       reread_configuration ();
938       break;
939       
940     case SIGUSR1:
941       if (opt.verbose < 5)
942         opt.verbose++;
943       log_info ("SIGUSR1 received - verbosity set to %d\n", opt.verbose);
944       break;
945
946     case SIGUSR2:
947       if (opt.verbose)
948         opt.verbose--;
949       log_info ("SIGUSR2 received - verbosity set to %d\n", opt.verbose );
950       break;
951
952     case SIGTERM:
953       if (!shutdown_pending)
954         log_info ("SIGTERM received - shutting down ...\n");
955       else
956         log_info ("SIGTERM received - still %ld running threads\n",
957                   pth_ctrl( PTH_CTRL_GETTHREADS ));
958       shutdown_pending++;
959       if (shutdown_pending > 2)
960         {
961           log_info ("shutdown forced\n");
962           log_info ("%s %s stopped\n", strusage(11), strusage(13) );
963           cleanup ();
964           agent_exit (0);
965         }
966       break;
967         
968     case SIGINT:
969       log_info ("SIGINT received - immediate shutdown\n");
970       log_info( "%s %s stopped\n", strusage(11), strusage(13));
971       cleanup ();
972       agent_exit (0);
973       break;
974
975     default:
976       log_info ("signal %d received - no action defined\n", signo);
977     }
978 }
979
980
981 static void *
982 start_connection_thread (void *arg)
983 {
984   int fd = (int)arg;
985
986   if (opt.verbose)
987     log_info ("handler for fd %d started\n", fd);
988   start_command_handler (-1, fd);
989   if (opt.verbose)
990     log_info ("handler for fd %d terminated\n", fd);
991   
992   return NULL;
993 }
994
995
996 static void
997 handle_connections (int listen_fd)
998 {
999   pth_attr_t tattr;
1000   pth_event_t ev;
1001   sigset_t sigs;
1002   int signo;
1003   struct sockaddr_un paddr;
1004   socklen_t plen = sizeof( paddr );
1005   int fd;
1006
1007   tattr = pth_attr_new();
1008   pth_attr_set (tattr, PTH_ATTR_JOINABLE, 0);
1009   pth_attr_set (tattr, PTH_ATTR_STACK_SIZE, 32*1024);
1010   pth_attr_set (tattr, PTH_ATTR_NAME, "gpg-agent");
1011
1012   sigemptyset (&sigs );
1013   sigaddset (&sigs, SIGHUP);
1014   sigaddset (&sigs, SIGUSR1);
1015   sigaddset (&sigs, SIGUSR2);
1016   sigaddset (&sigs, SIGINT);
1017   sigaddset (&sigs, SIGTERM);
1018   ev = pth_event (PTH_EVENT_SIGS, &sigs, &signo);
1019
1020   for (;;)
1021     {
1022       if (shutdown_pending)
1023         {
1024           if (pth_ctrl (PTH_CTRL_GETTHREADS) == 1)
1025             break; /* ready */
1026
1027           /* Do not accept anymore connections and wait for existing
1028              connections to terminate */
1029           signo = 0;
1030           pth_wait (ev);
1031           if (pth_event_occurred (ev) && signo)
1032             handle_signal (signo);
1033           continue;
1034         }
1035
1036       fd = pth_accept_ev (listen_fd, (struct sockaddr *)&paddr, &plen, ev);
1037       if (fd == -1)
1038         {
1039 #ifdef PTH_STATUS_OCCURRED     /* This is Pth 2 */
1040           if (pth_event_status (ev) == PTH_STATUS_OCCURRED)
1041 #else
1042           if (pth_event_occurred (ev))
1043 #endif
1044             {
1045               handle_signal (signo);
1046               continue;
1047             }
1048           log_error ("accept failed: %s - waiting 1s\n", strerror (errno));
1049           pth_sleep(1);
1050           continue;
1051         }
1052
1053       if (!pth_spawn (tattr, start_connection_thread, (void*)fd))
1054         {
1055           log_error ("error spawning connection handler: %s\n",
1056                      strerror (errno) );
1057           close (fd);
1058         }
1059     }
1060
1061   pth_event_free (ev, PTH_FREE_ALL);
1062   cleanup ();
1063   log_info ("%s %s stopped\n", strusage(11), strusage(13));
1064 }
1065 #endif /*USE_GNU_PTH*/