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