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