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