ed12fed4f3d2a912897108d03cb51b90ef51e2cf
[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 /*HAVE_W32_SYSTEM*/
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 GCRY_THREAD_OPTION_PTH_IMPL;
183
184 #endif /*USE_GNU_PTH*/
185 static void check_for_running_agent (void);
186
187
188
189 static const char *
190 my_strusage (int level)
191 {
192   const char *p;
193   switch (level)
194     {
195     case 11: p = "gpg-agent (GnuPG)";
196       break;
197     case 13: p = VERSION; break;
198     case 17: p = PRINTABLE_OS_NAME; break;
199     case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
200       break;
201     case 1:
202     case 40: p =  _("Usage: gpg-agent [options] (-h for help)");
203       break;
204     case 41: p =  _("Syntax: gpg-agent [options] [command [args]]\n"
205                     "Secret key management for GnuPG\n");
206     break;
207     
208     default: p = NULL;
209     }
210   return p;
211 }
212
213
214
215 static void
216 i18n_init (void)
217 {
218 #ifdef USE_SIMPLE_GETTEXT
219     set_gettext_file( PACKAGE_GT );
220 #else
221 #ifdef ENABLE_NLS
222     setlocale (LC_ALL, "");
223     bindtextdomain (PACKAGE_GT, LOCALEDIR);
224     textdomain (PACKAGE_GT);
225 #endif
226 #endif
227 }
228
229
230
231 /* Used by gcry for logging */
232 static void
233 my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
234 {
235   /* translate the log levels */
236   switch (level)
237     {
238     case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
239     case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
240     case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
241     case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
242     case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
243     case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
244     case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
245     default:            level = JNLIB_LOG_ERROR; break;  
246     }
247   log_logv (level, fmt, arg_ptr);
248 }
249
250
251 /* Setup the debugging.  With the global variable DEBUG_LEVEL set to NULL
252    only the active debug flags are propagated to the subsystems.  With
253    DEBUG_LEVEL set, a specific set of debug flags is set; thus overriding
254    all flags already set. Note that we don't fail here, because it is
255    important to keep gpg-agent running even after re-reading the
256    options due to a SIGHUP. */
257 static void
258 set_debug (void)
259 {
260   if (!debug_level)
261     ;
262   else if (!strcmp (debug_level, "none"))
263     opt.debug = 0;
264   else if (!strcmp (debug_level, "basic"))
265     opt.debug = DBG_ASSUAN_VALUE;
266   else if (!strcmp (debug_level, "advanced"))
267     opt.debug = DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE;
268   else if (!strcmp (debug_level, "expert"))
269     opt.debug = (DBG_ASSUAN_VALUE|DBG_COMMAND_VALUE
270                  |DBG_CACHE_VALUE);
271   else if (!strcmp (debug_level, "guru"))
272     opt.debug = ~0;
273   else
274     {
275       log_error (_("invalid debug-level `%s' given\n"), debug_level);
276       opt.debug = 0; /* Reset debugging, so that prior debug
277                         statements won't have an undesired effect. */
278     }
279
280   if (opt.debug && !opt.verbose)
281     opt.verbose = 1;
282   if (opt.debug && opt.quiet)
283     opt.quiet = 0;
284
285   if (opt.debug & DBG_MPI_VALUE)
286     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 2);
287   if (opt.debug & DBG_CRYPTO_VALUE )
288     gcry_control (GCRYCTL_SET_DEBUG_FLAGS, 1);
289   gcry_control (GCRYCTL_SET_VERBOSITY, (int)opt.verbose);
290 }
291  
292
293 static void
294 cleanup (void)
295 {
296   if (*socket_name)
297     {
298       char *p;
299
300       remove (socket_name);
301       p = strrchr (socket_name, '/');
302       if (p)
303         {
304           *p = 0;
305           rmdir (socket_name);
306           *p = '/';
307         }
308       *socket_name = 0;
309     }
310 }
311
312
313 static RETSIGTYPE
314 cleanup_sh (int sig)
315 {
316   if (caught_fatal_sig)
317     raise (sig);
318   caught_fatal_sig = 1;
319
320   /* gcry_control( GCRYCTL_TERM_SECMEM );*/
321   cleanup ();
322
323 #ifndef HAVE_DOSISH_SYSTEM
324   {     /* reset action to default action and raise signal again */
325     struct sigaction nact;
326     nact.sa_handler = SIG_DFL;
327     sigemptyset( &nact.sa_mask );
328     nact.sa_flags = 0;
329     sigaction( sig, &nact, NULL);
330   }
331 #endif
332   raise( sig );
333 }
334
335
336 /* Handle options which are allowed to be reset after program start.
337    Return true when the current option in PARGS could be handled and
338    false if not.  As a special feature, passing a value of NULL for
339    PARGS, resets the options to the default.  REREAD should be set
340    true if it is not the initial option parsing. */
341 static int
342 parse_rereadable_options (ARGPARSE_ARGS *pargs, int reread)
343 {
344   if (!pargs)
345     { /* reset mode */
346       opt.quiet = 0;
347       opt.verbose = 0;
348       opt.debug = 0;
349       opt.no_grab = 0;
350       opt.pinentry_program = NULL;
351       opt.scdaemon_program = NULL;
352       opt.def_cache_ttl = DEFAULT_CACHE_TTL;
353       opt.max_cache_ttl = MAX_CACHE_TTL;
354       opt.ignore_cache_for_signing = 0;
355       opt.allow_mark_trusted = 0;
356       return 1;
357     }
358
359   switch (pargs->r_opt)
360     {
361     case oQuiet: opt.quiet = 1; break;
362     case oVerbose: opt.verbose++; break;
363
364     case oDebug: opt.debug |= pargs->r.ret_ulong; break;
365     case oDebugAll: opt.debug = ~0; break;
366     case oDebugLevel: debug_level = pargs->r.ret_str; break;
367
368     case oLogFile:
369       if (!reread)
370         return 0; /* not handeld */
371       if (!current_logfile || !pargs->r.ret_str
372           || strcmp (current_logfile, pargs->r.ret_str))
373         {
374           log_set_file (pargs->r.ret_str);
375           xfree (current_logfile);
376           current_logfile = xtrystrdup (pargs->r.ret_str);
377         }
378       break;
379
380     case oNoGrab: opt.no_grab = 1; break;
381       
382     case oPinentryProgram: opt.pinentry_program = pargs->r.ret_str; break;
383     case oScdaemonProgram: opt.scdaemon_program = pargs->r.ret_str; break;
384
385     case oDefCacheTTL: opt.def_cache_ttl = pargs->r.ret_ulong; break;
386     case oMaxCacheTTL: opt.max_cache_ttl = pargs->r.ret_ulong; break;
387       
388     case oIgnoreCacheForSigning: opt.ignore_cache_for_signing = 1; break;
389
390     case oAllowMarkTrusted: opt.allow_mark_trusted = 1; break;
391
392     default:
393       return 0; /* not handled */
394     }
395   return 1; /* handled */
396 }
397
398
399 int
400 main (int argc, char **argv )
401 {
402   ARGPARSE_ARGS pargs;
403   int orig_argc;
404   int may_coredump;
405   char **orig_argv;
406   FILE *configfp = NULL;
407   char *configname = NULL;
408   const char *shell;
409   unsigned configlineno;
410   int parse_debug = 0;
411   int default_config =1;
412   int greeting = 0;
413   int nogreeting = 0;
414   int pipe_server = 0;
415   int is_daemon = 0;
416   int nodetach = 0;
417   int csh_style = 0;
418   char *logfile = NULL;
419   int debug_wait = 0;
420   int disable_pth = 0;
421   int gpgconf_list = 0;
422   gpg_error_t err;
423
424
425   set_strusage (my_strusage);
426   gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
427   /* Please note that we may running SUID(ROOT), so be very CAREFUL
428      when adding any stuff between here and the call to INIT_SECMEM()
429      somewhere after the option parsing */
430   log_set_prefix ("gpg-agent", JNLIB_LOG_WITH_PREFIX|JNLIB_LOG_WITH_PID); 
431
432   /* Try to auto set the character set.  */
433   set_native_charset (NULL); 
434
435   i18n_init ();
436
437   /* Libgcrypt requires us to register the threading model first.
438      Note that this will also do the pth_init. */
439 #ifdef USE_GNU_PTH
440 #ifdef HAVE_W32_SYSTEM
441   /* For W32 we need pth.  */
442   pth_init ();
443 #else
444   err = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
445   if (err)
446     {
447       log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
448                  gpg_strerror (err));
449     }
450 #endif
451 #endif /*USE_GNU_PTH*/
452
453
454   /* Check that the libraries are suitable.  Do it here because
455      the option parsing may need services of the library. */
456   if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
457     {
458       log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
459                  NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
460     }
461
462   assuan_set_malloc_hooks (gcry_malloc, gcry_realloc, gcry_free);
463   assuan_set_assuan_log_stream (log_get_stream ());
464   assuan_set_assuan_log_prefix (log_get_prefix (NULL));
465
466   gcry_set_log_handler (my_gcry_logger, NULL);
467   gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);
468
469   may_coredump = disable_core_dumps ();
470
471   parse_rereadable_options (NULL, 0); /* Reset them to default values. */
472
473   shell = getenv ("SHELL");
474   if (shell && strlen (shell) >= 3 && !strcmp (shell+strlen (shell)-3, "csh") )
475     csh_style = 1;
476   
477   opt.homedir = getenv("GNUPGHOME");
478   if (!opt.homedir || !*opt.homedir)
479     opt.homedir = GNUPG_DEFAULT_HOMEDIR;
480
481
482   /* check whether we have a config file on the commandline */
483   orig_argc = argc;
484   orig_argv = argv;
485   pargs.argc = &argc;
486   pargs.argv = &argv;
487   pargs.flags= 1|(1<<6);  /* do not remove the args, ignore version */
488   while (arg_parse( &pargs, opts))
489     {
490       if (pargs.r_opt == oDebug || pargs.r_opt == oDebugAll)
491         parse_debug++;
492       else if (pargs.r_opt == oOptions)
493         { /* yes there is one, so we do not try the default one, but
494              read the option file when it is encountered at the
495              commandline */
496           default_config = 0;
497         }
498         else if (pargs.r_opt == oNoOptions)
499           default_config = 0; /* --no-options */
500         else if (pargs.r_opt == oHomedir)
501           opt.homedir = pargs.r.ret_str;
502     }
503
504   /* initialize the secure memory. */
505   gcry_control (GCRYCTL_INIT_SECMEM, 16384, 0);
506   maybe_setuid = 0;
507
508   /* 
509      Now we are now working under our real uid 
510   */
511
512
513   if (default_config)
514     configname = make_filename (opt.homedir, "gpg-agent.conf", NULL );
515   
516   argc = orig_argc;
517   argv = orig_argv;
518   pargs.argc = &argc;
519   pargs.argv = &argv;
520   pargs.flags=  1;  /* do not remove the args */
521  next_pass:
522   if (configname)
523     {
524       configlineno = 0;
525       configfp = fopen (configname, "r");
526       if (!configfp)
527         {
528           if (default_config)
529             {
530               if( parse_debug )
531                 log_info (_("NOTE: no default option file `%s'\n"),
532                           configname );
533             }
534           else
535             {
536               log_error (_("option file `%s': %s\n"),
537                          configname, strerror(errno) );
538               exit(2);
539             }
540           xfree (configname); 
541           configname = NULL;
542         }
543       if (parse_debug && configname )
544         log_info (_("reading options from `%s'\n"), configname );
545       default_config = 0;
546     }
547
548   while (optfile_parse( configfp, configname, &configlineno, &pargs, opts) )
549     {
550       if (parse_rereadable_options (&pargs, 0))
551         continue; /* Already handled */
552       switch (pargs.r_opt)
553         {
554         case aGPGConfList: gpgconf_list = 1; break;
555         case oBatch: opt.batch=1; break;
556
557         case oDebugWait: debug_wait = pargs.r.ret_int; break;
558
559         case oOptions:
560           /* config files may not be nested (silently ignore them) */
561           if (!configfp)
562             {
563                 xfree(configname);
564                 configname = xstrdup(pargs.r.ret_str);
565                 goto next_pass;
566             }
567           break;
568         case oNoGreeting: nogreeting = 1; break;
569         case oNoVerbose: opt.verbose = 0; break;
570         case oNoOptions: break; /* no-options */
571         case oHomedir: opt.homedir = pargs.r.ret_str; break;
572         case oNoDetach: nodetach = 1; break;
573         case oLogFile: logfile = pargs.r.ret_str; break;
574         case oCsh: csh_style = 1; break;
575         case oSh: csh_style = 0; break;
576         case oServer: pipe_server = 1; break;
577         case oDaemon: is_daemon = 1; break;
578         case oDisablePth: disable_pth = 1; break;
579
580         case oDisplay: default_display = xstrdup (pargs.r.ret_str); break;
581         case oTTYname: default_ttyname = xstrdup (pargs.r.ret_str); break;
582         case oTTYtype: default_ttytype = xstrdup (pargs.r.ret_str); break;
583         case oLCctype: default_lc_ctype = xstrdup (pargs.r.ret_str); break;
584         case oLCmessages: default_lc_messages = xstrdup (pargs.r.ret_str);
585           break;
586
587         case oKeepTTY: opt.keep_tty = 1; break;
588         case oKeepDISPLAY: opt.keep_display = 1; break;
589
590         default : pargs.err = configfp? 1:2; break;
591         }
592     }
593   if (configfp)
594     {
595       fclose( configfp );
596       configfp = NULL;
597       /* Keep a copy of the name so that it can be read on SIGHUP. */
598       config_filename = configname;
599       configname = NULL;
600       goto next_pass;
601     }
602   xfree (configname);
603   configname = NULL;
604   if (log_get_errorcount(0))
605     exit(2);
606   if (nogreeting )
607     greeting = 0;
608
609   if (greeting)
610     {
611       fprintf (stderr, "%s %s; %s\n",
612                  strusage(11), strusage(13), strusage(14) );
613       fprintf (stderr, "%s\n", strusage(15) );
614     }
615 #ifdef IS_DEVELOPMENT_VERSION
616   /* We don't want to print it here because gpg-agent is useful of its
617      own and quite matured.  */
618   /*log_info ("NOTE: this is a development version!\n");*/
619 #endif
620
621   set_debug ();
622   
623   if (atexit (cleanup))
624     {
625       log_error ("atexit failed\n");
626       cleanup ();
627       exit (1);
628     }
629
630   create_directories ();
631
632   if (debug_wait && pipe_server)
633     {
634       log_debug ("waiting for debugger - my pid is %u .....\n",
635                  (unsigned int)getpid());
636       sleep (debug_wait);
637       log_debug ("... okay\n");
638     }
639   
640   if (gpgconf_list)
641     {
642       char *filename;
643
644       /* List options and default values in the GPG Conf format.  */
645
646       /* The following list is taken from gnupg/tools/gpgconf-comp.c.  */
647       /* Option flags.  YOU MUST NOT CHANGE THE NUMBERS OF THE EXISTING
648          FLAGS, AS THEY ARE PART OF THE EXTERNAL INTERFACE.  */
649 #define GC_OPT_FLAG_NONE        0UL
650       /* The RUNTIME flag for an option indicates that the option can be
651          changed at runtime.  */
652 #define GC_OPT_FLAG_RUNTIME     (1UL << 3)
653       /* The DEFAULT flag for an option indicates that the option has a
654          default value.  */
655 #define GC_OPT_FLAG_DEFAULT     (1UL << 4)
656       /* The DEF_DESC flag for an option indicates that the option has a
657          default, which is described by the value of the default field.  */
658 #define GC_OPT_FLAG_DEF_DESC    (1UL << 5)
659       /* The NO_ARG_DESC flag for an option indicates that the argument has
660          a default, which is described by the value of the ARGDEF field.  */
661 #define GC_OPT_FLAG_NO_ARG_DESC (1UL << 6)
662
663       filename = make_filename (opt.homedir, "gpg-agent.conf", NULL );
664       printf ("gpgconf-gpg-agent.conf:%lu:\"%s\n",
665               GC_OPT_FLAG_DEFAULT, filename);
666       xfree (filename);
667
668       printf ("verbose:%lu:\n"
669               "quiet:%lu:\n"
670               "debug-level:%lu:\"none:\n"
671               "log-file:%lu:\n",
672               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
673               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME,
674               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME,
675               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME );
676       printf ("default-cache-ttl:%lu:%d:\n",
677               GC_OPT_FLAG_DEFAULT|GC_OPT_FLAG_RUNTIME, DEFAULT_CACHE_TTL );
678       printf ("no-grab:%lu:\n", 
679               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
680       printf ("ignore-cache-for-signing:%lu:\n",
681               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
682       printf ("allow-mark-trusted:%lu:\n",
683               GC_OPT_FLAG_NONE|GC_OPT_FLAG_RUNTIME);
684
685       agent_exit (0);
686     }
687
688   /* If this has been called without any options, we merely check
689      whether an agent is already running.  We do this here so that we
690      don't clobber a logfile but print it directly to stderr. */
691   if (!pipe_server && !is_daemon)
692     {
693       log_set_prefix (NULL, JNLIB_LOG_WITH_PREFIX); 
694       check_for_running_agent ();
695       agent_exit (0);
696     }
697   
698 #ifdef ENABLE_NLS
699   /* gpg-agent usually does not output any messages because it runs in
700      the background.  For log files it is acceptable to have messages
701      always encoded in utf-8.  We switch here to utf-8, so that
702      commands like --help still give native messages.  It is far
703      easier to switch only once instead of for every message and it
704      actually helps when more then one thread is active (avoids an
705      extra copy step). */
706     bind_textdomain_codeset (PACKAGE_GT, "UTF-8");
707 #endif
708
709   /* Now start with logging to a file if this is desired. */
710   if (logfile)
711     {
712       log_set_file (logfile);
713       log_set_prefix (NULL, (JNLIB_LOG_WITH_PREFIX
714                              |JNLIB_LOG_WITH_TIME
715                              |JNLIB_LOG_WITH_PID));
716       current_logfile = xstrdup (logfile);
717     }
718
719   /* Make sure that we have a default ttyname. */
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
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 }